work-in-progress - checking in while looking at other code on master. may be broken

code/debugging.js

@@ -5,9 +5,9 @@
 window.debug = function() {}
 
 window.debug.renderDetails = function() {
-  console.log('portals: ' + window.portalsCount);
+  console.log('portals: ' + Object.keys(window.portals).length);
-  console.log('links:   ' + window.linksCount);
+  console.log('links:   ' + Object.keys(window.links).length);
-  console.log('fields:  ' + window.fieldsCount);
+  console.log('fields:  ' + Object.keys(window.fields).length);
 }
 
 window.debug.printStackTrace = function() {

code/hooks.js

@@ -41,16 +41,6 @@
 //              array [GUID, time, details]. Plugin can manipulate the
 //              array to change order or add additional values to the
 //              details of a portal.
-// beforePortalReRender: the callback argument is
-//              {portal: ent[2], oldPortal : d, portalGuid: ent[0], reRender : false}.
-//              The callback needs to update the value of reRender to
-//              true if the plugin has a reason to have the portal
-//              redrawn. It is called early on in the
-//              code/map_data.js#renderPortal as long as there was an
-//              old portal for the guid.
-// checkRenderLimit: callback is passed the argument of
-//              {reached : false} to indicate that the renderlimit is reached
-//              set reached to true.
 // requestFinished: called after each request finished. Argument is
 //              {success: boolean} indicated the request success or fail.
 // iitcLoaded: called after IITC and all plugins loaded
@@ -59,7 +49,7 @@
 window._hooks = {}
 window.VALID_HOOKS = ['portalAdded', 'portalDetailsUpdated',
   'publicChatDataAvailable', 'factionChatDataAvailable', 'portalDataLoaded',
-  'beforePortalReRender', 'checkRenderLimit', 'requestFinished', 'nicknameClicked',
+  'requestFinished', 'nicknameClicked',
   'geoSearch', 'iitcLoaded'];
 
 window.runHooks = function(event, data) {

code/map_data.js

@@ -147,9 +147,6 @@ window.requestData = function() {
     }
   }
 
-  // Reset previous result of Portal Render Limit handler
-  portalRenderLimit.init();
-
 
   // send ajax requests
   console.log('requesting '+requestTileCount+' tiles in '+Object.keys(tiles).length+' requests');

code/portal_marker.js

@@ -0,0 +1,26 @@
+// PORTAL MARKER //////////////////////////////////////////////
+// code to create and update a portal marker
+
+// sequence of calls:
+// 1. var marker = createMarker();
+// 2. // IITC (elsewhere) sets up options.details, options.guid, etc
+// 3. // IITC (elsewhere) calls marker.setLatLng()
+// 3. setMarkerStyle(selected);
+
+
+// create a blank marker. no data specified at this point
+window.createMarker = function() {
+  return new L.CircleMarker();
+}
+
+
+window.setMarkerStyle = function(selected) {
+
+  var options = {
+  };
+
+  // call highlighter
+
+
+
+}

code/portal_render_limit.js

@@ -1,178 +0,0 @@
-
-// PORTAL RENDER LIMIT HANDLER ///////////////////////////////////////
-// Functions to handle hiding low level portal when portal render 
-// limit is reached. 
-//
-// On initialization, previous minLevel will preserve to previousMinLevel
-// and modify with zoom level difference. 
-//
-// After initialized and reset in window.requestData(), "processPortals" 
-// intercept all portals data in "handleDataResponse". Put the count of 
-// new portals to newPortalsPerLevel[portal level]. Portals with level >= 
-// previousMinLevel and already on map will return as result and continue 
-// to render. Others will save to portalsLowerThanPrevMinLv. If there is 
-// no more active request of map data, portalsLowerThanPrevMinLv will add 
-// back to result and render base on current minLevel. 
-//
-// "window.handleFailRequest" is added to handle the case when the last request 
-// failed and "processPortals" didn't get called. It will get
-// portalsLowerThanPrevMinLv base on current minLevel and render them.
-//
-// "getMinLevel" will be called by "getMinPortalLevel" in utils_misc.js 
-// to determine min portal level to draw on map.
-// 
-// "getMinLevel" will return minLevel and call "setMinLevel" if 
-// minLevel hasn't set yet. 
-// 
-// In "setMinLevel", it will loop through all portal level from 
-// high to low, and sum total portal count (old + new) to check 
-// minLevel. 
-//
-// minLevel is preserved and only replaced when render limit reached in 
-// higher level, until next window.requestData() called and reset.
-// 
-
-window.portalRenderLimit = function() {}
-
-window.portalRenderLimit.initialized = false;
-window.portalRenderLimit.minLevelSet = false;
-window.portalRenderLimit.minLevel = -1;
-window.portalRenderLimit.previousMinLevel = -1;
-window.portalRenderLimit.previousZoomLevel = null;
-window.portalRenderLimit.newPortalsPerLevel = new Array(MAX_PORTAL_LEVEL + 1);
-window.portalRenderLimit.portalsLowerThanPrevMinLv = new Array(MAX_PORTAL_LEVEL + 1);
-window.portalRenderLimit.portalsLowerThanPrevMinLvCnt = new Array(MAX_PORTAL_LEVEL + 1);
-
-window.portalRenderLimit.init = function () {
-  var currentZoomLevel = map.getZoom();
-  // previousZoomLevel set to current zoom level on the first run
-  portalRenderLimit.previousZoomLevel = portalRenderLimit.previousZoomLevel || currentZoomLevel;
-
-  // If there is a minLevel set in previous run, calculate previousMinLevel with it.
-  if(portalRenderLimit.minLevelSet) {
-    var zoomDiff = currentZoomLevel - portalRenderLimit.previousZoomLevel;
-    portalRenderLimit.previousMinLevel = Math.max(portalRenderLimit.minLevel - zoomDiff, -1);
-    portalRenderLimit.previousMinLevel = Math.min(portalRenderLimit.previousMinLevel, MAX_PORTAL_LEVEL);
-  }
-
-  portalRenderLimit.previousZoomLevel = currentZoomLevel;
-
-  portalRenderLimit.minLevel = -1;
-  portalRenderLimit.resetCounting();
-  portalRenderLimit.resetPortalsLowerThanPrevMinLv();
-  portalRenderLimit.initialized = true;
-}
-
-window.portalRenderLimit.resetCounting = function() {
-  portalRenderLimit.minLevelSet = false;
-  for(var i = 0; i <= MAX_PORTAL_LEVEL; i++) {
-    portalRenderLimit.newPortalsPerLevel[i] = 0;
-  }
-}
-
-window.portalRenderLimit.resetPortalsLowerThanPrevMinLv = function() {
-  for(var i = 0; i <= MAX_PORTAL_LEVEL; i++) {
-    portalRenderLimit.portalsLowerThanPrevMinLv[i] = {};
-    portalRenderLimit.portalsLowerThanPrevMinLvCnt[i] = 0;
-  }
-}
-
-// Use to clean up level of portals which is over render limit after counting new portals
-window.portalRenderLimit.cleanUpOverLimitPortalLevel = function() {
-  var currentMinLevel = window.getMinPortalLevel();
-  for(var i = 0; i < currentMinLevel; i++) {
-    portalsLayers[i].eachLayer(function(item) {
-      var itemGuid = item.options.guid;
-      // check if 'item' is a portal
-      if(getTypeByGuid(itemGuid) != TYPE_PORTAL) return true;
-      // Don’t remove if it is selected.
-      if(itemGuid == window.selectedPortal) return true;
-      portalsLayers[i].removeLayer(item);
-    });
-  }
-}
-
-// Count new portals. Then split lower level portal if it's not last request. 
-// And Merge back if it's last request and render limit not yet hit
-window.portalRenderLimit.splitOrMergeLowLevelPortals = function(originPortals) {
-  portalRenderLimit.resetCounting();
-  portalRenderLimit.countingPortals(originPortals);
-
-  var resultPortals = requests.isLastRequest('getThinnedEntitiesV4')
-    ? portalRenderLimit.mergeLowLevelPortals(originPortals)
-    : portalRenderLimit.splitLowLevelPortals(originPortals);
-
-  return resultPortals;
-}
-
-window.portalRenderLimit.countingPortals = function(portals) {
-  $.each(portals, function(ind, portal) {
-    var portalGuid = portal[0];
-    var portalLevel = parseInt(getPortalLevel(portal[2]));
-    var layerGroup = portalsLayers[portalLevel];
-
-    if(findEntityInLeaflet(layerGroup, window.portals, portalGuid)) return true;
-
-    portalRenderLimit.newPortalsPerLevel[portalLevel]++;
-  });
-}
-
-// Split the portal if it's lower level and not on map
-window.portalRenderLimit.splitLowLevelPortals = function(portals) {
-  var resultPortals = {};
-
-  $.each(portals || {}, function(guid, portal) {
-    var portalLevel = parseInt(getPortalLevel(portal[2]));
-    var portalOnMap = window.portals[guid];
-
-    if(!portalOnMap && portalLevel < portalRenderLimit.previousMinLevel) {
-      portalRenderLimit.portalsLowerThanPrevMinLv[portalLevel][guid] = portal;
-      portalRenderLimit.portalsLowerThanPrevMinLvCnt[portalLevel]++;
-    } else {
-      resultPortals[guid] = portal;
-    }
-  });
-  return resultPortals;
-}
-
-window.portalRenderLimit.mergeLowLevelPortals = function(appendTo) {
-  var resultPortals = appendTo ? appendTo : {};
-  for(var i = portalRenderLimit.getMinLevel();
-      i < portalRenderLimit.previousMinLevel;
-     i++) {
-    $.extend(resultPortals, portalRenderLimit.portalsLowerThanPrevMinLv[i]);
-  }
-
-  // Reset portalsLowerThanPrevMinLv, ensure they return only once
-  portalRenderLimit.resetPortalsLowerThanPrevMinLv();
-  return resultPortals;
-}
-
-window.portalRenderLimit.getMinLevel = function() {
-  if(!portalRenderLimit.initialized) return -1;
-  if(!portalRenderLimit.minLevelSet) portalRenderLimit.setMinLevel();
-  return portalRenderLimit.minLevel;
-}
-
-window.portalRenderLimit.setMinLevel = function() {
-  var totalPortalsCount = 0;
-  var newMinLevel = MAX_PORTAL_LEVEL + 1;
-  
-  // Find the min portal level under render limit
-  while(newMinLevel > 0) {
-    var oldPortalCount = layerGroupLength(portalsLayers[newMinLevel - 1]);
-    var storedPortalCount = portalRenderLimit.portalsLowerThanPrevMinLvCnt[newMinLevel - 1];
-    var newPortalCount = Math.max(storedPortalCount, portalRenderLimit.newPortalsPerLevel[newMinLevel - 1]);
-
-    totalPortalsCount += oldPortalCount + newPortalCount;
-    if(totalPortalsCount >= MAX_DRAWN_PORTALS)
-      break;
-    newMinLevel--;
-  }
-  
-  // If render limit reached at max portal level, still let portal at max level render
-  newMinLevel = Math.min(newMinLevel, MAX_PORTAL_LEVEL);
-  
-  portalRenderLimit.minLevel = Math.max(newMinLevel, portalRenderLimit.minLevel);
-  portalRenderLimit.minLevelSet = true;
-}

code/request_handling.js

@@ -78,9 +78,6 @@ window.renderUpdateStatus = function() {
   }
   t += '</span>';
 
-  if(renderLimitReached())
-    t += ' <span style="color:#f66" class="help" title="Can only render so much before it gets unbearably slow. Not all entities are shown. Zoom in or increase the limit (search for MAX_DRAWN_*).">RENDER LIMIT</span>'
-
   if(window.failedRequestCount > 0)
     t += ' <span style="color:#f66">' + window.failedRequestCount + ' failed</span>'
 

code/utils_misc.js

@@ -230,7 +230,6 @@ window.getPaddedBounds = function() {
       window._storedPaddedBounds = null;
     });
   }
-  if(renderLimitReached(0.7)) return window.map.getBounds();
   if(window._storedPaddedBounds) return window._storedPaddedBounds;
 
   var p = window.map.getBounds().pad(VIEWPORT_PAD_RATIO);
@@ -238,20 +237,6 @@ window.getPaddedBounds = function() {
   return p;
 }
 
-// returns true if the render limit has been reached. The default ratio
-// is 1, which means it will tell you if there are more items drawn than
-// acceptable. A value of 0.9 will tell you if 90% of the amount of
-// acceptable entities have been drawn. You can use this to heuristi-
-// cally detect if the render limit will be hit.
-window.renderLimitReached = function(ratio) {
-  ratio = ratio || 1;
-  if(window.portalsCount*ratio >= MAX_DRAWN_PORTALS) return true;
-  if(window.linksCount*ratio >= MAX_DRAWN_LINKS) return true;
-  if(window.fieldsCount*ratio >= MAX_DRAWN_FIELDS) return true;
-  var param = { 'reached': false };
-  window.runHooks('checkRenderLimit', param);
-  return param.reached;
-}
 
 window.getPortalDataZoom = function() {
   var z = map.getZoom();
@@ -275,14 +260,36 @@ window.getPortalDataZoom = function() {
 }
 
 window.getMinPortalLevelForZoom = function(z) {
-  if(z >= 17) return 0;
+//based on code from stock gen_dashboard.js
-  if(z < 0) return 8;
+  switch(z) {
-  var conv = [8,8,8,8,7,7,6,6,5,4,4,3,3,2,2,1,1];
+    case 0:
-  var minLevelByRenderLimit = portalRenderLimit.getMinLevel();
+    case 1:
-  var result = minLevelByRenderLimit > conv[z]
+    case 2:
-    ? minLevelByRenderLimit
+    case 3:
-    : conv[z];
+      return 8;
-  return result;
+    case 4:
+    case 5:
+      return 7;
+    case 6:
+    case 7:
+      return 6;
+    case 8:
+      return 5;
+    case 9:
+    case 10:
+      return 4;
+    case 11:
+    case 12:
+      return 3;
+    case 13:
+    case 14:
+      return 2;
+    case 15:
+    case 16:
+      return 1;
+    default:
+      return 0
+  }
 }
 
 

main.js

@@ -143,15 +143,12 @@ window.CHAT_FACTION_ITEMS = 100;
 window.CHAT_REQUEST_SCROLL_TOP = 200;
 window.CHAT_SHRINKED = 60;
 
-// Leaflet will get very slow for MANY items. It’s better to display
-// only some instead of crashing the browser.
-window.MAX_DRAWN_PORTALS = 1000;
-window.MAX_DRAWN_LINKS = 400;
-window.MAX_DRAWN_FIELDS = 200;
 // Minimum zoom level resonator will display
 window.RESONATOR_DISPLAY_ZOOM_LEVEL = 17;
+
 // Minimum area to zoom ratio that field MU's will display
 window.FIELD_MU_DISPLAY_AREA_ZOOM_RATIO = 0.001;
+
 // Point tolerance for displaying MU's
 window.FIELD_MU_DISPLAY_POINT_TOLERANCE = 60
 
@@ -246,15 +243,12 @@ window.portalAccessIndicator = null;
 window.mapRunsUserAction = false;
 var portalsLayers, linksLayer, fieldsLayer;
 
-// contain references to all entities shown on the map. These are
+// contain references to all entities loaded from the server. If render limits are hit,
-// automatically kept in sync with the items on *sLayer, so never ever
+// not all may be added to the leaflet layers
-// write to them.
 window.portals = {};
-window.portalsCount = 0;
 window.links = {};
-window.linksCount = 0;
 window.fields = {};
-window.fieldsCount = 0;
+
 window.resonators = {};
 
 // contain current status(on/off) of overlay layerGroups.

plugins/show-more-portals.user.js

@@ -29,9 +29,6 @@ window.plugin.showMorePortals.setup  = function() {
   window.getPortalDataZoom = function() {
     var mapZoom = map.getZoom();
 
-    // on mobile (at least), the map zoom has been non-integer occasionally. fix it.
-    z = Math.floor(z);
-
     // yes, it is possible to increase this beyond "+1" - however, that will end up producing a rediculous number
     // of requests to the Niantic servers, giving many request failed errors/tile timeouts
     // (every increase by one requests four times as many data tiles)