iitcp
Version:
IITC Plugin creator and developer tools
6,693 lines • 219 kB
JavaScript
/**
* @fileOverview Externs for IITC
* with thanks to Filip Wieland
* @see http://ingress-intel-total-conversion.readthedocs.io
* @externs
*/
/**
* @const {string}
*/
window.iitcBuildDate;
/**
* Stores info about the IITC plugin
* @const {object}
*/
window.script_info;
/**
* @const {string}
*/
window.script_info.buildName;
/**
* @const {string}
*/
window.script_info.dateTimeVersion;
/**
* Stores info about the IITC plugin from the header
* @const {object}
*/
window.script_info.script;
/**
* @const {string}
*/
window.script_info.script.version;
/**
* @const {string}
*/
window.script_info.script.name;
/**
* @const {string}
*/
window.script_info.script.description;
/**
* Controls how often the map should refresh, in seconds, default 30.
* @const {number}
*/
window.REFRESH;
/**
* Controls the extra refresh delay per zoom level, in seconds, default 5.
* @const {number}
*/
window.ZOOM_LEVEL_ADJ;
/**
* Wait this long before refreshing the view after the map has been moved, in seconds, default 2.5
* @const {number}
*/
window.ON_MOVE_REFRESH;
/**
* “limit on refresh time since previous refresh, limiting repeated move refresh rate” (?), in seconds, default 10
* @const {number}
*/
window.MINIMUM_OVERRIDE_REFRESH;
/**
* Controls how long to wait between refreshing the global score, in seconds, default 15*60 (15 mins)
* @const {number}
*/
window.REFRESH_GAME_SCORE;
/**
* Controls how long, at most, can the map be inactive before refreshing, in secods, default 15*60 (15 mins)
* @const {number}
*/
window.MAX_IDLE_TIME;
/**
* How much space to leave for scrollbars, in pixels, default 20.
* @const {number}
*/
window.HIDDEN_SCROLLBAR_ASSUMED_WIDTH;
/**
* How wide should the sidebar be, in pixels, default 300.
* @const {number}
*/
window.SIDEBAR_WIDTH;
/**
* Controls requesting chat data if chat is expanded based on the pixel distance from the line currently in view and the top of history, in pixels, default 200
* @const {number}
*/
window.CHAT_REQUEST_SCROLL_TOP;
/**
* Controls height of chat when chat is collapsed, in pixels, default 60
* @const {number}
*/
window.CHAT_SHRINKED;
/**
* Minimum area to zoom ratio that field MU's will display, default 0.001
* @const {number}
* @deprecated IITC no longer shows MU of fields due to intel changes.
*/
window.FIELD_MU_DISPLAY_AREA_ZOOM_RATIO;
/**
* Point tolerance(?) for displaying MUs, in unknown units, default 60
* @const {number}
* @deprecated IITC no longer shows MU of fields due to intel changes.
*/
window.FIELD_MU_DISPLAY_POINT_TOLERANCE;
/**
* What colour should the selected portal be, string(css hex code), default ‘#f0f’ (hot pink)
* @const {string}
*/
window.COLOR_SELECTED_PORTAL;
/**
* Colour hex values for teams used in portals, player names, etc.
* @const {Array<string>}
*/
window.COLORS;
/**
* Colour hex values for levels, consistent with Ingress, with index 0 being white for neutral portals.
* @const {Array<string>}
*/
window.COLORS_LVL;
/**
* Colour hex values for displaying mods, consistent with Ingress. Very Rare also used for AXA shields and Ultra Links.
* @const {object}
*/
window.COLORS_MOD;
/**
* Colour hex values for displaying mods
* @type {string}
*/
window.COLORS_MOD.VERY_RARE;
/**
* Colour hex values for displaying mods
* @type {string}
*/
window.COLORS_MOD.RARE;
/**
* Colour hex values for displaying mods
* @type {string}
*/
window.COLORS_MOD.COMMON;
/**
* Mod type dict for displaying mod names.
* @const {object}
*/
window.MOD_TYPE;
/**
* Mod type dict for displaying mod name
* @const {string}
*/
window.MOD_TYPE.RES_SHIELD;
/**
* Mod type dict for displaying mod name
* @const {string}
*/
window.MOD_TYPE.MULTIHACK;
/**
* Mod type dict for displaying mod name
* @const {string}
*/
window.MOD_TYPE.FORCE_AMP;
/**
* Mod type dict for displaying mod name
* @const {string}
*/
window.MOD_TYPE.HEATSINK;
/**
* Mod type dict for displaying mod name
* @const {string}
*/
window.MOD_TYPE.TURRET;
/**
* Mod type dict for displaying mod name
* @const {string}
*/
window.MOD_TYPE.LINK_AMPLIFIER;
/**
* What colour should the hacking range circle be (the small circle that appears around a selected portal, marking a ~40 metre radius), string(css colour value), default ‘orange’
* @const {string}
*/
window.ACCESS_INDICATOR_COLOR;
/**
* What colour should the linkable range circle be, string(css colour value), default ‘red’
* @const {string}
*/
window.RANGE_INDICATOR_COLOR;
/**
* “min zoom for intel map - should match that used by stock intel”, in (leaflet zoom levels?), default 3
* @const {number}
*/
window.MIN_ZOOM;
/**
* URL to blank portal image png.
* @const {string}
*/
window.DEFAULT_PORTAL_IMG;
/**
* URL to call the Nominatim (geocoder?) service, string.
* @const {string}
*/
window.NOMINATIM;
/**
* Resonator energy per level, 1-based array, XM
* @const {Array<number>}
*/
window.RESO_NRG;
/**
* Maximum radius around a portal from which the portal is hackable, metres.
* @const {number}
*/
window.HACK_RANGE;
/**
* Resonator octant cardinal directions
* @const {Array<string>}
*/
window.OCTANTS;
/**
* Resonator octant arrows
* @const {Array<string>}
*/
window.OCTANT_ARROW;
/**
* AP value for performing in-game action
* @const {number}
*/
window.DESTROY_RESONATOR;
/**
* AP value for performing in-game action
* @const {number}
*/
window.DESTROY_LINK;
/**
* AP value for performing in-game action
* @const {number}
*/
window.DESTROY_FIELD;
/**
* AP value for performing in-game action
* @const {number}
*/
window.CAPTURE_PORTAL;
/**
* AP value for performing in-game action
* @const {number}
*/
window.DEPLOY_RESONATOR;
/**
* AP value for performing in-game action
* @const {number}
*/
window.UPGRADE_ANOTHERS_RESONATOR;
/**
* AP value for performing in-game action
* refers to the extra AP for deploying the last resonator on a portal.
* @const {number}
*/
window.COMPLETION_BONUS;
/**
* Maximum portal level.
* @const {number}
*/
window.MAX_PORTAL_LEVEL;
/**
* How many resonators of a given level can one deploy
* 1-based array where the index is the resonator level.
* @const {Array<number>}
*/
window.MAX_RESO_PER_PLAYER;
/**
* Faction. NONE is 0, RES is 1, ENL is 2.
* @const {number}
*/
window.TEAM_NONE;
/**
* Faction. NONE is 0, RES is 1, ENL is 2.
* @const {number}
*/
window.TEAM_RES;
/**
* Faction. NONE is 0, RES is 1, ENL is 2.
* @const {number}
*/
window.TEAM_ENL;
/**
* Maps team to its CSS class.
* ['none', 'res', 'enl']
* @const {Array<string>}
*/
window.TEAM_TO_CSS;
/**
* Array for calculating direction of resonator
* @const {Array<number>}
* @deprecated resonator position is no longer provided by NIA
*/
window.SLOT_TO_LAT;
/**
* Array for calculating direction of resonator
* @const {Array<number>}
* @deprecated resonator position is no longer provided by NIA
*/
window.SLOT_TO_LNG;
/**
* The Earth’s approximate radius at the equator in metres.
* @const {number}
*/
window.EARTH_RADIUS;
/**
* Constant for converting degrees to radians
* Math.PI / 180
* @const {number}
*/
window.DEG2RAD;
/**
* stores the id of the timeout that kicks off the next refresh (ie value returned by setTimeout())
* @type {?number}
*/
window.refreshTimeout;
/**
* Portal GUID if the original URL had it.
* @type {?string}
*/
window.urlPortal;
/**
* Portal lng/lat if the orignial URL had it.
* @type {?string}
*/
window.urlPortalLL;
/**
* Stores the ID of the selected portal, or is null if there is none.
* @type {?string}
*/
window.selectedPortal;
/**
* Reference to the linking range indicator of the selected portal. This is a Leaflet layer.
* @type {?object}
*/
window.portalRangeIndicator;
/**
* Reference to the hacking range indicator of the selected portal. This is a Leaflet layer.
* @type {?object}
*/
window.portalAccessIndicator;
/**
* Bool, true if the map is currently being moved. More precisely, this is true between the movestart and moveend events of the Leaflet map.
* @type {boolean}
*/
window.mapRunsUserAction;
/**
* References to Leaflet objects for portals. These are indexed by the entity ID in an object
* @type {object<string, object>}
*/
window.portals;
/**
* References to Leaflet objects for links. These are indexed by the entity ID in an object
* @type {object<string, object>}
*/
window.links;
/**
* References to Leaflet objects for fields. These are indexed by the entity ID in an object
* @type {object<string, object>}
*/
window.fields;
/**
* From when NIA provided resonator data
* @type {object}
* @deprecated
*/
window.resonators;
/**
* An object, where the keys are layer names and their values are bools true if the layer is enabled. Should mirror the layer selector UI.
*
* Note: The variable comment states that “you should use :function:`window.isLayerGroupDisplayed(name)` to check the [layer] status”
* @type {object<string, boolean>}
*/
window.overlayStatus;
/**
* A noop function/namespace/”plugin framework”.
* @nosideeffects
*/
window.plugin = function() {};
/**
* A noop function/namespace.
* @nosideeffects
*/
window.artifact = function() {};
/**
* Initiate artifacts
*/
window.artifact.setup = function() {};
/**
* 2 minute random period so not all users refresh at once
* @type {number}
*/
window.artifact.REFRESH_JITTER;
/**
* 60 minutes on success
* @type {number}
*/
window.artifact.REFRESH_SUCCESS;
/**
* 2 minute retry on failure
* @type {number}
*/
window.artifact.REFRESH_FAILURE;
/**
* Flag to show if artifacts refresh is in idle state
* @type {boolean}
*/
window.artifact.idle;
/**
* Leaflet layer group for displaying artifacts
* @type {object}
*/
window.artifact._layer;
/**
* Call to NIA for artict partals
*/
window.artifact.requestData = function() {};
/**
* Resume refresh after timeout
*/
window.artifact.idleResume = function() {};
/**
* Success callback after fetching artifact data
* sets timeout to refresh the data later
* @param {object} data
*/
window.artifact.handleSuccess = function(data) {};
/**
* Error callback after fetching artifact data
* no useful data on failure - do nothing
* sets timeout to refresh the data later
* @param {object} data
*/
window.artifact.handleFailure = function(data) {};
/**
* Checks status of result from fetching artifact data
* Runs hook when result processed
* @param {object} data
*/
window.artifact.processData = function(data) {};
/**
* Resets cache of artifact data
*/
window.artifact.clearData = function() {};
/**
* Stores cache of portals with artifacts
* @type {object}
*/
window.artifact.portalInfo;
/**
* Stores cache of artifact types
* @type {object}
*/
window.artifact.artifactTypes;
/**
* Stores cache of artifacts
* @type {Array<Array>}
*/
window.artifact.entities;
/**
* Caches the fresh artifact data
* @param {object} portals an object, keyed from the portal GUID, containing the portal entity array
*/
window.artifact.processResult = function (portals) {};
/**
* @returns {Array<string>} Array of artifact types
*/
window.artifact.getArtifactTypes = function() {};
/**
* @param {string} type artifact name to check
* @returns {boolean} true if type exists
*/
window.artifact.isArtifact = function(type) {};
/**
* used to render portals that would otherwise be below the visible level
* @returns {Array<Array>} window.artifact.entities
*/
window.artifact.getArtifactEntities = function() {};
/**
* Get an array of portal guids with artifacts
* @returns {Array<string>} Artifact portal guids
*/
window.artifact.getInterestingPortals = function() {};
/**
* quick test for portal being relevant to artifacts - of any type
* @param {string} guid guid of portalto test
* @returns {boolean} true if portal has an artifact
*/
window.artifact.isInterestingPortal = function(guid) {
return guid in artifact.portalInfo;
}
/**
* get the artifact data for a specified artifact id (e.g. 'jarvis'), if it exists - otherwise returns something 'false'y
* @param {string} guid guid of portal to check
* @param {string} artifactId the ID of a specific artifact
* @returns {(boolean|undefined|null)} true if it exists - otherwise returns something 'false'y
*/
window.artifact.getPortalData = function(guid,artifactId) {};
/**
* Updates the leaflet artifact layer
*/
window.artifact.updateLayer = function() {};
/**
* Opens a dialog containing the known artifacts
*/
window.artifact.showArtifactList = function() {};
/**
* sets up a click event listener on the portal image in the side bar that opens a dialog showing a larger image.
* Run once.
*/
window.setupLargeImagePreview = function() {};
/**
* adds listeners to the layer chooser such that a long press hides all custom layers except the long pressed one.
* Run once.
*/
window.setupLayerChooserSelectOne = function() {};
/**
* Setup the function to record the on/off status of overlay layerGroups.
* Run once.
*/
window.setupLayerChooserStatusRecorder = function() {};
/**
* Enable/disable layers that aren't visible due to zoom level
*/
window.layerChooserSetDisabledStates = function() {};
/**
* Adds a style tag to te document.head
* Run once.
*/
window.setupStyles = function() {};
/**
* Initiates the Leaflet Map.
* Run Once
*/
window.setupMap = function() {};
/**
* Adds a base layer to the map. done separately from the above, so that plugins that add base layers can be the default.
*/
window.setMapBaseLayer = function() {};
/**
* Stores info about the signed in agent
* @const {object}
*/
window.PLAYER;
/**
* Agent's current AP
* @const {string}
*/
window.PLAYER.ap;
/**
* Agent's current XM
* @const {number}
*/
window.PLAYER.energy;
/**
* Agent's level
* @const {number}
*/
window.PLAYER.level;
/**
* Minimum AP for the agent's current level
* @const {string}
*/
window.PLAYER.min_ap_for_current_level;
/**
* Minimum AP for the agent's next level
* @const {string}
*/
window.PLAYER.min_ap_for_next_level;
/**
* A regex for testing if the agent's nickname appears in a text string
* @const {RegExp}
*/
window.PLAYER.nickMatcher;
/**
* The agent's in game name (IGN) or nickname
* @const {string}
*/
window.PLAYER.nickname;
/**
* The agent's faction ('ENLIGHTENED' or 'RESISTANCE')
* @const {string}
*/
window.PLAYER.team;
/**
* The same as the agent's current level
* @const {number}
*/
window.PLAYER.verified_level;
/**
* The maximum amount of XM the agent can have
* @const {string}
*/
window.PLAYER.xm_capacity;
/**
* renders player details into the website. Since the player info is included as inline script in the original site, the data is static and cannot be updated.
* Run once.
*/
window.setupPlayerStat = function() {};
/**
* Add click event listener to side bar toggle.
* Run once.
*/
window.setupSidebarToggle = function() {};
/**
* Set up tool tips on an element (deault element is document).
* @param {?HTMLElement} element default is document
*/
window.setupTooltips = function(element) {};
/**
* Implements a tap and hold functionality. If you click/tap and release, it will trigger a normal click event. But if you click/tap and hold for 1s (default), it will trigger a taphold event instead.
*/
window.setupTaphold = function() {};
/**
* Initiates QR Library
*/
window.setupQRLoadLib = function() {};
/**
* Leaflet control for selecting the visibility of layers.
* It also has API methods for layers
* @type {object} Leaflet control
*/
window.layerChooser;
/**
* hook some additional code into the LayerControl so it's easy for the mobile app to interface with it.
* WARNING: does depend on internals of the L.Control.Layers code.
* @returns {object} The layer
*/
window.layerChooser.getLayers = function() {};
/**
* Show or hide a layer
* @param {string} id The ID of the layer to toggle
* @param {?boolean} show true to show (default), false to hide
* @returns {boolean} true if the layer exists
*/
window.layerChooser.showLayer = function(id,show) {};
/**
* Initiates the layerchooser API methods
*/
window.setupLayerChooserApi = function() {};
/**
* An array of functions that should be called after IITC has finished booting. Mostly used to initialise plugins. Note: These will not run if some blacklisted plugins are detected.
* @type {(Array<function>|undefined)}
*/
window.bootPlugins;
/**
* A noop function/namespace for the chat.
* @nosideeffects
*/
window.chat = function() {};
/**
* @type {Array<object>}
*/
window.chat.commTabs = [];
window.chat.handleTabCompletion = function() {};
/**
* Generates an object to post in order to receive chat messages
* @param {string} channel 'all' / 'faction' / 'alerts'
* @param {object} storageHash object storing last timestamps
* @param {?boolean} getOlderMsgs flag for fetching older messages
* @returns {object}
*/
window.chat.genPostData = function(channel, storageHash, getOlderMsgs) {};
/**
* Fetch faction chat messages. It will retry once if there is an error
* @param {boolean} getOlderMsgs flag for fetching older messages
* @param {?boolean} isRetry flag to tell if it's a retry
*/
window.chat.requestFaction = function(getOlderMsgs, isRetry) {};
/**
* Handles faction chat response
* @param {object} data the response from NIA
* @param {?boolean} olderMsgs flag if fetching older messages
*/
window.chat.handleFaction = function(data, olderMsgs) {};
/**
* calls window.chat.renderData
* @param {?boolean} oldMsgsWereAdded
*/
window.chat.renderFaction = function(oldMsgsWereAdded) {};
/**
* Fetch public chat messages. It will retry once if there is an error
* @param {boolean} getOlderMsgs flag for fetching older messages
* @param {?boolean} isRetry flag to tell if it's a retry
*/
window.chat.requestPublic = function(getOlderMsgs, isRetry) {};
/**
* Handles public chat response
* @param {object} data the response from NIA
* @param {?boolean} olderMsgs flag if fetching older messages
*/
window.chat.handlePublic = function(data, olderMsgs) {};
/**
* calls window.chat.renderData
* @param {?boolean} oldMsgsWereAdded
*/
window.chat.renderPublic = function(oldMsgsWereAdded) {};
/**
* Fetch alert messages. It will retry once if there is an error
* @param {boolean} getOlderMsgs flag for fetching older messages
* @param {?boolean} isRetry flag to tell if it's a retry
*/
window.chat.requestAlerts = function(getOlderMsgs, isRetry) {};
/**
* Handles alerts response
* @param {object} data the response from NIA
* @param {?boolean} olderMsgs flag if fetching older messages
*/
window.chat.handleAlerts = function(data, olderMsgs) {};
/**
* calls window.chat.renderData
* @param {?boolean} oldMsgsWereAdded
*/
window.chat.renderAlerts = function(oldMsgsWereAdded) {};
/**
* Event handler for when agent names are clicked
* Runs hook 'nicknameClicked' and adds name in chat input
* @param {Event} event
* @param {string} nickname Name of clicked agent
* @returns {boolean} false
*/
window.chat.nicknameClicked = function(event, nickname) {};
/**
* stores provided chat data in a hash
* @param {object} newData the response object from NIA
* @param {object} storageHash the hash for this channel
* @param {boolean} isPublicChannel flag for public channel
* @param {?boolean} isOlderMsgs flag for older messages
*/
window.chat.writeDataToHash = function(newData, storageHash, isPublicChannel, isOlderMsgs) {};
/**
* Override portal names that are used over and over, such as 'US Post Office'
* @param {object} Plext markup
* @returns {string} possibly ammended portal name
*/
window.chat.getChatPortalName = function(markup) {}
/**
* Renders data from the data-hash to the element defined by the given ID. Set 3rd argument to true if it is likely that old data has been added. Latter is only required for scrolling.
* @param {object} data from hash
* @param {string} element the element ID
* @param {boolean} likelyWereOldMsgs Set to true if it is likely that old data has been added. Only required for scrolling.
*/
window.chat.renderData = function(data, element, likelyWereOldMsgs) {};
/**
* Returns a string for innerHTML to represent a divider in the comm
* @param {string} text Text to insert in the divider (usually a date string)
* @returns {string}
*/
window.chat.renderDivider = function(text) {};
/**
* converts a message into an html string between TR tags
* @param {string} msg The message to render
* @param {string} nick The agent name of the originator of the message
* @param {number} time timestamp of message in ms
* @param {string} team faction of the originator
* @param {?boolean} msgToPlayer If the message mentions the user
* @param {?boolean} systemNarrowcast If it is not player generated
*/
window.chat.renderMsg = function(msg, nick, time, team, msgToPlayer, systemNarrowcast) {};
/**
* Adds a nickname to the chat input
* @param {string} nick nickname to add
*/
window.chat.addNickname= function(nick) {};
/**
* Find the active chat channel
* @returns {string} the name of the chat channel
*/
window.chat.getActive = function() {};
/**
* convert tab text to a legitimate channel
* @param {string} tab the tab name
* @returns {string} 'all' / 'faction' / 'alerts'
*/
window.chat.tabToChannel = function(tab) {};
/**
* Expands or contracts the chat pane
*/
window.chat.toggle = function() {};
/**
* called by plugins (or other things?) that need to monitor COMM data streams when the user is not viewing them
* @param {string} instance a unique string identifying the plugin requesting background COMM
* @param {string} channel either 'all', 'faction' or (soon) 'alerts' - others possible in the future
* @param {boolean} flag true for data wanted, false for not wanted
*/
window.chat.backgroundChannelData = function(instance,channel,flag) {};
/**
* Starts a call to request the latest chat data for the open tab
*/
window.chat.request = function() {};
/**
* checks if there are enough messages in the selected chat tab and loads more if not.
*/
window.chat.needMoreMessages = function() {};
/**
* Select a tab
* @param {string} tab the tab to select, only "all", "faction" and "alerts" are valid
*/
window.chat.chooseTab = function(tab) {};
/**
* Show a tab
* @param {string} name the tab to select, only "all", "faction" and "alerts" are valid
*/
window.chat.show = function(name) {};
/**
* an event handler for clicking on the tab selector
* @param {DOMEvent} event
*/
window.chat.chooser = function(event) {};
/**
* Contains the logic to keep the correct scroll position.
* If scrolled down completely, keep it that way so new messages can be seen easily. If scrolled up, only need to fix scroll position when old messages are added. New messages added at the bottom don’t change the view and enabling this would make the chat scroll down for every added message, even if the user wants to read old stuff.
* @param {*} box jquery element
* @param {number} scrollBefore in pixels
* @param {?boolean} isOldMsgs flag for old messages
*/
window.chat.keepScrollPosition = function(box, scrollBefore, isOldMsgs) {};
/**
* Initiate the chat and related event handlers
*/
window.chat.setup = function() {};
/**
* Set the time on the left of the chat input and setTimeout to update it
*/
window.chat.setupTime = function() {};
/**
* Sets up event handlers for chat input
*/
window.chat.setupPosting = function() {};
/**
* Gets text from chat input and sends it to all or faction depending on the tab
*/
window.chat.postMsg = function() {};
// MAP DATA CACHE ///////////////////////////////////
// cache for map data tiles.
/**
* cache for map data tiles.
* @constructor
*/
window.DataCache = function() {};
/**
* Store an item in the cache
* @param {string} qk key to store in the cache for this data
* @param {(object|Array)} data a value that will be JSON.stringified
* @param {?number} freshTime number of milliseconds this will be fresh for, default 180000 (3 mins)
*/
window.DataCache.prototype.store = function(qk,data,freshTime) {};
/**
* Remove an item in the cache
* @param {string} qk key for the data to remove
*/
window.DataCache.prototype.remove = function(qk) {};
/**
* Get the data stored in a cache
* @param {string} qk key of data to get
* @returns {(object|Array|undefined)} the stored data or undefined
*/
window.DataCache.prototype.get = function(qk) {};
/**
* Get the time data was stored in a cache
* @param {string} qk key of time to get
* @returns {number} the stored time in ms or 0
*/
window.DataCache.prototype.getTime = function(qk) {}
/**
* check if the data has expired
* @param {string} qk key to check
* @returns {(boolean|undefined)} true if fresh, false if not or undefined if not there
*/
window.DataCache.prototype.isFresh = function(qk) {};
/**
* Sets a setInterval to clear expired data
* @param {number} period The number of seconds for the interval
*/
window.DataCache.prototype.startExpireInterval = function(period) {};
/**
* clears the interval set to remove expired data
*/
window.DataCache.prototype.stopExpireInterval = function() {};
/**
* Iterate through the cache expiring old data
*/
window.DataCache.prototype.runExpire = function() {};
/**
* Get the size of the cache for debugging purposes
* @returns {string} Number of items, bytes & Kb
*/
window.DataCache.prototype.debug = function() {};
/**
* Object to store all open dialogs. { Element.id: Element}
* @type {object}
*/
window.DIALOGS;
/**
* Count of open dialogs
* @type {number}
*/
window.DIALOG_COUNT;
/**
* The HTML Element of the dialog in focus
* @type {?HTMLElement}
*/
window.DIALOG_FOCUS;
/**
* The global ID of onscreen dialogs.
* Starts at 0.
* @type {?number}
*/
window.DIALOG_ID;
/**
* Controls how quickly the slide toggle animation
* should play for dialog collapsing and expanding.
* default 100ms
* @type {number}
*/
window.DIALOG_SLIDE_DURATION;
/**
*
* @typedef {Array<{text:string,click:function(){}}>}
* {text:string,click:function(){}}>
*
*/
var DialogButtonsArrayOptions;
/**
*
* @typedef {Object<string, function(event:DOMEvent):void>}
*/
var DialogButtonsObjectOptions;
/**
* Dialog buttons options
* @typedef {({*:string,function(){}}|undefined)}
*/
var DialogButtonsOptions
/**
* Options param for dialog function
* @typedef {{text:(string|undefined), html:(string|undefined), title:(string|undefined), modal:(boolean|undefined), id:(string|undefined), appendTo:(string|undefined), autoOpen:(boolean|undefined), classes:(Object<string, string>|undefined), buttons:(Object<string, function(){}>|Array<{{text:string, click:function(){}}}>|undefined), closeOnEscape:(boolean|undefined), draggable:(boolean|undefined), height:(number|string|undefined), width:(number|string|undefined), maxHeight:(number|undefined), maxWidth:(number|undefined), minHeight:(number|undefined), minWidth:(number|undefined), position:{{ my:string, at:string, of:(Element|window) }},resizable:(boolean|undefined)}}
*/
var DialogOptions;
/**
* Creates a dialog and puts it onscreen. Takes one argument: options, a JS object.
*
* == Common options
*
* (text|html): The text or HTML to display in the dialog. Text is auto-converted to HTML.
*
* title: The dialog's title.
*
* modal: Whether to open a modal dialog. Implies draggable=false; dialogClass='ui-dialog-modal'.
* Please note that modal dialogs hijack the entire screen and should only be used in very
* specific cases. (If IITC is running on mobile, modal will always be true).
* id: A unique ID for this dialog. If a dialog with id `id' is already open and dialog() is called
* again, it will be automatically closed.
*
* == Callbacks
*
* closeCallback: A callback to run on close. Takes no arguments.
* collapseCallback: A callback to run on dialog collapse. Takes no arguments.
* expandCallback: A callback to run on dialog expansion. Takes no arguments.
* collapseExpandCallback: A callback to run on both collapse and expand (overrides collapseCallback
* and expandCallback, takes a boolean argument `collapsing' - true if collapsing;
* false if expanding)
* focusCallback: A callback to run when the dialog gains focus.
* blurCallback: A callback to run when the dialog loses focus.
*
* See http://docs.jquery.com/UI/API/1.8/Dialog for a list of all the options. If you previously
* applied a class to your dialog after creating it with alert(), dialogClass may be particularly
* useful.
* @param {{text:(string|undefined), html:(string|undefined), title:(string|undefined), modal:(boolean|undefined), id:(string|undefined), appendTo:(string|undefined), text:(string|undefined), autoOpen:(boolean|undefined), classes:(Object<string, string>|undefined), buttons:(Object<string, function>|Array<Object>|undefined)}} options dialog options
* @returns {object} the created dialog object
*/
window.dialog = function(options) {};
/**
* Creates an alert dialog with default settings.
* If you want more configurability, use window.dialog instead.
* @param {string} text text for the body of the dialog
* @param {?boolean} isHTML flag to indicate if the text is HTML
* @param {function} closeCallback callback to run when dialog closes
* @returns {object} the created dialog object
*/
window.alert = function(text, isHTML, closeCallback) {};
/**
* Initiates dialogs
*/
window.setupDialogs = function() {};
// decode the on-network array entity format into an object format closer to that used before
// makes much more sense as an object, means that existing code didn't need to change, and it's what the
// stock intel site does internally too (the array format is only on the network)
// anonymous wrapper function
(function(){
window.decodeArray = function(){};
function parseMod(arr) {
if(arr == null) { return null; }
return {
owner: arr[0],
name: arr[1],
rarity: arr[2],
stats: arr[3],
};
}
function parseResonator(arr) {
if(arr == null) { return null; }
return {
owner: arr[0],
level: arr[1],
energy: arr[2],
};
}
function parseArtifactBrief(arr) {
if (arr === null) return null;
// array index 0 is for fragments at the portal. index 1 is for target portals
// each of those is two dimensional - not sure why. part of this is to allow for multiple types of artifacts,
// with their own targets, active at once - but one level for the array is enough for that
// making a guess - first level is for different artifact types, second index would allow for
// extra data for that artifact type
function decodeArtifactArray(arr) {
var result = {};
for (var i=0; i<arr.length; i++) {
// we'll use the type as the key - and store any additional array values as the value
// that will be an empty array for now, so only object keys are useful data
result[arr[i][0]] = arr[i].slice(1);
}
return result;
}
return {
fragment: decodeArtifactArray(arr[0]),
target: decodeArtifactArray(arr[1]),
};
}
function parseArtifactDetail(arr) {
if (arr == null) { return null; }
// empty artifact data is pointless - ignore it
if (arr.length == 3 && arr[0] == "" && arr[1] == "" && arr[2].length == 0) { return null; }
return {
type: arr[0],
displayName: arr[1],
fragments: arr[2],
};
}
//there's also a 'placeholder' portal - generated from the data in links/fields. only has team/lat/lng
var CORE_PORTA_DATA_LENGTH = 4;
function corePortalData(a) {
return {
// a[0] == type (always 'p')
team: a[1],
latE6: a[2],
lngE6: a[3]
}
};
var SUMMARY_PORTAL_DATA_LENGTH = 14;
function summaryPortalData(a) {
return {
level: a[4],
health: a[5],
resCount: a[6],
image: a[7],
title: a[8],
ornaments: a[9],
mission: a[10],
mission50plus: a[11],
artifactBrief: parseArtifactBrief(a[12]),
timestamp: a[13]
};
};
var DETAILED_PORTAL_DATA_LENGTH = SUMMARY_PORTAL_DATA_LENGTH+4;
window.decodeArray.portalSummary = function(a) {
if (!a) return undefined;
if (a[0] != 'p') throw 'Error: decodeArray.portalSUmmary - not a portal';
if (a.length == CORE_PORTA_DATA_LENGTH) {
return corePortalData(a);
}
// NOTE: allow for either summary or detailed portal data to be passed in here, as details are sometimes
// passed into code only expecting summaries
if (a.length != SUMMARY_PORTAL_DATA_LENGTH && a.length != DETAILED_PORTAL_DATA_LENGTH) {
console.warn('Portal summary length changed - portal details likely broken!');
debugger;
}
return $.extend(corePortalData(a), summaryPortalData(a));
}
window.decodeArray.portalDetail = function(a) {
if (!a) return undefined;
if (a[0] != 'p') throw 'Error: decodeArray.portalDetail - not a portal';
if (a.length != DETAILED_PORTAL_DATA_LENGTH) {
console.warn('Portal detail length changed - portal details may be wrong');
debugger;
}
//TODO look at the array values, make a better guess as to which index the mods start at, rather than using the hard-coded SUMMARY_PORTAL_DATA_LENGTH constant
// the portal details array is just an extension of the portal summary array
// to allow for niantic adding new items into the array before the extended details start,
// use the length of the summary array
return $.extend(corePortalData(a), summaryPortalData(a),{
mods: a[SUMMARY_PORTAL_DATA_LENGTH+0].map(parseMod),
resonators:a[SUMMARY_PORTAL_DATA_LENGTH+1].map(parseResonator),
owner: a[SUMMARY_PORTAL_DATA_LENGTH+2],
artifactDetail: parseArtifactDetail(a[SUMMARY_PORTAL_DATA_LENGTH+3]),
});
}
})();
;
// ENTITY DETAILS TOOLS //////////////////////////////////////////////
// hand any of these functions the details-hash of an entity (i.e.
// portal, link, field) and they will return useful data.
// given the entity detail data, returns the team the entity belongs
// to. Uses TEAM_* enum values.
window.getTeam = function(details) {
return teamStringToId(details.team);
}
window.teamStringToId = function(teamStr) {
var team = TEAM_NONE;
if(teamStr === 'ENLIGHTENED') team = TEAM_ENL;
if(teamStr === 'RESISTANCE') team = TEAM_RES;
if(teamStr === 'E') team = TEAM_ENL;
if(teamStr === 'R') team = TEAM_RES;
return team;
}
;
// as of 2014-08-14, Niantic have returned to minifying the javascript. This means we no longer get the nemesis object
// and it's various member objects, functions, etc.
// so we need to extract some essential parameters from the code for IITC to use
window.extractFromStock = function() {
window.niantic_params = {}
// extract the former nemesis.dashboard.config.CURRENT_VERSION from the code
var reVersion = new RegExp('"X-CSRFToken".*[a-z].v="([a-f0-9]{40})";');
var minified = new RegExp('^[a-zA-Z$][a-zA-Z$0-9]?$');
for (var topLevel in window) {
if (minified.test(topLevel)) {
// a minified object - check for minified prototype entries
var topObject = window[topLevel];
if (topObject && topObject.prototype) {
// the object has a prototype - iterate through the properties of that
for (var secLevel in topObject.prototype) {
if (minified.test(secLevel)) {
// looks like we've found an object of the format "XX.prototype.YY"...
var item = topObject.prototype[secLevel];
if (item && typeof(item) == "function") {
// a function - test it against the relevant regular expressions
var funcStr = item.toString();
var match = reVersion.exec(funcStr);
if (match) {
console.log('Found former CURRENT_VERSION in '+topLevel+'.prototype.'+secLevel);
niantic_params.CURRENT_VERSION = match[1];
}
}
}
}
} //end 'if .prototype'
if (topObject && Array.isArray && Array.isArray(topObject)) {
// find all non-zero length arrays containing just numbers
if (topObject.length>0) {
var justInts = true;
for (var i=0; i<topObject.length; i++) {
if (typeof(topObject[i]) !== 'number' || topObject[i] != parseInt(topObject[i])) {
justInts = false;
break;
}
}
if (justInts) {
// current lengths are: 17: ZOOM_TO_LEVEL, 14: TILES_PER_EDGE
// however, slightly longer or shorter are a possibility in the future
if (topObject.length >= 12 && topObject.length <= 18) {
// a reasonable array length for tile parameters
// need to find two types:
// a. portal level limits. decreasing numbers, starting at 8
// b. tiles per edge. increasing numbers. current max is 36000, 9000 was the previous value - 18000 is a likely possibility too
if (topObject[0] == 8) {
// check for tile levels
var decreasing = true;
for (var i=1; i<topObject.length; i++) {
if (topObject[i-1] < topObject[i]) {
decreasing = false;
break;
}
}
if (decreasing) {
console.log ('int array '+topLevel+' looks like ZOOM_TO_LEVEL: '+JSON.stringify(topObject));
window.niantic_params.ZOOM_TO_LEVEL = topObject;
}
} // end if (topObject[0] == 8)
// 2015-06-25 - changed to top value of 64000, then to 32000 - allow for them to restore it just in case
if (topObject[topObject.length-1] >= 9000 && topObject[topObject.length-1] <= 64000) {
var increasing = true;
for (var i=1; i<topObject.length; i++) {
if (topObject[i-1] > topObject[i]) {
increasing = false;
break;
}
}
if (increasing) {
console.log ('int array '+topLevel+' looks like TILES_PER_EDGE: '+JSON.stringify(topObject));
window.niantic_params.TILES_PER_EDGE = topObject;
}
} //end if (topObject[topObject.length-1] == 9000) {
}
}
}
}
}
}
if (niantic_params.CURRENT_VERSION === undefined) {
dialog({
title: 'IITC Broken',
html: '<p>IITC failed to extract the required parameters from the intel site</p>'
+'<p>This can happen after Niantic update the standard intel site. A fix will be needed from the IITC developers.</p>',
});
console.log('Discovered parameters');
console.log(JSON.stringify(window.niantic_params,null,2));
throw('Error: IITC failed to extract CURRENT_VERSION string - cannot continue');
}
}
;
// GAME STATUS ///////////////////////////////////////////////////////
// MindUnit display
window.updateGameScore = function(data) {
if(!data) {
// move the postAjax call onto a very short timer. this way, if it throws an exception, it won't prevent IITC booting
setTimeout (function() { window.postAjax('getGameScore', {}, window.updateGameScore); }, 1);
return;
}
if (data && data.result) {
var e = parseInt(data.result[0]); //enlightened score in result[0]
var r = parseInt(data.result[1]); //resistance score in result[1]
var s = r+e;
var rp = r/s*100, ep = e/s*100;
r = digits(r), e = digits(e);
var rs = '<span class="res" style="width:'+rp+'%;">'+Math.round(rp)+'% </span>';
var es = '<span class="enl" style="width:'+ep+'%;"> '+Math.round(ep)+'%</span>';
$('#gamestat').html(rs+es).one('click', function() { window.updateGameScore() });
// help cursor via “#gamestat span”
$('#gamestat').attr('title', 'Resistance:\t'+r+' MindUnits\nEnlightened:\t'+e+' MindUnits');
} else if (data && data.error) {
console.warn('game score failed to load: '+data.error);
} else {
console.warn('game score failed to load - unknown reason');
}
// TODO: idle handling - don't refresh when IITC is idle!
window.setTimeout('window.updateGameScore', REFRESH_GAME_SCORE*1000);
}
;
// PLUGIN HOOKS ////////////////////////////////////////////////////////
// Plugins may listen to any number of events by specifying the name of
// the event to listen to and handing a function that should be exe-
// cuted when an event occurs. Callbacks will receive additional data
// the event created as their first parameter. The value is always a
// hash that contains more details.
//
// For example, this line will listen for portals to be added and print
// the data generated by the event to the console:
// window.addHook('portalAdded', function(data) { console.log(data) });
//
// Boot hook: booting is handled differently because IITC may not yet
// be available. Have a look at the plugins in plugins/. All
// code before “// PLUGIN START” and after “// PLUGIN END” is
// required to successfully boot the plugin.
//
// Here’s more specific information about each event:
// portalSelected: called when portal on map is selected/unselected.
// Provide guid of selected and unselected portal.
// mapDataRefreshStart: called when we start refreshing map data
// mapDataEntityInject: called just as we start to render data. has callback to inject cached entities into the map render
// mapDataRefreshEnd: called when we complete the map data load
// portalAdded: called when a portal has been received and is about to
// be added to its layer group. Note that this does NOT
// mean it is already visible or will be, shortly after.
// If a portal is added to a hidden layer it may never be
// shown at all. Injection point is in
// code/map_data.js#renderPortal near the end. Will hand
// the Leaflet CircleMarker for the portal in "portal" var.
// linkAdded: called when a link is about to be added to the map
// fieldAdded: called when a field is about to be added to the map
// portalRemoved: called when a portal has been removed
// linkRemoved: called when a link has been removed
// fieldRemoved: called when a field has been removed
// portalDetailsUpdated: fired after the details in the sidebar have
// been (re-)rendered Provides data about the portal that
// has been selected.
// publicChatDataAvailable: this hook runs after data for any of the
// public chats has been received and processed, but not
// yet been displayed. The data hash contains both the un-
// processed raw ajax response as well as the processed
// chat data that is going to be used for display.
// factionChatDataAvailable: this hook runs after data for the faction
// chat has been received and processed, but not yet been
// displayed. The data hash contains both the unprocessed
// raw ajax response as well as the processed chat data
// that is going to be used for display.
// requestFinished: DEPRECATED: best to use mapDataRefreshEnd instead
// called after each map data request finished. Argument is
// {success: boolean} indicated the request success or fail.
// iitcLoaded: called after IITC and all plugins loaded
// portalDetailLoaded: called when a request to load full portal detail
// completes. guid, success, details parameters
// paneChanged called when the current pane has changed. On desktop,
// this only selects the current chat pane; on mobile, it
// also switches between map, info and other panes defined
// by plugins
// artifactsUpdated: called when the set of artifacts (including targets)
// has changed. Parameters names are old, new.
window._hooks = {}
window.VALID_HOOKS = [
'portalSelected', 'portalDetailsUpdated', 'artifactsUpdated',
'mapDataRefreshStart', 'mapDataEntityInject', 'mapDataRefreshEnd',
'portalAdded', 'linkAdded', 'fieldAdded',
'portalRemoved', 'linkRemoved', 'fieldRemoved',
'publicChatDataAvailable', 'factionChatDataAvailable',
'requestFinished', 'nicknameClicked',
'geoSearch', 'search', 'iitcLoaded',
'portalDetailLoaded', 'paneChanged'];
window.runHooks = function(event, data) {
if(VALID_HOOKS.indexOf(event) === -1) throw('Unknown event type: ' + event);
if(!_hooks[event]) return true;
var interrupted = false;
$.each(_hooks[event], function(ind, callback) {
try {
if (callback(data) === false) {
interrupted = true;
return false; //break from $.each
}
} catch(err) {
console.error('error running hook '+event+', error: '+err);
debugger;
}
});
return !interrupted;
}
// helper method to allow plugins to create new hooks
window.pluginCreateHook = function(event) {
if($.inArray(event, window.VALID_HOOKS) < 0) {
window.VALID_HOOKS.push(event);
}
}
window.addHook = function(event, callback) {
if(VALID_HOOKS.indexOf(event) === -1) {
console.error('addHook: Unknown event type: ' + event + ' - ignoring');
debugger;
return;
}
if(typeof callback !== 'function') throw('Callback must be a function.');
if(!_hooks[event])
_hooks[event] = [callback];
else
_hooks[event].push(callback);
}
// callback must the SAME function to be unregistered.
window.removeHook = function(event, callback) {
if (typeof callback !== 'function') throw('Callback must be a function.');
if (_hooks[event]) {
var index = _hooks[event].indexOf(callback);
if(index == -1)
console.warn('Callback wasn\'t registered for this event.');
else
_hooks[event].splice(index, 1);
}
}
;
// IDLE HANDLING /////////////////////////////////////////////////////
window.idleTime = 0; // in seconds
window._idleTimeLimit = MAX_IDLE_TIME;
var IDLE_POLL_TIME = 10;
var idlePoll = function() {
var wasIdle = isIdle();
window.idleTime += IDLE_POLL_TIME;
var hidden = (document.hidden || document.webkitHidden || document.mozHidden || document.msHidden || false);
if (hidden) {
window._idleTimeLimit = window.REFRESH; // set a small time limit before entering idle mode
}
if (!wasIdle && isIdle()) {
console.log('idlePoll: entering idle mode');
}
}
setInterval(idlePoll, IDLE_POLL_TIME*1000);
window.idleReset = function () {
// update immediately when the user comes back
if(isIdle()) {
console.log ('idleReset: leaving idle mode');
window.idleTime = 0;
$.each(window._onResumeFunctions, function(ind, f) {
f();
});
}
window.idleTime = 0;
window._idleTimeLimit = MAX_IDLE_TIME;
};
window.idleSet = function() {
var wasIdle = isIdle();
window._idleTimeLimit = 0; // a zero time here will cause idle to start immediately
if (!wasIdle && isIdle()) {
console.log ('idleSet: entering idle mode');
}
}
// only reset idle on mouse move where the coordinates are actually different.
// some browsers send the event when not moving!
var _lastMouseX=-1, _lastMouseY=-1;
var idleMouseMove = function(e) {
var dX = _lastMouseX-e.clientX;
var dY = _lastMouseY-e.clientY;
var deltaSquared = dX*dX + dY*dY;
// only treat movements over 3 pixels as enough to reset us
if (deltaSquared > 3*3) {
_lastMouseX = e.clientX;
_lastMouseY = e.clientY;
idleReset();
}
}
window.setupIdle = function() {
$('body').keypress(idleReset);
$('body').mousemove(idleMouseMove);
}
window.isIdle = function() {
return window.idleTime >= window._idleTimeLimit;
}
window._onResumeFunctions = [];
// add your function here if you want to be notified when the user
// resumes from being idle
window.addResumeFunction = function(f) {
window._onResumeFunctions.push(f);
}
;
// LOCATION HANDLING /////////////////////////////////////////////////
// i.e. setting initial position and storing new position after moving
// retrieves current position from map and stores it cookies
window.storeMapPosition = function() {
var m = window.map.getCenter();
if(m['lat'] >= -90 && m['lat'] <= 90)
writeCookie('ingress.intelmap.lat', m['lat']);
if(m['lng'] >= -180 && m['lng'] <= 180)
writeCookie('ingress.intelmap.lng', m['lng']);
writeCookie('ingress.intelmap.zoom', window.map.getZoom());
}
// either retrieves the last shown position from a cookie, from the
// URL or if neither is present, via Geolocation. If that fails, it
// returns a map that shows the whole world.
window.getPosition = function() {
if(getURLParam('latE6') && getURLParam('lngE6')) {
console.log("mappos: reading email URL params");
var lat = parseInt(getURLParam('latE6'))/1E6 || 0.0;
var lng = parseInt(getURLParam('lngE6'))/1E6 || 0.0;
var z = parseInt(getURLParam('z')) || 17;
return {center: new L.LatLng(lat, lng), zoom: z};
}
if(getURLParam('ll')) {
console.log("mappos: reading stock Intel URL params");
var lat = parseFloat(getURLParam('ll').split(",")[0]) || 0.0;
var lng = parseFloat(getURLParam('ll').split(",")[1]) || 0.0;
var z = parseInt(getURLParam('z')) || 17;
return {center: new L.LatLng(lat, lng), zoom: z};
}
if(getURLParam('pll')) {
console.log("mappos: reading stock Intel URL portal params");
var lat = parseFloat(getURLParam('pll').split(",")[0]) || 0.0;
var lng = parseFloat(getURLParam('pll').split(",")[1]) || 0.0;
var z = parseInt(getURLParam('z')) || 17;
return {center: new L.LatLng(lat, lng), zoom: z};
}
if(readCookie('ingress.intelmap.lat') && readCookie('ingress.intelmap.lng')) {
console.log("mappos: reading cookies");
var lat = parseFloat(readCookie('ingress.intelmap.lat')) || 0.0;
var lng = parseFloat(readCookie('ingress.intelmap.lng')) || 0.0;
var z = parseInt(readCookie('ingress.intelmap.zoom')) || 17;
if(lat < -90 || lat > 90) lat = 0.0;
if(lng < -180 || lng > 180) lng = 0.0;
return {center: new L.LatLng(lat, lng), zoom: z};
}
setTimeout("window.map.locate({setView : true});", 50);
return {center: new L.LatLng(0.0, 0.0), zoom: 1};
}
;
// MAP DATA REQUEST CALCULATORS //////////////////////////////////////
// Ingress Intel splits up requests for map data (portals, links,
// fields) into tiles. To get data for the current viewport (i.e. what
// is currently visible) it first calculates which tiles intersect.
// For all those tiles, it then calculates the lat/lng bounds of that
// tile and a quadkey. Both the bounds and the quadkey are “somewhat”
// required to get complete data.
//
// Conversion functions courtesy of
// http://wiki.openstreetmap.org/wiki/Slippy_map_tilenames
window.setupDataTileParams = function() {
// default values - used to fall back to if we can't detect those used in stock intel
var DEFAULT_ZOOM_TO_TILES_PER_EDGE = [1,1,1,40,40,80,80,320,1000,2000,2000,4000,8000,16000,16000,32000];
var DEFAULT_ZOOM_TO_LEVEL = [8,8,8,8,7,7,7,6,6,5,4,4,3,2,2,1,1];
// stock intel doesn't have this array (they use a switch statement instead), but this is far neater
var DEFAULT_ZOOM_TO_LINK_LENGTH = [200000,200000,200000,200000,200000,60000,60000,10000,5000,2500,2500,800,300,0,0];
window.TILE_PARAMS = {};
// not in stock to detect - we'll have to assume the above values...
window.TILE_PARAMS.ZOOM_TO_LINK_LENGTH = DEFAULT_ZOOM_TO_LINK_LENGTH;
if (niantic_params.ZOOM_TO_LEVEL && niantic_params.TILES_PER_EDGE) {
window.TILE_PARAMS.ZOOM_TO_LEVEL = niantic_params.ZOOM_TO_LEVEL;
window.TILE_PARAMS.TILES_PER_EDGE = niantic_params.TILES_PER_EDGE;
// lazy numerical array comparison
if ( JSON.stringify(niantic_params.ZOOM_TO_LEVEL) != JSON.stringify(DEFAULT_ZOOM_TO_LEVEL)) {
console.warn('Tile parameter ZOOM_TO_LEVEL have changed in stock intel. Detected correct values, but code should be updated');
debugger;
}
if ( JSON.stringify(niantic_params.TILES_PER_EDGE) != JSON.stringify(DEFAULT_ZOOM_TO_TILES_PER_EDGE)) {
console.warn('Tile parameter TILES_PER_EDGE have changed in stock intel. Detected correct values, but code should be updated');
debugger;
}
} else {
dialog({
title: 'IITC Warning',
html: "<p>IITC failed to detect the ZOOM_TO_LEVEL and/or TILES_PER_EDGE settings from the stock intel site.</p>"
+"<p>IITC is now using fallback default values. However, if detection has failed it's likely the values have changed."
+" IITC may not load the map if these default values are wrong.</p>",
});
window.TILE_PARAMS.ZOOM_TO_LEVEL = DEFAULT_ZOOM_TO_LEVEL;
window.TILE_PARAMS.TILES_PER_EDGE = DEFAULT_ZOOM_TO_TILES_PER_EDGE;
}
// 2015-07-01: niantic added code to the stock site that overrides the min zoom level for unclaimed portals to 15 and above
// instead of updating the zoom-to-level array. makes no sense really....
// we'll just chop off the array at that point, so the code defaults to level 0 (unclaimed) everywhere...
window.TILE_PARAMS.ZOOM_TO_LEVEL = window.TILE_PARAMS.ZOOM_TO_LEVEL.slice(0,15);
}
window.debugMapZoomParameters = function() {
//for debug purposes, log the tile params used for each zoom level
console.log('DEBUG: Map Zoom Parameters');
var doneZooms = {};
for (var z=MIN_ZOOM; z<=21; z++) {
var ourZoom = getDataZoomForMapZoom(z);
console.log('DEBUG: map zoom '+z+': IITC requests '+ourZoom+(ourZoom!=z?' instead':''));
if (!doneZooms[ourZoom]) {
var params = getMapZoomTileParameters(ourZoom);
var msg = 'DEBUG: data zoom '+ourZoom;
if (params.hasPortals) {
msg += ' has portals, L'+params.level+'+';
} else {
msg += ' NO portals (was L'+params.level+'+)';
}
msg += ', minLinkLength='+params.minLinkLength;
msg += ', tiles per edge='+params.tilesPerEdge;
console.log(msg);
doneZooms[ourZoom] = true;
}
}
}
window.getMapZoomTileParameters = function(zoom) {
// the current API allows the client to request a minimum portal level. the window.TILE_PARAMS.ZOOM_TO_LEVEL list are minimums
// however, in my view, this can return excessive numbers of portals in many cases. let's try an optional reduction
// of detail level at some zoom levels
var level = window.TILE_PARAMS.ZOOM_TO_LEVEL[zoom] || 0; // default to level 0 (all portals) if not in array
// if (window.CONFIG_ZOOM_SHOW_LESS_PORTALS_ZOOMED_OUT) {
// if (level <= 7 && level >= 4) {
// // reduce portal detail level by one - helps reduce clutter
// level = level+1;
// }
// }
var maxTilesPerEdge = window.TILE_PARAMS.TILES_PER_EDGE[window.TILE_PARAMS.TILES_PER_EDGE.length-1];
return {
level: level,
maxLevel: window.TILE_PARAMS.ZOOM_TO_LEVEL[zoom] || 0, // for reference, for log purposes, etc
tilesPerEdge: window.TILE_PARAMS.TILES_PER_EDGE[zoom] || maxTilesPerEdge,
minLinkLength: window.TILE_PARAMS.ZOOM_TO_LINK_LENGTH[zoom] || 0,
hasPortals: zoom >= window.TILE_PARAMS.ZOOM_TO_LINK_LENGTH.length, // no portals returned at all when link length limits things
zoom: zoom // include the zoom level, for reference
};
}
window.getDataZoomForMapZoom = function(zoom) {
// we can fetch data at a zoom level different to the map zoom.
//NOTE: the specifics of this are tightly coupled with the above ZOOM_TO_LEVEL and TILES_PER_EDGE arrays
// firstly, some of IITCs zoom levels, depending on base map layer, can be higher than stock. limit zoom level
// (stock site max zoom may vary depending on google maps detail in the area - 20 or 21 max is common)
if (zoom > 21) {
zoom = 21;
}
if (!window.CONFIG_ZOOM_DEFAULT_DETAIL_LEVEL) {
// to improve the cacheing performance, we try and limit the number of zoom levels we retrieve data for
// to avoid impacting server load, we keep ourselves restricted to a zoom level with the sane numbre
// of tilesPerEdge and portal levels visible
var origTileParams = getMapZoomTileParameters(zoom);
while (zoom > MIN_ZOOM) {
var newTileParams = getMapZoomTileParameters(zoom-1);
if ( newTileParams.tilesPerEdge != origTileParams.tilesPerEdge
|| newTileParams.hasPortals != origTileParams.hasPortals
|| newTileParams.level*newTileParams.hasPortals != origTileParams.level*origTileParams.hasPortals // multiply by 'hasPortals' bool - so comparison does not matter when no portals available
) {
// switching to zoom-1 would result in a different detail level - so we abort changing things
break;
} else {
// changing to zoom = zoom-1 results in identical tile parameters - so we can safely step back
// with no increase in either server load or number of requests
zoom = zoom-1;
}
}
}
return zoom;
}
window.lngToTile = function(lng, params) {
return Math.floor((lng + 180) / 360 * params.tilesPerEdge);
}
window.latToTile = function(lat, params) {
return Math.floor((1 - Math.log(Math.tan(lat * Math.PI / 180) +
1 / Math.cos(lat * Math.PI / 180)) / Math.PI) / 2 * params.tilesPerEdge);
}
window.tileToLng = function(x, params) {
return x / params.tilesPerEdge * 360 - 180;
}
window.tileToLat = function(y, params) {
var n = Math.PI - 2 * Math.PI * y / params.tilesPerEdge;
return 180 / Math.PI * Math.atan(0.5 * (Math.exp(n) - Math.exp(-n)));
}
window.pointToTileId = function(params, x, y) {
//change to quadkey construction
//as of 2014-05-06: zoom_x_y_minlvl_maxlvl_maxhealth
return params.zoom + "_" + x + "_" + y + "_" + params.level + "_8_100";
}
window.getResonatorLatLng = function(dist, slot, portalLatLng) {
// offset in meters
var dn = dist*SLOT_TO_LAT[slot];
var de = dist*SLOT_TO_LNG[slot];
// Coordinate offset in radians
var dLat = dn/EARTH_RADIUS;
var dLon = de/(EARTH_RADIUS*Math.cos(Math.PI/180*portalLatLng[0]));
// OffsetPosition, decimal degrees
var lat0 = portalLatLng[0] + dLat * 180/Math.PI;
var lon0 = portalLatLng[1] + dLon * 180/Math.PI;
return [lat0, lon0];
}
;
// MAP DATA DEBUG //////////////////////////////////////
// useful bits to assist debugging map data tiles
window.RenderDebugTiles = function() {
this.CLEAR_CHECK_TIME = L.Path.CANVAS ? 2.0 : 0.5;
this.FADE_TIME = 2.0;
this.debugTileLayer = L.layerGroup();
window.addLayerGroup("DEBUG Data Tiles", this.debugTileLayer, false);
this.debugTileToRectangle = {};
this.debugTileClearTimes = {};
this.timer = undefined;
}
window.RenderDebugTiles.prototype.reset = function() {
this.debugTileLayer.clearLayers();
this.debugTileToRectangle = {};
this.debugTileClearTimes = {};
}
window.RenderDebugTiles.prototype.create = function(id,bounds) {
var s = {color: '#666', weight: 2, opacity: 0.4, fillColor: '#666', fillOpacity: 0.1, clickable: false};
var bounds = new L.LatLngBounds(bounds);
bounds = bounds.pad(-0.02);
var l = L.rectangle(bounds,s);
this.debugTileToRectangle[id] = l;
this.debugTileLayer.addLayer(l);
if (map.hasLayer(this.debugTileLayer)) {
// only bring to back if we have the debug layer turned on
l.bringToBack();
}
}
window.RenderDebugTiles.prototype.setColour = function(id,bordercol,fillcol) {
var l = this.debugTileToRectangle[id];
if (l) {
var s = {color: bordercol, fillColor: fillcol};
l.setStyle(s);
}
}
window.RenderDebugTiles.prototype.setState = function(id,state) {
var col = '#f0f';
var fill = '#f0f';
var clearDelay = -1;
switch(state) {
case 'ok': col='#0f0'; fill='#0f0'; clearDelay = 2; break;
case 'error': col='#f00'; fill='#f00'; clearDelay = 30; break;
case 'cache-fresh': col='#0f0'; fill='#ff0'; clearDelay = 2; break;
case 'cache-stale': col='#f00'; fill='#ff0'; clearDelay = 10; break;
case 'requested': col='#66f'; fill='#66f'; break;
case 'retrying': col='#666'; fill='#666'; break;
case 'request-fail': col='#a00'; fill='#666'; break;
case 'tile-fail': col='#f00'; fill='#666'; break;
case 'tile-timeout': col='#ff0'; fill='#666'; break;
case 'render-queue': col='#f0f'; fill='#f0f'; break;
}
this.setColour (id, col, fill);
if (clearDelay >= 0) {
var clearAt = Date.now() + clearDelay*1000;
this.debugTileClearTimes[id] = clearAt;
if (!this.timer) {
this.startTimer(clearDelay*1000);
}
}
}
window.RenderDebugTiles.prototype.startTimer = function(waitTime) {
var _this = this;
if (!_this.timer) {
// a timeout of 0 firing the actual timeout - helps things run smoother
_this.timer = setTimeout ( function() {
_this.timer = setTimeout ( function() { _this.timer = undefined; _this.runClearPass(); }, waitTime );
}, 0);
}
}
window.RenderDebugTiles.prototype.runClearPass = function() {
var now = Date.now();
for (var id in this.debugTileClearTimes) {
var diff = now - this.debugTileClearTimes[id];
if (diff > 0) {
if (diff > this.FADE_TIME*1000) {
this.debugTileLayer.removeLayer(this.debugTileToRectangle[id]);
delete this.debugTileClearTimes[id];
} else {
var fade = 1.0 - (diff / (this.FADE_TIME*1000));
this.debugTileToRectangle[id].setStyle ({ opacity: 0.4*fade, fillOpacity: 0.1*fade });
}
}
}
if (Object.keys(this.debugTileClearTimes).length > 0) {
this.startTimer(this.CLEAR_CHECK_TIME*1000);
}
}
;
// MAP DATA RENDER ////////////////////////////////////////////////
// class to handle rendering into leaflet the JSON data from the servers
window.Render = function() {
this.portalMarkerScale = undefined;
}
// start a render pass. called as we start to make the batch of data requests to the servers
window.Render.prototype.startRenderPass = function(level,bounds) {
this.isRendering = true;
this.deletedGuid = {}; // object - represents the set of all deleted game entity GUIDs seen in a render pass
this.seenPortalsGuid = {};
this.seenLinksGuid = {};
this.seenFieldsGuid = {};
this.bounds = bounds;
this.level = level;
// we pad the bounds used for clearing a litle bit, as entities are sometimes returned outside of their specified tile boundaries
// this will just avoid a few entity removals at start of render when they'll just be added again
var paddedBounds = bounds.pad(0.1);
this.clearPortalsOutsideBounds(paddedBounds);
this.clearLinksOutsideBounds(paddedBounds);
this.clearFieldsOutsideBounds(paddedBounds);
this.rescalePortalMarkers();
}
window.Render.prototype.clearPortalsOutsideBounds = function(bounds) {
var count = 0;
for (var guid in window.portals) {
var p = portals[guid];
// clear portals outside visible bounds - unless it's the selected portal, or it's relevant to artifacts
if (!bounds.contains(p.getLatLng()) && guid !== selectedPortal && !artifact.isInterestingPortal(guid)) {
this.deletePortalEntity(guid);
count++;
}
}
console.log('Render: deleted '+count+' portals by level/bounds');
}
window.Render.prototype.clearLinksOutsideBounds = function(bounds) {
var count = 0;
for (var guid in window.links) {
var l = links[guid];
// NOTE: our geodesic lines can have lots of intermediate points. the bounds calculation hasn't been optimised for this
// so can be particularly slow. a simple bounds check based on start+end point will be good enough for this check
var lls = l.getLatLngs();
var linkBounds = L.latLngBounds(lls);
if (!bounds.intersects(linkBounds)) {
this.deleteLinkEntity(guid);
count++;
}
}
console.log('Render: deleted '+count+' links by bounds');
}
window.Render.prototype.clearFieldsOutsideBounds = function(bounds) {
var count = 0;
for (var guid in window.fields) {
var f = fields[guid];
// NOTE: our geodesic polys can have lots of intermediate points. the bounds calculation hasn't been optimised for this
// so can be particularly slow. a simple bounds check based on corner points will be good enough for this check
var lls = f.getLatLngs();
var fieldBounds = L.latLngBounds([lls[0],lls[1]]).extend(lls[2]);
if (!bounds.intersects(fieldBounds)) {
this.deleteFieldEntity(guid);
count++;
}
}
console.log('Render: deleted '+count+' fields by bounds');
}
// process deleted entity list and entity data
window.Render.prototype.processTileData = function(tiledata) {
this.processDeletedGameEntityGuids(tiledata.deletedGameEntityGuids||[]);
this.processGameEntities(tiledata.gameEntities||[]);
}
window.Render.prototype.processDeletedGameEntityGuids = function(deleted) {
for(var i in deleted) {
var guid = deleted[i];
if ( !(guid in this.deletedGuid) ) {
this.deletedGuid[guid] = true; // flag this guid as having being processed
if (guid == selectedPortal) {
// the rare case of the selected portal being deleted. clear the details tab and deselect it
renderPortalDetails(null);
}
this.deleteEntity(guid);
}
}
}
window.Render.prototype.processGameEntities = function(entities) {
// we loop through the entities three times - for fields, links and portals separately
// this is a reasonably efficient work-around for leafletjs limitations on svg render order
for (var i in entities) {
var ent = entities[i];
if (ent[2][0] == 'r' && !(ent[0] in this.deletedGuid)) {
this.createFieldEntity(ent);
}
}
for (var i in entities) {
var ent = entities[i];
if (ent[2][0] == 'e' && !(ent[0] in this.deletedGuid)) {
this.createLinkEntity(ent);
}
}
for (var i in entities) {
var ent = entities[i];
if (ent[2][0] == 'p' && !(ent[0] in this.deletedGuid)) {
this.createPortalEntity(ent);
}
}
}
// end a render pass. does any cleaning up required, postponed processing of data, etc. called when the render
// is considered complete
window.Render.prototype.endRenderPass = function() {
var countp=0,countl=0,countf=0;
// check to see if there are any entities we haven't seen. if so, delete them
for (var guid in window.portals) {
// special case for selected portal - it's kept even if not seen
// artifact (e.g. jarvis shard) portals are also kept - but they're always 'seen'
if (!(guid in this.seenPortalsGuid) && guid !== selectedPortal) {
this.deletePortalEntity(guid);
countp++;
}
}
for (var guid in window.links) {
if (!(guid in this.seenLinksGuid)) {
this.deleteLinkEntity(guid);
countl++;
}
}
for (var guid in window.fields) {
if (!(guid in this.seenFieldsGuid)) {
this.deleteFieldEntity(guid);
countf++;
}
}
console.log('Render: end cleanup: removed '+countp+' portals, '+countl+' links, '+countf+' fields');
// reorder portals to be after links/fields
this.bringPortalsToFront();
this.isRendering = false;
// re-select the selected portal, to re-render the side-bar. ensures that any data calculated from the map data is up to date
if (selectedPortal) {
renderPortalDetails (selectedPortal);
}
}
window.Render.prototype.bringPortalsToFront = function() {
for (var lvl in portalsFactionLayers) {
// portals are stored in separate layers per faction
// to avoid giving weight to one faction or another, we'll push portals to front based on GUID order
var lvlPortals = {};
for (var fac in portalsFactionLayers[lvl]) {
var layer = portalsFactionLayers[lvl][fac];
if (layer._map) {
layer.eachLayer (function(p) {
lvlPortals[p.options.guid] = p;
});
}
}
var guids = Object.keys(lvlPortals);
guids.sort();
for (var j in guids) {
var guid = guids[j];
lvlPortals[guid].bringToFront();
}
}
// artifact portals are always brought to the front, above all others
$.each(artifact.getInterestingPortals(), function(i,guid) {
if (portals[guid] && portals[guid]._map) {
portals[guid].bringToFront();
}
});
}
window.Render.prototype.deleteEntity = function(guid) {
this.deletePortalEntity(guid);
this.deleteLinkEntity(guid);
this.deleteFieldEntity(guid);
}
window.Render.prototype.deletePortalEntity = function(guid) {
if (guid in window.portals) {
var p = window.portals[guid];
window.ornaments.removePortal(p);
this.removePortalFromMapLayer(p);
delete window.portals[guid];
window.runHooks('portalRemoved', {portal: p, data: p.options.data });
}
}
window.Render.prototype.deleteLinkEntity = function(guid) {
if (guid in window.links) {
var l = window.links[guid];
linksFactionLayers[l.options.team].removeLayer(l);
delete window.links[guid];
window.runHooks('linkRemoved', {link: l, data: l.options.data });
}
}
window.Render.prototype.deleteFieldEntity = function(guid) {
if (guid in window.fields) {
var f = window.fields[guid];
var fd = f.options.details;
fieldsFactionLayers[f.options.team].removeLayer(f);
delete window.fields[guid];
window.runHooks('fieldRemoved', {field: f, data: f.options.data });
}
}
window.Render.prototype.createPlaceholderPortalEntity = function(guid,latE6,lngE6,team) {
// intel no longer returns portals at anything but the closest zoom
// stock intel creates 'placeholder' portals from the data in links/fields - IITC needs to do the same
// we only have the portal guid, lat/lng coords, and the faction - no other data
// having the guid, at least, allows the portal details to be loaded once it's selected. however,
// no highlighters, portal level numbers, portal names, useful counts of portals, etc are possible
var ent = [
guid, //ent[0] = guid
0, //ent[1] = timestamp - zero will mean any other source of portal data will have a higher timestamp
//ent[2] = an array with the entity data
[ 'p', //0 - a portal
team, //1 - team
latE6, //2 - lat
lngE6 //3 - lng
]
];
// placeholder portals don't have a useful timestamp value - so the standard code that checks for updated
// portal details doesn't apply
// so, check that the basic details are valid and delete the existing portal if out of date
if (guid in window.portals) {
var p = window.portals[guid];
if (team != p.options.data.team || latE6 != p.options.data.latE6 || lngE6 != p.options.data.lngE6) {
// team or location have changed - delete existing portal
this.deletePortalEntity(guid);
}
}
this.createPortalEntity(ent);
}
window.Render.prototype.createPortalEntity = function(ent) {
this.seenPortalsGuid[ent[0]] = true; // flag we've seen it
var previousData = undefined;
// check if entity already exists
if (ent[0] in window.portals) {
// yes. now check to see if the entity data we have is newer than that in place
var p = window.portals[ent[0]];
if (p.options.timestamp >= ent[1]) return; // this data is identical or older - abort processing
// the data we have is newer. many data changes require re-rendering of the portal
// (e.g. level changed, so size is different, or stats changed so highlighter is different)
// so to keep things simple we'll always re-create the entity in this case
// remember the old details, for the callback
previousData = p.options.data;
this.deletePortalEntity(ent[0]);
}
var portalLevel = parseInt(ent[2][4])||0;
var team = teamStringToId(ent[2][1]);
// the data returns unclaimed portals as level 1 - but IITC wants them treated as level 0
if (team == TEAM_NONE) portalLevel = 0;
var latlng = L.latLng(ent[2][2]/1E6, ent[2][3]/1E6);
var data = decodeArray.portalSummary(ent[2]);
var dataOptions = {
level: portalLevel,
team: team,
ent: ent, // LEGACY - TO BE REMOVED AT SOME POINT! use .guid, .timestamp and .data instead
guid: ent[0],
timestamp: ent[1],
data: data
};
window.pushPortalGuidPositionCache(ent[0], data.latE6, data.lngE6);
var marker = createMarker(latlng, dataOptions);
marker.on('click', function() { window.renderPortalDetails(ent[0]); });
marker.on('dblclick', function() { window.renderPortalDetails(ent[0]); window.map.setView(latlng, 17); });
window.runHooks('portalAdded', {portal: marker, previousData: previousData});
window.portals[ent[0]] = marker;
// check for URL links to portal, and select it if this is the one
if (urlPortalLL && urlPortalLL[0] == marker.getLatLng().lat && urlPortalLL[1] == marker.getLatLng().lng) {
// URL-passed portal found via pll parameter - set the guid-based parameter
console.log('urlPortalLL '+urlPortalLL[0]+','+urlPortalLL[1]+' matches portal GUID '+ent[0]);
urlPortal = ent[0];
urlPortalLL = undefined; // clear the URL parameter so it's not matched again
}
if (urlPortal == ent[0]) {
// URL-passed portal found via guid parameter - set it as the selected portal
console.log('urlPortal GUID '+urlPortal+' found - selecting...');
selectedPortal = ent[0];
urlPortal = undefined; // clear the URL parameter so it's not matched again
}
// (re-)select the portal, to refresh the sidebar on any changes
if (ent[0] == selectedPortal) {
console.log('portal guid '+ent[0]+' is the selected portal - re-rendering portal details');
renderPortalDetails (selectedPortal);
}
window.ornaments.addPortal(marker);
//TODO? postpone adding to the map layer
this.addPortalToMapLayer(marker);
}
window.Render.prototype.createFieldEntity = function(ent) {
this.seenFieldsGuid[ent[0]] = true; // flag we've seen it
var data = {
// type: ent[2][0],
team: ent[2][1],
points: ent[2][2].map(function(arr) { return {guid: arr[0], latE6: arr[1], lngE6: arr[2] }; })
};
//create placeholder portals for field corners. we already do links, but there are the odd case where this is useful
for (var i=0; i<3; i++) {
var p=data.points[i];
this.createPlaceholderPortalEntity(p.guid, p.latE6, p.lngE6, data.team);
}
// check if entity already exists
if(ent[0] in window.fields) {
// yes. in theory, we should never get updated data for an existing field. they're created, and they're destroyed - never changed
// but theory and practice may not be the same thing...
var f = window.fields[ent[0]];
if (f.options.timestamp >= ent[1]) return; // this data is identical (or order) than that rendered - abort processing
// the data we have is newer - two options
// 1. just update the data, assume the field render appearance is unmodified
// 2. delete the entity, then re-create with the new data
this.deleteFieldEntity(ent[0]); // option 2, for now
}
var team = teamStringToId(ent[2][1]);
var latlngs = [
L.latLng(data.points[0].latE6/1E6, data.points[0].lngE6/1E6),
L.latLng(data.points[1].latE6/1E6, data.points[1].lngE6/1E6),
L.latLng(data.points[2].latE6/1E6, data.points[2].lngE6/1E6)
];
var poly = L.geodesicPolygon(latlngs, {
fillColor: COLORS[team],
fillOpacity: 0.25,
stroke: false,
clickable: false,
team: team,
ent: ent, // LEGACY - TO BE REMOVED AT SOME POINT! use .guid, .timestamp and .data instead
guid: ent[0],
timestamp: ent[1],
data: data,
});
runHooks('fieldAdded',{field: poly});
window.fields[ent[0]] = poly;
// TODO? postpone adding to the layer??
fieldsFactionLayers[poly.options.team].addLayer(poly);
}
window.Render.prototype.createLinkEntity = function(ent,faked) {
// Niantic have been faking link entities, based on data from fields
// these faked links are sent along with the real portal links, causing duplicates
// the faked ones all have longer GUIDs, based on the field GUID (with _ab, _ac, _bc appended)
var fakedLink = new RegExp("^[0-9a-f]{32}\.b_[ab][bc]$"); //field GUIDs always end with ".b" - faked links append the edge identifier
if (fakedLink.test(ent[0])) return;
this.seenLinksGuid[ent[0]] = true; // flag we've seen it
var data = { // TODO add other properties and check correction direction
// type: ent[2][0],
team: ent[2][1],
oGuid: ent[2][2],
oLatE6: ent[2][3],
oLngE6: ent[2][4],
dGuid: ent[2][5],
dLatE6: ent[2][6],
dLngE6: ent[2][7]
};
// create placeholder entities for link start and end points (before checking if the link itself already exists
this.createPlaceholderPortalEntity(data.oGuid, data.oLatE6, data.oLngE6, data.team);
this.createPlaceholderPortalEntity(data.dGuid, data.dLatE6, data.dLngE6, data.team);
// check if entity already exists
if (ent[0] in window.links) {
// yes. now, as sometimes links are 'faked', they have incomplete data. if the data we have is better, replace the data
var l = window.links[ent[0]];
// the faked data will have older timestamps than real data (currently, faked set to zero)
if (l.options.timestamp >= ent[1]) return; // this data is older or identical to the rendered data - abort processing
// the data is newer/better - two options
// 1. just update the data. assume the link render appearance is unmodified
// 2. delete the entity, then re-create it with the new data
this.deleteLinkEntity(ent[0]); // option 2 - for now
}
var team = teamStringToId(ent[2][1]);
var latlngs = [
L.latLng(data.oLatE6/1E6, data.oLngE6/1E6),
L.latLng(data.dLatE6/1E6, data.dLngE6/1E6)
];
var poly = L.geodesicPolyline(latlngs, {
color: COLORS[team],
opacity: 1,
weight: faked ? 1 : 2,
clickable: false,
team: team,
ent: ent, // LEGACY - TO BE REMOVED AT SOME POINT! use .guid, .timestamp and .data instead
guid: ent[0],
timestamp: ent[1],
data: data
});
runHooks('linkAdded', {link: poly});
window.links[ent[0]] = poly;
linksFactionLayers[poly.options.team].addLayer(poly);
}
window.Render.prototype.rescalePortalMarkers = function() {
if (this.portalMarkerScale === undefined || this.portalMarkerScale != portalMarkerScale()) {
this.portalMarkerScale = portalMarkerScale();
console.log('Render: map zoom '+map.getZoom()+' changes portal scale to '+portalMarkerScale()+' - redrawing all portals');
//NOTE: we're not calling this because it resets highlights - we're calling it as it
// resets the style (inc size) of all portal markers, applying the new scale
resetHighlightedPortals();
}
}
// add the portal to the visible map layer
window.Render.prototype.addPortalToMapLayer = function(portal) {
portalsFactionLayers[parseInt(portal.options.level)||0][portal.options.team].addLayer(portal);
}
window.Render.prototype.removePortalFromMapLayer = function(portal) {
//remove it from the portalsLevels layer
portalsFactionLayers[parseInt(portal.options.level)||0][portal.options.team].removeLayer(portal);
}
;
// MAP DATA REQUEST ///////////////////////////////////////////////////
// class to request the map data tiles from the Ingress servers
// and then pass it on to the render class for display purposes
// Uses the map data cache class to reduce network requests
window.MapDataRequest = function() {
this.cache = new DataCache();
this.render = new Render();
this.debugTiles = new RenderDebugTiles();
this.activeRequestCount = 0;
this.requestedTiles = {};
this.renderQueue = [];
this.renderQueueTimer = undefined;
this.renderQueuePaused = false;
this.idle = false;
// no more than this many requests in parallel. stock site seems to rely on browser limits (6, usually), sending
// many requests at once.
// using our own queue limit ensures that other requests (e.g. chat, portal details) don't get delayed
this.MAX_REQUESTS = 5;
// this many tiles in one request
this.NUM_TILES_PER_REQUEST = 25;
// number of times to retry a tile after an error (including "error: TIMEOUT" now - as stock intel does)
// TODO? different retry counters for TIMEOUT vs other errors..?
this.MAX_TILE_RETRIES = 5;
// refresh timers
this.MOVE_REFRESH = 3; //time, after a map move (pan/zoom) before starting the refresh processing
this.STARTUP_REFRESH = 3; //refresh time used on first load of IITC
this.IDLE_RESUME_REFRESH = 5; //refresh time used after resuming from idle
// after one of the above, there's an additional delay between preparing the refresh (clearing out of bounds,
// processing cache, etc) and actually sending the first network requests
this.DOWNLOAD_DELAY = 1; //delay after preparing the data download before tile requests are sent
// a short delay between one request finishing and the queue being run for the next request.
this.RUN_QUEUE_DELAY = 0;
// delay before processing the queue after failed requests
this.BAD_REQUEST_RUN_QUEUE_DELAY = 5; // longer delay before doing anything after errors (other than TIMEOUT)
// delay before processing the queue after empty responses
this.EMPTY_RESPONSE_RUN_QUEUE_DELAY = 5; // also long delay - empty responses are likely due to some server issues
// delay before processing the queue after error==TIMEOUT requests. this is 'expected', so minimal extra delay over the regular RUN_QUEUE_DELAY
this.TIMEOUT_REQUEST_RUN_QUEUE_DELAY = 0;
// render queue
// number of items to process in each render pass. there are pros and cons to smaller and larger values
// (however, if using leaflet canvas rendering, it makes sense to push as much as possible through every time)
this.RENDER_BATCH_SIZE = L.Path.CANVAS ? 1E9 : 1500;
// delay before repeating the render loop. this gives a better chance for user interaction
this.RENDER_PAUSE = (typeof android === 'undefined') ? 0.1 : 0.2; //100ms desktop, 200ms mobile
this.REFRESH_CLOSE = 300; // refresh time to use for close views z>12 when not idle and not moving
this.REFRESH_FAR = 900; // refresh time for far views z <= 12
this.FETCH_TO_REFRESH_FACTOR = 2; //minumum refresh time is based on the time to complete a data fetch, times this value
// ensure we have some initial map status
this.setStatus ('startup', undefined, -1);
// add a portalDetailLoaded hook, so we can use the exteneed details to update portals on the map
var _this = this;
addHook('portalDetailLoaded',function(data){
_this.render.processGameEntities([data.ent]);
});
}
window.MapDataRequest.prototype.start = function() {
var savedContext = this;
// setup idle resume function
window.addResumeFunction ( function() { savedContext.idleResume(); } );
// and map move start/end callbacks
window.map.on('movestart', this.mapMoveStart, this);
window.map.on('moveend', this.mapMoveEnd, this);
// then set a timeout to start the first refresh
this.refreshOnTimeout (this.STARTUP_REFRESH);
this.setStatus ('refreshing', undefined, -1);
this.cache && this.cache.startExpireInterval (15);
}
window.MapDataRequest.prototype.mapMoveStart = function() {
console.log('refresh map movestart');
this.setStatus('paused');
this.clearTimeout();
this.pauseRenderQueue(true);
}
window.MapDataRequest.prototype.mapMoveEnd = function() {
var bounds = clampLatLngBounds(map.getBounds());
var zoom = map.getZoom();
if (this.fetchedDataParams) {
// we have fetched (or are fetching) data...
if (this.fetchedDataParams.mapZoom == map.getZoom() && this.fetchedDataParams.bounds.contains(bounds)) {
// ... and the zoom level is the same and the current bounds is inside the fetched bounds
// so, no need to fetch data. if there's time left, restore the original timeout
var remainingTime = (this.timerExpectedTimeoutTime - new Date().getTime())/1000;
if (remainingTime > this.MOVE_REFRESH) {
this.setStatus('done','Map moved, but no data updates needed');
this.refreshOnTimeout(remainingTime);
this.pauseRenderQueue(false);
return;
}
}
}
this.setStatus('refreshing', undefined, -1);
this.refreshOnTimeout(this.MOVE_REFRESH);
}
window.MapDataRequest.prototype.idleResume = function() {
// if we have no timer set and there are no active requests, refresh has gone idle and the timer needs restarting
if (this.idle) {
console.log('refresh map idle resume');
this.idle = false;
this.setStatus('idle restart', undefined, -1);
this.refreshOnTimeout(this.IDLE_RESUME_REFRESH);
}
}
window.MapDataRequest.prototype.clearTimeout = function() {
if (this.timer) {
console.log('cancelling existing map refresh timer');
clearTimeout(this.timer);
this.timer = undefined;
}
}
window.MapDataRequest.prototype.refreshOnTimeout = function(seconds) {
this.clearTimeout();
console.log('starting map refresh in '+seconds+' seconds');
// 'this' won't be right inside the callback, so save it
// also, double setTimeout used to ensure the delay occurs after any browser-related rendering/updating/etc
var _this = this;
this.timer = setTimeout ( function() {
_this.timer = setTimeout ( function() { _this.timer = undefined; _this.refresh(); }, seconds*1000);
}, 0);
this.timerExpectedTimeoutTime = new Date().getTime() + seconds*1000;
}
window.MapDataRequest.prototype.setStatus = function(short,long,progress) {
this.status = { short: short, long: long, progress: progress };
window.renderUpdateStatus();
}
window.MapDataRequest.prototype.getStatus = function() {
return this.status;
};
window.MapDataRequest.prototype.refresh = function() {
// if we're idle, don't refresh
if (window.isIdle()) {
console.log('suspending map refresh - is idle');
this.setStatus ('idle');
this.idle = true;
return;
}
//time the refresh cycle
this.refreshStartTime = new Date().getTime();
this.debugTiles.reset();
this.resetRenderQueue();
// a 'set' to keep track of hard failures for tiles
this.tileErrorCount = {};
// the 'set' of requested tile QKs
// NOTE: javascript does not guarantee any order to properties of an object. however, in all major implementations
// properties retain the order they are added in. IITC uses this to control the tile fetch order. if browsers change
// then fetch order isn't optimal, but it won't break things.
this.queuedTiles = {};
var bounds = clampLatLngBounds(map.getBounds());
var mapZoom = map.getZoom();
var dataZoom = getDataZoomForMapZoom(mapZoom);
var tileParams = getMapZoomTileParameters(dataZoom);
//DEBUG: resize the bounds so we only retrieve some data
//bounds = bounds.pad(-0.4);
//var debugrect = L.rectangle(bounds,{color: 'red', fill: false, weight: 4, opacity: 0.8}).addTo(map);
//setTimeout (function(){ map.removeLayer(debugrect); }, 10*1000);
var x1 = lngToTile(bounds.getWest(), tileParams);
var x2 = lngToTile(bounds.getEast(), tileParams);
var y1 = latToTile(bounds.getNorth(), tileParams);
var y2 = latToTile(bounds.getSouth(), tileParams);
// calculate the full bounds for the data - including the part of the tiles off the screen edge
var dataBounds = L.latLngBounds([
[tileToLat(y2+1,tileParams), tileToLng(x1,tileParams)],
[tileToLat(y1,tileParams), tileToLng(x2+1,tileParams)]
]);
//var debugrect2 = L.rectangle(dataBounds,{color: 'magenta', fill: false, weight: 4, opacity: 0.8}).addTo(map);
//setTimeout (function(){ map.removeLayer(debugrect2); }, 10*1000);
// store the parameters used for fetching the data. used to prevent unneeded refreshes after move/zoom
this.fetchedDataParams = { bounds: dataBounds, mapZoom: mapZoom, dataZoom: dataZoom };
window.runHooks ('mapDataRefreshStart', {bounds: bounds, mapZoom: mapZoom, dataZoom: dataZoom, minPortalLevel: tileParams.level, tileBounds: dataBounds});
this.render.startRenderPass(tileParams.level, dataBounds);
var _render = this.render;
window.runHooks ('mapDataEntityInject', {callback: function(ents) { _render.processGameEntities(ents);}});
this.render.processGameEntities(artifact.getArtifactEntities());
var logMessage = 'requesting data tiles at zoom '+dataZoom;
if (tileParams.level != tileParams.maxLevel) {
logMessage += ' (L'+tileParams.level+'+ portals - could have done L'+tileParams.maxLevel+'+';
} else {
logMessage += ' (L'+tileParams.level+'+ portals';
}
logMessage += ', '+tileParams.tilesPerEdge+' tiles per global edge), map zoom is '+mapZoom;
console.log(logMessage);
this.cachedTileCount = 0;
this.requestedTileCount = 0;
this.successTileCount = 0;
this.failedTileCount = 0;
this.staleTileCount = 0;
var tilesToFetchDistance = {};
// map center point - for fetching center tiles first
var mapCenterPoint = map.project(map.getCenter(), mapZoom);
// y goes from left to right
for (var y = y1; y <= y2; y++) {
// x goes from bottom to top(?)
for (var x = x1; x <= x2; x++) {
var tile_id = pointToTileId(tileParams, x, y);
var latNorth = tileToLat(y,tileParams);
var latSouth = tileToLat(y+1,tileParams);
var lngWest = tileToLng(x,tileParams);
var lngEast = tileToLng(x+1,tileParams);
this.debugTiles.create(tile_id,[[latSouth,lngWest],[latNorth,lngEast]]);
//TODO: with recent backend changes there are now multiple zoom levels of data that is identical except perhaps for some
// reduction of detail when zoomed out. to take good advantage of the cache, a check for cached data at a closer zoom
// but otherwise the same parameters (min portal level, tiles per edge) will mean less downloads when zooming out
// (however, the default code in getDataZoomForMapZoom currently reduces the need for this, as it forces the furthest
// out zoom tiles for a detail level)
if (this.cache && this.cache.isFresh(tile_id) ) {
// data is fresh in the cache - just render it
this.pushRenderQueue(tile_id,this.cache.get(tile_id),'cache-fresh');
this.cachedTileCount += 1;
} else {
// no fresh data
// tile needed. calculate the distance from the centre of the screen, to optimise the load order
var latCenter = (latNorth+latSouth)/2;
var lngCenter = (lngEast+lngWest)/2;
var tileLatLng = L.latLng(latCenter,lngCenter);
var tilePoint = map.project(tileLatLng, mapZoom);
var delta = mapCenterPoint.subtract(tilePoint);
var distanceSquared = delta.x*delta.x + delta.y*delta.y;
tilesToFetchDistance[tile_id] = distanceSquared;
this.requestedTileCount += 1;
}
}
}
// re-order the tile list by distance from the centre of the screen. this should load more relevant data first
var tilesToFetch = Object.keys(tilesToFetchDistance);
tilesToFetch.sort(function(a,b) {
return tilesToFetchDistance[a]-tilesToFetchDistance[b];
});
for (var i in tilesToFetch) {
var qk = tilesToFetch[i];
this.queuedTiles[qk] = qk;
}
this.setStatus ('loading', undefined, -1);
// technically a request hasn't actually finished - however, displayed portal data has been refreshed
// so as far as plugins are concerned, it should be treated as a finished request
window.runHooks('requestFinished', {success: true});
console.log ('done request preparation (cleared out-of-bounds and invalid for zoom, and rendered cached data)');
if (Object.keys(this.queuedTiles).length > 0) {
// queued requests - don't start processing the download queue immediately - start it after a short delay
this.delayProcessRequestQueue (this.DOWNLOAD_DELAY,true);
} else {
// all data was from the cache, nothing queued - run the queue 'immediately' so it handles the end request processing
this.delayProcessRequestQueue (0,true);
}
}
window.MapDataRequest.prototype.delayProcessRequestQueue = function(seconds,isFirst) {
if (this.timer === undefined) {
var _this = this;
this.timer = setTimeout ( function() {
_this.timer = setTimeout ( function() { _this.timer = undefined; _this.processRequestQueue(isFirst); }, seconds*1000 );
}, 0);
}
}
window.MapDataRequest.prototype.processRequestQueue = function(isFirstPass) {
// if nothing left in the queue, finish
if (Object.keys(this.queuedTiles).length == 0) {
// we leave the renderQueue code to handle ending the render pass now
// (but we need to make sure it's not left without it's timer running!)
if (!this.renderQueuePaused) {
this.startQueueTimer(this.RENDER_PAUSE);
}
return;
}
// create a list of tiles that aren't requested over the network
var pendingTiles = [];
for (var id in this.queuedTiles) {
if (!(id in this.requestedTiles) ) {
pendingTiles.push(id);
}
}
// console.log('- request state: '+Object.keys(this.requestedTiles).length+' tiles in '+this.activeRequestCount+' active requests, '+pendingTiles.length+' tiles queued');
var requestBuckets = this.MAX_REQUESTS - this.activeRequestCount;
if (pendingTiles.length > 0 && requestBuckets > 0) {
for (var bucket=0; bucket < requestBuckets; bucket++) {
// if the tiles for this request have had several retries, use smaller requests
// maybe some of the tiles caused all the others to error? no harm anyway, and it may help...
var numTilesThisRequest = Math.min(this.NUM_TILES_PER_REQUEST,pendingTiles.length);
var id = pendingTiles[0];
var retryTotal = (this.tileErrorCount[id]||0);
for (var i=1; i<numTilesThisRequest; i++) {
id = pendingTiles[i];
retryTotal += (this.tileErrorCount[id]||0);
if (retryTotal > this.MAX_TILE_RETRIES) {
numTilesThisRequest = i;
break;
}
}
var tiles = pendingTiles.splice(0, numTilesThisRequest);
if (tiles.length > 0) {
this.sendTileRequest(tiles);
}
}
}
// update status
var pendingTileCount = this.requestedTileCount - (this.successTileCount+this.failedTileCount+this.staleTileCount);
var longText = 'Tiles: ' + this.cachedTileCount + ' cached, ' +
this.successTileCount + ' loaded, ' +
(this.staleTileCount ? this.staleTileCount + ' stale, ' : '') +
(this.failedTileCount ? this.failedTileCount + ' failed, ' : '') +
pendingTileCount + ' remaining';
progress = this.requestedTileCount > 0 ? (this.requestedTileCount-pendingTileCount) / this.requestedTileCount : undefined;
this.setStatus ('loading', longText, progress);
}
window.MapDataRequest.prototype.sendTileRequest = function(tiles) {
var tilesList = [];
for (var i in tiles) {
var id = tiles[i];
this.debugTiles.setState (id, 'requested');
this.requestedTiles[id] = true;
if (id in this.queuedTiles) {
tilesList.push (id);
} else {
console.warn('no queue entry for tile id '+id);
}
}
var data = { tileKeys: tilesList };
this.activeRequestCount += 1;
var savedThis = this;
// NOTE: don't add the request with window.request.add, as we don't want the abort handling to apply to map data any more
window.postAjax('getEntities', data,
function(data, textStatus, jqXHR) { savedThis.handleResponse (data, tiles, true); }, // request successful callback
function() { savedThis.handleResponse (undefined, tiles, false); } // request failed callback
);
}
window.MapDataRequest.prototype.requeueTile = function(id, error) {
if (id in this.queuedTiles) {
// tile is currently wanted...
// first, see if the error can be ignored due to retry counts
if (error) {
this.tileErrorCount[id] = (this.tileErrorCount[id]||0)+1;
if (this.tileErrorCount[id] <= this.MAX_TILE_RETRIES) {
// retry limit low enough - clear the error flag
error = false;
}
}
if (error) {
// if error is still true, retry limit hit. use stale data from cache if available
var data = this.cache ? this.cache.get(id) : undefined;
if (data) {
// we have cached data - use it, even though it's stale
this.pushRenderQueue(id,data,'cache-stale');
this.staleTileCount += 1;
} else {
// no cached data
this.debugTiles.setState (id, 'error');
this.failedTileCount += 1;
}
// and delete from the pending requests...
delete this.queuedTiles[id];
} else {
// if false, was a 'timeout' or we're retrying, so unlimited retries (as the stock site does)
this.debugTiles.setState (id, 'retrying');
// FIXME? it's nice to move retried tiles to the end of the request queue. however, we don't actually have a
// proper queue, just an object with guid as properties. Javascript standards don't guarantee the order of properties
// within an object. however, all current browsers do keep property order, and new properties are added at the end.
// therefore, delete and re-add the requeued tile and it will be added to the end of the queue
delete this.queuedTiles[id];
this.queuedTiles[id] = id;
}
} // else the tile wasn't currently wanted (an old non-cancelled request) - ignore
}
window.MapDataRequest.prototype.handleResponse = function (data, tiles, success) {
this.activeRequestCount -= 1;
var successTiles = [];
var errorTiles = [];
var retryTiles = [];
var timeoutTiles = [];
var unaccountedTiles = tiles.slice(0); // Clone
if (!success || !data || !data.result) {
console.warn('Request.handleResponse: request failed - requeuing...'+(data && data.error?' error: '+data.error:''));
//request failed - requeue all the tiles(?)
if (data && data.error && data.error == 'RETRY') {
// the server can sometimes ask us to retry a request. this is botguard related, I believe
for (var i in tiles) {
var id = tiles[i];
retryTiles.push(id);
this.debugTiles.setState (id, 'retrying');
}
window.runHooks('requestFinished', {success: false});
} else {
for (var i in tiles) {
var id = tiles[i];
errorTiles.push(id);
this.debugTiles.setState (id, 'request-fail');
}
window.runHooks('requestFinished', {success: false});
}
unaccountedTiles = [];
} else {
// TODO: use result.minLevelOfDetail ??? stock site doesn't use it yet...
var m = data.result.map;
for (var id in m) {
var val = m[id];
unaccountedTiles.splice(unaccountedTiles.indexOf(id), 1);
if ('error' in val) {
// server returned an error for this individual data tile
if (val.error == "TIMEOUT") {
// TIMEOUT errors for individual tiles are quite common. used to be unlimited retries, but not any more
timeoutTiles.push (id);
} else {
console.warn('map data tile '+id+' failed: error=='+val.error);
errorTiles.push (id);
this.debugTiles.setState (id, 'tile-fail');
}
} else {
// no error for this data tile - process it
successTiles.push (id);
// store the result in the cache
this.cache && this.cache.store (id, val);
// if this tile was in the render list, render it
// (requests aren't aborted when new requests are started, so it's entirely possible we don't want to render it!)
if (id in this.queuedTiles) {
this.pushRenderQueue(id,val,'ok');
delete this.queuedTiles[id];
this.successTileCount += 1;
} // else we don't want this tile (from an old non-cancelled request) - ignore
}
}
// TODO? check for any requested tiles in 'tiles' not being mentioned in the response - and handle as if it's a 'timeout'?
window.runHooks('requestFinished', {success: true});
}
// set the queue delay based on any errors or timeouts
// NOTE: retryTimes are retried at the regular delay - no longer wait as for error/timeout cases
var nextQueueDelay = errorTiles.length > 0 ? this.BAD_REQUEST_RUN_QUEUE_DELAY :
unaccountedTiles.length > 0 ? this.EMPTY_RESPONSE_RUN_QUEUE_DELAY :
timeoutTiles.length > 0 ? this.TIMEOUT_REQUEST_RUN_QUEUE_DELAY :
this.RUN_QUEUE_DELAY;
var statusMsg = 'getEntities status: '+tiles.length+' tiles: ';
statusMsg += successTiles.length+' successful';
if (retryTiles.length) statusMsg += ', '+retryTiles.length+' retried';
if (timeoutTiles.length) statusMsg += ', '+timeoutTiles.length+' timed out';
if (errorTiles.length) statusMsg += ', '+errorTiles.length+' failed';
if (unaccountedTiles.length) statusMsg += ', '+unaccountedTiles.length+' unaccounted';
statusMsg += '. delay '+nextQueueDelay+' seconds';
console.log (statusMsg);
// requeue any 'timeout' tiles immediately
if (timeoutTiles.length > 0) {
for (var i in timeoutTiles) {
var id = timeoutTiles[i];
delete this.requestedTiles[id];
this.requeueTile(id, true);
}
}
if (retryTiles.length > 0) {
for (var i in retryTiles) {
var id = retryTiles[i];
delete this.requestedTiles[id];
this.requeueTile(id, false); //tiles from a error==RETRY request are requeued without counting it as an error
}
}
if (errorTiles.length > 0) {
for (var i in errorTiles) {
var id = errorTiles[i];
delete this.requestedTiles[id];
this.requeueTile(id, true);
}
}
if (unaccountedTiles.length > 0) {
for (var i in unaccountedTiles) {
var id = unaccountedTiles[i];
delete this.requestedTiles[id];
this.requeueTile(id, true);
}
}
for (var i in successTiles) {
var id = successTiles[i];
delete this.requestedTiles[id];
}
this.delayProcessRequestQueue(nextQueueDelay);
}
window.MapDataRequest.prototype.resetRenderQueue = function() {
this.renderQueue = [];
if (this.renderQueueTimer) {
clearTimeout(this.renderQueueTimer);
this.renderQueueTimer = undefined;
}
this.renderQueuePaused = false;
}
window.MapDataRequest.prototype.pushRenderQueue = function (id, data, status) {
this.debugTiles.setState(id,'render-queue');
this.renderQueue.push({
id:id,
// the data in the render queue is modified as we go, so we need to copy the values of the arrays. just storing the reference would modify the data in the cache!
deleted: (data.deletedGameEntityGuids||[]).slice(0),
entities: (data.gameEntities||[]).slice(0),
status:status});
if (!this.renderQueuePaused) {
this.startQueueTimer(this.RENDER_PAUSE);
}
}
window.MapDataRequest.prototype.startQueueTimer = function(delay) {
if (this.renderQueueTimer === undefined) {
var _this = this;
this.renderQueueTimer = setTimeout( function() {
_this.renderQueueTimer = setTimeout ( function() { _this.renderQueueTimer = undefined; _this.processRenderQueue(); }, (delay||0)*1000 );
}, 0);
}
}
window.MapDataRequest.prototype.pauseRenderQueue = function(pause) {
this.renderQueuePaused = pause;
if (pause) {
if (this.renderQueueTimer) {
clearTimeout(this.renderQueueTimer);
this.renderQueueTimer = undefined;
}
} else {
if (this.renderQueue.length > 0) {
this.startQueueTimer(this.RENDER_PAUSE);
}
}
}
window.MapDataRequest.prototype.processRenderQueue = function() {
var drawEntityLimit = this.RENDER_BATCH_SIZE;
//TODO: we don't take account of how many of the entities are actually new/removed - they
// could already be drawn and not changed. will see how it works like this...
while (drawEntityLimit > 0 && this.renderQueue.length > 0) {
var current = this.renderQueue[0];
if (current.deleted.length > 0) {
var deleteThisPass = current.deleted.splice(0,drawEntityLimit);
drawEntityLimit -= deleteThisPass.length;
this.render.processDeletedGameEntityGuids(deleteThisPass);
}
if (drawEntityLimit > 0 && current.entities.length > 0) {
var drawThisPass = current.entities.splice(0,drawEntityLimit);
drawEntityLimit -= drawThisPass.length;
this.render.processGameEntities(drawThisPass);
}
if (current.deleted.length == 0 && current.entities.length == 0) {
this.renderQueue.splice(0,1);
this.debugTiles.setState(current.id, current.status);
}
}
if (this.renderQueue.length > 0) {
this.startQueueTimer(this.RENDER_PAUSE);
} else if (Object.keys(this.queuedTiles).length == 0) {
this.render.endRenderPass();
var endTime = new Date().getTime();
var duration = (endTime - this.refreshStartTime)/1000;
console.log('finished requesting data! (took '+duration+' seconds to complete)');
window.runHooks ('mapDataRefreshEnd', {});
var longStatus = 'Tiles: ' + this.cachedTileCount + ' cached, ' +
this.successTileCount + ' loaded, ' +
(this.staleTileCount ? this.staleTileCount + ' stale, ' : '') +
(this.failedTileCount ? this.failedTileCount + ' failed, ' : '') +
'in ' + duration + ' seconds';
// refresh timer based on time to run this pass, with a minimum of REFRESH seconds
var minRefresh = map.getZoom()>12 ? this.REFRESH_CLOSE : this.REFRESH_FAR;
var refreshTimer = Math.max(minRefresh, duration*this.FETCH_TO_REFRESH_FACTOR);
this.refreshOnTimeout(refreshTimer);
this.setStatus (this.failedTileCount ? 'errors' : this.staleTileCount ? 'out of date' : 'done', longStatus);
}
}
;
/*
OMS doesn't cancel the original click event, so the topmost marker will get a click event while spiderfying.
Also, OMS only supports a global callback for all managed markers. Therefore, we will use a custom event that gets fired
for each marker.
*/
window.setupOMS = function() {
window.oms = new OverlappingMarkerSpiderfier(map, {
keepSpiderfied: true,
legWeight: 3.5,
legColors: {
usual: '#FFFF00',
highlighted: '#FF0000'
}
});
window.oms.addListener('click', function(marker) {
map.closePopup();
marker.fireEvent('spiderfiedclick', {target: marker});
});
window.oms.addListener('spiderfy', function(markers) {
map.closePopup();
});
map._container.addEventListener("keypress", function(ev) {
if(ev.keyCode === 27) // Esc
window.oms.unspiderfy();
}, false);
}
window.registerMarkerForOMS = function(marker) {
marker.on('add', function () {
window.oms.addMarker(marker);
});
marker.on('remove', function () {
window.oms.removeMarker(marker);
});
if(marker._map) // marker has already been added
window.oms.addMarker(marker);
}
;
// ORNAMENTS ///////////////////////////////////////////////////////
// added as part of the ingress #helios in 2014, ornaments
// are additional image overlays for portals
// currently there are 28 known ornaments: ap$x$suffix
// - cluster portals (without suffix)
// - volatile portals (_v)
// - meeting points (_start)
// - finish points (_end)
// (there are 7 different colors for each of them)
window.ornaments = {}
window.ornaments.OVERLAY_SIZE = 60;
window.ornaments.OVERLAY_OPACITY = 0.6;
window.ornaments.setup = function() {
window.ornaments._portals = {};
window.ornaments._layer = L.layerGroup();
window.addLayerGroup('Ornaments', window.ornaments._layer, true);
}
// quick test for portal having ornaments
window.ornaments.isInterestingPortal = function(portal) {
return portal.options.data.ornaments.length != 0;
}
window.ornaments.addPortal = function(portal) {
var guid = portal.options.guid;
window.ornaments.removePortal(portal);
var size = window.ornaments.OVERLAY_SIZE;
var latlng = portal.getLatLng();
if (portal.options.data.ornaments) {
window.ornaments._portals[guid] = portal.options.data.ornaments.map(function(ornament) {
var icon = L.icon({
iconUrl: "//commondatastorage.googleapis.com/ingress.com/img/map_icons/marker_images/"+ornament+".png",
iconSize: [size, size],
iconAnchor: [size/2,size/2],
className: 'no-pointer-events' // the clickable: false below still blocks events going through to the svg underneath
});
return L.marker(latlng, {icon: icon, clickable: false, keyboard: false, opacity: window.ornaments.OVERLAY_OPACITY }).addTo(window.ornaments._layer);
});
}
}
window.ornaments.removePortal = function(portal) {
var guid = portal.options.guid;
if(window.ornaments._portals[guid]) {
window.ornaments._portals[guid].forEach(function(marker) {
window.ornaments._layer.removeLayer(marker);
});
delete window.ornaments._portals[guid];
}
}
;
// created to start cleaning up "window" interaction
//
window.currentPane = '';
window.show = function(id) {
if(window.currentPane == id) return;
window.currentPane = id;
window.hideall();
runHooks("paneChanged", id);
switch(id) {
case 'all':
case 'faction':
case 'alerts':
window.chat.show(id);
break;
case 'debug':
window.debug.console.show();
break;
case 'map':
window.smartphone.mapButton.click();
$('#portal_highlight_select').show();
$('#farm_level_select').show();
break;
case 'info':
window.smartphone.sideButton.click();
break;
}
if (typeof android !== 'undefined' && android && android.switchToPane) {
android.switchToPane(id);
}
}
window.hideall = function() {
$('#chatcontrols, #chat, #chatinput, #sidebartoggle, #scrollwrapper, #updatestatus, #portal_highlight_select').hide();
$('#farm_level_select').hide();
$('#map').css('visibility', 'hidden');
$('.ui-tooltip').remove();
}
;
// PLAYER NAMES //////////////////////////////////////////////////////
// test to see if a specific player GUID is a special system account (e.g. __JARVIS__, __ADA__) that shouldn't
// be listed as a player
window.isSystemPlayer = function(name) {
switch (name) {
case '__ADA__':
case '__JARVIS__':
return true;
default:
return false;
}
}
;
/// PORTAL DATA TOOLS ///////////////////////////////////////////////////
// misc functions to get portal info
// search through the links data for all that link from or to a portal. returns an object with separate lists of in
// and out links. may or may not be as accurate as the portal details, depending on how much data the API returns
window.getPortalLinks = function(guid) {
var links = { in: [], out: [] };
$.each(window.links, function(g,l) {
var d = l.options.data;
if (d.oGuid == guid) {
links.out.push(g);
}
if (d.dGuid == guid) {
links.in.push(g);
}
});
return links;
}
window.getPortalLinksCount = function(guid) {
var links = getPortalLinks(guid);
return links.in.length+links.out.length;
}
// search through the fields for all that reference a portal
window.getPortalFields = function(guid) {
var fields = [];
$.each(window.fields, function(g,f) {
var d = f.options.data;
if ( d.points[0].guid == guid
|| d.points[1].guid == guid
|| d.points[2].guid == guid ) {
fields.push(g);
}
});
return fields;
}
window.getPortalFieldsCount = function(guid) {
var fields = getPortalFields(guid);
return fields.length;
}
// find the lat/lon for a portal, using any and all available data
// (we have the list of portals, the cached portal details, plus links and fields as sources of portal locations)
window.findPortalLatLng = function(guid) {
if (window.portals[guid]) {
return window.portals[guid].getLatLng();
}
// not found in portals - try the cached (and possibly stale) details - good enough for location
var details = portalDetail.get(guid);
if (details) {
return L.latLng (details.latE6/1E6, details.lngE6/1E6);
}
// now try searching through fields
for (var fguid in window.fields) {
var f = window.fields[fguid].options.data;
for (var i in f.points) {
if (f.points[i].guid == guid) {
return L.latLng (f.points[i].latE6/1E6, f.points[i].lngE6/1E6);
}
}
}
// and finally search through links
for (var lguid in window.links) {
var l = window.links[lguid].options.data;
if (l.oGuid == guid) {
return L.latLng (l.oLatE6/1E6, l.oLngE6/1E6);
}
if (l.dGuid == guid) {
return L.latLng (l.dLatE6/1E6, l.dLngE6/1E6);
}
}
// no luck finding portal lat/lng
return undefined;
};
(function() {
var cache = {};
var cache_level = 0;
var GC_LIMIT = 15000; // run garbage collector when cache has more that 5000 items
var GC_KEEP = 10000; // keep the 4000 most recent items
window.findPortalGuidByPositionE6 = function(latE6, lngE6) {
var item = cache[latE6+","+lngE6];
if(item) return item[0];
// now try searching through currently rendered portals
for(var guid in window.portals) {
var data = window.portals[guid].options.data;
if(data.latE6 == latE6 && data.lngE6 == lngE6) return guid;
}
// now try searching through fields
for(var fguid in window.fields) {
var points = window.fields[fguid].options.data.points;
for(var i in points) {
var point = points[i];
if(point.latE6 == latE6 && point.lngE6 == lngE6) return point.guid;
}
}
// and finally search through links
for(var lguid in window.links) {
var l = window.links[lguid].options.data;
if(l.oLatE6 == latE6 && l.oLngE6 == lngE6) return l.oGuid;
if(l.dLatE6 == latE6 && l.dLngE6 == lngE6) return l.dGuid;
}
return null;
};
window.pushPortalGuidPositionCache = function(guid, latE6, lngE6) {
cache[latE6+","+lngE6] = [guid, Date.now()];
cache_level += 1;
if(cache_level > GC_LIMIT) {
Object.keys(cache) // get all latlngs
.map(function(latlng) { return [latlng, cache[latlng][1]]; }) // map them to [latlng, timestamp]
.sort(function(a,b) { return b[1] - a[1]; }) // sort them
.slice(GC_KEEP) // drop the MRU
.forEach(function(item) { delete cache[item[0]] }); // delete the rest
cache_level = Object.keys(cache).length
}
}
})();
// get the AP gains from a portal, based only on the brief summary data from portals, links and fields
// not entirely accurate - but available for all portals on the screen
window.getPortalApGain = function(guid) {
var p = window.portals[guid];
if (p) {
var data = p.options.data;
var linkCount = getPortalLinksCount(guid);
var fieldCount = getPortalFieldsCount(guid);
var result = portalApGainMaths(data.resCount, linkCount, fieldCount);
return result;
}
return undefined;
}
// given counts of resonators, links and fields, calculate the available AP
// doesn't take account AP for resonator upgrades or AP for adding mods
window.portalApGainMaths = function(resCount, linkCount, fieldCount) {
var deployAp = (8-resCount)*DEPLOY_RESONATOR;
if (resCount == 0) deployAp += CAPTURE_PORTAL;
if (resCount != 8) deployAp += COMPLETION_BONUS;
// there could also be AP for upgrading existing resonators, and for deploying mods - but we don't have data for that
var friendlyAp = deployAp;
var destroyResoAp = resCount*DESTROY_RESONATOR;
var destroyLinkAp = linkCount*DESTROY_LINK;
var destroyFieldAp = fieldCount*DESTROY_FIELD;
var captureAp = CAPTURE_PORTAL + 8 * DEPLOY_RESONATOR + COMPLETION_BONUS;
var destroyAp = destroyResoAp+destroyLinkAp+destroyFieldAp;
var enemyAp = destroyAp+captureAp;
return {
friendlyAp: friendlyAp,
enemyAp: enemyAp,
destroyAp: destroyAp,
destroyResoAp: destroyResoAp,
captureAp: captureAp
}
}
;
/// PORTAL DETAIL //////////////////////////////////////
// code to retrieve the new portal detail data from the servers
// NOTE: the API for portal detailed information is NOT FINAL
// this is a temporary measure to get things working again after a major change to the intel map
// API. expect things to change here
// anonymous function wrapper for the code - any variables/functions not placed into 'window' will be private
(function(){
var cache;
var requestQueue = {};
window.portalDetail = function() {};
window.portalDetail.setup = function() {
cache = new DataCache();
cache.startExpireInterval(20);
}
window.portalDetail.get = function(guid) {
return cache.get(guid);
}
window.portalDetail.isFresh = function(guid) {
return cache.isFresh(guid);
}
var handleResponse = function(guid, data, success) {
delete requestQueue[guid];
if (!data || data.error || !data.result) {
success = false;
}
if (success) {
var dict = decodeArray.portalDetail(data.result);
// entity format, as used in map data
var ent = [guid,dict.timestamp,data.result];
cache.store(guid,dict);
//FIXME..? better way of handling sidebar refreshing...
if (guid == selectedPortal) {
renderPortalDetails(guid);
}
window.runHooks ('portalDetailLoaded', {guid:guid, success:success, details:dict, ent:ent});
} else {
if (data && data.error == "RETRY") {
// server asked us to try again
portalDetail.request(guid);
} else {
window.runHooks ('portalDetailLoaded', {guid:guid, success:success});
}
}
}
window.portalDetail.request = function(guid) {
if (!requestQueue[guid]) {
requestQueue[guid] = true;
window.postAjax('getPortalDetails', {guid:guid},
function(data,textStatus,jqXHR) { handleResponse(guid, data, true); },
function() { handleResponse(guid, undefined, false); }
);
}
}
})(); // anonymous wrapper function end
;
// PORTAL DETAILS MAIN ///////////////////////////////////////////////
// main code block that renders the portal details in the sidebar and
// methods that highlight the portal in the map view.
window.renderPortalDetails = function(guid) {
selectPortal(window.portals[guid] ? guid : null);
if (guid && !portalDetail.isFresh(guid)) {
portalDetail.request(guid);
}
// TODO? handle the case where we request data for a particular portal GUID, but it *isn't* in
// window.portals....
if(!window.portals[guid]) {
urlPortal = guid;
$('#portaldetails').html('');
if(isSmartphone()) {
$('.fullimg').remove();
$('#mobileinfo').html('<div style="text-align: center"><b>tap here for info screen</b></div>');
}
return;
}
var portal = window.portals[guid];
var data = portal.options.data;
var details = portalDetail.get(guid);
// details and data can get out of sync. if we have details, construct a matching 'data'
if (details) {
data = getPortalSummaryData(details);
}
var modDetails = details ? '<div class="mods">'+getModDetails(details)+'</div>' : '';
var miscDetails = details ? getPortalMiscDetails(guid,details) : '';
var resoDetails = details ? getResonatorDetails(details) : '';
//TODO? other status details...
var statusDetails = details ? '' : '<div id="portalStatus">Loading details...</div>';
var img = fixPortalImageUrl(details ? details.image : data.image);
var title = (details && details.title) || (data && data.title) || 'null';
var lat = data.latE6/1E6;
var lng = data.lngE6/1E6;
var imgTitle = title+'\n\nClick to show full image.';
// portal level. start with basic data - then extend with fractional info in tooltip if available
var levelInt = (teamStringToId(data.team) == TEAM_NONE) ? 0 : data.level;
var levelDetails = levelInt;
if (details) {
levelDetails = getPortalLevel(details);
if(levelDetails != 8) {
if(levelDetails==Math.ceil(levelDetails))
levelDetails += "\n8";
else
levelDetails += "\n" + (Math.ceil(levelDetails) - levelDetails)*8;
levelDetails += " resonator level(s) needed for next portal level";
} else {
levelDetails += "\nfully upgraded";
}
}
levelDetails = "Level " + levelDetails;
var linkDetails = [];
var posOnClick = 'window.showPortalPosLinks('+lat+','+lng+',\''+escapeJavascriptString(title)+'\')';
var permalinkUrl = '/intel?ll='+lat+','+lng+'&z=17&pll='+lat+','+lng;
if (typeof android !== 'undefined' && android && android.intentPosLink) {
// android devices. one share link option - and the android app provides an interface to share the URL,
// share as a geo: intent (navigation via google maps), etc
var shareLink = $('<div>').html( $('<a>').attr({onclick:posOnClick}).text('Share portal') ).html();
linkDetails.push('<aside>'+shareLink+'</aside>');
} else {
// non-android - a permalink for the portal
var permaHtml = $('<div>').html( $('<a>').attr({href:permalinkUrl, title:'Create a URL link to this portal'}).text('Portal link') ).html();
linkDetails.push ( '<aside>'+permaHtml+'</aside>' );
// and a map link popup dialog
var mapHtml = $('<div>').html( $('<a>').attr({onclick:posOnClick, title:'Link to alternative maps (Google, etc)'}).text('Map links') ).html();
linkDetails.push('<aside>'+mapHtml+'</aside>');
}
$('#portaldetails')
.html('') //to ensure it's clear
.attr('class', TEAM_TO_CSS[teamStringToId(data.team)])
.append(
$('<h3>').attr({class:'title'}).text(title),
$('<span>').attr({
class: 'close',
title: 'Close [w]',
onclick:'renderPortalDetails(null); if(isSmartphone()) show("map");',
accesskey: 'w'
}).text('X'),
// help cursor via ".imgpreview img"
$('<div>')
.attr({class:'imgpreview', title:imgTitle, style:"background-image: url('"+img+"')"})
.append(
$('<span>').attr({id:'level', title: levelDetails}).text(levelInt),
$('<img>').attr({class:'hide', src:img})
),
modDetails,
miscDetails,
resoDetails,
statusDetails,
'<div class="linkdetails">' + linkDetails.join('') + '</div>'
);
// only run the hooks when we have a portalDetails object - most plugins rely on the extended data
// TODO? another hook to call always, for any plugins that can work with less data?
if (details) {
runHooks('portalDetailsUpdated', {guid: guid, portal: portal, portalDetails: details, portalData: data});
}
}
window.getPortalMiscDetails = function(guid,d) {
var randDetails;
if (d) {
// collect some random data that’s not worth to put in an own method
var linkInfo = getPortalLinks(guid);
var maxOutgoing = getMaxOutgoingLinks(d);
var linkCount = linkInfo.in.length + linkInfo.out.length;
var links = {incoming: linkInfo.in.length, outgoing: linkInfo.out.length};
var title = 'at most ' + maxOutgoing + ' outgoing links\n' +
links.outgoing + ' links out\n' +
links.incoming + ' links in\n' +
'(' + (links.outgoing+links.incoming) + ' total)'
var linksText = ['links', links.outgoing+' out / '+links.incoming+' in', title];
var player = d.owner
? '<span class="nickname">' + d.owner + '</span>'
: '-';
var playerText = ['owner', player];
var fieldCount = getPortalFieldsCount(guid);
var fieldsText = ['fields', fieldCount];
var apGainText = getAttackApGainText(d,fieldCount,linkCount);
var attackValues = getPortalAttackValues(d);
// collect and html-ify random data
var randDetailsData = [
// these pieces of data are only relevant when the portal is captured
// maybe check if portal is captured and remove?
// But this makes the info panel look rather empty for unclaimed portals
playerText, getRangeText(d),
linksText, fieldsText,
getMitigationText(d,linkCount), getEnergyText(d),
// and these have some use, even for uncaptured portals
apGainText, getHackDetailsText(d),
];
if(attackValues.attack_frequency != 0)
randDetailsData.push([
'<span title="attack frequency" class="text-overflow-ellipsis">attack frequency</span>',
'×'+attackValues.attack_frequency]);
if(attackValues.hit_bonus != 0)
randDetailsData.push(['hit bonus', attackValues.hit_bonus+'%']);
if(attackValues.force_amplifier != 0)
randDetailsData.push([
'<span title="force amplifier" class="text-overflow-ellipsis">force amplifier</span>',
'×'+attackValues.force_amplifier]);
randDetails = '<table id="randdetails">' + genFourColumnTable(randDetailsData) + '</table>';
// artifacts - tacked on after (but not as part of) the 'randdetails' table
// instead of using the existing columns....
if (d.artifactBrief && d.artifactBrief.target && Object.keys(d.artifactBrief.target).length > 0) {
var targets = Object.keys(d.artifactBrief.target);
//currently (2015-07-10) we no longer know the team each target portal is for - so we'll just show the artifact type(s)
randDetails += '<div id="artifact_target">Target portal: '+targets.map(function(x) { return x.capitalize(); }).join(', ')+'</div>';
}
// shards - taken directly from the portal details
if (d.artifactDetail) {
randDetails += '<div id="artifact_fragments">Shards: '+d.artifactDetail.displayName+' #'+d.artifactDetail.fragments.join(', ')+'</div>';
}
}
return randDetails;
}
// draws link-range and hack-range circles around the portal with the
// given details. Clear them if parameter 'd' is null.
window.setPortalIndicators = function(p) {
if(portalRangeIndicator) map.removeLayer(portalRangeIndicator);
portalRangeIndicator = null;
if(portalAccessIndicator) map.removeLayer(portalAccessIndicator);
portalAccessIndicator = null;
// if we have a portal...
if(p) {
var coord = p.getLatLng();
// range is only known for sure if we have portal details
// TODO? render a min range guess until details are loaded..?
var d = portalDetail.get(p.options.guid);
if (d) {
var range = getPortalRange(d);
portalRangeIndicator = (range.range > 0
? L.geodesicCircle(coord, range.range, {
fill: false,
color: RANGE_INDICATOR_COLOR,
weight: 3,
dashArray: range.isLinkable ? undefined : "10,10",
clickable: false })
: L.circle(coord, range.range, { fill: false, stroke: false, clickable: false })
).addTo(map);
}
portalAccessIndicator = L.circle(coord, HACK_RANGE,
{ fill: false, color: ACCESS_INDICATOR_COLOR, weight: 2, clickable: false }
).addTo(map);
}
}
// highlights portal with given GUID. Automatically clears highlights
// on old selection. Returns false if the selected portal changed.
// Returns true if it's still the same portal that just needs an
// update.
window.selectPortal = function(guid) {
var update = selectedPortal === guid;
var oldPortalGuid = selectedPortal;
selectedPortal = guid;
var oldPortal = portals[oldPortalGuid];
var newPortal = portals[guid];
// Restore style of unselected portal
if(!update && oldPortal) setMarkerStyle(oldPortal,false);
// Change style of selected portal
if(newPortal) {
setMarkerStyle(newPortal, true);
if (map.hasLayer(newPortal)) {
newPortal.bringToFront();
}
}
setPortalIndicators(newPortal);
runHooks('portalSelected', {selectedPortalGuid: guid, unselectedPortalGuid: oldPortalGuid});
return update;
}
;
// PORTAL DETAILS DISPLAY ////////////////////////////////////////////
// hand any of these functions the details-hash of a portal, and they
// will return pretty, displayable HTML or parts thereof.
// returns displayable text+link about portal range
window.getRangeText = function(d) {
var range = getPortalRange(d);
var title = 'Base range:\t' + digits(Math.floor(range.base))+'m'
+ '\nLink amp boost:\t×'+range.boost
+ '\nRange:\t'+digits(Math.floor(range.range))+'m';
if(!range.isLinkable) title += '\nPortal is missing resonators,\nno new links can be made';
return ['range',
'<a onclick="window.rangeLinkClick()"'
+ (range.isLinkable ? '' : ' style="text-decoration:line-through;"')
+ '>'
+ (range.range > 1000
? Math.floor(range.range/1000) + ' km'
: Math.floor(range.range) + ' m')
+ '</a>',
title];
}
// given portal details, returns html code to display mod details.
window.getModDetails = function(d) {
var mods = [];
var modsTitle = [];
var modsColor = [];
$.each(d.mods, function(ind, mod) {
var modName = '';
var modTooltip = '';
var modColor = '#000';
if (mod) {
// all mods seem to follow the same pattern for the data structure
// but let's try and make this robust enough to handle possible future differences
modName = mod.name || '(unknown mod)';
if (mod.rarity) {
modName = mod.rarity.capitalize().replace(/_/g,' ') + ' ' + modName;
}
modTooltip = modName + '\n';
if (mod.owner) {
modTooltip += 'Installed by: '+ mod.owner + '\n';
}
if (mod.stats) {
modTooltip += 'Stats:';
for (var key in mod.stats) {
if (!mod.stats.hasOwnProperty(key)) continue;
var val = mod.stats[key];
// if (key === 'REMOVAL_STICKINESS' && val == 0) continue; // stat on all mods recently - unknown meaning, not displayed in stock client
// special formatting for known mod stats, where the display of the raw value is less useful
if (key === 'HACK_SPEED') val = (val/10000)+'%'; // 500000 = 50%
else if (key === 'HIT_BONUS') val = (val/10000)+'%'; // 300000 = 30%
else if (key === 'ATTACK_FREQUENCY') val = (val/1000) +'x'; // 2000 = 2x
else if (key === 'FORCE_AMPLIFIER') val = (val/1000) +'x'; // 2000 = 2x
else if (key === 'LINK_RANGE_MULTIPLIER') val = (val/1000) +'x'; // 2000 = 2x
else if (key === 'LINK_DEFENSE_BOOST') val = (val/1000) +'x'; // 1500 = 1.5x
else if (key === 'REMOVAL_STICKINESS' && val > 100) val = (val/10000)+'%'; // an educated guess
// else display unmodified. correct for shield mitigation and multihack - unknown for future/other mods
modTooltip += '\n+' + val + ' ' + key.capitalize().replace(/_/g,' ');
}
}
if (mod.rarity) {
modColor = COLORS_MOD[mod.rarity];
} else {
modColor = '#fff';
}
}
mods.push(modName);
modsTitle.push(modTooltip);
modsColor.push(modColor);
});
var t = '';
for (var i=0; i<mods.length; i++) {
t += '<span'+(modsTitle[i].length ? ' title="'+modsTitle[i]+'"' : '')+' style="color:'+modsColor[i]+'">'+mods[i]+'</span>'
}
// and add blank entries if we have less than 4 mods (as the server no longer returns all mod slots, but just the filled ones)
for (var i=mods.length; i<4; i++) {
t += '<span style="color:#000"></span>'
}
return t;
}
window.getEnergyText = function(d) {
var currentNrg = getCurrentPortalEnergy(d);
var totalNrg = getTotalPortalEnergy(d);
var title = currentNrg + ' / ' + totalNrg;
var fill = prettyEnergy(currentNrg) + ' / ' + prettyEnergy(totalNrg)
return ['energy', fill, title];
}
window.getResonatorDetails = function(d) {
var resoDetails = [];
// octant=slot: 0=E, 1=NE, 2=N, 3=NW, 4=W, 5=SW, 6=S, SE=7
// resos in the display should be ordered like this:
// N NE Since the view is displayed in rows, they
// NW E need to be ordered like this: N NE NW E W SE SW S
// W SE i.e. 2 1 3 0 4 7 5 6
// SW S
// note: as of 2014-05-23 update, this is not true for portals with empty slots!
var processResonatorSlot = function(reso,slot) {
var lvl=0, nrg=0, owner=null;
if (reso) {
lvl = parseInt(reso.level);
nrg = parseInt(reso.energy);
owner = reso.owner;
}
resoDetails.push(renderResonatorDetails(slot, lvl, nrg, owner));
};
// if all 8 resonators are deployed, we know which is in which slot
if (d.resonators.length == 8) {
// fully deployed - we can make assumptions about deployment slots
$.each([2, 1, 3, 0, 4, 7, 5, 6], function(ind, slot) {
processResonatorSlot(d.resonators[slot],slot);
});
} else {
// partially deployed portal - we can no longer find out which resonator is in which slot
for(var ind=0; ind<8; ind++) {
processResonatorSlot(ind < d.resonators.length ? d.resonators[ind] : null, null);
}
}
return '<table id="resodetails">' + genFourColumnTable(resoDetails) + '</table>';
}
// helper function that renders the HTML for a given resonator. Does
// not work with raw details-hash. Needs digested infos instead:
// slot: which slot this resonator occupies. Starts with 0 (east) and
// rotates clockwise. So, last one is 7 (southeast).
window.renderResonatorDetails = function(slot, level, nrg, nick) {
if(OCTANTS[slot] === 'N')
var className = 'meter north';
else
var className = 'meter';
var max = RESO_NRG[level];
var fillGrade = level > 0 ? nrg/max*100 : 0;
var inf = (level > 0 ? 'energy:\t' + nrg + ' / ' + max + ' (' + Math.round(fillGrade) + '%)\n'
+'level:\t' + level + '\n'
+'owner:\t' + nick + '\n'
: '')
+ (slot !== null ? 'octant:\t' + OCTANTS[slot] + ' ' + OCTANTS_ARROW[slot]:'');
var style = fillGrade ? 'width:'+fillGrade+'%; background:'+COLORS_LVL[level]+';':'';
var color = (level < 3 ? "#9900FF" : "#FFFFFF");
var lbar = level > 0 ? '<span class="meter-level" style="color: ' + color + ';"> L ' + level + ' </span>' : '';
var fill = '<span style="'+style+'"></span>';
var meter = '<span class="' + className + '" title="'+inf+'">' + fill + lbar + '</span>';
nick = nick ? '<span class="nickname">'+nick+'</span>' : null;
return [meter, nick || ''];
}
// calculate AP gain from destroying portal and then capturing it by deploying resonators
window.getAttackApGainText = function(d,fieldCount,linkCount) {
var breakdown = getAttackApGain(d,fieldCount,linkCount);
var totalGain = breakdown.enemyAp;
var t = '';
if (teamStringToId(PLAYER.team) == teamStringToId(d.team)) {
totalGain = breakdown.friendlyAp;
t += 'Friendly AP:\t' + breakdown.friendlyAp + '\n';
t += ' Deploy ' + breakdown.deployCount + ', ';
t += 'Upgrade ' + breakdown.upgradeCount + '\n';
t += '\n';
}
t += 'Enemy AP:\t' + breakdown.enemyAp + '\n';
t += ' Destroy AP:\t' + breakdown.destroyAp + '\n';
t += ' Capture AP:\t' + breakdown.captureAp + '\n';
return ['AP Gain', digits(totalGain), t];
}
window.getHackDetailsText = function(d) {
var hackDetails = getPortalHackDetails(d);
var shortHackInfo = hackDetails.hacks+' @ '+formatInterval(hackDetails.cooldown);
var title = 'Hacks available every 4 hours\n'
+ 'Hack count:\t'+hackDetails.hacks+'\n'
+ 'Cooldown time:\t'+formatInterval(hackDetails.cooldown)+'\n'
+ 'Burnout time:\t'+formatInterval(hackDetails.burnout);
return ['hacks', shortHackInfo, title];
}
window.getMitigationText = function(d,linkCount) {
var mitigationDetails = getPortalMitigationDetails(d,linkCount);
var mitigationShort = mitigationDetails.total;
if (mitigationDetails.excess) mitigationShort += ' (+'+mitigationDetails.excess+')';
var title = 'Total shielding:\t'+(mitigationDetails.shields+mitigationDetails.links)+'\n'
+ '- active:\t'+mitigationDetails.total+'\n'
+ '- excess:\t'+mitigationDetails.excess+'\n'
+ 'From\n'
+ '- shields:\t'+mitigationDetails.shields+'\n'
+ '- links:\t'+mitigationDetails.links;
return ['shielding', mitigationShort, title];
}
;
// Portal Highlighter //////////////////////////////////////////////////////////
// these functions handle portal highlighters
// an object mapping highlighter names to the object containing callback functions
window._highlighters = null;
// the name of the current highlighter
window._current_highlighter = localStorage.portal_highlighter;
window._no_highlighter = 'No Highlights';
window.addPortalHighlighter = function(name, data) {
if(_highlighters === null) {
_highlighters = {};
}
// old-format highlighters just passed a callback function. this is the same as just a highlight method
if (!data.highlight) {
data = {highlight: data}
}
_highlighters[name] = data;
if (typeof android !== 'undefined' && android && android.addPortalHighlighter)
android.addPortalHighlighter(name);
if(window._current_highlighter === undefined) {
_current_highlighter = name;
}
if (_current_highlighter == name) {
if (typeof android !== 'undefined' && android && android.setActiveHighlighter)
android.setActiveHighlighter(name);
// call the setSelected callback
if (_highlighters[_current_highlighter].setSelected) {
_highlighters[_current_highlighter].setSelected(true);
}
}
updatePortalHighlighterControl();
}
// (re)creates the highlighter dropdown list
window.updatePortalHighlighterControl = function() {
if (typeof android !== 'undefined' && android && android.addPortalHighlighter) {
$('#portal_highlight_select').remove();
return;
}
if(_highlighters !== null) {
if($('#portal_highlight_select').length === 0) {
$("body").append("<select id='portal_highlight_select'></select>");
$("#portal_highlight_select").change(function(){ changePortalHighlights($(this).val());});
$(".leaflet-top.leaflet-left").css('padding-top', '20px');
$(".leaflet-control-scale-line").css('margin-top','25px');
}
$("#portal_highlight_select").html('');
$("#portal_highlight_select").append($("<option>").attr('value',_no_highlighter).text(_no_highlighter));
var h_names = Object.keys(_highlighters).sort();
$.each(h_names, function(i, name) {
$("#portal_highlight_select").append($("<option>").attr('value',name).text(name));
});
$("#portal_highlight_select").val(_current_highlighter);
}
}
window.changePortalHighlights = function(name) {
// first call any previous highlighter select callback
if (_current_highlighter && _highlighters[_current_highlighter] && _highlighters[_current_highlighter].setSelected) {
_highlighters[_current_highlighter].setSelected(false);
}
_current_highlighter = name;
if (typeof android !== 'undefined' && android && android.setActiveHighlighter)
android.setActiveHighlighter(name);
// now call the setSelected callback for the new highlighter
if (_current_highlighter && _highlighters[_current_highlighter] && _highlighters[_current_highlighter].setSelected) {
_highlighters[_current_highlighter].setSelected(true);
}
resetHighlightedPortals();
localStorage.portal_highlighter = name;
}
window.highlightPortal = function(p) {
if(_highlighters !== null && _highlighters[_current_highlighter] !== undefined) {
_highlighters[_current_highlighter].highlight({portal: p});
}
}
window.resetHighlightedPortals = function() {
$.each(portals, function(guid, portal) {
setMarkerStyle(portal, guid === selectedPortal);
});
}
;
// PORTAL DETAILS TOOLS //////////////////////////////////////////////
// hand any of these functions the details-hash of a portal, and they
// will return useful, but raw data.
// returns a float. Displayed portal level is always rounded down from
// that value.
window.getPortalLevel = function(d) {
var lvl = 0;
var hasReso = false;
$.each(d.resonators, function(ind, reso) {
if(!reso) return true;
lvl += parseInt(reso.level);
hasReso = true;
});
return hasReso ? Math.max(1, lvl/8) : 0;
}
window.getTotalPortalEnergy = function(d) {
var nrg = 0;
$.each(d.resonators, function(ind, reso) {
if(!reso) return true;
var level = parseInt(reso.level);
var max = RESO_NRG[level];
nrg += max;
});
return nrg;
}
// For backwards compatibility
window.getPortalEnergy = window.getTotalPortalEnergy;
window.getCurrentPortalEnergy = function(d) {
var nrg = 0;
$.each(d.resonators, function(ind, reso) {
if(!reso) return true;
nrg += parseInt(reso.energy);
});
return nrg;
}
window.getPortalRange = function(d) {
// formula by the great gals and guys at
// http://decodeingress.me/2012/11/18/ingress-portal-levels-and-link-range/
var lvl = 0;
var resoMissing = false;
// currently we get a short resonator array when some are missing
if (d.resonators.length < 8) {
resoMissing = true;
}
// but in the past we used to always get an array of 8, but will 'null' objects for some entries. maybe that will return?
$.each(d.resonators, function(ind, reso) {
if(!reso) {
resoMissing = true;
return;
}
});
var range = {
base: 160*Math.pow(getPortalLevel(d), 4),
boost: getLinkAmpRangeBoost(d)
};
range.range = range.boost * range.base;
range.isLinkable = !resoMissing;
return range;
}
window.getLinkAmpRangeBoost = function(d) {
// additional range boost calculation
// link amps scale: first is full, second a quarter, the last two an eighth
var scale = [1.0, 0.25, 0.125, 0.125];
var boost = 0.0; // initial boost is 0.0 (i.e. no boost over standard range)
var linkAmps = getPortalModsByType(d, 'LINK_AMPLIFIER');
linkAmps.forEach(function(mod, i) {
// link amp stat LINK_RANGE_MULTIPLIER is 2000 for rare, and gives 2x boost to the range
// and very-rare is 7000 and gives 7x the range
var baseMultiplier = mod.stats.LINK_RANGE_MULTIPLIER/1000;
boost += baseMultiplier*scale[i];
});
return (linkAmps.length > 0) ? boost : 1.0;
}
window.getAttackApGain = function(d,fieldCount,linkCount) {
if (!fieldCount) fieldCount = 0;
var resoCount = 0;
var maxResonators = MAX_RESO_PER_PLAYER.slice(0);
var curResonators = [ 0, 0, 0, 0, 0, 0, 0, 0, 0];
for(var n = PLAYER.level + 1; n < 9; n++) {
maxResonators[n] = 0;
}
$.each(d.resonators, function(ind, reso) {
if(!reso)
return true;
resoCount += 1;
var reslevel=parseInt(reso.level);
if(reso.owner === PLAYER.nickname) {
if(maxResonators[reslevel] > 0) {
maxResonators[reslevel] -= 1;
}
} else {
curResonators[reslevel] += 1;
}
});
var resoAp = resoCount * DESTROY_RESONATOR;
var linkAp = linkCount * DESTROY_LINK;
var fieldAp = fieldCount * DESTROY_FIELD;
var destroyAp = resoAp + linkAp + fieldAp;
var captureAp = CAPTURE_PORTAL + 8 * DEPLOY_RESONATOR + COMPLETION_BONUS;
var enemyAp = destroyAp + captureAp;
var deployCount = 8 - resoCount;
var completionAp = (deployCount > 0) ? COMPLETION_BONUS : 0;
var upgradeCount = 0;
var upgradeAvailable = maxResonators[8];
for(var n = 7; n >= 0; n--) {
upgradeCount += curResonators[n];
if(upgradeAvailable < upgradeCount) {
upgradeCount -= (upgradeCount - upgradeAvailable);
}
upgradeAvailable += maxResonators[n];
}
var friendlyAp = deployCount * DEPLOY_RESONATOR + upgradeCount * UPGRADE_ANOTHERS_RESONATOR + completionAp;
return {
friendlyAp: friendlyAp,
deployCount: deployCount,
upgradeCount: upgradeCount,
enemyAp: enemyAp,
destroyAp: destroyAp,
resoAp: resoAp,
captureAp: captureAp
};
}
//This function will return the potential level a player can upgrade it to
window.potentialPortalLevel = function(d) {
var current_level = getPortalLevel(d);
var potential_level = current_level;
if(PLAYER.team === d.team) {
var resonators_on_portal = d.resonators;
var resonator_levels = new Array();
// figure out how many of each of these resonators can be placed by the player
var player_resontators = new Array();
for(var i=1;i<=MAX_PORTAL_LEVEL; i++) {
player_resontators[i] = i > PLAYER.level ? 0 : MAX_RESO_PER_PLAYER[i];
}
$.each(resonators_on_portal, function(ind, reso) {
if(reso !== null && reso.owner === window.PLAYER.nickname) {
player_resontators[reso.level]--;
}
resonator_levels.push(reso === null ? 0 : reso.level);
});
resonator_levels.sort(function(a, b) {
return(a - b);
});
// Max out portal
var install_index = 0;
for(var i=MAX_PORTAL_LEVEL;i>=1; i--) {
for(var install = player_resontators[i]; install>0; install--) {
if(resonator_levels[install_index] < i) {
resonator_levels[install_index] = i;
install_index++;
}
}
}
//console.log(resonator_levels);
potential_level = resonator_levels.reduce(function(a, b) {return a + b;}) / 8;
}
return(potential_level);
}
window.fixPortalImageUrl = function(url) {
if (url) {
if (window.location.protocol === 'https:') {
url = url.indexOf('www.panoramio.com') !== -1
? url.replace(/^http:\/\/www/, 'https://ssl').replace('small', 'medium')
: url.replace(/^http:\/\//, '//');
}
return url;
} else {
return DEFAULT_PORTAL_IMG;
}
}
window.getPortalModsByType = function(d, type) {
var mods = [];
var typeToStat = {
RES_SHIELD: 'MITIGATION',
FORCE_AMP: 'FORCE_AMPLIFIER',
TURRET: 'HIT_BONUS', // and/or ATTACK_FREQUENCY??
HEATSINK: 'HACK_SPEED',
MULTIHACK: 'BURNOUT_INSULATION',
LINK_AMPLIFIER: 'LINK_RANGE_MULTIPLIER',
ULTRA_LINK_AMP: 'OUTGOING_LINKS_BONUS', // and/or LINK_DEFENSE_BOOST??
};
var stat = typeToStat[type];
$.each(d.mods || [], function(i,mod) {
if (mod && mod.stats.hasOwnProperty(stat)) mods.push(mod);
});
// sorting mods by the stat keeps code simpler, when calculating combined mod effects
mods.sort (function(a,b) {
return b.stats[stat] - a.stats[stat];
});
return mods;
}
window.getPortalShieldMitigation = function(d) {
var shields = getPortalModsByType(d, 'RES_SHIELD');
var mitigation = 0;
$.each(shields, function(i,s) {
mitigation += parseInt(s.stats.MITIGATION);
});
return mitigation;
}
window.getPortalLinksMitigation = function(linkCount) {
var mitigation = Math.round(400/9*Math.atan(linkCount/Math.E));
return mitigation;
}
window.getPortalMitigationDetails = function(d,linkCount) {
var mitigation = {
shields: getPortalShieldMitigation(d),
links: getPortalLinksMitigation(linkCount)
};
// mitigation is limited to 95% (as confirmed by Brandon Badger on G+)
mitigation.total = Math.min(95, mitigation.shields+mitigation.links);
mitigation.excess = (mitigation.shields+mitigation.links) - mitigation.total;
return mitigation;
}
window.getMaxOutgoingLinks = function(d) {
var linkAmps = getPortalModsByType(d, 'ULTRA_LINK_AMP');
var links = 8;
linkAmps.forEach(function(mod, i) {
links += parseInt(mod.stats.OUTGOING_LINKS_BONUS);
});
return links;
};
window.getPortalHackDetails = function(d) {
var heatsinks = getPortalModsByType(d, 'HEATSINK');
var multihacks = getPortalModsByType(d, 'MULTIHACK');
// first mod of type is fully effective, the others are only 50% effective
var effectivenessReduction = [ 1, 0.5, 0.5, 0.5 ];
var cooldownTime = 300; // 5 mins - 300 seconds
$.each(heatsinks, function(index,mod) {
var hackSpeed = parseInt(mod.stats.HACK_SPEED)/1000000;
cooldownTime = Math.round(cooldownTime * (1 - hackSpeed * effectivenessReduction[index]));
});
var numHacks = 4; // default hacks
$.each(multihacks, function(index,mod) {
var extraHacks = parseInt(mod.stats.BURNOUT_INSULATION);
numHacks = numHacks + (extraHacks * effectivenessReduction[index]);
});
return {cooldown: cooldownTime, hacks: numHacks, burnout: cooldownTime*(numHacks-1)};
}
// given a detailed portal structure, return summary portal data, as seen in the map tile data
window.getPortalSummaryData = function(d) {
// NOTE: the summary data reports unclaimed portals as level 1 - not zero as elsewhere in IITC
var level = parseInt(getPortalLevel(d));
if (level == 0) level = 1; //niantic returns neutral portals as level 1, not 0 as used throughout IITC elsewhere
var resCount = 0;
if (d.resonators) {
for (var x in d.resonators) {
if (d.resonators[x]) resCount++;
}
}
var maxEnergy = getTotalPortalEnergy(d);
var curEnergy = getCurrentPortalEnergy(d);
var health = maxEnergy>0 ? parseInt(curEnergy/maxEnergy*100) : 0;
return {
level: level,
title: d.title,
image: d.image,
resCount: resCount,
latE6: d.latE6,
health: health,
team: d.team,
lngE6: d.lngE6,
type: 'portal'
};
}
window.getPortalAttackValues = function(d) {
var forceamps = getPortalModsByType(d, 'FORCE_AMP');
var turrets = getPortalModsByType(d, 'TURRET');
// at the time of writing, only rare force amps and turrets have been seen in the wild, so there's a little guesswork
// at how the stats work and combine
// algorithm has been compied from getLinkAmpRangeBoost
// FIXME: only extract stats and put the calculation in a method to be used for link range, force amplifier and attack
// frequency
// note: scanner shows rounded values (adding a second FA shows: 2.5x+0.2x=2.8x, which should be 2.5x+0.25x=2.75x)
// amplifier scale: first is full, second a quarter, the last two an eighth
var scale = [1.0, 0.25, 0.125, 0.125];
var attackValues = {
hit_bonus: 0,
force_amplifier: 0,
attack_frequency: 0,
};
forceamps.forEach(function(mod, i) {
// force amp stat FORCE_AMPLIFIER is 2000 for rare, and gives 2x boost to the range
var baseMultiplier = mod.stats.FORCE_AMPLIFIER / 1000;
attackValues.force_amplifier += baseMultiplier * scale[i];
});
turrets.forEach(function(mod, i) {
// turret stat ATTACK_FREQUENCY is 2000 for rare, and gives 2x boost to the range
var baseMultiplier = mod.stats.ATTACK_FREQUENCY / 1000;
attackValues.attack_frequency += baseMultiplier * scale[i];
attackValues.hit_bonus += mod.stats.HIT_BONUS / 10000;
});
return attackValues;
}
;
// PORTAL MARKER //////////////////////////////////////////////
// code to create and update a portal marker
window.portalMarkerScale = function() {
var zoom = map.getZoom();
if (L.Browser.mobile)
return zoom >= 16 ? 1.5 : zoom >= 14 ? 1.2 : zoom >= 11 ? 1.0 : zoom >= 8 ? 0.65 : 0.5;
else
return zoom >= 14 ? 1 : zoom >= 11 ? 0.8 : zoom >= 8 ? 0.65 : 0.5;
}
// create a new marker. 'data' contain the IITC-specific entity data to be stored in the object options
window.createMarker = function(latlng, data) {
var styleOptions = window.getMarkerStyleOptions(data);
var options = L.extend({}, data, styleOptions, { clickable: true });
var marker = L.circleMarker(latlng, options);
highlightPortal(marker);
return marker;
}
window.setMarkerStyle = function(marker, selected) {
var styleOptions = window.getMarkerStyleOptions(marker.options);
marker.setStyle(styleOptions);
// FIXME? it's inefficient to set the marker style (above), then do it again inside the highlighter
// the highlighter API would need to be changed for this to be improved though. will it be too slow?
highlightPortal(marker);
if (selected) {
marker.setStyle ({color: COLOR_SELECTED_PORTAL});
}
}
window.getMarkerStyleOptions = function(details) {
var scale = window.portalMarkerScale();
// portal level 0 1 2 3 4 5 6 7 8
var LEVEL_TO_WEIGHT = [2, 2, 2, 2, 2, 3, 3, 4, 4];
var LEVEL_TO_RADIUS = [7, 7, 7, 7, 8, 8, 9,10,11];
var level = Math.floor(details.level||0);
var lvlWeight = LEVEL_TO_WEIGHT[level] * Math.sqrt(scale);
var lvlRadius = LEVEL_TO_RADIUS[level] * scale;
var dashArray = null;
// thinner and dashed outline for placeholder portals
if (details.team != TEAM_NONE && level==0) {
lvlWeight = 1;
dashArray = [1,2];
}
var options = {
radius: lvlRadius,
stroke: true,
color: COLORS[details.team],
weight: lvlWeight,
opacity: 1,
fill: true,
fillColor: COLORS[details.team],
fillOpacity: 0.5,
dashArray: dashArray
};
return options;
}
;
// REDEEMING ///////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
window.REDEEM_SHORT_NAMES = {
'portal shield':'S',
'force amp':'FA',
'link amp':'LA',
'heatsink':'H',
'multihack':'M',
'turret':'T',
'unusual object':'U',
'resonator':'R',
'xmp burster':'X',
'power cube':'C',
'media':'M',
'ultra strike':'US',
}
/* These are HTTP status codes returned by the redemption API.
* TODO: Move to another file? Use more generally across IITC?
*/
window.REDEEM_STATUSES = {
429: 'You have been rate-limited by the server. Wait a bit and try again.',
500: 'Internal server error'
};
window.handleRedeemResponse = function(data, textStatus, jqXHR) {
var passcode = jqXHR.passcode;
if(data.error) {
console.error('Error redeeming passcode "'+passcode+'": ' + data.error)
dialog({
title: 'Error: ' + passcode,
html: '<strong>' + data.error + '</strong>'
});
return;
}
if(!data.rewards) {
console.error('Error redeeming passcode "'+passcode+'": ', data)
dialog({
title: 'Error: ' + passcode,
html: '<strong>An unexpected error occured</strong>'
});
return;
}
if(data.playerData) {
window.PLAYER = data.playerData;
window.setupPlayerStat();
}
var format = "long";
try {
format = localStorage["iitc-passcode-format"];
} catch(e) {}
var formatHandlers = {
"short": formatPasscodeShort,
"long": formatPasscodeLong
}
if(!formatHandlers[format])
format = "long";
var html = formatHandlers[format](data.rewards);
var buttons = {};
Object.keys(formatHandlers).forEach(function(label) {
if(label == format) return;
buttons[label.toUpperCase()] = function() {
$(this).dialog("close");
localStorage["iitc-passcode-format"] = label;
handleRedeemResponse(data, textStatus, jqXHR);
}
});
// Display it
dialog({
title: 'Passcode: ' + passcode,
html: html,
buttons: buttons
});
};
window.formatPasscodeLong = function(data) {
var html = '<p><strong>Passcode confirmed. Acquired items:</strong></p><ul class="redeemReward">';
if(data.other) {
data.other.forEach(function(item) {
html += '<li>' + window.escapeHtmlSpecialChars(item) + '</li>';
});
}
if(0 < data.xm)
html += '<li>' + window.escapeHtmlSpecialChars(data.xm) + ' XM</li>';
if(0 < data.ap)
html += '<li>' + window.escapeHtmlSpecialChars(data.ap) + ' AP</li>';
if(data.inventory) {
data.inventory.forEach(function(type) {
type.awards.forEach(function(item) {
html += '<li>' + item.count + 'x ';
var l = item.level;
if(0 < l) {
l = parseInt(l);
html += '<span class="itemlevel" style="color:' + COLORS_LVL[l] + '">L' + l + '</span> ';
}
html += window.escapeHtmlSpecialChars(type.name) + '</li>';
});
});
}
html += '</ul>'
return html;
}
window.formatPasscodeShort = function(data) {
if(data.other) {
var awards = data.other.map(window.escapeHtmlSpecialChars);
} else {
var awards = [];
}
if(0 < data.xm)
awards.push(window.escapeHtmlSpecialChars(data.xm) + ' XM');
if(0 < data.ap)
awards.push(window.escapeHtmlSpecialChars(data.ap) + ' AP');
if(data.inventory) {
data.inventory.forEach(function(type) {
type.awards.forEach(function(item) {
var str = "";
if(item.count > 1)
str += item.count + " ";
if(window.REDEEM_SHORT_NAMES[type.name.toLowerCase()]) {
var shortName = window.REDEEM_SHORT_NAMES[type.name.toLowerCase()];
var l = item.level;
if(0 < l) {
l = parseInt(l);
str += '<span class="itemlevel" style="color:' + COLORS_LVL[l] + '">' + shortName + l + '</span>';
} else {
str += shortName;
}
} else { // no short name known
var l = item.level;
if(0 < l) {
l = parseInt(l);
str += '<span class="itemlevel" style="color:' + COLORS_LVL[l] + '">L' + l + '</span> ';
}
str += type.name;
}
awards.push(str);
});
});
}
return '<p class="redeemReward">' + awards.join(', ') + '</p>'
}
window.setupRedeem = function() {
$("#redeem").keypress(function(e) {
if((e.keyCode ? e.keyCode : e.which) !== 13) return;
var passcode = $(this).val();
passcode = passcode.replace(/[^\x20-\x7E]+/g, ''); //removes non-printable characters
if(!passcode) return;
var jqXHR = window.postAjax('redeemReward', {passcode:passcode}, window.handleRedeemResponse, function(response) {
var extra = '';
if(response.status) {
extra = (window.REDEEM_STATUSES[response.status] || 'The server indicated an error.') + ' (HTTP ' + response.status + ')';
} else {
extra = 'No status code was returned.';
}
dialog({
title: 'Request failed: ' + data.passcode,
html: '<strong>The HTTP request failed.</strong> ' + extra
});
});
jqXHR.passcode = passcode;
});
};
;
window.regionScoreboard = function() {
// TODO: rather than just load the region scores for the center of the map, display a list of regions in the current view
// and let the user select one (with automatic selection when just one region, and limited to close enough zooms so list size is reasonable)
var latLng = map.getCenter();
var latE6 = Math.round(latLng.lat*1E6);
var lngE6 = Math.round(latLng.lng*1E6);
var dlg = dialog({title:'Region scores',html:'Loading regional scores...',width:450,minHeight:320});
window.postAjax('getRegionScoreDetails', {latE6:latE6,lngE6:lngE6}, function(res){regionScoreboardSuccess(res,dlg);}, function(){regionScoreboardFailure(dlg);});
}
function regionScoreboardFailure(dlg) {
dlg.html('Failed to load region scores - try again');
}
function regionScoreboardScoreHistoryChart(result, logscale) {
// svg area 400x130. graph area 350x100, offset to 40,10
if(!Math.log10)
Math.log10 = function(x) { return Math.log(x) / Math.LN10; };
var max = Math.max(result.gameScore[0],result.gameScore[1],10); //NOTE: ensure a min of 10 for the graph
var items = []; //we'll copy the items to an array indexed by checkpoint number - easier to access!
for (var i=0; i<result.scoreHistory.length; i++) {
max = Math.max(max, result.scoreHistory[i][1], result.scoreHistory[i][2]); //note: index 0 is the checkpoint number here
items[result.scoreHistory[i][0]] = [result.scoreHistory[i][1], result.scoreHistory[i][2]];
}
// scale up maximum a little, so graph isn't squashed right against upper edge
max *= 1.09;
// 0 cannot be displayed on a log scale, so we set the minimum to 0.001 and divide by lg(0.001)=-3
var scale = logscale
? function(y) { return 10 - Math.log10(Math.max(0.001,y/max)) / 3 * 100; }
: function(y) { return 110-y/max*100; };
var teamPaths = [[],[]];
var otherSvg = [];
for (var i=0; i<items.length; i++) {
var x=i*10+40;
if (items[i] !== undefined) {
// paths
if (i>0 && items[i-1] !== undefined) {
for (var t=0; t<2; t++) {
teamPaths[t].push('M'+(x-10)+','+scale(items[i-1][t])+' L'+x+','+scale(items[i][t]));
}
}
// markers
otherSvg.push('<g title="test" class="checkpoint" data-cp="'+i+'" data-enl="'+items[i][0]+'" data-res="'+items[i][1]+'">');
otherSvg.push('<rect x="'+(i*10+35)+'" y="10" width="10" height="100" fill="black" fill-opacity="0" />');
for (var t=0; t<2; t++) {
var col = t==0 ? COLORS[TEAM_ENL] : COLORS[TEAM_RES];
otherSvg.push('<circle cx="'+x+'" cy="'+scale(items[i][t])+'" r="3" stroke-width="1" stroke="'+col+'" fill="'+col+'" fill-opacity="0.5" />');
}
otherSvg.push('</g>');
}
}
var paths = '<path d="M40,110 L40,10 M40,110 L390,110" stroke="#fff" />';
// graph tickmarks - horizontal
var ticks = [];
for (var i=5; i<=35; i+=5) {
var x=i*10+40;
ticks.push('M'+x+',10 L'+x+',110');
otherSvg.push('<text x="'+x+'" y="125" font-size="12" font-family="Roboto, Helvetica, sans-serif" text-anchor="middle" fill="#fff">'+i+'</text>');
}
// vertical
// first we calculate the power of 10 that is smaller than the max limit
var vtickStep = Math.pow(10,Math.floor(Math.log10(max)));
var vticks = [];
if(logscale) {
for(var i=0;i<4;i++) {
vticks.push(vtickStep);
vtickStep /= 10;
}
} else {
// this could be between 1 and 10 grid lines - so we adjust to give nicer spacings
if (vtickStep < (max/5)) {
vtickStep *= 2;
} else if (vtickStep > (max/2)) {
vtickStep /= 2;
}
for (var i=vtickStep; i<=max; i+=vtickStep) {
vticks.push(i);
}
}
vticks.forEach(function(i) {
var y = scale(i);
ticks.push('M40,'+y+' L390,'+y);
var istr = i>=1000000000 ? i/1000000000+'B' : i>=1000000 ? i/1000000+'M' : i>=1000 ? i/1000+'k' : i;
otherSvg.push('<text x="35" y="'+y+'" font-size="12" font-family="Roboto, Helvetica, sans-serif" text-anchor="end" fill="#fff">'+istr+'</text>');
});
paths += '<path d="'+ticks.join(' ')+'" stroke="#fff" opacity="0.3" />;'
for (var t=0; t<2; t++) {
var col = t==0 ? COLORS[TEAM_ENL] : COLORS[TEAM_RES];
if (teamPaths[t].length > 0) {
paths += '<path d="'+teamPaths[t].join(' ')+'" stroke="'+col+'" />';
}
var y = scale(result.gameScore[t]);
paths += '<path d="M40,'+y+' L390,'+y+'" stroke="'+col+'" stroke-dasharray="3,2" opacity="0.8" />';
}
var svg = '<div><svg width="400" height="130">'
+'<rect x="0" y="0" width="400" height="130" stroke="#FFCE00" fill="#08304E" />'
+paths
+otherSvg.join('')
+'<foreignObject height="18" width="45" y="111" x="0" class="node"><label title="Logarithmic scale">'
+'<input type="checkbox" class="logscale" style="height:auto;padding:0;vertical-align:middle"'+(logscale?' checked':'')+'/>'
+'log</label></foreignObject>'
+'</svg></div>';
return svg;
}
function regionScoreboardScoreHistoryTable(result) {
var history = result.scoreHistory;
var table = '<table class="checkpoint_table"><thead><tr><th>Checkpoint</th><th>Enlightened</th><th>Resistance</th></tr></thead>';
for(var i=0; i<history.length; i++) {
table += '<tr><td>' + history[i][0] + '</td><td>' + digits(history[i][1]) + '</td><td>' + digits(history[i][2]) + '</td></tr>';
}
table += '</table>';
return table;
}
function regionScoreboardSuccess(data,dlg,logscale) {
if (data.result === undefined) {
return regionScoreboardFailure(dlg);
}
var agentTable = '<table><tr><th>#</th><th>Agent</th></tr>';
for (var i=0; i<data.result.topAgents.length; i++) {
var agent = data.result.topAgents[i];
agentTable += '<tr><td>'+(i+1)+'</td><td class="nickname '+(agent.team=='RESISTANCE'?'res':'enl')+'">'+agent.nick+'</td></tr>';
}
if (data.result.topAgents.length==0) {
agentTable += '<tr><td colspan="2"><i>no top agents</i></td></tr>';
}
agentTable += '</table>';
var maxAverage = Math.max(data.result.gameScore[0], data.result.gameScore[1], 1);
var teamRow = [];
for (var t=0; t<2; t++) {
var team = t==0 ? 'Enlightened' : 'Resistance';
var teamClass = t==0 ? 'enl' : 'res';
var teamCol = t==0 ? COLORS[TEAM_ENL] : COLORS[TEAM_RES];
var barSize = Math.round(data.result.gameScore[t]/maxAverage*200);
teamRow[t] = '<tr><th class="'+teamClass+'">'+team+'</th><td class="'+teamClass+'">'+digits(data.result.gameScore[t])+'</td><td><div style="background:'+teamCol+'; width: '+barSize+'px; height: 1.3ex; border: 2px outset '+teamCol+'"> </td></tr>';
}
var first = PLAYER.team == 'RESISTANCE' ? 1 : 0;
// we need some divs to make the accordion work properly
dlg.html('<div class="cellscore">'
+'<b>Region scores for '+data.result.regionName+'</b>'
+'<div><table>'+teamRow[first]+teamRow[1-first]+'</table>'
+regionScoreboardScoreHistoryChart(data.result, logscale)+'</div>'
+'<b>Checkpoint overview</b>'
+'<div>'+regionScoreboardScoreHistoryTable(data.result)+'</div>'
+'<b>Top agents</b>'
+'<div>'+agentTable+'</div>'
+'</div>');
$('g.checkpoint', dlg).each(function(i, elem) {
elem = $(elem);
var tooltip = 'CP:\t'+elem.attr('data-cp')
+ '\nEnl:\t' + digits(elem.attr('data-enl'))
+ '\nRes:\t' + digits(elem.attr('data-res'));
elem.tooltip({
content: convertTextToTableMagic(tooltip),
position: {my: "center bottom", at: "center top-10"}
});
});
$('.cellscore', dlg).accordion({
header: 'b',
heightStyle: "fill",
});
$('input.logscale', dlg).change(function(){
var input = $(this);
regionScoreboardSuccess(data, dlg, input.prop('checked'));
});
}
;
// REQUEST HANDLING //////////////////////////////////////////////////
// note: only meant for portal/links/fields request, everything else
// does not count towards “loading”
window.activeRequests = [];
window.failedRequestCount = 0;
window.statusTotalMapTiles = 0;
window.statusCachedMapTiles = 0;
window.statusSuccessMapTiles = 0;
window.statusStaleMapTiles = 0;
window.statusErrorMapTiles = 0;
window.requests = function() {}
//time of last refresh
window.requests._lastRefreshTime = 0;
window.requests._quickRefreshPending = false;
window.requests.add = function(ajax) {
window.activeRequests.push(ajax);
renderUpdateStatus();
}
window.requests.remove = function(ajax) {
window.activeRequests.splice(window.activeRequests.indexOf(ajax), 1);
renderUpdateStatus();
}
window.requests.abort = function() {
$.each(window.activeRequests, function(ind, actReq) {
if(actReq) actReq.abort();
});
window.activeRequests = [];
window.failedRequestCount = 0;
window.chat._requestPublicRunning = false;
window.chat._requestFactionRunning = false;
renderUpdateStatus();
}
// sets the timer for the next auto refresh. Ensures only one timeout
// is queued. May be given 'override' in milliseconds if time should
// not be guessed automatically. Especially useful if a little delay
// is required, for example when zooming.
window.startRefreshTimeout = function(override) {
// may be required to remove 'paused during interaction' message in
// status bar
window.renderUpdateStatus();
if(refreshTimeout) clearTimeout(refreshTimeout);
if(override == -1) return; //don't set a new timeout
var t = 0;
if(override) {
window.requests._quickRefreshPending = true;
t = override;
//ensure override can't cause too fast a refresh if repeatedly used (e.g. lots of scrolling/zooming)
timeSinceLastRefresh = new Date().getTime()-window.requests._lastRefreshTime;
if(timeSinceLastRefresh < 0) timeSinceLastRefresh = 0; //in case of clock adjustments
if(timeSinceLastRefresh < MINIMUM_OVERRIDE_REFRESH*1000)
t = (MINIMUM_OVERRIDE_REFRESH*1000-timeSinceLastRefresh);
} else {
window.requests._quickRefreshPending = false;
t = REFRESH*1000;
var adj = ZOOM_LEVEL_ADJ * (18 - map.getZoom());
if(adj > 0) t += adj*1000;
}
var next = new Date(new Date().getTime() + t).toLocaleTimeString();
// console.log('planned refresh in ' + (t/1000) + ' seconds, at ' + next);
refreshTimeout = setTimeout(window.requests._callOnRefreshFunctions, t);
renderUpdateStatus();
}
window.requests._onRefreshFunctions = [];
window.requests._callOnRefreshFunctions = function() {
// console.log('running refresh at ' + new Date().toLocaleTimeString());
startRefreshTimeout();
if(isIdle()) {
// console.log('user has been idle for ' + idleTime + ' seconds, or window hidden. Skipping refresh.');
renderUpdateStatus();
return;
}
// console.log('refreshing');
//store the timestamp of this refresh
window.requests._lastRefreshTime = new Date().getTime();
$.each(window.requests._onRefreshFunctions, function(ind, f) {
f();
});
}
// add method here to be notified of auto-refreshes
window.requests.addRefreshFunction = function(f) {
window.requests._onRefreshFunctions.push(f);
}
window.requests.isLastRequest = function(action) {
var result = true;
$.each(window.activeRequests, function(ind, req) {
if(req.action === action) {
result = false;
return false;
}
});
return result;
}
;
// SEARCH /////////////////////////////////////////////////////////
/*
you can implement your own result provider by listing to the search hook:
addHook('search', function(query) {});
`query` is an object with the following members:
- `term` is the term for which the user has searched
- `confirmed` is a boolean indicating if the user has pressed enter after searching. You should not search online or
do heavy processing unless the user has confirmed the search term
- `addResult(result)` can be called to add a result to the query.
`result` may have the following members (`title` is required, as well as one of `position` and `bounds`):
- `title`: the label for this result. Will be interpreted as HTML, so make sure to escape properly.
- `description`: secondary information for this result. Will be interpreted as HTML, so make sure to escape properly.
- `position`: a L.LatLng object describing the position of this result
- `bounds`: a L.LatLngBounds object describing the bounds of this result
- `layer`: a ILayer to be added to the map when the user selects this search result. Will be generated if not set.
Set to `null` to prevent the result from being added to the map.
- `icon`: a URL to a icon to display in the result list. Should be 12x12.
- `onSelected(result, event)`: a handler to be called when the result is selected. May return `true` to prevent the map
from being repositioned. You may reposition the map yourself or do other work.
- `onRemove(result)`: a handler to be called when the result is removed from the map (because another result has been
selected or the search was cancelled by the user).
*/
window.search = {
lastSearch: null,
};
window.search.Query = function(term, confirmed) {
this.term = term;
this.confirmed = confirmed;
this.init();
};
window.search.Query.prototype.init = function() {
this.results = [];
this.container = $('<div>').addClass('searchquery');
this.header = $('<h3>')
.text(this.confirmed
? this.term
: ((this.term.length > 16
? this.term.substr(0,8) + '…' + this.term.substr(this.term.length-8,8)
: this.term)
+ ' (Return to load more)'))
.appendTo(this.container);
this.list = $('<ul>')
.appendTo(this.container)
.append($('<li>').text(this.confirmed ? 'No local results, searching online...' : 'No local results.'));
this.container.accordion({
collapsible: true,
heightStyle: 'content',
});
runHooks('search', this);
};
window.search.Query.prototype.show = function() {
this.container.appendTo('#searchwrapper');
};
window.search.Query.prototype.hide = function() {
this.container.remove();
this.removeSelectedResult();
};
window.search.Query.prototype.addResult = function(result) {
if(this.results.length == 0) {
// remove 'No results'
this.list.empty();
}
this.results.push(result);
var item = $('<li>')
.appendTo(this.list)
.attr('tabindex', '0')
.on('click dblclick', function(ev) {
this.onResultSelected(result, ev);
}.bind(this))
.keypress(function(ev) {
if((ev.keyCode || ev.charCode || ev.which) == 32) {
ev.preventDefault();
ev.type = 'click';
$(this).trigger(ev);
return;
}
if((ev.keyCode || ev.charCode || ev.which) == 13) {
ev.preventDefault();
ev.type = 'dblclick';
$(this).trigger(ev);
return;
}
});
var link = $('<a>')
.append(result.title)
.appendTo(item);
if(result.icon) {
link.css('background-image', 'url("'+result.icon+'")');
item.css('list-style', 'none');
}
if(result.description) {
item
.append($('<br>'))
.append($('<em>')
.append(result.description));
}
};
window.search.Query.prototype.onResultSelected = function(result, ev) {
this.removeSelectedResult();
this.selectedResult = result;
if(result.onSelected) {
if(result.onSelected(result, ev)) return;
}
if(ev.type == 'dblclick') {
if(result.position) {
map.setView(result.position, 17);
} else if(result.bounds) {
map.fitBounds(result.bounds, {maxZoom: 17});
}
} else { // ev.type != 'dblclick'
if(result.bounds) {
map.fitBounds(result.bounds, {maxZoom: 17});
} else if(result.position) {
map.setView(result.position);
}
}
if(result.layer !== null && !result.layer) {
result.layer = L.layerGroup();
if(result.position) {
createGenericMarker(result.position, 'red', {
title: result.title
}).addTo(result.layer);
}
if(result.bounds) {
L.rectangle(result.bounds, {
title: result.title,
clickable: false,
color: 'red',
fill: false,
}).addTo(result.layer);
}
}
if(result.layer)
map.addLayer(result.layer);
if(window.isSmartphone()) window.show('map');
}
window.search.Query.prototype.removeSelectedResult = function() {
if(this.selectedResult) {
if(this.selectedResult.layer) map.removeLayer(this.selectedResult.layer);
if(this.selectedResult.onRemove) this.selectedResult.onRemove(this.selectedResult);
}
}
window.search.doSearch = function(term, confirmed) {
term = term.trim();
// minimum 3 characters for automatic search
if(term.length < 3 && !confirmed) return;
// don't clear last confirmed search
if(window.search.lastSearch
&& window.search.lastSearch.confirmed
&& !confirmed)
return;
// don't make the same query again
if(window.search.lastSearch
&& window.search.lastSearch.confirmed == confirmed
&& window.search.lastSearch.term == term)
return;
if(window.search.lastSearch) window.search.lastSearch.hide();
window.search.lastSearch = null;
// clear results
if(term == '') return;
if(useAndroidPanes()) show('info');
$('.ui-tooltip').remove();
window.search.lastSearch = new window.search.Query(term, confirmed);
window.search.lastSearch.show();
};
window.search.setup = function() {
$('#search')
.keypress(function(e) {
if((e.keyCode ? e.keyCode : e.which) != 13) return;
e.preventDefault();
var term = $(this).val();
clearTimeout(window.search.timer);
window.search.doSearch(term, true);
})
.on('keyup keypress change paste', function(e) {
clearTimeout(window.search.timer);
window.search.timer = setTimeout(function() {
var term = $(this).val();
window.search.doSearch(term, false);
}.bind(this), 500);
});
$('#buttongeolocation').click(function(){
map.locate({setView : true, maxZoom: 13});
});
};
// search for portals
addHook('search', function(query) {
var term = query.term.toLowerCase();
var teams = ['NEU','RES','ENL'];
$.each(portals, function(guid, portal) {
var data = portal.options.data;
if(!data.title) return;
if(data.title.toLowerCase().indexOf(term) !== -1) {
var team = portal.options.team;
var color = team==TEAM_NONE ? '#CCC' : COLORS[team];
query.addResult({
title: data.title,
description: teams[team] + ', L' + data.level + ', ' + data.health + '%, ' + data.resCount + ' Resonators',
position: portal.getLatLng(),
icon: 'data:image/svg+xml;base64,'+btoa('<svg xmlns:xlink="http://www.w3.org/1999/xlink" xmlns="http://www.w3.org/2000/svg" width="12" height="12" version="1.1">\n <g style="fill:%COLOR%;stroke:none">\n <path d="m 6,12 -2,-12 4,0 z" />\n <path d="m 6,12 -4, -8 8,0 z" />\n <path d="m 6,12 -6, -4 12,0 z" />\n </g>\n</svg>\n'.replace(/%COLOR%/g, color)),
onSelected: function(result, event) {
if(event.type == 'dblclick') {
zoomToAndShowPortal(guid, portal.getLatLng());
} else if(window.portals[guid]) {
if(!map.getBounds().contains(result.position)) map.setView(result.position);
renderPortalDetails(guid);
} else {
window.selectPortalByLatLng(portal.getLatLng());
}
return true; // prevent default behavior
},
});
}
});
});
// search for locations
// TODO: recognize 50°31'03.8"N 7°59'05.3"E and similar formats
addHook('search', function(query) {
var locations = query.term.match(/[+-]?\d+\.\d+,[+-]?\d+\.\d+/g);
var added = {};
if(!locations) return;
locations.forEach(function(location) {
var pair = location.split(',').map(function(s) { return parseFloat(s).toFixed(6); });
var ll = pair.join(",");
var latlng = L.latLng(pair.map(function(s) { return parseFloat(s); }));
if(added[ll]) return;
added[ll] = true;
query.addResult({
title: ll,
description: 'geo coordinates',
position: latlng,
onSelected: function(result, event) {
for(var guid in window.portals) {
var p = window.portals[guid].getLatLng();
if((p.lat.toFixed(6)+","+p.lng.toFixed(6)) == ll) {
renderPortalDetails(guid);
return;
}
}
urlPortalLL = [result.position.lat, result.position.lng];
},
});
});
});
// search on OpenStreetMap
addHook('search', function(query) {
if(!query.confirmed) return;
$.getJSON(NOMINATIM + encodeURIComponent(query.term), function(data) {
if(data.length == 0) {
query.addResult({
title: 'No results on OpenStreetMap',
icon: '//www.openstreetmap.org/favicon.ico',
onSelected: function() {return true;},
});
return;
}
data.forEach(function(item) {
var result = {
title: item.display_name,
description: 'Type: ' + item.type,
position: L.latLng(parseFloat(item.lat), parseFloat(item.lon)),
icon: item.icon,
};
if(item.geojson) {
result.layer = L.geoJson(item.geojson, {
clickable: false,
color: 'red',
opacity: 0.7,
weight: 2,
fill: false,
pointToLayer: function(featureData,latLng) {
return createGenericMarker(latLng,'red');
}
});
}
var b = item.boundingbox;
if(b) {
var southWest = new L.LatLng(b[0], b[2]),
northEast = new L.LatLng(b[1], b[3]);
result.bounds = new L.LatLngBounds(southWest, northEast);
}
query.addResult(result);
});
});
});
;
// posts AJAX request to Ingress API.
// action: last part of the actual URL, the rpc/dashboard. is
// added automatically
// data: JSON data to post. method will be derived automatically from
// action, but may be overridden. Expects to be given Hash.
// Strings are not supported.
// success: method to call on success. See jQuery API docs for avail-
// able arguments: http://api.jquery.com/jQuery.ajax/
// error: see above. Additionally it is logged if the request failed.
window.postAjax = function(action, data, successCallback, errorCallback) {
// state management functions... perhaps should be outside of this func?
// var remove = function(data, textStatus, jqXHR) { window.requests.remove(jqXHR); };
// var errCnt = function(jqXHR) { window.failedRequestCount++; window.requests.remove(jqXHR); };
if (window.latestFailedRequestTime && window.latestFailedRequestTime < Date.now()-120*1000) {
// no errors in the last two minutes - clear the error count
window.failedRequestCount = 0;
window.latestFailedRequestTime = undefined;
}
var onError = function(jqXHR, textStatus, errorThrown) {
window.requests.remove(jqXHR);
window.failedRequestCount++;
window.latestFailedRequestTime = Date.now();
// pass through to the user error func, if one exists
if (errorCallback) {
errorCallback(jqXHR, textStatus, errorThrown);
}
};
var onSuccess = function(data, textStatus, jqXHR) {
window.requests.remove(jqXHR);
// the Niantic server can return a HTTP success, but the JSON response contains an error. handle that sensibly
if (data && data.error && data.error == 'out of date') {
window.failedRequestCount++;
// let's call the error callback in thos case...
if (errorCallback) {
errorCallback(jqXHR, textStatus, "data.error == 'out of date'");
}
window.outOfDateUserPrompt();
} else {
successCallback(data, textStatus, jqXHR);
}
};
// we set this flag when we want to block all requests due to having an out of date CURRENT_VERSION
if (window.blockOutOfDateRequests) {
window.failedRequestCount++;
window.latestFailedRequestTime = Date.now();
// call the error callback, if one exists
if (errorCallback) {
// NOTE: error called on a setTimeout - as it won't be expected to be synchronous
// ensures no recursion issues if the error handler immediately resends the request
setTimeout(function(){errorCallback(null, undefined, "window.blockOutOfDateRequests is set");}, 10);
}
return;
}
var versionStr = niantic_params.CURRENT_VERSION;
var post_data = JSON.stringify($.extend({}, data, {v: versionStr}));
var result = $.ajax({
url: '/r/'+action,
type: 'POST',
data: post_data,
context: data,
dataType: 'json',
success: [onSuccess],
error: [onError],
contentType: 'application/json; charset=utf-8',
beforeSend: function(req) {
req.setRequestHeader('X-CSRFToken', readCookie('csrftoken'));
}
});
result.action = action;
requests.add(result);
return result;
}
window.outOfDateUserPrompt = function()
{
// we block all requests while the dialog is open.
if (!window.blockOutOfDateRequests) {
window.blockOutOfDateRequests = true;
dialog({
title: 'Reload IITC',
html: '<p>IITC is using an outdated version code. This will happen when Niantic updates the standard intel site.</p>'
+'<p>You need to reload the page to get the updated changes.</p>'
+'<p>If you have just reloaded the page, then an old version of the standard site script is cached somewhere.'
+'In this case, try clearing your cache, or waiting 15-30 minutes for the stale data to expire.</p>',
buttons: {
'RELOAD': function() {
if (typeof android !== 'undefined' && android && android.reloadIITC) {
android.reloadIITC();
} else {
window.location.reload();
}
}
},
close: function(event, ui) {
delete window.blockOutOfDateRequests;
}
});
}
}
;
window.isSmartphone = function() {
// this check is also used in main.js. Note it should not detect
// tablets because their display is large enough to use the desktop
// version.
// The stock intel site allows forcing mobile/full sites with a vp=m or vp=f
// parameter - let's support the same. (stock only allows this for some
// browsers - e.g. android phone/tablet. let's allow it for all, but
// no promises it'll work right)
var viewParam = getURLParam('vp');
if (viewParam == 'm') return true;
if (viewParam == 'f') return false;
return navigator.userAgent.match(/Android.*Mobile/);
}
window.smartphone = function() {};
window.runOnSmartphonesBeforeBoot = function() {
if(!isSmartphone()) return;
console.warn('running smartphone pre boot stuff');
// add smartphone stylesheet
headHTML = document.getElementsByTagName('head')[0].innerHTML;
headHTML += '<style>body {\n color: #fff;\n}\n\n#updatestatus {\n background: #262c32;\n width: 100%;\n color: #d4d5d6;\n border: 0;\n padding: 0;\n}\n\n#updatestatus .map {\n margin-left: 4px;\n}\n\n#innerstatus {\n padding: 4px;\n float: right;\n width: 50%;\n text-overflow: ellipsis;\n white-space: nowrap;\n overflow: hidden;\n -moz-box-sizing: border-box;\n -webkit-box-sizing: border-box;\n box-sizing: border-box;\n}\n\n#loadlevel {\n border-width: 0;\n background: transparent;\n color: #FFF;\n}\n\n#mobileinfo {\n float: left;\n width: 50%;\n text-overflow: ellipsis;\n white-space: nowrap;\n overflow: hidden;\n position:relative;\n padding: 4px 0;\n -moz-box-sizing: border-box;\n -webkit-box-sizing: border-box;\n box-sizing: border-box;\n}\n\n#mobileinfo .portallevel {\n padding: 0 0.25em;\n color: #FFF;\n}\n\n#mobileinfo .resonator {\n position: absolute;\n width: 12%; /* a little less that 1/8 to have a small distance */\n height: 100%;\n top: 0;\n border-top: 3px solid red;\n box-sizing: border-box;\n -moz-box-sizing: border-box;\n -webkit-box-sizing: border-box;\n}\n\n#mobileinfo .resonator.north:before {\n content: "";\n background-color: red;\n border-radius: 100%;\n display: block;\n height: 6px;\n width: 6px;\n left: 50%;\n top: -3px; \n margin-left: -3px;\n position: absolute;\n z-index: -1;\n}\n\n#mobileinfo .filllevel {\n position: absolute;\n bottom: 0;\n height: 3px;\n}\n\n#mobileinfo .enl .filllevel {\n background-color: #03fe03 !important;\n}\n\n#mobileinfo .res .filllevel {\n background-color: #00c5ff !important;\n}\n\n#name #signout { /* no hover, always show signout button */\n display: block;\n}\n\n#sidebar, #chatcontrols, #chat, #chatinput {\n background: transparent !important;\n}\n\n.leaflet-top .leaflet-control {\n margin-top: 5px !important;\n margin-left: 5px !important;\n}\n\n#searchwrapper {\n font-size: 1.2em;\n}\n#searchwrapper .ui-accordion-header {\n padding: 0.3em 0;\n}\n#searchwrapper li {\n line-height: 1.3em;\n}\n\n#chatcontrols {\n height: 38px;\n width: 100%;\n display: none !important;\n}\n\n/* hide shrink button */\n#chatcontrols a:first-child {\n display: none;\n}\n\n#chatcontrols a {\n width: 50px;\n height:36px;\n overflow: hidden;\n vertical-align: middle;\n line-height: 36px;\n text-decoration: none;\n -moz-box-sizing: border-box;\n -webkit-box-sizing: border-box;\n box-sizing: border-box;\n}\n\n#chat {\n left:0;\n right:0;\n top: 1px !important;\n bottom:30px;\n width: auto;\n}\n\n#chatinput {\n width: 100%;\n height: 30px;\n}\n\n#chat td:nth-child(2), #chatinput td:nth-child(2) {\n width: 77px;\n}\n\n#chatcontrols a.active {\n border-color: #FFCE00;\n border-bottom-width:0px;\n font-weight:bold\n}\n\n#chatcontrols a.active + a {\n border-left-color: #FFCE00\n}\n\n#sidebartoggle {\n display: none !important;\n}\n\n#scrollwrapper {\n bottom: 0;\n max-height: none !important;\n width: 100% !important;\n right: 0;\n left:0;\n}\n\n#sidebar {\n width: 100% !important;\n min-height: 100%;\n border:0;\n}\n\n#sidebar > * {\n width: 100%;\n}\n\n#playerstat {\n margin-top: 5px;\n}\n\n#portaldetails {\n min-height: 0;\n}\n\n.fullimg {\n width: 100%;\n}\n\n/*\n * for some reason leaflet popups on mobile are colored white on white\n * so force the popup msg color to black\n */\n.leaflet-popup-content{\n color:black;\n}\n\n\n/* add extra padding, and a button effect, to sidebar link areas */\n.linkdetails aside {\n padding: 5px;\n margin-top: 3px;\n margin-bottom: 3px;\n border: 2px outset #20A8B1;\n}\n\n#toolbox > a {\n padding: 5px;\n margin-top: 3px;\n margin-bottom: 3px;\n border: 2px outset #20A8B1;\n}\n\n#portaldetails .close {\n padding: 4px;\n border: 1px outset #20A8B1;\n margin-top: 2px;\n}\n</style>';
document.getElementsByTagName('head')[0].innerHTML = headHTML;
// don’t need many of those
window.setupStyles = function() {
$('head').append('<style>' +
[ '#largepreview.enl img { border:2px solid '+COLORS[TEAM_ENL]+'; } ',
'#largepreview.res img { border:2px solid '+COLORS[TEAM_RES]+'; } ',
'#largepreview.none img { border:2px solid '+COLORS[TEAM_NONE]+'; } '].join("\n")
+ '</style>');
}
window.smartphone.mapButton = $('<a>map</a>').click(function() {
$('#map').css('visibility', 'visible');
$('#updatestatus').show();
$('#chatcontrols a .active').removeClass('active');
$("#chatcontrols a:contains('map')").addClass('active');
});
window.smartphone.sideButton = $('<a>info</a>').click(function() {
$('#scrollwrapper').show();
$('.active').removeClass('active');
$("#chatcontrols a:contains('info')").addClass('active');
});
$('#chatcontrols').append(smartphone.mapButton).append(smartphone.sideButton);
window.addHook('portalDetailsUpdated', function(data) {
var x = $('.imgpreview img').removeClass('hide');
if(!x.length) {
$('.fullimg').remove();
return;
}
if($('.fullimg').length) {
$('.fullimg').replaceWith(x.addClass('fullimg'));
} else {
x.addClass('fullimg').appendTo('#sidebar');
}
});
}
window.smartphoneInfo = function(data) {
var guid = data.selectedPortalGuid;
if(!window.portals[guid]) return;
var data = window.portals[selectedPortal].options.data;
var details = window.portalDetail.get(guid);
var lvl = data.level;
if(data.team === "NEUTRAL")
var t = '<span class="portallevel">L0</span>';
else
var t = '<span class="portallevel" style="background: '+COLORS_LVL[lvl]+';">L' + lvl + '</span>';
var percentage = data.health;
if(details) {
var totalEnergy = getTotalPortalEnergy(details);
if(getTotalPortalEnergy(details) > 0) {
percentage = Math.floor(getCurrentPortalEnergy(details) / totalEnergy * 100);
}
}
t += ' ' + percentage + '% ';
t += data.title;
if(details) {
var l,v,max,perc;
var eastAnticlockwiseToNorthClockwise = [2,1,0,7,6,5,4,3];
for(var ind=0;ind<8;ind++)
{
if (details.resonators.length == 8) {
var slot = eastAnticlockwiseToNorthClockwise[ind];
var reso = details.resonators[slot];
} else {
var slot = null;
var reso = ind < details.resonators.length ? details.resonators[ind] : null;
}
var className = TEAM_TO_CSS[getTeam(details)];
if(slot !== null && OCTANTS[slot] === 'N')
className += ' north'
if(reso) {
l = parseInt(reso.level);
v = parseInt(reso.energy);
max = RESO_NRG[l];
perc = v/max*100;
} else {
l = 0;
v = 0;
max = 0;
perc = 0;
}
t += '<div class="resonator '+className+'" style="border-top-color: '+COLORS_LVL[l]+';left: '+(100*ind/8.0)+'%;">';
t += '<div class="filllevel" style="width:'+perc+'%;"></div>';
t += '</div>'
}
}
$('#mobileinfo').html(t);
}
window.runOnSmartphonesAfterBoot = function() {
if(!isSmartphone()) return;
console.warn('running smartphone post boot stuff');
window.show('map');
// add a div/hook for updating mobile info
$('#updatestatus').prepend('<div id="mobileinfo" onclick="show(\'info\')"></div>');
window.addHook('portalSelected', window.smartphoneInfo);
// init msg of status bar. hint for the user that a tap leads to the info screen
$('#mobileinfo').html('<div style="text-align: center"><b>tap here for info screen</b></div>');
// disable img full view
$('#portaldetails').off('click', '**');
// make buttons in action bar flexible
var l = $('#chatcontrols a:visible');
l.css('width', 100/l.length + '%');
// notify android that a select spinner is enabled.
// this disables javascript injection on android side.
// if android is not notified, the spinner closes on the next JS call
if (typeof android !== 'undefined' && android && android.spinnerEnabled) {
$("body").on("click", "select", function() {
android.spinnerEnabled(true);
});
}
// add event to portals that allows long press to switch to sidebar
window.addHook('portalAdded', function(data) {
data.portal.on('add', function() {
if(!this._container || this.options.addedTapHoldHandler) return;
this.options.addedTapHoldHandler = true;
var guid = this.options.guid;
// this is a hack, accessing Leaflet’s private _container is evil
$(this._container).on('taphold', function() {
window.renderPortalDetails(guid);
window.show('info');
});
});
});
if(typeof android !== 'undefined' && android && android.setPermalink) {
window.map.on('moveend', window.setAndroidPermalink);
addHook('portalSelected', window.setAndroidPermalink);
}
// for some reason, leaflet misses the WebView size being set at startup on IITC Mobile
// create a short timer that checks for this issue
setTimeout (function() { map.invalidateSize(); }, 0.2*1000);
}
window.setAndroidPermalink = function() {
var c = window.map.getCenter();
var lat = Math.round(c.lat*1E6)/1E6;
var lng = Math.round(c.lng*1E6)/1E6;
var href = '/intel?ll='+lat+','+lng+'&z=' + map.getZoom();
if(window.selectedPortal && window.portals[window.selectedPortal]) {
var p = window.portals[window.selectedPortal].getLatLng();
lat = Math.round(p.lat*1E6)/1E6;
lng = Math.round(p.lng*1E6)/1E6;
href += '&pll='+lat+','+lng;
}
href = $('<a>').prop('href', href).prop('href'); // to get absolute URI
android.setPermalink(href);
}
window.useAndroidPanes = function() {
// isSmartphone is important to disable panes in desktop mode
return (typeof android !== 'undefined' && android && android.addPane && window.isSmartphone());
}
if(typeof android !== 'undefined' && android && android.getFileRequestUrlPrefix) {
window.requestFile = function(callback) {
do {
var funcName = "onFileSelected" + parseInt(Math.random()*0xFFFF).toString(16);
} while(window[funcName] !== undefined)
window[funcName] = function(filename, content) {
callback(decodeURIComponent(filename), atob(content));
};
var script = document.createElement('script');
script.src = android.getFileRequestUrlPrefix() + funcName;
(document.body || document.head || document.documentElement).appendChild(script);
};
}
;
// STATUS BAR ///////////////////////////////////////
// gives user feedback about pending operations. Draws current status
// to website. Updates info in layer chooser.
window.renderUpdateStatusTimer_ = undefined;
window.renderUpdateStatus = function() {
var progress = 1;
// portal/limk level display
var zoom = map.getZoom();
zoom = getDataZoomForMapZoom(zoom);
var tileParams = getMapZoomTileParameters(zoom);
var t = '<span class="help portallevel" title="Indicates portal levels/link lengths displayed. Zoom in to display more.">';
if (tileParams.hasPortals) {
// zoom level includes portals (and also all links/fields)
if(!window.isSmartphone()) // space is valuable
t += '<b>portals</b>: ';
if(tileParams.level === 0)
t += '<span id="loadlevel">all</span>';
else
t += '<span id="loadlevel" style="background:'+COLORS_LVL[tileParams.level]+'">L'+tileParams.level+(tileParams.level<8?'+':'') + '</span>';
} else {
if(!window.isSmartphone()) // space is valuable
t += '<b>links</b>: ';
if (tileParams.minLinkLength > 0)
t += '<span id="loadlevel">>'+(tileParams.minLinkLength>1000?tileParams.minLinkLength/1000+'km':tileParams.minLinkLength+'m')+'</span>';
else
t += '<span id="loadlevel">all links</span>';
}
t +='</span>';
// map status display
t += ' <span class="map"><b>map</b>: ';
if (window.mapDataRequest) {
var status = window.mapDataRequest.getStatus();
// status.short - short description of status
// status.long - longer description, for tooltip (optional)
// status.progress - fractional progress (from 0 to 1; -1 for indeterminate) of current state (optional)
if (status.long)
t += '<span class="help" title="'+status.long+'">'+status.short+'</span>';
else
t += '<span>'+status.short+'</span>';
if (status.progress !== undefined) {
if(status.progress !== -1)
t += ' '+Math.floor(status.progress*100)+'%';
progress = status.progress;
}
} else {
// no mapDataRequest object - no status known
t += '...unknown...';
}
t += '</span>';
//request status
if (window.activeRequests.length > 0)
t += ' ' + window.activeRequests.length + ' requests';
if (window.failedRequestCount > 0)
t += ' <span style="color:#f66">' + window.failedRequestCount + ' failed</span>'
//it's possible that updating the status bar excessively causes some performance issues. so rather than doing it
//immediately, delay it to the next javascript event loop, cancelling any pending update
// will also cause any browser-related rendering to occur first, before the status actually updates
if (window.renderUpdateStatusTimer_) clearTimeout(window.renderUpdateStatusTimer_);
window.renderUpdateStatusTimer_ = setTimeout ( function() {
window.renderUpdateStatusTimer_ = undefined;
$('#innerstatus').html(t);
//$('#updatestatus').click(function() { startRefreshTimeout(10); });
//. <a style="cursor: pointer" onclick="startRefreshTimeout(10)" title="Refresh">⟳</a>';
if(progress == 1 && window.activeRequests.length > 0) {
// we don't know the exact progress, but we have requests (e.g. chat) running, so show it as indeterminate.
progress = -1;
}
if (typeof android !== 'undefined' && android && android.setProgress)
android.setProgress(progress);
}, 0);
}
;
// UTILS + MISC ///////////////////////////////////////////////////////
window.aboutIITC = function() {
var v = (script_info.script && script_info.script.version || script_info.dateTimeVersion) + ' ['+script_info.buildName+']';
if (typeof android !== 'undefined' && android && android.getVersionName) {
v += '[IITC Mobile '+android.getVersionName()+']';
}
var plugins = '<ul>';
for (var i in bootPlugins) {
var info = bootPlugins[i].info;
if (info) {
var pname = info.script && info.script.name || info.pluginId;
if (pname.substr(0,13) == 'IITC plugin: ' || pname.substr(0,13) == 'IITC Plugin: ') {
pname = pname.substr(13);
}
var pvers = info.script && info.script.version || info.dateTimeVersion;
var ptext = pname + ' - ' + pvers;
if (info.buildName != script_info.buildName) {
ptext += ' ['+(info.buildName||'<i>non-standard plugin</i>')+']';
}
plugins += '<li>'+ptext+'</li>';
} else {
// no 'info' property of the plugin setup function - old plugin wrapper code
// could attempt to find the "window.plugin.NAME = function() {};" line it's likely to have..?
plugins += '<li>(unknown plugin: index '+i+')</li>';
}
}
plugins += '</ul>';
var attrib = '<p>This project is licensed under the permissive <a href="http://www.isc.org/downloads/software-support-policy/isc-license/">ISC license</a>. Parts imported from other projects remain under their respective licenses:</p>\n\n<ul>\n<li><a href="https://github.com/bryanwoods/autolink-js">autolink-js by Bryan Woods; MIT</a></li>\n<li><a href="https://github.com/chriso/load.js">load.js by Chris O\'Hara; MIT</a></li>\n<li><a href="http://leafletjs.com/">leaflet.js; custom license (but appears free)</a></li>\n<li><a href="https://github.com/Leaflet/Leaflet.draw">leaflet.draw.js by jacobtoye; MIT</a></li>\n<li>\n<a href="https://github.com/shramov/leaflet-plugins">leaflet_google.js by Pavel Shramov; same as Leaflet</a> (modified, though)</li>\n<li><a href="https://github.com/jeromeetienne/jquery-qrcode">jquery.qrcode.js by Jerome Etienne; MIT</a></li>\n<li><a href="https://github.com/jawj/OverlappingMarkerSpiderfier-Leaflet">oms.min.js by George MacKerron; MIT</a></li>\n<li><a href="https://github.com/richadams/jquery-taphold">taphold.js by Rich Adams; unknown</a></li>\n<li><a href="https://github.com/kartena/Leaflet.Pancontrol">L.Control.Pan.js by Kartena AB; same as Leaflet</a></li>\n<li><a href="https://github.com/kartena/Leaflet.zoomslider">L.Control.Zoomslider.js by Kartena AB; same as Leaflet</a></li>\n<li><a href="https://github.com/shramov/leaflet-plugins">KML.js by shramov; same as Leaflet</a></li>\n<li><a href="https://github.com/shramov/leaflet-plugins">leaflet.filelayer.js by shramov; same as Leaflet</a></li>\n<li><a href="https://github.com/shramov/leaflet-plugins">togeojson.js by shramov; same as Leaflet</a></li>\n<li>StackOverflow-CopyPasta is attributed in the source; <a href="https://creativecommons.org/licenses/by-sa/3.0/">CC-Wiki</a>\n</li>\n<li>all Ingress/Niantic related stuff obviously remains non-free and is still copyrighted by Niantic/Google</li>\n</ul>\n';
var contrib = '<p>So far, these people have contributed:</p>\n\n<p><a href="https://github.com/Bananeweizen">Bananeweizen</a>,\n<a href="https://github.com/blakjakau">blakjakau</a>,\n<a href="https://github.com/boombuler">boombuler</a>,\n<a href="https://github.com/breunigs">breunigs</a>,\n<a href="https://github.com/cathesaurus">cathesaurus</a>,\n<a href="https://github.com/ccjon">ccjon</a>,\n<a href="https://github.com/cmrn">cmrn</a>,\n<a href="https://github.com/epf">epf</a>,\n<a href="https://github.com/fkloft">fkloft</a>,\n<a href="https://github.com/Fragger">Fragger</a>,\n<a href="https://github.com/hastarin">hastarin</a>,\n<a href="https://github.com/integ3r">integ3r</a>,\n<a href="https://github.com/j16sdiz">j16sdiz</a>,\n<a href="https://github.com/JasonMillward">JasonMillward</a>,\n<a href="https://github.com/jonatkins">jonatkins</a>,\n<a href="https://github.com/leCradle">leCradle</a>,\n<a href="https://github.com/Merovius">Merovius</a>,\n<a href="https://github.com/mledoze">mledoze</a>,\n<a href="https://github.com/OshiHidra">OshiHidra</a>,\n<a href="https://github.com/phoenixsong6">phoenixsong6</a>,\n<a href="https://github.com/Pirozek">Pirozek</a>,\n<a href="https://github.com/saithis">saithis</a>,\n<a href="https://github.com/Scrool">Scrool</a>,\n<a href="https://github.com/sorgo">sorgo</a>,\n<a href="https://github.com/tpenner">tpenner</a>,\n<a href="https://github.com/vita10gy">vita10gy</a>,\n<a href="https://github.com/Xelio">Xelio</a>,\n<a href="https://github.com/ZauberNerd">ZauberNerd</a>,\n<a href="https://github.com/waynn">waynn</a></p>\n'
var a = ''
+ ' <div><b>About IITC</b></div> '
+ ' <div>Ingress Intel Total Conversion</div> '
+ ' <hr>'
+ ' <div>'
+ ' <a href="http://iitc.me/" target="_blank">IITC Homepage</a><br />'
+ ' On the script’s homepage you can:'
+ ' <ul>'
+ ' <li>Find Updates</li>'
+ ' <li>Get Plugins</li>'
+ ' <li>Report Bugs</li>'
+ ' <li>Contribute!</li>'
+ ' </ul>'
+ ' </div>'
+ ' <div>'
+ ' MapQuest OSM tiles Courtesy of <a href="http://www.mapquest.com/" target="_blank">MapQuest</a> <img src="https://developer.mapquest.com/content/osm/mq_logo.png">'
+ ' </div>'
+ ' <hr>'
+ ' <div>Version: ' + v + '</div>'
+ ' <div>Plugins: ' + plugins + '</div>'
+ ' <hr>'
+ ' <div>' + attrib + '</div>'
+ ' <hr>'
+ ' <div>' + contrib + '</div>';
dialog({
title: 'IITC ' + v,
html: a,
dialogClass: 'ui-dialog-aboutIITC'
});
}
window.layerGroupLength = function(layerGroup) {
var layersCount = 0;
var layers = layerGroup._layers;
if (layers)
layersCount = Object.keys(layers).length;
return layersCount;
}
// retrieves parameter from the URL?query=string.
window.getURLParam = function(param) {
var items = window.location.search.substr(1).split('&');
if (items == "") return "";
for (var i=0; i<items.length; i++) {
var item = items[i].split('=');
if (item[0] == param) {
var val = item.length==1 ? '' : decodeURIComponent (item[1].replace(/\+/g,' '));
return val;
}
}
return '';
}
// read cookie by name.
// http://stackoverflow.com/a/5639455/1684530 by cwolves
window.readCookie = function(name){
var C, i, c = document.cookie.split('; ');
var cookies = {};
for(i=c.length-1; i>=0; i--){
C = c[i].split('=');
cookies[C[0]] = unescape(C[1]);
}
return cookies[name];
}
window.writeCookie = function(name, val) {
var d = new Date(Date.now() + 10 * 365 * 24 * 60 * 60 * 1000).toUTCString();
document.cookie = name + "=" + val + '; expires='+d+'; path=/';
}
window.eraseCookie = function(name) {
document.cookie = name + '=; expires=Thu, 1 Jan 1970 00:00:00 GMT; path=/';
}
//certain values were stored in cookies, but we're better off using localStorage instead - make it easy to convert
window.convertCookieToLocalStorage = function(name) {
var cookie=readCookie(name);
if(cookie !== undefined) {
console.log('converting cookie '+name+' to localStorage');
if(localStorage[name] === undefined) {
localStorage[name] = cookie;
}
eraseCookie(name);
}
}
// add thousand separators to given number.
// http://stackoverflow.com/a/1990590/1684530 by Doug Neiner.
window.digits = function(d) {
// U+2009 - Thin Space. Recommended for use as a thousands separator...
// https://en.wikipedia.org/wiki/Space_(punctuation)#Table_of_spaces
return (d+"").replace(/(\d)(?=(\d\d\d)+(?!\d))/g, "$1 ");
}
window.zeroPad = function(number,pad) {
number = number.toString();
var zeros = pad - number.length;
return Array(zeros>0?zeros+1:0).join("0") + number;
}
// converts javascript timestamps to HH:mm:ss format if it was today;
// otherwise it returns YYYY-MM-DD
window.unixTimeToString = function(time, full) {
if(!time) return null;
var d = new Date(typeof time === 'string' ? parseInt(time) : time);
var time = d.toLocaleTimeString();
// var time = zeroPad(d.getHours(),2)+':'+zeroPad(d.getMinutes(),2)+':'+zeroPad(d.getSeconds(),2);
var date = d.getFullYear()+'-'+zeroPad(d.getMonth()+1,2)+'-'+zeroPad(d.getDate(),2);
if(typeof full !== 'undefined' && full) return date + ' ' + time;
if(d.toDateString() == new Date().toDateString())
return time;
else
return date;
}
// converts a javascript time to a precise date and time (optionally with millisecond precision)
// formatted in ISO-style YYYY-MM-DD hh:mm:ss.mmm - but using local timezone
window.unixTimeToDateTimeString = function(time, millisecond) {
if(!time) return null;
var d = new Date(typeof time === 'string' ? parseInt(time) : time);
return d.getFullYear()+'-'+zeroPad(d.getMonth()+1,2)+'-'+zeroPad(d.getDate(),2)
+' '+zeroPad(d.getHours(),2)+':'+zeroPad(d.getMinutes(),2)+':'+zeroPad(d.getSeconds(),2)+(millisecond?'.'+zeroPad(d.getMilliseconds(),3):'');
}
window.unixTimeToHHmm = function(time) {
if(!time) return null;
var d = new Date(typeof time === 'string' ? parseInt(time) : time);
var h = '' + d.getHours(); h = h.length === 1 ? '0' + h : h;
var s = '' + d.getMinutes(); s = s.length === 1 ? '0' + s : s;
return h + ':' + s;
}
window.formatInterval = function(seconds,maxTerms) {
var d = Math.floor(seconds / 86400);
var h = Math.floor((seconds % 86400) / 3600);
var m = Math.floor((seconds % 3600) / 60);
var s = seconds % 60;
var terms = [];
if (d > 0) terms.push(d+'d');
if (h > 0) terms.push(h+'h');
if (m > 0) terms.push(m+'m');
if (s > 0 || terms.length==0) terms.push(s+'s');
if (maxTerms) terms = terms.slice(0,maxTerms);
return terms.join(' ');
}
window.rangeLinkClick = function() {
if(window.portalRangeIndicator)
window.map.fitBounds(window.portalRangeIndicator.getBounds());
if(window.isSmartphone())
window.show('map');
}
window.showPortalPosLinks = function(lat, lng, name) {
var encoded_name = 'undefined';
if(name !== undefined) {
encoded_name = encodeURIComponent(name);
}
if (typeof android !== 'undefined' && android && android.intentPosLink) {
android.intentPosLink(lat, lng, map.getZoom(), name, true);
} else {
var qrcode = '<div id="qrcode"></div>';
var script = '<script>$(\'#qrcode\').qrcode({text:\'GEO:'+lat+','+lng+'\'});</script>';
var gmaps = '<a href="https://maps.google.com/maps?ll='+lat+','+lng+'&q='+lat+','+lng+'%20('+encoded_name+')">Google Maps</a>';
var bingmaps = '<a href="http://www.bing.com/maps/?v=2&cp='+lat+'~'+lng+'&lvl=16&sp=Point.'+lat+'_'+lng+'_'+encoded_name+'___">Bing Maps</a>';
var osm = '<a href="http://www.openstreetmap.org/?mlat='+lat+'&mlon='+lng+'&zoom=16">OpenStreetMap</a>';
var latLng = '<span><' + lat + ',' + lng +'></span>';
dialog({
html: '<div style="text-align: center;">' + qrcode + script + gmaps + '; ' + bingmaps + '; ' + osm + '<br />' + latLng + '</div>',
title: name,
id: 'poslinks'
});
}
}
window.isTouchDevice = function() {
return 'ontouchstart' in window // works on most browsers
|| 'onmsgesturechange' in window; // works on ie10
};
window.androidCopy = function(text) {
if(typeof android === 'undefined' || !android || !android.copy)
return true; // i.e. execute other actions
else
android.copy(text);
return false;
}
window.androidPermalink = function() {
if(typeof android === 'undefined' || !android || !android.intentPosLink)
return true; // i.e. execute other actions
var center = map.getCenter();
android.intentPosLink(center.lat, center.lng, map.getZoom(), "Selected map view", false);
return false;
}
window.getMinPortalLevel = function() {
var z = map.getZoom();
z = getDataZoomForMapZoom(z);
return getMapZoomTileParameters(z).level;
}
// returns number of pixels left to scroll down before reaching the
// bottom. Works similar to the native scrollTop function.
window.scrollBottom = function(elm) {
if(typeof elm === 'string') elm = $(elm);
return elm.get(0).scrollHeight - elm.innerHeight() - elm.scrollTop();
}
window.zoomToAndShowPortal = function(guid, latlng) {
map.setView(latlng, 17);
// if the data is available, render it immediately. Otherwise defer
// until it becomes available.
if(window.portals[guid])
renderPortalDetails(guid);
else
urlPortal = guid;
}
window.selectPortalByLatLng = function(lat, lng) {
if(lng === undefined && lat instanceof Array) {
lng = lat[1];
lat = lat[0];
} else if(lng === undefined && lat instanceof L.LatLng) {
lng = lat.lng;
lat = lat.lat;
}
for(var guid in window.portals) {
var latlng = window.portals[guid].getLatLng();
if(latlng.lat == lat && latlng.lng == lng) {
renderPortalDetails(guid);
return;
}
}
// not currently visible
urlPortalLL = [lat, lng];
map.setView(urlPortalLL, 17);
};
String.prototype.capitalize = function() {
return this.charAt(0).toUpperCase() + this.slice(1).toLowerCase();
}
// http://stackoverflow.com/a/646643/1684530 by Bergi and CMS
if (typeof String.prototype.startsWith !== 'function') {
String.prototype.startsWith = function (str){
return this.slice(0, str.length) === str;
};
}
// escape a javascript string, so quotes and backslashes are escaped with a backslash
// (for strings passed as parameters to html onclick="..." for example)
window.escapeJavascriptString = function(str) {
return (str+'').replace(/[\\"']/g,'\\$&');
}
//escape special characters, such as tags
window.escapeHtmlSpecialChars = function(str) {
var div = document.createElement(div);
var text = document.createTextNode(str);
div.appendChild(text);
return div.innerHTML;
}
window.prettyEnergy = function(nrg) {
return nrg> 1000 ? Math.round(nrg/1000) + ' k': nrg;
}
window.setPermaLink = function(elm) {
var c = map.getCenter();
var lat = Math.round(c.lat*1E6)/1E6;
var lng = Math.round(c.lng*1E6)/1E6;
var qry = 'll='+lat+','+lng+'&z=' + map.getZoom();
$(elm).attr('href', '/intel?' + qry);
}
window.uniqueArray = function(arr) {
return $.grep(arr, function(v, i) {
return $.inArray(v, arr) === i;
});
}
window.genFourColumnTable = function(blocks) {
var t = $.map(blocks, function(detail, index) {
if(!detail) return '';
var title = detail[2] ? ' title="'+escapeHtmlSpecialChars(detail[2]) + '"' : '';
if(index % 2 === 0)
return '<tr><td'+title+'>'+detail[1]+'</td><th'+title+'>'+detail[0]+'</th>';
else
return ' <th'+title+'>'+detail[0]+'</th><td'+title+'>'+detail[1]+'</td></tr>';
}).join('');
if(t.length % 2 === 1) t + '<td></td><td></td></tr>';
return t;
}
// converts given text with newlines (\n) and tabs (\t) to a HTML
// table automatically.
window.convertTextToTableMagic = function(text) {
// check if it should be converted to a table
if(!text.match(/\t/)) return text.replace(/\n/g, '<br>');
var data = [];
var columnCount = 0;
// parse data
var rows = text.split('\n');
$.each(rows, function(i, row) {
data[i] = row.split('\t');
if(data[i].length > columnCount) columnCount = data[i].length;
});
// build the table
var table = '<table>';
$.each(data, function(i, row) {
table += '<tr>';
$.each(data[i], function(k, cell) {
var attributes = '';
if(k === 0 && data[i].length < columnCount) {
attributes = ' colspan="'+(columnCount - data[i].length + 1)+'"';
}
table += '<td'+attributes+'>'+cell+'</td>';
});
table += '</tr>';
});
table += '</table>';
return table;
}
// Given 3 sets of points in an array[3]{lat, lng} returns the area of the triangle
window.calcTriArea = function(p) {
return Math.abs((p[0].lat*(p[1].lng-p[2].lng)+p[1].lat*(p[2].lng-p[0].lng)+p[2].lat*(p[0].lng-p[1].lng))/2);
}
// Update layerGroups display status to window.overlayStatus and localStorage 'ingress.intelmap.layergroupdisplayed'
window.updateDisplayedLayerGroup = function(name, display) {
overlayStatus[name] = display;
localStorage['ingress.intelmap.layergroupdisplayed'] = JSON.stringify(overlayStatus);
}
// Read layerGroup status from window.overlayStatus if it was added to map,
// read from cookie if it has not added to map yet.
// return 'defaultDisplay' if both overlayStatus and cookie didn't have the record
window.isLayerGroupDisplayed = function(name, defaultDisplay) {
if(typeof(overlayStatus[name]) !== 'undefined') return overlayStatus[name];
convertCookieToLocalStorage('ingress.intelmap.layergroupdisplayed');
var layersJSON = localStorage['ingress.intelmap.layergroupdisplayed'];
if(!layersJSON) return defaultDisplay;
var layers = JSON.parse(layersJSON);
// keep latest overlayStatus
overlayStatus = $.extend(layers, overlayStatus);
if(typeof(overlayStatus[name]) === 'undefined') return defaultDisplay;
return overlayStatus[name];
}
window.addLayerGroup = function(name, layerGroup, defaultDisplay) {
if (defaultDisplay === undefined) defaultDisplay = true;
if(isLayerGroupDisplayed(name, defaultDisplay)) map.addLayer(layerGroup);
layerChooser.addOverlay(layerGroup, name);
}
window.removeLayerGroup = function(layerGroup) {
if(!layerChooser._layers[layerGroup._leaflet_id]) throw('Layer was not found');
// removing the layer will set it's default visibility to false (store if layer gets added again)
var name = layerChooser._layers[layerGroup._leaflet_id].name;
var enabled = isLayerGroupDisplayed(name);
map.removeLayer(layerGroup);
layerChooser.removeLayer(layerGroup);
updateDisplayedLayerGroup(name, enabled);
};
window.clampLat = function(lat) {
// the map projection used does not handle above approx +- 85 degrees north/south of the equator
if (lat > 85.051128)
lat = 85.051128;
else if (lat < -85.051128)
lat = -85.051128;
return lat;
}
window.clampLng = function(lng) {
if (lng > 179.999999)
lng = 179.999999;
else if (lng < -180.0)
lng = -180.0;
return lng;
}
window.clampLatLng = function(latlng) {
return new L.LatLng ( clampLat(latlng.lat), clampLng(latlng.lng) );
}
window.clampLatLngBounds = function(bounds) {
return new L.LatLngBounds ( clampLatLng(bounds.getSouthWest()), clampLatLng(bounds.getNorthEast()) );
}
window.getGenericMarkerSvg = function(color) {
var markerTemplate = '<?xml version="1.0" encoding="UTF-8"?>\n<svg xmlns="http://www.w3.org/2000/svg"\n version="1.1" baseProfile="full"\n width="25px" height="41px" viewBox="0 0 25 41">\n\n <path d="M1.36241844765,18.67488124675 A12.5,12.5 0 1,1 23.63758155235,18.67488124675 L12.5,40.5336158073 Z" style="stroke:none; fill: %COLOR%;" />\n <path d="M1.80792170975,18.44788599685 A12,12 0 1,1 23.19207829025,18.44788599685 L12.5,39.432271175 Z" style="stroke:#000000; stroke-width:1px; stroke-opacity: 0.15; fill: none;" />\n <path d="M2.921679865,17.8803978722 A10.75,10.75 0 1,1 22.078320135,17.8803978722 L12.5,36.6789095943 Z" style="stroke:#ffffff; stroke-width:1.5px; stroke-opacity: 0.35; fill: none;" />\n\n <path d="M19.86121593215,17.25 L12.5,21.5 L5.13878406785,17.25 L5.13878406785,8.75 L12.5,4.5 L19.86121593215,8.75 Z M7.7368602792,10.25 L17.2631397208,10.25 L12.5,18.5 Z M12.5,13 L7.7368602792,10.25 M12.5,13 L17.2631397208,10.25 M12.5,13 L12.5,18.5 M19.86121593215,17.25 L16.39711431705,15.25 M5.13878406785,17.25 L8.60288568295,15.25 M12.5,4.5 L12.5,8.5" style="stroke:#ffffff; stroke-width:1.25px; stroke-opacity: 1; fill: none;" />\n\n</svg>';
return markerTemplate.replace(/%COLOR%/g, color);
}
window.getGenericMarkerIcon = function(color,className) {
return L.divIcon({
iconSize: new L.Point(25, 41),
iconAnchor: new L.Point(12, 41),
html: getGenericMarkerSvg(color),
className: className || 'leaflet-iitc-divicon-generic-marker'
});
}
window.createGenericMarker = function(ll,color,options) {
options = options || {};
var markerOpt = $.extend({
icon: getGenericMarkerIcon(color || '#a24ac3')
}, options);
return L.marker(ll, markerOpt);
}
// Fix Leaflet: handle touchcancel events in Draggable
L.Draggable.prototype._onDownOrig = L.Draggable.prototype._onDown;
L.Draggable.prototype._onDown = function(e) {
L.Draggable.prototype._onDownOrig.apply(this, arguments);
if(e.type === "touchstart") {
L.DomEvent.on(document, "touchcancel", this._onUp, this);
}
}
} // end of wrapper
// inject code into site context
var script = document.createElement('script');
var info = { buildName: 'iitc', dateTimeVersion: '20170108.21732' };
if (this.GM_info && this.GM_info.script) info.script = { version: GM_info.script.version, name: GM_info.script.name, description: GM_info.script.description };
script.appendChild(document.createTextNode('('+ wrapper +')('+JSON.stringify(info)+');'));
(document.body || document.head || document.documentElement).appendChild(script);