Merged trackplayers branch back into default.

cmd/mtwebmapper/forwardupdates.go

@@ -17,7 +17,7 @@ type websocketForwarder struct {
 	upgrader    *websocket.Upgrader
 	register    chan *connection
 	unregister  chan *connection
-	broadcast   chan map[xz]bool
+	broadcast   chan msg
 	connections map[*connection]bool
 }
 
@@ -26,13 +26,18 @@ type connection struct {
 	send chan []byte
 }
 
+type msg struct {
+	tiles map[xz]bool
+	pls   []*player
+}
+
 func newWebsocketForwarder() *websocketForwarder {
 	upgrader := &websocket.Upgrader{ReadBufferSize: 512, WriteBufferSize: 2048}
 	return &websocketForwarder{
 		upgrader:    upgrader,
 		register:    make(chan *connection),
 		unregister:  make(chan *connection),
-		broadcast:   make(chan map[xz]bool),
+		broadcast:   make(chan msg),
 		connections: make(map[*connection]bool)}
 }
 
@@ -46,26 +51,34 @@ func (wsf *websocketForwarder) run() {
 				delete(wsf.connections, c)
 				close(c.send)
 			}
-		case changes := <-wsf.broadcast:
+		case message := <-wsf.broadcast:
 			if len(wsf.connections) == 0 {
 				continue
 			}
-			// Do the JSON encoding this late to save
-			// some CPU cyles if no client is connected.
-			xzs := make([]xz, 0, len(changes))
-			for xz := range changes {
-				xzs = append(xzs, xz)
+			encMsg := map[string]interface{}{}
+
+			if tiles := message.tiles; tiles != nil {
+				xzs := make([]xz, 0, len(tiles))
+				for xz := range tiles {
+					xzs = append(xzs, xz)
+				}
+				encMsg["tiles"] = xzs
 			}
+
+			if message.pls != nil {
+				encMsg["players"] = message.pls
+			}
+
 			var buf bytes.Buffer
 			encoder := json.NewEncoder(&buf)
-			if err := encoder.Encode(xzs); err != nil {
+			if err := encoder.Encode(encMsg); err != nil {
 				log.Printf("encoding changes failed: %s\n", err)
 				continue
 			}
-			msg := buf.Bytes()
+			m := buf.Bytes()
 			for c := range wsf.connections {
 				select {
-				case c.send <- msg:
+				case c.send <- m:
 				default:
 					delete(wsf.connections, c)
 					close(c.send)
@@ -89,7 +102,11 @@ func (wsf *websocketForwarder) ServeHTTP(rw http.ResponseWriter, r *http.Request
 }
 
 func (wsf *websocketForwarder) BaseTilesUpdated(changes map[xz]bool) {
-	wsf.broadcast <- changes
+	wsf.broadcast <- msg{tiles: changes}
+}
+
+func (wsf *websocketForwarder) BroadcastPlayers(pls []*player) {
+	wsf.broadcast <- msg{pls: pls}
 }
 
 func (c *connection) writer() {

cmd/mtwebmapper/main.go

@@ -29,6 +29,7 @@ func main() {
 		transparent bool
 		updateHosts string
 		websockets  bool
+		playersFIFO string
 	)
 	flag.IntVar(&webPort, "web-port", 8808, "port of the web server")
 	flag.IntVar(&webPort, "p", 8808, "port of the web server (shorthand)")
@@ -53,6 +54,8 @@ func main() {
 	flag.BoolVar(&transparent, "t", false, "Render transparent blocks (shorthand).")
 	flag.BoolVar(&websockets, "websockets", false, "Forward tile changes to clients via websockets.")
 	flag.BoolVar(&websockets, "ws", false, "Forward tile changes to clients via websockets (shorthand).")
+	flag.StringVar(&playersFIFO, "players", "", "Path to FIFO file to read active players from.")
+	flag.StringVar(&playersFIFO, "ps", "", "Path to FIFO file to read active players from (shorthand).")
 
 	flag.Parse()
 
@@ -62,14 +65,21 @@ func main() {
 	router.Path("/map/{z:[0-9]+}/{x:[0-9]+}/{y:[0-9]+}.png").Handler(subBaseLine)
 
 	var btu baseTilesUpdates
+	var wsf *websocketForwarder
 
 	if websockets {
-		wsf := newWebsocketForwarder()
+		wsf = newWebsocketForwarder()
 		go wsf.run()
 		router.Path("/ws").Methods("GET").Handler(wsf)
 		btu = wsf
 	}
 
+	if playersFIFO != "" {
+		plys := newPlayers(playersFIFO, wsf)
+		go plys.run()
+		router.Path("/players").Methods("GET").Handler(plys)
+	}
+
 	if redisHost != "" {
 		var colors *common.Colors
 		var err error

cmd/mtwebmapper/players.go

@@ -0,0 +1,144 @@
+package main
+
+import (
+	"bufio"
+	"bytes"
+	"encoding/json"
+	"html/template"
+	"log"
+	"math"
+	"net/http"
+	"os"
+	"sort"
+	"sync"
+	"time"
+)
+
+const sleepInterval = time.Second * 5
+
+var geoJSONTmpl = template.Must(template.New("geojson").Parse(
+	`{ "type": "Feature",
+  "geometry": {
+    "type": "Point",
+    "coordinates": [{{.Z}}, {{.X}}]
+  },
+  "properties": {
+    "name": "{{.Name | html }}"
+  }
+}`))
+
+type player struct {
+	X    float64 `json:"x"`
+	Y    float64 `json:"y"`
+	Z    float64 `json:"z"`
+	Name string  `json:"name"`
+}
+
+type players struct {
+	fifo string
+	wsf  *websocketForwarder
+	pls  []*player
+	mu   sync.RWMutex
+}
+
+func newPlayers(fifo string, wsf *websocketForwarder) *players {
+	return &players{fifo: fifo, wsf: wsf, pls: []*player{}}
+}
+
+func (p *player) MarshalJSON() ([]byte, error) {
+	var buf bytes.Buffer
+	if err := geoJSONTmpl.Execute(&buf, p); err != nil {
+		return nil, err
+	}
+	return buf.Bytes(), nil
+}
+
+func (p *player) same(o *player) bool {
+	return p.Name == o.Name &&
+		math.Abs(p.X-o.X) < 0.000001 &&
+		math.Abs(p.Y-o.Y) < 0.000001 &&
+		math.Abs(p.Z-o.Z) < 0.000001
+}
+
+type sortPlayersByName []*player
+
+func (pls sortPlayersByName) Len() int {
+	return len(pls)
+}
+
+func (pls sortPlayersByName) Less(i, j int) bool {
+	return pls[i].Name < pls[j].Name
+}
+
+func (pls sortPlayersByName) Swap(i, j int) {
+	pls[i], pls[j] = pls[j], pls[i]
+}
+
+func (ps *players) readFromFIFO() ([]*player, error) {
+	file, err := os.Open(ps.fifo)
+	if err != nil {
+		return nil, err
+	}
+	defer file.Close()
+	reader := bufio.NewReader(file)
+	decoder := json.NewDecoder(reader)
+	var pls []*player
+
+	if err = decoder.Decode(&pls); err != nil {
+		return nil, err
+	}
+	return pls, nil
+}
+
+func samePlayers(a, b []*player) bool {
+	if len(a) != len(b) {
+		return false
+	}
+	for i, p := range a {
+		if !p.same(b[i]) {
+			return false
+		}
+	}
+	return true
+}
+
+func (ps *players) run() {
+	for {
+		pls, err := ps.readFromFIFO()
+		if err != nil {
+			//log.Printf("err: %s\n", err)
+			time.Sleep(sleepInterval)
+			continue
+		}
+		if pls == nil {
+			//log.Println("no players")
+			continue
+		}
+		//log.Printf("%+q\n", pls)
+		sort.Sort(sortPlayersByName(pls))
+		var change bool
+		ps.mu.Lock()
+		//log.Printf("%+q\n", pls)
+		//log.Printf("%+q\n", ps.pls)
+		if change = !samePlayers(pls, ps.pls); change {
+			ps.pls = pls
+		}
+		ps.mu.Unlock()
+		if change && ps.wsf != nil {
+			// TODO: Throttle this!
+			ps.wsf.BroadcastPlayers(pls)
+		}
+	}
+}
+
+func (ps *players) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
+	rw.Header().Set("Content-Type", "application/json")
+	var pls []*player
+	ps.mu.RLock()
+	pls = ps.pls
+	ps.mu.RUnlock()
+	encoder := json.NewEncoder(rw)
+	if err := encoder.Encode(pls); err != nil {
+		log.Printf("error: sending JSON failed: %s\n", err)
+	}
+}

cmd/mtwebmapper/web/css/leaflet.awesome-markers.css

@@ -0,0 +1,124 @@
+/*
+Author: L. Voogdt
+License: MIT
+Version: 1.0
+*/
+
+/* Marker setup */
+.awesome-marker {
+  background: url('images/markers-soft.png') no-repeat 0 0;
+  width: 35px;
+  height: 46px;
+  position:absolute;
+  left:0;
+  top:0;
+  display: block;
+  text-align: center;
+}
+
+.awesome-marker-shadow {
+  background: url('images/markers-shadow.png') no-repeat 0 0;
+  width: 36px;
+  height: 16px;
+}
+
+/* Retina displays */
+@media (min--moz-device-pixel-ratio: 1.5),(-o-min-device-pixel-ratio: 3/2),
+(-webkit-min-device-pixel-ratio: 1.5),(min-device-pixel-ratio: 1.5),(min-resolution: 1.5dppx) {
+ .awesome-marker {
+  background-image: url('images/markers-soft@2x.png');
+  background-size: 720px 46px;
+ }
+ .awesome-marker-shadow {
+  background-image: url('images/markers-shadow@2x.png');
+  background-size: 35px 16px;
+ }
+}
+
+.awesome-marker i {
+  color: #333;
+  margin-top: 10px;
+  display: inline-block;
+  font-size: 14px;
+}
+
+.awesome-marker .icon-white {
+  color: #fff;
+}
+
+/* Colors */
+.awesome-marker-icon-red {
+  background-position: 0 0;
+}
+
+.awesome-marker-icon-darkred {
+  background-position: -180px 0;
+}
+
+.awesome-marker-icon-lightred {
+  background-position: -360px 0;
+}
+
+.awesome-marker-icon-orange {
+  background-position: -36px 0;
+}
+
+.awesome-marker-icon-beige {
+  background-position: -396px 0;
+}
+
+.awesome-marker-icon-green {
+  background-position: -72px 0;
+}
+
+.awesome-marker-icon-darkgreen {
+  background-position: -252px 0;
+}
+
+.awesome-marker-icon-lightgreen {
+  background-position: -432px 0;
+}
+
+.awesome-marker-icon-blue {
+  background-position: -108px 0;
+}
+
+.awesome-marker-icon-darkblue {
+  background-position: -216px 0;
+}
+
+.awesome-marker-icon-lightblue {
+  background-position: -468px 0;
+}
+
+.awesome-marker-icon-purple {
+  background-position: -144px 0;
+}
+
+.awesome-marker-icon-darkpurple {
+  background-position: -288px 0;
+}
+
+.awesome-marker-icon-pink {
+  background-position: -504px 0;
+}
+
+.awesome-marker-icon-cadetblue {
+  background-position: -324px 0;
+}
+
+.awesome-marker-icon-white {
+  background-position: -574px 0;
+}
+
+.awesome-marker-icon-gray {
+  background-position: -648px 0;
+}
+
+.awesome-marker-icon-lightgray {
+  background-position: -612px 0;
+}
+
+.awesome-marker-icon-black {
+  background-position: -682px 0;
+}

cmd/mtwebmapper/web/index.html

@@ -6,6 +6,7 @@
     <link rel="stylesheet" href="css/leaflet.css" />
     <link rel="stylesheet" href="css/Leaflet.Coordinates-0.1.4.css" />
     <link rel="stylesheet" href="css/font-awesome.css" />
+    <link rel="stylesheet" href="css/leaflet.awesome-markers.css" />
     <style type="text/css">
         body {
             height: 100%;
@@ -30,6 +31,10 @@
             box-shadow: 0 1px 3px rgba(0,0,0,0.3);
             background-color:rgba(255,255,255,.85);
         }
+        .awesome-marker i {
+            font-size: 18px;
+            margin-left: -1px;
+        }
     </style>
 </head>
 <body>
@@ -39,6 +44,8 @@
     <script src="js/easy-button.js"></script>
     <script src="js/auto-update.js"></script>
     <script type="text/javascript" src="js/leaflet-hash.js"></script>
+    <script type="text/javascript" src="js/leaflet.ajax.js"></script>
+    <script type="text/javascript" src="js/leaflet.awesome-markers.js"></script>
     <script>
 
 var useWebsocket = false; // Set to true if you want websocket support
@@ -69,13 +76,26 @@ var world = new L.tileLayer('map/{z}/{x}/{y}.png', {
     unloadInvisibleTiles: true
 });
 
+var players = L.geoJson.ajax('/players', {
+    pointToLayer: function(feature, latlng) {
+        return L.marker(latlng, {
+            icon: L.AwesomeMarkers.icon({
+                icon: 'male',
+                iconColor: 'black',
+                prefix: 'fa',
+                markerColor: 'orange'
+            }),
+            title: feature.properties.name
+        })
+    }
+});
 var rasterMaps = {
     "A demo world": world,
 };
 
 var latest = world
 
-var overlayMaps = {};
+var overlayMaps = {'Players': players};
 
 var map = L.map('map', {
     center: [0,0],
@@ -98,13 +118,10 @@ L.control.coordinates({
 var manualUpdateControl;
 if (useWebsocket && 'WebSocket' in window) {
     L.autoUpdate('autoUpdate', function(pressed) {
-        if (pressed) {
-            manualUpdateControl.getContainer().style = 'visibility: hidden';
-        }
-        else {
-            manualUpdateControl.getContainer().style = 'visibility: visible';
-        }
-    });
+        var styleDec = manualUpdateControl.getContainer().style;
+        styleDec.visibility = pressed ? 'hidden' : 'visible';
+    },
+    players);
 }
 var layersControl = new L.Control.Layers(rasterMaps, overlayMaps, {collapsed: false});
 map.addControl(layersControl);
@@ -115,7 +132,7 @@ manualUpdateControl = L.easyButton('fa-refresh',
         for (var i = 0; i < tiles.length; i++) {
             var img = tiles[i];
             var cl = img.getAttribute("class");
-            if (cl.contains("leaflet-tile-loaded")) {
+            if (cl.indexOf("leaflet-tile-loaded") >= 0) {
                 var src = img.src;
                 var idx = src.lastIndexOf("#");
                 if (idx >= 0) {
@@ -125,6 +142,7 @@ manualUpdateControl = L.easyButton('fa-refresh',
             }
         }
         //map._resetView(map.getCenter(), map.getZoom(), false);
+        players.refresh("/players");
     },
     'Update view'
 );

cmd/mtwebmapper/web/js/auto-update.js

@@ -1,7 +1,8 @@
 L.Control.AutoUpdate = L.Control.extend({
     options: {
         position: 'topleft',
-        label: 'Automatic update'
+        label: 'Automatic update',
+        layer: undefined
     },
     pressed: true,
 
@@ -14,9 +15,7 @@ L.Control.AutoUpdate = L.Control.extend({
         return container;
     },
 
-    cbClick: function (e) {
-        L.DomEvent.stopPropagation(e);
-        this.intendedFunction(this.pressed);
+    switchButtons: function() {
         if (this.pressed) {
             this.pressed = false;
             this.iconStart.setAttribute('class', 'fa fa-pause');
@@ -28,38 +27,84 @@ L.Control.AutoUpdate = L.Control.extend({
         }
     },
 
+    cbClick: function (e) {
+        L.DomEvent.stopPropagation(e);
+        this.intendedFunction(this.pressed);
+        this.switchButtons();
+    },
+
     intendedFunction: function() {
         alert('no function selected');
     },
 
     stopUpdate: function() {
-        this.socket.close();
+        if (this.socket) {
+            var s = this.socket;
+            this.socket = null;
+            s.close();
+        }
     },
 
     autoUpdate: function() {
+        var me = this;
         this.socket = new WebSocket('ws://' + window.location.host + '/ws');
 
+        this.socket.onerror = function(evt) {
+            me.stopUpdate();
+            me.switchButtons();
+        };
+
+        this.socket.onclose = function(evt) {
+            this.socket = null;
+        }
+
+        this.socket.onopen = function(evt) {
+            // Sending pings every 5 secs to keep connection alive.
+            var heartbeat = function() {
+                if (heartbeat && me.socket) {
+                    me.socket.send("PING");
+                    setTimeout(heartbeat, 8000);
+                } else {
+                    // Prevent sending pings to re-opened sockets.
+                    heartbeat = null;
+                }
+            };
+            setTimeout(heartbeat, 8000);
+        };
+
         this.socket.onmessage = function(evt) {
 
-            var invalidate = function(json) {
-                var invalidateAll = function(x, y, z) { return true; };
+            var json = evt.data;
+            if (!(typeof json === "string")) {
+                return;
+            }
 
-                if (!(typeof json === "string")) {
-                    return invalidateAll;
-                }
-                var tiles;
-                try {
-                    tiles = JSON.parse(json);
-                } catch (err) {
-                    return invalidateAll;
-                }
+            var msg;
+            try {
+                msg = JSON.parse(json);
+            }
+            catch (err) {
+                return;
+            }
+
+            if (msg.players) {
+                me.options.layer.clearLayers();
+                me.options.layer.addData(msg.players);
+            }
+
+            var tilesData = msg.tiles;
+            if (!tilesData) {
+                return;
+            }
+
+            var invalidate = function(td) {
 
                 var pyramid = new Array(9);
                 var last = new Object();
                 pyramid[8] = last;
 
-                for (var i = 0; i < tiles.length; i++) {
-                    var xz = tiles[i];
+                for (var i = 0; i < td.length; i++) {
+                    var xz = td[i];
                     last[xz.X + "#" + xz.Z] = xz;
                 }
                 for (var p = 7; p >= 0; p--) {
@@ -84,14 +129,15 @@ L.Control.AutoUpdate = L.Control.extend({
                     var k = x + "#" + z;
                     return level.hasOwnProperty(k);
                 };
-            } (evt.data);
+            } (tilesData);
+
 
             var tiles = document.getElementsByTagName('img');
             var re = /\/map\/([0-9]+)\/([0-9]+)\/([0-9]+).*/;
             for (var i = 0; i < tiles.length; i++) {
                 var img = tiles[i];
                 var cl = img.getAttribute('class');
-                if (!cl.contains('leaflet-tile-loaded')) {
+                if (cl.indexOf('leaflet-tile-loaded') < 0) {
                     continue;
                 }
                 var src = img.src;
@@ -114,7 +160,7 @@ L.Control.AutoUpdate = L.Control.extend({
     }
 });
 
-L.autoUpdate = function(cbLabel, cbFunc, cbMap) {
+L.autoUpdate = function(cbLabel, cbFunc, layer, cbMap) {
     var control = new L.Control.AutoUpdate();
     if (cbLabel) {
         control.options.label = cbLabel;
@@ -124,6 +170,10 @@ L.autoUpdate = function(cbLabel, cbFunc, cbMap) {
         control.intendedFunction = cbFunc;
     }
 
+    if (layer) {
+        control.options.layer = layer;
+    }
+
     if (cbMap === '') {
         return control;
     }

cmd/mtwebmapper/web/js/leaflet.ajax.js

@@ -0,0 +1,740 @@
+;(function(){
+
+/**
+ * Require the given path.
+ *
+ * @param {String} path
+ * @return {Object} exports
+ * @api public
+ */
+
+function require(path, parent, orig) {
+  var resolved = require.resolve(path);
+
+  // lookup failed
+  if (null == resolved) {
+    orig = orig || path;
+    parent = parent || 'root';
+    var err = new Error('Failed to require "' + orig + '" from "' + parent + '"');
+    err.path = orig;
+    err.parent = parent;
+    err.require = true;
+    throw err;
+  }
+
+  var module = require.modules[resolved];
+
+  // perform real require()
+  // by invoking the module's
+  // registered function
+  if (!module.exports) {
+    module.exports = {};
+    module.client = module.component = true;
+    module.call(this, module.exports, require.relative(resolved), module);
+  }
+
+  return module.exports;
+}
+
+/**
+ * Registered modules.
+ */
+
+require.modules = {};
+
+/**
+ * Registered aliases.
+ */
+
+require.aliases = {};
+
+/**
+ * Resolve `path`.
+ *
+ * Lookup:
+ *
+ *   - PATH/index.js
+ *   - PATH.js
+ *   - PATH
+ *
+ * @param {String} path
+ * @return {String} path or null
+ * @api private
+ */
+
+require.resolve = function(path) {
+  if (path.charAt(0) === '/') path = path.slice(1);
+
+  var paths = [
+    path,
+    path + '.js',
+    path + '.json',
+    path + '/index.js',
+    path + '/index.json'
+  ];
+
+  for (var i = 0; i < paths.length; i++) {
+    var path = paths[i];
+    if (require.modules.hasOwnProperty(path)) return path;
+    if (require.aliases.hasOwnProperty(path)) return require.aliases[path];
+  }
+};
+
+/**
+ * Normalize `path` relative to the current path.
+ *
+ * @param {String} curr
+ * @param {String} path
+ * @return {String}
+ * @api private
+ */
+
+require.normalize = function(curr, path) {
+  var segs = [];
+
+  if ('.' != path.charAt(0)) return path;
+
+  curr = curr.split('/');
+  path = path.split('/');
+
+  for (var i = 0; i < path.length; ++i) {
+    if ('..' == path[i]) {
+      curr.pop();
+    } else if ('.' != path[i] && '' != path[i]) {
+      segs.push(path[i]);
+    }
+  }
+
+  return curr.concat(segs).join('/');
+};
+
+/**
+ * Register module at `path` with callback `definition`.
+ *
+ * @param {String} path
+ * @param {Function} definition
+ * @api private
+ */
+
+require.register = function(path, definition) {
+  require.modules[path] = definition;
+};
+
+/**
+ * Alias a module definition.
+ *
+ * @param {String} from
+ * @param {String} to
+ * @api private
+ */
+
+require.alias = function(from, to) {
+  if (!require.modules.hasOwnProperty(from)) {
+    throw new Error('Failed to alias "' + from + '", it does not exist');
+  }
+  require.aliases[to] = from;
+};
+
+/**
+ * Return a require function relative to the `parent` path.
+ *
+ * @param {String} parent
+ * @return {Function}
+ * @api private
+ */
+
+require.relative = function(parent) {
+  var p = require.normalize(parent, '..');
+
+  /**
+   * lastIndexOf helper.
+   */
+
+  function lastIndexOf(arr, obj) {
+    var i = arr.length;
+    while (i--) {
+      if (arr[i] === obj) return i;
+    }
+    return -1;
+  }
+
+  /**
+   * The relative require() itself.
+   */
+
+  function localRequire(path) {
+    var resolved = localRequire.resolve(path);
+    return require(resolved, parent, path);
+  }
+
+  /**
+   * Resolve relative to the parent.
+   */
+
+  localRequire.resolve = function(path) {
+    var c = path.charAt(0);
+    if ('/' == c) return path.slice(1);
+    if ('.' == c) return require.normalize(p, path);
+
+    // resolve deps by returning
+    // the dep in the nearest "deps"
+    // directory
+    var segs = parent.split('/');
+    var i = lastIndexOf(segs, 'deps') + 1;
+    if (!i) i = 0;
+    path = segs.slice(0, i + 1).join('/') + '/deps/' + path;
+    return path;
+  };
+
+  /**
+   * Check if module is defined at `path`.
+   */
+
+  localRequire.exists = function(path) {
+    return require.modules.hasOwnProperty(localRequire.resolve(path));
+  };
+
+  return localRequire;
+};
+require.register("calvinmetcalf-setImmediate/lib/index.js", function(exports, require, module){
+"use strict";
+var types = [
+    require("./nextTick"),
+    require("./mutation"),
+    require("./postMessage"),
+    require("./messageChannel"),
+    require("./stateChange"),
+    require("./timeout")
+];
+var handlerQueue = [];
+
+function drainQueue() {
+    var i = 0,
+        task,
+        innerQueue = handlerQueue;
+	handlerQueue = [];
+	/*jslint boss: true */
+	while (task = innerQueue[i++]) {
+		task();
+	}
+}
+var nextTick;
+types.some(function (obj) {
+    var t = obj.test();
+    if (t) {
+        nextTick = obj.install(drainQueue);
+    }
+    return t;
+});
+var retFunc = function (task) {
+    var len, args;
+    if (arguments.length > 1 && typeof task === "function") {
+        args = Array.prototype.slice.call(arguments, 1);
+        args.unshift(undefined);
+        task = task.bind.apply(task, args);
+    }
+    if ((len = handlerQueue.push(task)) === 1) {
+        nextTick(drainQueue);
+    }
+    return len;
+};
+retFunc.clear = function (n) {
+    if (n <= handlerQueue.length) {
+        handlerQueue[n - 1] = function () {};
+    }
+    return this;
+};
+module.exports = retFunc;
+
+});
+require.register("calvinmetcalf-setImmediate/lib/nextTick.js", function(exports, require, module){
+"use strict";
+exports.test = function () {
+    // Don't get fooled by e.g. browserify environments.
+    return typeof process === "object" && Object.prototype.toString.call(process) === "[object process]";
+};
+
+exports.install = function () {
+    return process.nextTick;
+};
+});
+require.register("calvinmetcalf-setImmediate/lib/postMessage.js", function(exports, require, module){
+"use strict";
+var globe = require("./global");
+exports.test = function () {
+    // The test against `importScripts` prevents this implementation from being installed inside a web worker,
+    // where `global.postMessage` means something completely different and can"t be used for this purpose.
+
+    if (!globe.postMessage || globe.importScripts) {
+        return false;
+    }
+
+    var postMessageIsAsynchronous = true;
+    var oldOnMessage = globe.onmessage;
+    globe.onmessage = function () {
+        postMessageIsAsynchronous = false;
+    };
+    globe.postMessage("", "*");
+    globe.onmessage = oldOnMessage;
+
+    return postMessageIsAsynchronous;
+};
+
+exports.install = function (func) {
+    var codeWord = "com.calvinmetcalf.setImmediate" + Math.random();
+    function globalMessage(event) {
+        if (event.source === globe && event.data === codeWord) {
+            func();
+        }
+    }
+    if (globe.addEventListener) {
+        globe.addEventListener("message", globalMessage, false);
+    } else {
+        globe.attachEvent("onmessage", globalMessage);
+    }
+    return function () {
+        globe.postMessage(codeWord, "*");
+    };
+};
+});
+require.register("calvinmetcalf-setImmediate/lib/messageChannel.js", function(exports, require, module){
+"use strict";
+var globe = require("./global");
+exports.test = function () {
+    return !!globe.MessageChannel;
+};
+
+exports.install = function (func) {
+    var channel = new globe.MessageChannel();
+    channel.port1.onmessage = func;
+    return function () {
+        channel.port2.postMessage(0);
+    };
+};
+});
+require.register("calvinmetcalf-setImmediate/lib/stateChange.js", function(exports, require, module){
+"use strict";
+var globe = require("./global");
+exports.test = function () {
+    return "document" in globe && "onreadystatechange" in globe.document.createElement("script");
+};
+
+exports.install = function (handle) {
+    return function () {
+
+        // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted
+        // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.
+        var scriptEl = globe.document.createElement("script");
+        scriptEl.onreadystatechange = function () {
+            handle();
+
+            scriptEl.onreadystatechange = null;
+            scriptEl.parentNode.removeChild(scriptEl);
+            scriptEl = null;
+        };
+        globe.document.documentElement.appendChild(scriptEl);
+
+        return handle;
+    };
+};
+});
+require.register("calvinmetcalf-setImmediate/lib/timeout.js", function(exports, require, module){
+"use strict";
+exports.test = function () {
+    return true;
+};
+
+exports.install = function (t) {
+    return function () {
+        setTimeout(t, 0);
+    };
+};
+});
+require.register("calvinmetcalf-setImmediate/lib/global.js", function(exports, require, module){
+module.exports = typeof global === "object" && global ? global : this;
+});
+require.register("calvinmetcalf-setImmediate/lib/mutation.js", function(exports, require, module){
+"use strict";
+//based off rsvp
+//https://github.com/tildeio/rsvp.js/blob/master/lib/rsvp/async.js
+var globe = require("./global");
+
+var MutationObserver = globe.MutationObserver || globe.WebKitMutationObserver;
+
+exports.test = function () {
+    return MutationObserver;
+};
+
+exports.install = function (handle) {
+    var observer = new MutationObserver(handle);
+    var element = globe.document.createElement("div");
+    observer.observe(element, { attributes: true });
+
+    // Chrome Memory Leak: https://bugs.webkit.org/show_bug.cgi?id=93661
+    globe.addEventListener("unload", function () {
+        observer.disconnect();
+        observer = null;
+    }, false);
+    return function () {
+        element.setAttribute("drainQueue", "drainQueue");
+    };
+};
+});
+require.register("lie/lie.js", function(exports, require, module){
+var immediate = require('immediate');
+// Creates a deferred: an object with a promise and corresponding resolve/reject methods
+function Promise(resolver) {
+     if (!(this instanceof Promise)) {
+        return new Promise(resolver);
+    }
+    var queue = [];
+    var resolved = false;
+    // The `handler` variable points to the function that will
+    // 1) handle a .then(onFulfilled, onRejected) call
+    // 2) handle a .resolve or .reject call (if not fulfilled)
+    // Before 2), `handler` holds a queue of callbacks.
+    // After 2), `handler` is a simple .then handler.
+    // We use only one function to save memory and complexity.
+     // Case 1) handle a .then(onFulfilled, onRejected) call
+    function pending(onFulfilled, onRejected){
+        return Promise(function(resolver,rejecter){
+            queue.push({
+                resolve: onFulfilled,
+                reject: onRejected,
+                resolver:resolver,
+                rejecter:rejecter
+            });
+        });
+    }
+    function then(onFulfilled, onRejected) {
+        return resolved?resolved(onFulfilled, onRejected):pending(onFulfilled, onRejected);
+    }
+    // Case 2) handle a .resolve or .reject call
+        // (`onFulfilled` acts as a sentinel)
+        // The actual function signature is
+        // .re[ject|solve](sentinel, success, value)
+    function resolve(success, value){
+        var action = success ? 'resolve' : 'reject';
+        var queued;
+        var callback;
+        for (var i = 0, l = queue.length; i < l; i++) {
+            queued = queue[i];
+            callback = queued[action];
+            if (typeof callback === 'function') {
+                immediate(execute,callback, value, queued.resolver, queued.rejecter);
+            }else if(success){
+                queued.resolver(value);
+            }else{
+                queued.rejecter(value);
+            }
+        }
+        // Replace this handler with a simple resolved or rejected handler
+        resolved = createHandler(then, value, success);
+    }
+    this.then = then;
+    function yes(value) {
+        if (!resolved) {
+            resolve(true, value);
+        }
+    }
+    function no (reason) {
+        if (!resolved) {
+            resolve(false, reason);
+        }
+    }
+    try{
+        resolver(function(a){
+            if(a && typeof a.then==='function'){
+                a.then(yes,no);
+            }else{
+                yes(a);
+            }
+        },no);
+    }catch(e){
+        no(e);
+    }
+}
+
+// Creates a fulfilled or rejected .then function
+function createHandler(then, value, success) {
+    return function(onFulfilled, onRejected) {
+        var callback = success ? onFulfilled : onRejected;
+        if (typeof callback !== 'function') {
+            return Promise(function(resolve,reject){
+                then(resolve,reject);
+            });
+        }
+        return Promise(function(resolve,reject){
+            immediate(execute,callback,value,resolve,reject);
+       });
+    };
+}
+
+// Executes the callback with the specified value,
+// resolving or rejecting the deferred
+function execute(callback, value, resolve, reject) {
+        try {
+            var result = callback(value);
+            if (result && typeof result.then === 'function') {
+                result.then(resolve, reject);
+            }
+            else {
+                resolve(result);
+            }
+        }
+        catch (error) {
+            reject(error);
+        }
+}
+module.exports = Promise;
+
+});
+require.alias("calvinmetcalf-setImmediate/lib/index.js", "lie/deps/immediate/lib/index.js");
+require.alias("calvinmetcalf-setImmediate/lib/nextTick.js", "lie/deps/immediate/lib/nextTick.js");
+require.alias("calvinmetcalf-setImmediate/lib/postMessage.js", "lie/deps/immediate/lib/postMessage.js");
+require.alias("calvinmetcalf-setImmediate/lib/messageChannel.js", "lie/deps/immediate/lib/messageChannel.js");
+require.alias("calvinmetcalf-setImmediate/lib/stateChange.js", "lie/deps/immediate/lib/stateChange.js");
+require.alias("calvinmetcalf-setImmediate/lib/timeout.js", "lie/deps/immediate/lib/timeout.js");
+require.alias("calvinmetcalf-setImmediate/lib/global.js", "lie/deps/immediate/lib/global.js");
+require.alias("calvinmetcalf-setImmediate/lib/mutation.js", "lie/deps/immediate/lib/mutation.js");
+require.alias("calvinmetcalf-setImmediate/lib/index.js", "lie/deps/immediate/index.js");
+require.alias("calvinmetcalf-setImmediate/lib/index.js", "immediate/index.js");
+require.alias("calvinmetcalf-setImmediate/lib/index.js", "calvinmetcalf-setImmediate/index.js");
+
+require.alias("lie/lie.js", "lie/index.js");
+
+L.Util.Promise = require("lie");
+})();
+
+L.Util.ajax = function(url, options) {
+	'use strict';
+	options = options || {};
+	if (options.jsonp) {
+		return L.Util.ajax.jsonp(url, options);
+	}
+	var request;
+	var cancel;
+	var out = L.Util.Promise(function(resolve,reject){
+		var Ajax;
+		cancel=reject;
+		// the following is from JavaScript: The Definitive Guide
+		if (window.XMLHttpRequest === undefined) {
+			Ajax = function() {
+				try {
+					return new ActiveXObject('Microsoft.XMLHTTP.6.0');
+				}
+				catch (e1) {
+					try {
+						return new ActiveXObject('Microsoft.XMLHTTP.3.0');
+					}
+					catch (e2) {
+						reject('XMLHttpRequest is not supported');
+					}
+				}
+			};
+		}
+		else {
+			Ajax = window.XMLHttpRequest;
+		}
+		var response;
+		request = new Ajax();
+		request.open('GET', url);
+		request.onreadystatechange = function() {
+			/*jslint evil: true */
+			if (request.readyState === 4) {
+				if((request.status < 400&&options.local)|| request.status===200) {
+					if (window.JSON) {
+						response = JSON.parse(request.responseText);
+					} else if (options.evil) {
+						response = eval('(' + request.responseText + ')');
+					}
+					resolve(response);
+				} else {
+					if(!request.status){
+						reject('Attempted cross origin request without CORS enabled');
+					}else{
+						reject(request.statusText);
+					}
+				}
+			}
+		};
+		request.send();
+	});
+	out.then(null,function(reason){
+		request.abort();
+		return reason;
+	});
+	out.abort = cancel;
+	return out;
+};
+
+L.Util.jsonp = function(url, options) {
+	options = options || {};
+	var head = document.getElementsByTagName('head')[0];
+	var scriptNode = L.DomUtil.create('script', '', head);
+	var cbName, ourl, cbSuffix, cancel;
+	var out = L.Util.Promise(function(resolve, reject){
+		cancel=reject;
+		var cbParam = options.cbParam || 'callback';
+		if (options.callbackName) {
+			cbName = options.callbackName;
+		}
+		else {
+			cbSuffix = '_' + ('' + Math.random()).slice(2);
+			cbName = 'L.Util.jsonp.cb.' + cbSuffix;
+		}
+		scriptNode.type = 'text/javascript';
+		if (cbSuffix) {
+			L.Util.jsonp.cb[cbSuffix] = function(data) {
+				head.removeChild(scriptNode);
+				delete L.Util.jsonp.cb[cbSuffix];
+				resolve(data);
+			};
+		}
+		if (url.indexOf('?') === -1) {
+			ourl = url + '?' + cbParam + '=' + cbName;
+		}
+		else {
+			ourl = url + '&' + cbParam + '=' + cbName;
+		}
+		scriptNode.src = ourl;
+	}).then(null,function(reason){
+	    head.removeChild(scriptNode);
+		delete L.Util.ajax.cb[cbSuffix];
+		return reason;
+	});
+	out.abort = cancel;
+	return out;
+};
+L.Util.jsonp.cb = {};
+
+L.GeoJSON.AJAX = L.GeoJSON.extend({
+	defaultAJAXparams: {
+		dataType: 'json',
+		callbackParam: 'callback',
+		local:false,
+		middleware: function(f) {
+			return f;
+		}
+	},
+	initialize: function(url, options) {
+
+		this.urls = [];
+		if (url) {
+			if (typeof url === 'string') {
+				this.urls.push(url);
+			}
+			else if (typeof url.pop === 'function') {
+				this.urls = this.urls.concat(url);
+			}
+			else {
+				options = url;
+				url = undefined;
+			}
+		}
+		var ajaxParams = L.Util.extend({}, this.defaultAJAXparams);
+
+		for (var i in options) {
+			if (this.defaultAJAXparams.hasOwnProperty(i)) {
+				ajaxParams[i] = options[i];
+			}
+		}
+		this.ajaxParams = ajaxParams;
+		this._layers = {};
+		L.Util.setOptions(this, options);
+		this.on('data:loaded', function() {
+			if (this.filter) {
+				this.refilter(this.filter);
+			}
+		}, this);
+		var self = this;
+		if (this.urls.length > 0) {
+			L.Util.Promise(function(yes){
+			    yes();
+			}).then(function(){
+			    self.addUrl();
+		    });
+		}
+	},
+	clearLayers: function() {
+		this.urls = [];
+		L.GeoJSON.prototype.clearLayers.call(this);
+		return this;
+	},
+	addUrl: function(url) {
+		var self = this;
+		if (url) {
+			if (typeof url === 'string') {
+				self.urls.push(url);
+			}
+			else if (typeof url.pop === 'function') {
+				self.urls = self.urls.concat(url);
+			}
+		}
+		var loading = self.urls.length;
+		var done = 0;
+		self.fire('data:loading');
+		self.urls.forEach(function(url) {
+			if (self.ajaxParams.dataType.toLowerCase() === 'json') {
+				L.Util.ajax(url,self.ajaxParams).then(function(d) {
+					var data = self.ajaxParams.middleware(d);
+					self.addData(data);
+					self.fire('data:progress',data);
+				},function(err){
+					self.fire('data:progress',{error:err});
+				});
+			}
+			else if (self.ajaxParams.dataType.toLowerCase() === 'jsonp') {
+				L.Util.jsonp(url,self.ajaxParams).then(function(d) {
+					var data = self.ajaxParams.middleware(d);
+					self.addData(data);
+					self.fire('data:progress',data);
+				},function(err){
+					self.fire('data:progress',{error:err});
+				});
+			}
+		});
+		self.on('data:progress', function() {
+			if (++done === loading) {
+				self.fire('data:loaded');
+			}
+		});
+	},
+	refresh: function(url) {
+		url = url || this.urls;
+		this.clearLayers();
+		this.addUrl(url);
+	},
+	refilter: function(func) {
+		if (typeof func !== 'function') {
+			this.filter = false;
+			this.eachLayer(function(a) {
+				a.setStyle({
+					stroke: true,
+					clickable: true
+				});
+			});
+		}
+		else {
+			this.filter = func;
+			this.eachLayer(function(a) {
+
+				if (func(a.feature)) {
+					a.setStyle({
+						stroke: true,
+						clickable: true
+					});
+				}
+				else {
+					a.setStyle({
+						stroke: false,
+						clickable: false
+					});
+				}
+			});
+		}
+	}
+});
+L.geoJson.ajax = function(geojson, options) {
+	return new L.GeoJSON.AJAX(geojson, options);
+};

cmd/mtwebmapper/web/js/leaflet.awesome-markers.js

@@ -0,0 +1,125 @@
+/*
+  Leaflet.AwesomeMarkers, a plugin that adds colorful iconic markers for Leaflet, based on the Font Awesome icons
+  (c) 2012-2013, Lennard Voogdt
+
+  http://leafletjs.com
+  https://github.com/lvoogdt
+*/
+
+/*global L*/
+
+(function (window, document, undefined) {
+    "use strict";
+    /*
+     * Leaflet.AwesomeMarkers assumes that you have already included the Leaflet library.
+     */
+
+    L.AwesomeMarkers = {};
+
+    L.AwesomeMarkers.version = '2.0.1';
+
+    L.AwesomeMarkers.Icon = L.Icon.extend({
+        options: {
+            iconSize: [35, 45],
+            iconAnchor:   [17, 42],
+            popupAnchor: [1, -32],
+            shadowAnchor: [10, 12],
+            shadowSize: [36, 16],
+            className: 'awesome-marker',
+            prefix: 'glyphicon',
+            spinClass: 'fa-spin',
+            extraClasses: '',
+            icon: 'home',
+            markerColor: 'blue',
+            iconColor: 'white'
+        },
+
+        initialize: function (options) {
+            options = L.Util.setOptions(this, options);
+        },
+
+        createIcon: function () {
+            var div = document.createElement('div'),
+                options = this.options;
+
+            if (options.icon) {
+                div.innerHTML = this._createInner();
+            }
+
+            if (options.bgPos) {
+                div.style.backgroundPosition =
+                    (-options.bgPos.x) + 'px ' + (-options.bgPos.y) + 'px';
+            }
+
+            this._setIconStyles(div, 'icon-' + options.markerColor);
+            return div;
+        },
+
+        _createInner: function() {
+            var iconClass, iconSpinClass = "", iconColorClass = "", iconColorStyle = "", options = this.options;
+
+            if(options.icon.slice(0,options.prefix.length+1) === options.prefix + "-") {
+                iconClass = options.icon;
+            } else {
+                iconClass = options.prefix + "-" + options.icon;
+            }
+
+            if(options.spin && typeof options.spinClass === "string") {
+                iconSpinClass = options.spinClass;
+            }
+
+            if(options.iconColor) {
+                if(options.iconColor === 'white' || options.iconColor === 'black') {
+                    iconColorClass = "icon-" + options.iconColor;
+                } else {
+                    iconColorStyle = "style='color: " + options.iconColor + "' ";
+                }
+            }
+
+            return "<i " + iconColorStyle + "class='" + options.extraClasses + " " + options.prefix + " " + iconClass + " " + iconSpinClass + " " + iconColorClass + "'></i>";
+        },
+
+        _setIconStyles: function (img, name) {
+            var options = this.options,
+                size = L.point(options[name === 'shadow' ? 'shadowSize' : 'iconSize']),
+                anchor;
+
+            if (name === 'shadow') {
+                anchor = L.point(options.shadowAnchor || options.iconAnchor);
+            } else {
+                anchor = L.point(options.iconAnchor);
+            }
+
+            if (!anchor && size) {
+                anchor = size.divideBy(2, true);
+            }
+
+            img.className = 'awesome-marker-' + name + ' ' + options.className;
+
+            if (anchor) {
+                img.style.marginLeft = (-anchor.x) + 'px';
+                img.style.marginTop  = (-anchor.y) + 'px';
+            }
+
+            if (size) {
+                img.style.width  = size.x + 'px';
+                img.style.height = size.y + 'px';
+            }
+        },
+
+        createShadow: function () {
+            var div = document.createElement('div');
+
+            this._setIconStyles(div, 'shadow');
+            return div;
+      }
+    });
+        
+    L.AwesomeMarkers.icon = function (options) {
+        return new L.AwesomeMarkers.Icon(options);
+    };
+
+}(this, document));
+
+
+

mods/track_players/init.lua

@@ -0,0 +1,32 @@
+local time_interval = 1.0
+local fifo_path = "/tmp/mt_players_fifo"
+
+function players_data()
+    local ps = {}
+    for _, player in ipairs(minetest.get_connected_players()) do
+        local pos = player:getpos()
+        local pname = player:get_player_name()
+        local data = {
+            name = pname,
+            x = pos.x,
+            y = pos.y,
+            z = pos.z }
+        table.insert(ps, data)
+    end
+    if table.getn(ps) == 0 then
+        return '[]\n'
+    end
+    return minetest.write_json(ps) .. '\n'
+end
+
+function time_interval_func()
+    local players = players_data()
+    local fifo = io.open(fifo_path, 'w')
+    if (fifo ~= nil) then
+        fifo:write(players)
+        fifo:close()
+    end
+    minetest.after(time_interval, time_interval_func)
+end
+
+minetest.after(time_interval, time_interval_func)