|
|
| Line 1: |
Line 1: |
| -- <nowiki>
| | local getArgs = require('Module:Arguments').getArgs |
| local hc = require('Module:Paramtest').has_content | |
| local icons
| |
| local mapVersionList
| |
| local fileCache = {}
| |
| | |
| local p = {} | | local p = {} |
|
| |
|
| local zoomSizes = {
| | function p.main(frame) |
| { 3, 8 },
| | local args = getArgs(frame) |
| { 2, 4 },
| | return p._main(args) |
| { 1, 2 },
| |
| { 0, 1 },
| |
| { -1, 1/2 },
| |
| { -2, 1/4 },
| |
| { -3, 1/8 }
| |
| }
| |
| -- Default size of maps (to calc zoom)
| |
| local default_size = 800 -- 800px for full screen
| |
| -- Map feature (overlay) types
| |
| local featureMap = {
| |
| none = {},
| |
| square = { square=true },
| |
| rectangle = { square=true },
| |
| polygon = { polygon=true },
| |
| line = { line=true },
| |
| lines = { line=true },
| |
| linestring = { line=true },
| |
| circle = { circle=true },
| |
| pin = { pins=true },
| |
| pins = { pins=true },
| |
| dot = { dots=true },
| |
| dots = { dots=true },
| |
| sqdot = { sqdot=true },
| |
| sqdots = { sqdot=true },
| |
| circlemarker = { cmarker=true },
| |
| icons = { icons=true },
| |
| icon = { icons=true },
| |
| ['pin-polygon'] = { polygon=true, pins=true },
| |
| ['pins-polygon'] = { polygon=true, pins=true },
| |
| ['pin-line'] = { line=true, pins=true },
| |
| ['pins-line'] = { line=true, pins=true },
| |
| ['pin-circle'] = { circle=true, pins=true },
| |
| ['pins-circle'] = { circle=true, pins=true },
| |
| ['dot-polygon'] = { polygon=true, dots=true },
| |
| ['dots-polygon'] = { polygon=true, dots=true },
| |
| ['dot-line'] = { line=true, dots=true },
| |
| ['dots-line'] = { line=true, dots=true },
| |
| ['sqdot-polygon'] = { polygon=true, sqdot=true },
| |
| ['sqdot-polygon'] = { polygon=true, sqdot=true },
| |
| ['sqdot-line'] = { line=true, sqdot=true },
| |
| ['sqdot-line'] = { line=true, sqdot=true },
| |
| text = { text=true }
| |
| }
| |
| -- Possible properties
| |
| local properties = {
| |
| polygon = { title=true, description=true, stroke=true, ['stroke-opacity']=true, ['stroke-width']=true, fill=true, ['fill-opacity']=true },
| |
| line = { title=true, description=true, stroke=true, ['stroke-opacity']=true, ['stroke-width']=true },
| |
| circle = { title=true, description=true, stroke=true, ['stroke-opacity']=true, ['stroke-width']=true, fill=true, ['fill-opacity']=true },
| |
| dot = { title=true, description=true, fill=true, iconSize=true },
| |
| sqdot = { title=true, description=true, fill=true, iconSize=true },
| |
| cmarker = { title=true, description=true, stroke=true, ['stroke-opacity']=true, ['stroke-width']=true, fill=true, ['fill-opacity']=true },
| |
| pin = { title=true, description=true, icon=true, iconWikiLink=true, iconSize=true, iconAnchor=true, popupAnchor=true},
| |
| text = { title=true, description=true, label=true, direction=true, class=true }
| |
| }
| |
| local numprops = {'stroke-opacity', 'stroke-width', 'fill-opacity'}
| |
| | |
| -- Create JSON
| |
| function toJSON(j)
| |
| local json_good, json = pcall(mw.text.jsonEncode, j)--, mw.text.JSON_PRETTY)
| |
| if json_good then
| |
| return json
| |
| end
| |
| return error('Error converting to JSON')
| |
| end
| |
| -- Create map html element
| |
| function createMapElement(elem, args, json)
| |
| local mapelem = mw.html.create(elem)
| |
| mapelem:attr(args):newline():wikitext(toJSON(json)):newline()
| |
| return mapelem
| |
| end
| |
| -- Create pin description
| |
| function parseDesc(args, pin, pgname, ptype)
| |
| local desc = {}
| |
| if ptype == 'item' then
| |
| desc = {
| |
| "'''Item''': ".. (args.item or pgname),
| |
| "'''Quantity''': ".. (pin.qty or 1)
| |
| }
| |
| if pin.respawn then
| |
| table.insert(desc, "'''Respawn time''': "..pin.respawn)
| |
| elseif args.respawn then
| |
| table.insert(desc, "'''Respawn time''': "..args.respawn)
| |
| end
| |
| if pin.notes then
| |
| table.insert(desc, "'''Notes''': "..pin.notes)
| |
| elseif args.notes then
| |
| table.insert(desc, "'''Notes''': "..args.notes)
| |
| end
| |
| elseif ptype == 'npc' then
| |
| if pin.npcname then
| |
| table.insert(desc, "'''NPC''': "..pin.npcname)
| |
| elseif args.npcname then
| |
| table.insert(desc, "'''NPC''': "..args.npcname)
| |
| else
| |
| table.insert(desc, "'''NPC''': "..pgname)
| |
| end
| |
| if pin.version then
| |
| table.insert(desc, "'''Version''': "..pin.version)
| |
| elseif args.version then
| |
| table.insert(desc, "'''Version''': "..args.version)
| |
| end
| |
| if pin.npcid then
| |
| table.insert(desc, "'''NPC ID''': "..pin.npcid)
| |
| elseif args.npcid then
| |
| table.insert(desc, "'''NPC ID''': "..args.npcid)
| |
| end
| |
| if pin.objectid then
| |
| table.insert(desc, "'''Object ID''': "..pin.objectid)
| |
| elseif args.objectid then
| |
| table.insert(desc, "'''Object ID''': "..args.objectid)
| |
| end
| |
| if pin.respawn then
| |
| table.insert(desc, "'''Respawn time''': "..pin.respawn)
| |
| elseif args.respawn then
| |
| table.insert(desc, "'''Respawn time''': "..args.respawn)
| |
| end
| |
| if pin.notes then
| |
| table.insert(desc, "'''Notes''': "..pin.notes)
| |
| elseif args.notes then
| |
| table.insert(desc, "'''Notes''': "..args.notes)
| |
| end
| |
| elseif ptype == 'object' then
| |
| table.insert(desc, "'''Object''': "..(pin.objectname or args.objectname or pgname))
| |
| if pin.version then
| |
| table.insert(desc, "'''Version''': "..pin.version)
| |
| elseif args.version then
| |
| table.insert(desc, "'''Version''': "..args.version)
| |
| end
| |
| if pin.objectid then
| |
| table.insert(desc, "'''Object ID''': "..pin.objectid)
| |
| elseif args.objectid then
| |
| table.insert(desc, "'''Object ID''': "..args.objectid)
| |
| end
| |
| if pin.npcid then
| |
| table.insert(desc, "'''NPC ID''': "..pin.npcid)
| |
| elseif args.npcid then
| |
| table.insert(desc, "'''NPC ID''': "..args.npcid)
| |
| end
| |
| if pin.respawn then
| |
| table.insert(desc, "'''Respawn time''': "..pin.respawn)
| |
| elseif args.respawn then
| |
| table.insert(desc, "'''Respawn time''': "..args.respawn)
| |
| end
| |
| if pin.notes then
| |
| table.insert(desc, "'''Notes''': "..pin.notes)
| |
| elseif args.notes then
| |
| table.insert(desc, "'''Notes''': "..args.notes)
| |
| end
| |
| else
| |
| if args.desc then
| |
| table.insert(desc, args.desc)
| |
| end
| |
| if pin.desc then
| |
| table.insert(desc, pin.desc)
| |
| elseif pin.x and pin.y then
| |
| table.insert(desc, 'X,Y: '..pin.x..','..pin.y)
| |
| end
| |
| end
| |
| | |
| return table.concat(desc, '<br>')
| |
| end
| |
| -- Parse unnamed arguments (arg = pin)
| |
| function p.parseArgs(args, ptype) | |
| args.pins = {}
| |
| local sep = args.sep or '%s*,%s*' | |
| local pgname = mw.title.getCurrentTitle().text
| |
| local rng = {
| |
| xmin = 10000000,
| |
| xmax = -10000000,
| |
| ymin = 10000000,
| |
| ymax = -10000000
| |
| }
| |
| | |
| local i,cnt = 1,0
| |
| while (args[i]) do
| |
| local v = mw.text.trim(args[i])
| |
| if hc(v) then
| |
| local pin = {}
| |
| for u in mw.text.gsplit(v, sep) do
| |
| local _u = mw.text.split(u, '%s*:%s*')
| |
| if _u[2] then
| |
| local k = mw.text.trim(_u[1])
| |
| if k == 'x' or k == 'y' then
| |
| pin[k] = tonumber(mw.text.trim(_u[2]))
| |
| else
| |
| pin[k] = mw.text.trim(_u[2])
| |
| end
| |
| else
| |
| if pin.x then
| |
| pin.y = tonumber(_u[1])
| |
| else
| |
| pin.x = tonumber(_u[1])
| |
| end
| |
| end
| |
| end
| |
| | |
| if pin.x > rng.xmax then
| |
| rng.xmax = pin.x
| |
| end
| |
| if pin.x < rng.xmin then
| |
| rng.xmin = pin.x
| |
| end
| |
| if pin.y > rng.ymax then
| |
| rng.ymax = pin.y
| |
| end
| |
| if pin.y < rng.ymin then
| |
| rng.ymin = pin.y
| |
| end
| |
| | |
| -- Pin size/location args
| |
| if pin.iconSizeX and pin.iconSizeY then
| |
| pin.iconSize = {tonumber(pin.iconSizeX), tonumber(pin.iconSizeY)}
| |
| elseif pin.iconSize then
| |
| pin.iconSize = {tonumber(pin.iconSize), tonumber(pin.iconSize)}
| |
| end
| |
| if pin.iconAnchorX and pin.iconAnchorY then
| |
| pin.iconAnchor = {tonumber(pin.iconAnchorX), tonumber(pin.iconAnchorY)}
| |
| elseif pin.iconAnchor then
| |
| pin.iconAnchor = {tonumber(pin.iconAnchor), tonumber(pin.iconAnchor)}
| |
| end
| |
| if pin.popupAnchorX and pin.popupAnchorY then
| |
| pin.popupAnchor = {tonumber(pin.popupAnchorX), tonumber(pin.popupAnchorY)}
| |
| elseif pin.popupAnchor then
| |
| pin.popupAnchor = {tonumber(pin.popupAnchor), tonumber(pin.popupAnchor)}
| |
| end
| |
| | |
| pin.desc = parseDesc(args, pin, pgname, ptype)
| |
|
| |
| table.insert( args.pins, pin)
| |
| cnt = cnt + 1
| |
| end
| |
| i = i + 1
| |
| end
| |
| | |
| -- In no anonymous args then x,y are pin
| |
| if cnt == 0 then
| |
| local x = tonumber(args.x) or 3233 -- Default is Lumbridge loadstone
| |
| local y = tonumber(args.y) or 3222
| |
| rng.xmax = x
| |
| rng.xmin = x
| |
| rng.ymax = y
| |
| rng.ymin = y
| |
| local desc = parseDesc(args, {}, pgname, ptype)
| |
| table.insert( args.pins, {x = x, y = y, desc = desc} )
| |
| cnt = cnt + 1
| |
| end
| |
| | |
| local xrange = rng.xmax - rng.xmin
| |
| local yrange = rng.ymax - rng.ymin
| |
| | |
| if not tonumber(args.x) then
| |
| args.x = math.floor(rng.xmin + xrange/2)
| |
| end
| |
| if not tonumber(args.y) then
| |
| args.y = math.floor(rng.ymin + yrange/2)
| |
| end
| |
| -- Default range (1 pin) is 40
| |
| if not tonumber(args.x_range) then
| |
| if xrange > 0 then
| |
| args.x_range = xrange
| |
| else
| |
| args.x_range = 40
| |
| end
| |
| end
| |
| if not tonumber(args.y_range) then
| |
| if yrange > 0 then
| |
| args.y_range = yrange
| |
| else
| |
| args.y_range = 40
| |
| end
| |
| end
| |
| -- Default square (1 pin) is 20
| |
| if not tonumber(args.squareX) then
| |
| if xrange > 0 then
| |
| args.squareX = xrange
| |
| else
| |
| args.squareX = 20
| |
| end
| |
| end
| |
| if not tonumber(args.squareY) then
| |
| if yrange > 0 then
| |
| args.squareY = yrange
| |
| else
| |
| args.squareY = 20
| |
| end
| |
| end
| |
| | |
| args.pin_count = cnt
| |
| | |
| return args
| |
| end
| |
| -- Add styles
| |
| function styles(ftjson, args, this, ptype)
| |
| local props = properties[ptype]
| |
| for i,v in pairs(args) do
| |
| if props[i] then
| |
| if type(v) == "table" then
| |
| ftjson.properties[i] = mw.clone(v)
| |
| else
| |
| ftjson.properties[i] = v
| |
| end
| |
| end
| |
| end
| |
| for i,v in pairs(this) do
| |
| if props[i] then
| |
| ftjson.properties[i] = v
| |
| end
| |
| end
| |
| for _,v in ipairs(numprops) do
| |
| if ftjson.properties[v] then
| |
| ftjson.properties[v] = tonumber(ftjson.properties[v])
| |
| end
| |
| end
| |
| | |
| return ftjson | |
| end
| |
| | |
| -- Functions for templates were moved to the /templates submodule! --
| |
| | |
| -- Function for creating map or link
| |
| function p.createMap(args)
| |
| local opts = {
| |
| mapID = args.mapID or 28, -- RuneScape Surface
| |
| plane = tonumber(args.plane) or 0,
| |
| }
| |
|
| |
| local featColl, features = {}, {}
| |
| if hc(args.features) then
| |
| local _features = string.lower(args.features)
| |
| features = featureMap[_features] or {}
| |
| end
| |
| if features.square then
| |
| table.insert(featColl, p.featSquare(args, opts))
| |
| elseif features.circle then
| |
| table.insert(featColl, p.featCircle(args, opts))
| |
| end
| |
| if features.polygon then
| |
| table.insert(featColl, p.featPolygon(args, opts))
| |
| elseif features.line then
| |
| table.insert(featColl, p.featLine(args, opts))
| |
| end
| |
| if features.text then
| |
| for _,pin in ipairs(args.pins) do
| |
| table.insert(featColl, p.featText(args, opts, pin))
| |
| end
| |
| end
| |
| if features.pins then
| |
| if not opts.group then
| |
| opts.group = 'pins'
| |
| end
| |
| opts.icon = args.icon or 'greenPin'
| |
| for _,pin in ipairs(args.pins) do
| |
| table.insert(featColl, p.featPin(args, opts, pin))
| |
| end
| |
| elseif features.icons then
| |
| if not opts.group then
| |
| opts.group = 'pins'
| |
| end
| |
| for _,pin in ipairs(args.pins) do
| |
| table.insert(featColl, p.featIcon(args, opts, pin))
| |
| end
| |
| elseif features.dots then
| |
| if not opts.group then
| |
| opts.group = 'dots'
| |
| end
| |
| for _,pin in ipairs(args.pins) do
| |
| table.insert(featColl, p.featDot(args, opts, pin))
| |
| end
| |
| elseif features.sqdots then
| |
| if not opts.group then
| |
| opts.group = 'dots'
| |
| end
| |
| for _,pin in ipairs(args.pins) do
| |
| table.insert(featColl, p.featSqDot(args, opts, pin))
| |
| end
| |
| elseif features.cmarker then
| |
| if not opts.group then
| |
| opts.group = 'dots'
| |
| end
| |
| for _,pin in ipairs(args.pins) do
| |
| table.insert(featColl, p.featCirMark(args, opts, pin))
| |
| end
| |
| end
| |
| | |
| local json = {}
| |
| if #featColl > 0 then
| |
| json = {
| |
| type = 'FeatureCollection',
| |
| features = featColl
| |
| }
| |
| end
| |
| | |
| return p.createFeatMap(args, json)
| |
| end
| |
| | |
| -- Function for creating map or link with features already generated
| |
| function p.createFeatMap(args, ftcoljson)
| |
| local x, y = args.x, args.y
| |
| local opts = {
| |
| x = x,
| |
| y = y,
| |
| width = args.width or 300,
| |
| height = args.height or 300,
| |
| mapID = 28, -- RuneScape Surface is default
| |
| plane = tonumber(args.plane) or 0,
| |
| zoom = args.zoom or 2,
| |
| align = args.align or 'center'
| |
| }
| |
| -- make sure mapID passed as number 0 works
| |
| if type( tonumber(args.mapID) ) == 'number' then
| |
| opts.mapID = args.mapID
| |
| end
| |
|
| |
| if hc(args.group) then
| |
| opts.group = args.group
| |
| end
| |
| if hc(args.show) then
| |
| opts.show = args.show
| |
| end
| |
|
| |
| -- plain map tiles
| |
| if hc(args.plaintiles) then
| |
| opts.plainTiles = 'true'
| |
| end
| |
| if hc(args.plainTiles) then
| |
| opts.plainTiles = 'true'
| |
| end
| |
|
| |
| -- other map tile version
| |
| if hc(args.mapversion) or hc(args.mapVersion) then
| |
| local mapvers = args.mapversion
| |
| if hc(args.mapVersion) then
| |
| mapvers = args.mapVersion
| |
| end
| |
| if not mapVersionList then
| |
| mapVersionList = mw.loadData('Module:Map/versions')
| |
| end
| |
| if mapVersionList[mapvers] then
| |
| opts.mapVersion = mapVersionList[mapvers]
| |
| else
| |
| opts.mapVersion = mapvers
| |
| end
| |
| end
| |
| | |
| -- mapframe, maplink
| |
| local etype = 'mapframe'
| |
| if hc(args.etype) then
| |
| etype = args.etype
| |
| end
| |
|
| |
| -- translate "centre" spelling for align
| |
| if opts.align == 'centre' then
| |
| opts.align = 'center'
| |
| end
| |
| | |
| -- Caption or link text
| |
| if etype == 'maplink' then
| |
| opts.text = args.text or 'Maplink'
| |
| if string.find(opts.text,'[%[%]]') then
| |
| return error('Text cannot contain links')
| |
| end
| |
| elseif hc(args.caption) then
| |
| opts.text = args.caption
| |
| else
| |
| opts.frameless = ''
| |
| end
| |
|
| |
| -- Zoom
| |
| if type( tonumber(args.zoom) ) == 'number' then
| |
| opts.zoom = args.zoom
| |
| else
| |
| local width,height = opts.width, opts.height
| |
| if etype == 'maplink' then
| |
| width,height = default_size, default_size
| |
| end
| |
| local x_range = tonumber(args.squareX) or 40
| |
| local y_range = tonumber(args.squareY) or 40
| |
| if tonumber(args.r) then
| |
| x_range = tonumber(args.r)
| |
| y_range = tonumber(args.r)
| |
| end
| |
| if tonumber(args.x_range) then
| |
| x_range = tonumber(args.x_range)
| |
| end
| |
| if tonumber(args.y_range) then
| |
| y_range = tonumber(args.y_range)
| |
| end
| |
| | |
| local zoom = -3
| |
| for i,v in ipairs(zoomSizes) do
| |
| local sqsx, sqsy = width/v[2], height/v[2]
| |
| if sqsx > x_range and sqsy > y_range then
| |
| zoom = v[1]
| |
| break
| |
| end
| |
| end
| |
| if zoom > 2 then
| |
| zoom = 2
| |
| end
| |
| opts.zoom = zoom
| |
| end
| |
|
| |
| local map = createMapElement(etype, opts, ftcoljson)
| |
| if args.nopreprocess then
| |
| return map
| |
| end
| |
| return mw.getCurrentFrame():preprocess(tostring(map))
| |
| end
| |
| | |
| -- Create a square feature
| |
| function p.featSquare(args, opts)
| |
| local x, y = args.x, args.y
| |
| local squareX = tonumber(args.squareX) or 20
| |
| local squareY = tonumber(args.squareY) or 20
| |
| squareX = math.max(1, args.r or math.floor(squareX / 2))
| |
| squareY = math.max(1, args.r or math.floor(squareY / 2))
| |
|
| |
| if args.jagexCoords then
| |
| x = x + 0.5
| |
| y = y + 0.5
| |
| end
| |
| | |
| local ftjson = {
| |
| type = 'Feature',
| |
| properties = {['_']='_', mapID=opts.mapID, plane=opts.plane},
| |
| geometry = {
| |
| type = 'Polygon',
| |
| coordinates = {
| |
| {
| |
| { x-squareX, y-squareY },
| |
| { x-squareX, y+squareY },
| |
| { x+squareX, y+squareY },
| |
| { x+squareX, y-squareY }
| |
| }
| |
| }
| |
| }
| |
| }
| |
| | |
| ftjson = styles(ftjson, args, {}, 'polygon')
| |
| return ftjson
| |
| end
| |
| | |
| -- Create a polygon feature
| |
| function p.featPolygon(args, opts)
| |
| local points, lastpoint = {}, {}
| |
| for _,v in ipairs(args.pins) do
| |
| table.insert(points, {v.x, v.y,})
| |
| lastpoint = {v.x, v.y,}
| |
| 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 ftjson = {
| |
| type = 'Feature',
| |
| properties = {['_']='_', mapID=opts.mapID, plane=opts.plane},
| |
| geometry = {
| |
| type = 'Polygon',
| |
| coordinates = { points }
| |
| }
| |
| }
| |
| | |
| ftjson = styles(ftjson, args, {}, 'polygon')
| |
| return ftjson
| |
| end
| |
| -- Create a complex polygon feature (allows nested coords array)
| |
| function p.featComplPolygon(args, opts, coords)
| |
| local ftjson = {
| |
| type = 'Feature',
| |
| properties = {['_']='_', mapID=opts.mapID, plane=opts.plane},
| |
| geometry = {
| |
| type = 'Polygon',
| |
| coordinates = coords
| |
| }
| |
| }
| |
| | |
| ftjson = styles(ftjson, args, {}, 'polygon')
| |
| return ftjson
| |
| end
| |
| | |
| -- Create a line feature
| |
| function p.featLine(args, opts)
| |
| local points, lastpoint = {}, {}
| |
| for _,v in ipairs(args.pins) do
| |
| table.insert(points, {v.x, v.y,})
| |
| lastpoint = {v.x, v.y,}
| |
| end
| |
| if hc(args.close) then
| |
| -- Close line
| |
| if not (points[1][1] == lastpoint[1] and points[1][2] == lastpoint[2]) then
| |
| table.insert(points, {points[1][1], points[1][2]})
| |
| end
| |
| end
| |
| | |
| local ftjson = {
| |
| type = 'Feature',
| |
| properties = {
| |
| ['_'] = '_',
| |
| shape = 'Line',
| |
| mapID = opts.mapID,
| |
| plane = opts.plane
| |
| },
| |
| geometry = {
| |
| type = 'LineString',
| |
| coordinates = points
| |
| }
| |
| }
| |
| | |
| ftjson = styles(ftjson, args, {}, 'line')
| |
| return ftjson
| |
| end
| |
| | |
| -- Create a circle feature
| |
| function p.featCircle(args, opts)
| |
| local rad = tonumber(args.r) or 10
| |
| local ftjson = {
| |
| type = 'Feature',
| |
| properties = {
| |
| ['_']='_',
| |
| shape = 'Circle',
| |
| radius = rad,
| |
| mapID = opts.mapID,
| |
| plane = opts.plane
| |
| },
| |
| geometry = {
| |
| type = 'Point',
| |
| coordinates = {
| |
| args.x, args.y, opts.plane
| |
| }
| |
| }
| |
| }
| |
|
| |
| -- Center circles on tile, when using tile based coordinates eg from in game
| |
| if args.jagexCoords then
| |
| ftjson.geometry.coordinates[1] = ftjson.geometry.coordinates[1] + 0.5
| |
| ftjson.geometry.coordinates[2] = ftjson.geometry.coordinates[2] + 0.5
| |
| end
| |
| | |
| ftjson = styles(ftjson, args, {}, 'circle')
| |
| return ftjson
| |
| end
| |
| | |
| -- Create a text label feature
| |
| function p.featText(args, opts, pin)
| |
| local desc = pin.desc or args.desc
| |
| local ftjson = {
| |
| type = 'Feature',
| |
| properties = {
| |
| shape = 'Text',
| |
| description = desc,
| |
| mapID = opts.mapID,
| |
| plane = opts.plane
| |
| },
| |
| geometry = {
| |
| type = 'Point',
| |
| coordinates = {
| |
| pin.x, pin.y, opts.plane
| |
| -- pin.x+0.5, pin.y-0.5, opts.plane
| |
| }
| |
| }
| |
| }
| |
|
| |
| -- Center text on tile, when using tile based coordinates eg from in game
| |
| if args.jagexCoords then
| |
| ftjson.geometry.coordinates[1] = ftjson.geometry.coordinates[1] + 0.5
| |
| ftjson.geometry.coordinates[2] = ftjson.geometry.coordinates[2] + 0.5
| |
| end
| |
| | |
| ftjson = styles(ftjson, args, pin, 'text')
| |
| return ftjson
| |
| end
| |
| | |
| -- Create a dot type marker feature
| |
| function p.featDot(args, opts, pin)
| |
| local desc = pin.desc or pin.x..', '..pin.y
| |
| local ftjson = {
| |
| type = 'Feature',
| |
| properties = {
| |
| shape = 'Dot',
| |
| description = desc,
| |
| mapID = opts.mapID,
| |
| plane = opts.plane
| |
| },
| |
| geometry = {
| |
| type = 'Point',
| |
| coordinates = {
| |
| pin.x, pin.y, opts.plane
| |
| -- pin.x+0.5, pin.y-0.5, opts.plane
| |
| }
| |
| }
| |
| }
| |
|
| |
| -- Center dots on tile, when using tile based coordinates eg from in game
| |
| if args.jagexCoords then
| |
| ftjson.geometry.coordinates[1] = ftjson.geometry.coordinates[1] + 0.5
| |
| ftjson.geometry.coordinates[2] = ftjson.geometry.coordinates[2] + 0.5
| |
| end
| |
| | |
| ftjson = styles(ftjson, args, pin, 'dot')
| |
| return ftjson
| |
| end
| |
| | |
| -- Create a square dot marker type feature
| |
| function p.featSqDot(args, opts, pin)
| |
| local desc = pin.desc or pin.x..', '..pin.y
| |
| local ftjson = {
| |
| type = 'Feature',
| |
| properties = {
| |
| shape = 'SquareDot',
| |
| description = desc,
| |
| mapID = opts.mapID,
| |
| plane = opts.plane
| |
| },
| |
| geometry = {
| |
| type = 'Point',
| |
| coordinates = {
| |
| pin.x, pin.y, opts.plane
| |
| -- pin.x+0.5, pin.y-0.5, opts.plane
| |
| }
| |
| }
| |
| }
| |
|
| |
| -- Center square dots on tile, when using tile based coordinates eg from in game
| |
| if args.jagexCoords then
| |
| ftjson.geometry.coordinates[1] = ftjson.geometry.coordinates[1] + 0.5
| |
| ftjson.geometry.coordinates[2] = ftjson.geometry.coordinates[2] + 0.5
| |
| end
| |
| | |
| ftjson = styles(ftjson, args, pin, 'sqdot')
| |
| return ftjson
| |
| end
| |
| | |
| -- Create a circlemarker feature (like a pin it rescales on zoom)
| |
| function p.featCirMark(args, opts, pin)
| |
| local rad = tonumber(args.r) or 10
| |
| local desc = pin.desc or pin.x..', '..pin.y
| |
| local ftjson = {
| |
| type = 'Feature',
| |
| properties = {
| |
| shape = 'CircleMarker',
| |
| radius = rad,
| |
| description = desc,
| |
| mapID = opts.mapID,
| |
| plane = opts.plane
| |
| },
| |
| geometry = {
| |
| type = 'Point',
| |
| coordinates = {
| |
| pin.x, pin.y, opts.plane
| |
| -- pin.x+0.5, pin.y-0.5, opts.plane
| |
| }
| |
| }
| |
| }
| |
|
| |
| -- Center circle marker on tile, when using tile based coordinates eg from in game
| |
| if args.jagexCoords then
| |
| ftjson.geometry.coordinates[1] = ftjson.geometry.coordinates[1] + 0.5
| |
| ftjson.geometry.coordinates[2] = ftjson.geometry.coordinates[2] + 0.5
| |
| end
| |
| | |
| ftjson = styles(ftjson, args, pin, 'cmarker')
| |
| return ftjson
| |
| end
| |
| | |
| -- Create a pin feature
| |
| -- Pin types: greyPin, redPin, greenPin, bluePin, cyanPin, magentaPin, yellowPin
| |
| function p.featPin(args, opts, pin)
| |
| mw.logObject(args)
| |
| mw.logObject(opts)
| |
| mw.logObject(pin)
| |
| local desc = pin.desc or pin.x..', '..pin.y
| |
| local ftjson = {
| |
| type = 'Feature',
| |
| properties = {
| |
| providerID = 0,
| |
| description = desc,
| |
| mapID = opts.mapID,
| |
| plane = opts.plane
| |
| },
| |
| geometry = {
| |
| type = 'Point',
| |
| coordinates = {
| |
| pin.x, pin.y, opts.plane
| |
| -- pin.x+0.5, pin.y+0.5, opts.plane
| |
| }
| |
| }
| |
| }
| |
|
| |
| -- Center pin on tile, when using tile based coordinates eg from in game
| |
| if args.jagexCoords then
| |
| ftjson.geometry.coordinates[1] = ftjson.geometry.coordinates[1] + 0.5
| |
| ftjson.geometry.coordinates[2] = ftjson.geometry.coordinates[2] + 0.5
| |
| end
| |
|
| |
| if args.iconWikiLink then
| |
| if string.find(args.iconWikiLink, 'https://') or string.find(args.iconWikiLink, 'http://') then
| |
| elseif fileCache[args.iconWikiLink] then
| |
| args.iconWikiLink = fileCache[args.iconWikiLink]
| |
| else
| |
| local link = mw.ext.GloopTweaks.filepath(args.iconWikiLink)
| |
| fileCache[args.iconWikiLink] = link
| |
| args.iconWikiLink = link
| |
| end
| |
| if not args.popupAnchor and not pin.popupAnchor then
| |
| args.popupAnchor = {0,0}
| |
| end
| |
| end
| |
| ftjson = styles(ftjson, args, pin, 'pin')
| |
| | |
| if not (ftjson.properties.icon or ftjson.properties.iconWikiLink) then
| |
| ftjson.properties.icon = 'greenPin'
| |
| end
| |
| | |
| return ftjson
| |
| end | | end |
|
| |
|
| -- Predefined icons for pins froom [[Module:Map/icons]]
| | function p._main(args) |
| function p.featIcon(args, opts, pin) | | local first = args[1] or '' |
| local desc = pin.desc or pin.x..', '..pin.y | | local second = args[2] or '' |
| local ftjson = { | | return first .. ' ' .. second |
| type = 'Feature',
| |
| properties = {
| |
| providerID = 0,
| |
| description = desc,
| |
| mapID = opts.mapID,
| |
| plane = opts.plane
| |
| },
| |
| geometry = {
| |
| type = 'Point',
| |
| coordinates = {
| |
| pin.x, pin.y, opts.plane
| |
| -- pin.x+0.5, pin.y-0.5, opts.plane
| |
| }
| |
| }
| |
| }
| |
|
| |
| -- Center icon on tile, when using tile based coordinates eg from in game
| |
| if args.jagexCoords then
| |
| ftjson.geometry.coordinates[1] = ftjson.geometry.coordinates[1] + 0.5
| |
| ftjson.geometry.coordinates[2] = ftjson.geometry.coordinates[2] + 0.5
| |
| end
| |
|
| |
| if not icons then
| |
| icons = mw.loadData('Module:Map/icons')
| |
| end | |
| local ic = pin.icon or args.icon
| |
| ic = icons[ic]
| |
| if not ic then error('Invalid icon name, see [[Module:Map/icons]] for available icons and aliases') end
| |
|
| |
| if fileCache[ic.icon] then
| |
| pin.iconWikiLink = fileCache[ic.icon]
| |
| else
| |
| local link = mw.ext.GloopTweaks.filepath(ic.icon)
| |
| fileCache[ic.icon] = link
| |
| pin.iconWikiLink = link
| |
| end
| |
| pin.iconSize = {ic.iconSize[1], ic.iconSize[2]}
| |
| pin.iconAnchor = {ic.iconAnchor[1], ic.iconAnchor[2]}
| |
| pin.popupAnchor = {ic.popupAnchor[1], ic.popupAnchor[2]}
| |
|
| |
| ftjson = styles(ftjson, args, pin, 'pin')
| |
| return ftjson
| |
| end | | end |
|
| |
|
| return p | | return p |
| -- </nowiki>
| |
