☰

Planets.nu - Sensor Range Plugin

Plugin for Planets.nu which allows to visualize the sensor range of ships and planets on the starmap

  1. // ==UserScript==
  2. // @name          Planets.nu - Sensor Range Plugin
  3. // @description   Plugin for Planets.nu which allows to visualize the sensor range of ships and planets on the starmap
  4. // @namespace     kedalion/sensorRange
  5. // @version       0.31
  6. // @date          2014-12-24
  7. // @author        kedalion
  8. // @include       http://planets.nu/*
  9. // @include       http://play.planets.nu/*
  10. // @include       http://test.planets.nu/*
  11. // @resource      userscript https://greasyfork.org/en/scripts/7149-planets-nu-sensor-range-plugin
  12. // @homepage      http://planets.nu/discussion/utility-script-sensor-range-plugin
  13.  
  14. // ==/UserScript==
  15.  
  16. /*
  17. Change log:
  18. 0.31    Moved script location to Greasyfork.org and added support for Sphere addon [2014-12-24]
  19. 0.3     Moved script location to monkeyguts.com [2014-05-30]
  20. 0.21    Added support for Dark Sense (created by Arcanix) [2014-04-09] 
  21. 0.20 	Fixed a bug which made sensor range include all planets [2013-08-11]
  22. 0.19    Change sensor range to ignore Safe Passage [2013-08-02]
  23. 0.18    Removed bug causing Firefox to show everything washed out [2013-08-01]
  24. 0.17    Added additional enemy sensor range view [2013-07-30]
  25. 0.15    Changed the sensor range display to joint area instead of individual circles [2013-07-29]
  26. 0.14    Added hotkey 'x' support [2013-07-25]
  27. 0.13    Fixed button behavior (time machine) [2013-07-25]
  28. 0.12    Minor fixes, ensure settings stay through turn changes (time machine) [2013-07-25]
  29. 0.11    Initial release [2013-07-25]
  30. */
  31.  
  32. function wrapper () { // wrapper for injection
  33.     
  34. 	if (vgap.version < 3.0) {
  35. 		console.log("Sensor Range plugin requires at least NU version 3.0. Plugin disabled." );
  36. 		return;	
  37. 	}
  38. 	
  39. 	var plugin_version = 0.31;
  40.    
  41.     console.log("Sensor Range plugin version: v" + plugin_version );
  42. 	
  43. 	
  44. 	/*
  45. 	 *  Specify your plugin
  46. 	 *  You need to have all those methods defined or errors will be thrown. 
  47. 	 *  I inserted the print-outs in order to demonstrate when each method is 
  48. 	 *  being called. Just comment them out once you know your way around. 
  49. 	 *  
  50. 	 *  For any access to plugin class variables and methods from inside these
  51. 	 *  reserved methods, "vgap.plugins["nameOfMyPlugin"].my_variable" has to be 
  52. 	 *  used instead of "this.my_variable". 
  53. 	 */
  54. 	var sensorRangePlugin = {
  55. 			
  56. 			/*
  57. 			 * processload: executed whenever a turn is loaded: either the current turn or
  58. 			 * an older turn through time machine 
  59. 			 */
  60. 			processload: function() {
  61. 				//console.log("ProcessLoad: plugin called.");
  62. 				
  63. 				//check if plugin data is for current game
  64. 				if (vgap.plugins["sensorRangePlugin"].gameid != vgap.gameId) {
  65. 					vgap.plugins["sensorRangePlugin"].reset();
  66. 				}
  67. 			},	
  68. 			
  69. 			/*
  70. 			 * loaddashboard: executed to rebuild the dashboard content after a turn is loaded
  71. 			 */
  72. 			loaddashboard: function() {
  73. 				//console.log("LoadDashboard: plugin called.");
  74. 			},
  75.  
  76. 			/*
  77. 			 * showdashboard: executed when switching from starmap to dashboard
  78. 			 */
  79. 			showdashboard: function() {
  80. 				//console.log("ShowDashboard: plugin called.");
  81. 			},
  82. 			
  83. 			/*
  84. 			 * showsummary: executed when returning to the main screen of the dashboard
  85. 			 */
  86. 			showsummary: function() {
  87. 				//console.log("ShowSummary: plugin called.");
  88. 			},
  89. 			
  90. 			/*
  91. 			 * loadmap: executed after the first turn has been loaded to create the map
  92. 			 * as far as I can tell not executed again when using time machine
  93. 			 */
  94. 			loadmap: function() {
  95. 				//console.log("LoadMap: plugin called.");
  96. 				vgap.plugins["sensorRangePlugin"].reset();
  97. 				
  98. 				vgap.plugins["sensorRangePlugin"].addMapTool("Sensor Range", "ShowMinerals", "sensorrange", function () { 
  99. 					
  100. 					if (vgap.plugins["sensorRangePlugin"].enabled) {
  101. 						if (vgap.plugins["sensorRangePlugin"].mode == 0) {
  102. 							vgap.plugins["sensorRangePlugin"].enabled = false;									
  103. 						}
  104. 					} else {
  105. 						vgap.plugins["sensorRangePlugin"].enabled = true;
  106. 					}
  107. 					vgap.plugins["sensorRangePlugin"].mode = 0;
  108. 					
  109. 					vgap.plugins["sensorRangePlugin"].syncButtons();
  110. 					vgap.map.draw();	
  111. 					
  112. 				});
  113. 				vgap.plugins["sensorRangePlugin"].addMapTool("MineDetectRange", "ShowMinerals", "minedetectrange", function () {  
  114. 					if (vgap.plugins["sensorRangePlugin"].enabled) {
  115. 						if (vgap.plugins["sensorRangePlugin"].mode == 1) {
  116. 							vgap.plugins["sensorRangePlugin"].enabled = false;							
  117. 						}
  118. 					} else {
  119. 						vgap.plugins["sensorRangePlugin"].enabled = true;
  120. 					}
  121. 					vgap.plugins["sensorRangePlugin"].mode = 1;
  122. 						
  123. 					vgap.plugins["sensorRangePlugin"].syncButtons();
  124. 					vgap.map.draw();	
  125. 					
  126. 				});
  127. 				
  128. 				vgap.plugins["sensorRangePlugin"].addMapTool("EnemySense", "ShowMinerals", "enemysensorrange", function () {  
  129. 					if (vgap.plugins["sensorRangePlugin"].enabled) {
  130. 						if (vgap.plugins["sensorRangePlugin"].mode == 2) {
  131. 							vgap.plugins["sensorRangePlugin"].enabled = false;
  132. 						}	
  133. 					} else {
  134. 						vgap.plugins["sensorRangePlugin"].enabled = true;
  135. 					
  136. 					}
  137. 					vgap.plugins["sensorRangePlugin"].mode = 2;							
  138. 					
  139. 					vgap.plugins["sensorRangePlugin"].syncButtons();
  140. 					vgap.map.draw();	
  141. 					
  142. 				});
  143. 				
  144. 				if (vgap.player.raceid == 8) {
  145.                     vgap.plugins["sensorRangePlugin"].addMapTool("Dark Sense", "ShowMinerals", "darksenserange", function () {  
  146.                         if (vgap.plugins["sensorRangePlugin"].enabled) {
  147.                             if (vgap.plugins["sensorRangePlugin"].mode == 3) {
  148.                                 vgap.plugins["sensorRangePlugin"].enabled = false;
  149.                             }	
  150.                         } else {
  151.                             vgap.plugins["sensorRangePlugin"].enabled = true;
  152.                         
  153.                         }
  154.                         vgap.plugins["sensorRangePlugin"].mode = 3;							
  155.                         
  156.                         vgap.plugins["sensorRangePlugin"].syncButtons();
  157.                         vgap.map.draw();	
  158.                         
  159.                     });
  160.                 }
  161. 	
  162. 			},
  163. 			
  164. 			/*
  165. 			 * showmap: executed when switching from dashboard to starmap
  166. 			 */
  167. 			showmap: function() {
  168. 				//console.log("ShowMap: plugin called.");
  169. 			},
  170. 			
  171. 			/*
  172. 			 * draw: executed on any click or drag on the starmap
  173. 			 */			
  174. 			draw: function() {
  175. 				//console.log("Draw: plugin called.");
  176. 								
  177. 				if (vgap.plugins["sensorRangePlugin"].enabled) {
  178. 								
  179. 					if (vgap.plugins["sensorRangePlugin"].mode == 0) {
  180. 						var ctx = vgap.map.ctx;
  181. 							
  182. 						//ctx.clearRect(0, 0, vgap.map.canvas.width, vgap.map.canvas.height);	
  183. 						//ctx.globalAlpha = 0.2;
  184. 						vgap.plugins["sensorRangePlugin"].showSensorRange();
  185. 						//ctx.globalAlpha = 1.0;
  186. 						//vgap.plugins["sensorRangePlugin"].drawEssentials(false, ctx, false);					
  187. 						
  188. 					} else if (vgap.plugins["sensorRangePlugin"].mode == 2) {
  189. 						var ctx = vgap.map.ctx;
  190. 												
  191. 						vgap.plugins["sensorRangePlugin"].showEnemySensorRange();
  192. 					} else if (vgap.plugins["sensorRangePlugin"].mode == 3) { 
  193.                         vgap.plugins["sensorRangePlugin"].showDarkSenseRange();
  194. 					} else {
  195. 						vgap.plugins["sensorRangePlugin"].showMineDetectRange();
  196. 					}			
  197. 				}
  198. 				
  199. 			},		
  200. 			
  201. 			/*
  202. 			 * loadplanet: executed a planet is selected on dashboard or starmap
  203. 			 */
  204. 			loadplanet: function() {
  205. 				//console.log("LoadPlanet: plugin called.");
  206. 			},
  207. 			
  208. 			/*
  209. 			 * loadstarbase: executed a planet is selected on dashboard or starmap
  210. 			 */
  211. 			loadstarbase: function() {
  212. 				//console.log("LoadStarbase: plugin called.");
  213. 			},
  214. 			
  215. 			/*
  216. 			 * loadship: executed a planet is selected on dashboard or starmap
  217. 			 */
  218. 			loadship: function() {
  219. 				//console.log("LoadShip: plugin called.");
  220. 			},
  221. 			
  222. 			version: plugin_version,
  223.             plugin_name: "SensorRangePlugin",			
  224. 			enabled: false,
  225. 			mode: 0,  //0: range to detect ships and planets, 1: range of minefield detection, 2: Enemy Sensor Range, 3: Dark Sense
  226. 			gameid: -1,
  227. 			oldClearTools: null,
  228. 			canvas_shipscan: null,
  229. 			canvas_planetscan: null,
  230.  
  231. 			
  232. 			reset: function () {	
  233. 				
  234. 				//reset plugin settings 			
  235. 				this.enabled = false;
  236. 				this.mode = 0;
  237. 				this.gameid = vgap.gameId;			
  238. 								
  239. 				//make sure the buttons represent the actual plugin state				
  240. 				this.syncButtons();
  241. 				
  242. 			},
  243. 			
  244. 			syncButtons: function () {
  245. 		
  246. 				//make sure the buttons represent the actual plugin state
  247. 				if (document.getElementById("sensorrange") != null) {
  248. 					var sensor_on = (document.getElementById("sensorrange").className.indexOf("selectedmaptool") != -1);
  249. 				
  250. 					if ((sensor_on && !this.enabled) || (!sensor_on && this.enabled && this.mode == 0) || (sensor_on && this.enabled && this.mode != 0)) {
  251. 						$('#sensorrange').toggleClass("selectedmaptool");
  252. 					}				
  253. 				}
  254. 				
  255. 				
  256. 				if (document.getElementById("minedetectrange") != null) {
  257. 					var mine_on = (document.getElementById("minedetectrange").className.indexOf("selectedmaptool") != -1);
  258. 					
  259. 					if ((mine_on && !this.enabled) || (!mine_on && this.enabled && this.mode == 1) || (mine_on && this.enabled && this.mode != 1)) {
  260. 						$('#minedetectrange').toggleClass("selectedmaptool");
  261. 					}	
  262. 				}
  263. 				
  264. 				if (document.getElementById("enemysensorrange") != null) {
  265. 					var enemy_on = (document.getElementById("enemysensorrange").className.indexOf("selectedmaptool") != -1);
  266. 					
  267. 					if ((enemy_on && !this.enabled) || (!enemy_on && this.enabled && this.mode == 2) || (enemy_on && this.enabled && this.mode != 2)) {
  268. 						$('#enemysensorrange').toggleClass("selectedmaptool");
  269. 					}	
  270. 				}
  271.                
  272.                 if (document.getElementById("darksenserange") != null) {
  273. 					var dark_on = (document.getElementById("darksenserange").className.indexOf("selectedmaptool") != -1);
  274. 					
  275. 					if ((dark_on && !this.enabled) || (!dark_on && this.enabled && this.mode == 3) || (dark_on && this.enabled && this.mode != 3)) {
  276. 						$('#darksenserange').toggleClass("selectedmaptool");
  277. 					}	
  278. 				}
  279. 				
  280. 			},
  281. 			
  282. 			
  283. 			
  284. 			
  285. 			addMapTool: function (text, cls, id, onclick) {
  286. 		        
  287. 		        $("<li class='" + cls + "' id='" + id + "'>" + text + "</li>").tclick(onclick).appendTo("#MapTools");
  288. 		    },
  289.  
  290. 			/**
  291. 			 * Determine if the player has an agreement with another player which will give him information.
  292. 			 * Requires at least 'share intel' from the other player.
  293. 			 * @param 	int id of target player
  294. 			 * @return  bool true if player is delivering information
  295. 			 */
  296. 		 	receiveInfoFrom: function (fromId) {
  297. 				var relation = vgap.getRelation(fromId);
  298. 				if (relation == null)
  299. 					return false;
  300. 				return relation.relationfrom >= 3;
  301. 			},
  302.  
  303. 		    
  304. 			/**
  305. 			 * Draw the sensor range circles around own and allied ships and planets. Two different colors are used for
  306. 			 * ship and planet scan range. Planetscanrange is omitted if set to infinity (not explore map setting)			 
  307. 			 */
  308. 			showEnemySensorRange: function () {
  309. 				
  310. 				if (this.canvas_planetscan == null) {
  311. 					this.canvas_planetscan = document.createElement("canvas");
  312. 				}
  313. 		        this.canvas_planetscan.width = vgap.map.canvas.width;
  314.         		this.canvas_planetscan.height = vgap.map.canvas.height;
  315. 		        var ctx_planetscan = this.canvas_planetscan.getContext("2d");
  316. 				ctx_planetscan.clearRect(0, 0, vgap.map.canvas.width, vgap.map.canvas.height);	
  317. 				
  318. 				var color_planetscan = "#FF8000";	
  319. 				var alpha_planetscan = 1.0;
  320. 				
  321. 				if (this.canvas_shipscan == null) {
  322. 					this.canvas_shipscan = document.createElement("canvas");
  323. 				}
  324. 		        this.canvas_shipscan.width = vgap.map.canvas.width;
  325.         		this.canvas_shipscan.height = vgap.map.canvas.height;
  326. 		        var ctx_shipscan = this.canvas_shipscan.getContext("2d");
  327. 				ctx_shipscan.clearRect(0, 0, vgap.map.canvas.width, vgap.map.canvas.height);
  328. 					    		
  329. 				var color_shipscan = "#F5D0A9";								
  330. 				var alpha_shipscan = 1.0;
  331. 									   
  332. 				//var ctx = vgap.map.ctx; 
  333. 				//ctx.globalAlpha = 0.1;
  334. 				
  335. 				for (var i = 0; i < vgap.ships.length; i++) {
  336. 					var ship = vgap.ships[i];
  337. 												        
  338. 					//skip ship if owned by player or ally/neutral -> we want enemies
  339. 					if (ship.ownerid == vgap.player.id || (vgap.allied(ship.ownerid) && vgap.alliedTo(ship.ownerid))) {
  340. 						continue;	
  341. 					}
  342.  
  343. 					//draw a circle for planet visibility around each ship
  344. 					if (vgap.settings.planetscanrange < 10000) {
  345.  
  346. 						//console.log("ship #" + ship.id + " planet range");
  347. 						
  348. 						//check if area is visible
  349. 						if (vgap.map.isVisible(ship.x, ship.y, vgap.settings.planetscanrange)) {							
  350. 													
  351. 							//ctx_planetscan.strokeStyle = colorToRGBA(color_planetscan, alpha_planetscan);
  352. 							//ctx_planetscan.lineWidth = 2;
  353. 							ctx_planetscan.fillStyle = colorToRGBA(color_planetscan, alpha_planetscan);
  354. 							ctx_planetscan.beginPath();
  355. 							ctx_planetscan.arc(vgap.map.screenX(ship.x), vgap.map.screenY(ship.y), vgap.settings.planetscanrange * vgap.map.zoom, 0, Math.PI * 2, false);
  356. 							ctx_planetscan.closePath();
  357. 							ctx_planetscan.fill();
  358. 							//ctx_planetscan.stroke();									
  359. 						}					
  360. 					}
  361. 					
  362. 					//draw a circle for ship visibility around each ship
  363. 					
  364. 					//check if area is visible
  365. 					if (vgap.map.isVisible(ship.x, ship.y, vgap.settings.shipscanrange)) {						
  366. 						
  367. 						//console.log("ship #" + ship.id + " ship range");
  368. 															
  369. 						//ctx_shipscan.strokeStyle = colorToRGBA(color_shipscan, alpha_shipscan);
  370. 						//ctx_shipscan.lineWidth = 2;
  371. 						ctx_shipscan.fillStyle = colorToRGBA(color_shipscan, alpha_shipscan);
  372. 						ctx_shipscan.beginPath();
  373. 						ctx_shipscan.arc(vgap.map.screenX(ship.x), vgap.map.screenY(ship.y), vgap.settings.shipscanrange * vgap.map.zoom, 0, Math.PI * 2, false);
  374. 						ctx_shipscan.closePath();
  375. 						ctx_shipscan.fill();
  376. 						//ctx_shipscan.stroke();							
  377. 					}					
  378. 				}
  379. 				
  380. 				
  381. 				for (var i = 0; i < vgap.planets.length; i++) {
  382. 					var planet = vgap.planets[i];
  383. 												        
  384. 					//skip planet if not owned by player or ally/neutral 
  385. 					if (planet.ownerid == vgap.player.id || (vgap.allied(planet.ownerid) && vgap.alliedTo(planet.ownerid))) {
  386. 						continue;	
  387. 					}
  388.  
  389. 					//skip unowned planets
  390. 					if (planet.ownerid == 0 ) {
  391. 						continue;	
  392. 					}
  393. 					
  394. 					//draw a circle for planet visibility around each ship
  395. 					if (vgap.settings.planetscanrange < 10000) {
  396.  
  397. 						//console.log("planet #" + planet.id + " planet range");
  398. 						
  399. 						//check if area is visible
  400. 						if (vgap.map.isVisible(planet.x, planet.y, vgap.settings.planetscanrange)) {							
  401. 													
  402. 							//ctx_planetscan.strokeStyle = colorToRGBA(color_planetscan, alpha_planetscan);
  403. 							//ctx_planetscan.lineWidth = 3;
  404. 							ctx_planetscan.fillStyle = colorToRGBA(color_planetscan, alpha_planetscan);
  405. 							ctx_planetscan.beginPath();
  406. 							ctx_planetscan.arc(vgap.map.screenX(planet.x), vgap.map.screenY(planet.y), vgap.settings.planetscanrange * vgap.map.zoom, 0, Math.PI * 2, false);
  407. 							ctx_planetscan.closePath();
  408. 							ctx_planetscan.fill();
  409. 							//ctx_planetscan.stroke();									
  410. 						}					
  411. 					}
  412. 					
  413. 					//draw a circle for ship visibility around each planet
  414. 					
  415. 					//check if area is visible
  416. 					if (vgap.map.isVisible(planet.x, planet.y, vgap.settings.shipscanrange)) {						
  417. 						
  418. 						//console.log("planet #" + planet.id + " ship range");
  419. 						
  420. 						
  421. 						//ctx_shipscan.strokeStyle = colorToRGBA(color_shipscan, alpha_shipscan);
  422. 						//ctx_shipscan.lineWidth = 3;
  423. 						ctx_shipscan.fillStyle = colorToRGBA(color_shipscan, alpha_shipscan);
  424. 						ctx_shipscan.beginPath();
  425. 						ctx_shipscan.arc(vgap.map.screenX(planet.x), vgap.map.screenY(planet.y), vgap.settings.shipscanrange * vgap.map.zoom, 0, Math.PI * 2, false);
  426. 						ctx_shipscan.closePath();
  427. 						ctx_shipscan.fill();
  428. 						//ctx_shipscan.stroke();							
  429. 					}					
  430. 				}
  431. 								
  432. 				
  433. 				
  434. 				vgap.map.ctx.globalAlpha = 0.2;
  435. 				
  436. 				if ( vgap.settings.planetscanrange == 10000 ) {
  437. 					//console.log("shipscan only1");
  438. 					vgap.map.ctx.drawImage(this.canvas_shipscan, 0, 0);	
  439. 					//console.log("shipscan only2");
  440. 				} else if (vgap.settings.shipscanrange > vgap.settings.planetscanrange) {
  441. 					//console.log("shipsscan first1");
  442. 					ctx_shipscan.drawImage(this.canvas_planetscan, 0, 0);
  443. 					vgap.map.ctx.drawImage(this.canvas_shipscan, 0, 0);
  444. 					//console.log("shipsscan first2");
  445. 					
  446. 				} else {
  447. 					//console.log("shipsscan last1");
  448. 					ctx_planetscan.drawImage(this.canvas_shipscan, 0, 0);
  449. 					vgap.map.ctx.drawImage(this.canvas_planetscan, 0, 0);
  450. 					//console.log("shipsscan last2");
  451. 					
  452. 				}				
  453. 				vgap.map.ctx.globalAlpha = 1.0;
  454. 							    
  455. 			}, 
  456. 		    
  457. 		    
  458. 			/**
  459. 			 * Draw the sensor range circles around own and allied ships and planets. Two different colors are used for
  460. 			 * ship and planet scan range. Planetscanrange is omitted if set to infinity (not explore map setting)			 
  461. 			 */
  462. 			showSensorRange: function () {
  463. 				
  464. 				if (this.canvas_planetscan == null) {
  465. 					this.canvas_planetscan = document.createElement("canvas");
  466. 				}
  467. 		        this.canvas_planetscan.width = vgap.map.canvas.width;
  468.         		this.canvas_planetscan.height = vgap.map.canvas.height;
  469. 		        var ctx_planetscan = this.canvas_planetscan.getContext("2d");
  470. 				ctx_planetscan.clearRect(0, 0, vgap.map.canvas.width, vgap.map.canvas.height);	
  471. 				
  472. 				var color_planetscan = "#FF8000";	
  473. 				var alpha_planetscan = 1.0;
  474. 				
  475. 				if (this.canvas_shipscan == null) {
  476. 					this.canvas_shipscan = document.createElement("canvas");
  477. 				}
  478. 		        this.canvas_shipscan.width = vgap.map.canvas.width;
  479.         		this.canvas_shipscan.height = vgap.map.canvas.height;
  480. 		        var ctx_shipscan = this.canvas_shipscan.getContext("2d");
  481. 				ctx_shipscan.clearRect(0, 0, vgap.map.canvas.width, vgap.map.canvas.height);
  482. 					    		
  483. 				var color_shipscan = "#F5D0A9";								
  484. 				var alpha_shipscan = 1.0;
  485. 									   
  486. 				//var ctx = vgap.map.ctx; 
  487. 				//ctx.globalAlpha = 0.1;
  488. 				
  489. 				for (var i = 0; i < vgap.ships.length; i++) {
  490. 					var ship = vgap.ships[i];
  491. 												        
  492. 					//skip ship if not owned by player or ally
  493. 					if (ship.ownerid != vgap.player.id && !this.receiveInfoFrom(ship.ownerid)) { //   (vgap.allied(ship.ownerid) && vgap.alliedTo(ship.ownerid))) {
  494. 						continue;	
  495. 					}
  496.  
  497. 					//draw a circle for planet visibility around each ship
  498. 					if (vgap.settings.planetscanrange < 10000) {
  499.  
  500. 						//console.log("ship #" + ship.id + " planet range");
  501. 						
  502. 						//check if area is visible
  503. 						if (vgap.map.isVisible(ship.x, ship.y, vgap.settings.planetscanrange)) {							
  504. 													
  505. 							//ctx_planetscan.strokeStyle = colorToRGBA(color_planetscan, alpha_planetscan);
  506. 							//ctx_planetscan.lineWidth = 2;
  507. 							ctx_planetscan.fillStyle = colorToRGBA(color_planetscan, alpha_planetscan);
  508. 							ctx_planetscan.beginPath();
  509. 							ctx_planetscan.arc(vgap.map.screenX(ship.x), vgap.map.screenY(ship.y), vgap.settings.planetscanrange * vgap.map.zoom, 0, Math.PI * 2, false);
  510. 							ctx_planetscan.closePath();
  511. 							ctx_planetscan.fill();
  512. 							//ctx_planetscan.stroke();									
  513. 						}					
  514. 					}
  515. 					
  516. 					//draw a circle for ship visibility around each ship
  517. 					
  518. 					//check if area is visible
  519. 					if (vgap.map.isVisible(ship.x, ship.y, vgap.settings.shipscanrange)) {						
  520. 						
  521. 						//console.log("ship #" + ship.id + " ship range");
  522. 															
  523. 						//ctx_shipscan.strokeStyle = colorToRGBA(color_shipscan, alpha_shipscan);
  524. 						//ctx_shipscan.lineWidth = 2;
  525. 						ctx_shipscan.fillStyle = colorToRGBA(color_shipscan, alpha_shipscan);
  526. 						ctx_shipscan.beginPath();
  527. 						ctx_shipscan.arc(vgap.map.screenX(ship.x), vgap.map.screenY(ship.y), vgap.settings.shipscanrange * vgap.map.zoom, 0, Math.PI * 2, false);
  528. 						ctx_shipscan.closePath();
  529. 						ctx_shipscan.fill();
  530. 						//ctx_shipscan.stroke();							
  531. 					}					
  532. 				}
  533. 				
  534. 				
  535. 				for (var i = 0; i < vgap.planets.length; i++) {
  536. 					var planet = vgap.planets[i];
  537. 												        
  538. 					//skip planet if not owned by player or ally
  539. 					if (planet.ownerid != vgap.player.id &&  !this.receiveInfoFrom(planet.ownerid)) { //!(vgap.allied(planet.ownerid) && vgap.alliedTo(planet.ownerid))) {
  540. 						continue;	
  541. 					}
  542.  
  543. 					//draw a circle for planet visibility around each ship
  544. 					if (vgap.settings.planetscanrange < 10000) {
  545.  
  546. 						//console.log("planet #" + planet.id + " planet range");
  547. 						
  548. 						//check if area is visible
  549. 						if (vgap.map.isVisible(planet.x, planet.y, vgap.settings.planetscanrange)) {							
  550. 													
  551. 							//ctx_planetscan.strokeStyle = colorToRGBA(color_planetscan, alpha_planetscan);
  552. 							//ctx_planetscan.lineWidth = 3;
  553. 							ctx_planetscan.fillStyle = colorToRGBA(color_planetscan, alpha_planetscan);
  554. 							ctx_planetscan.beginPath();
  555. 							ctx_planetscan.arc(vgap.map.screenX(planet.x), vgap.map.screenY(planet.y), vgap.settings.planetscanrange * vgap.map.zoom, 0, Math.PI * 2, false);
  556. 							ctx_planetscan.closePath();
  557. 							ctx_planetscan.fill();
  558. 							//ctx_planetscan.stroke();									
  559. 						}					
  560. 					}
  561. 					
  562. 					//draw a circle for ship visibility around each planet
  563. 					
  564. 					//check if area is visible
  565. 					if (vgap.map.isVisible(planet.x, planet.y, vgap.settings.shipscanrange)) {						
  566. 						
  567. 						//console.log("planet #" + planet.id + " ship range");
  568. 						
  569. 						
  570. 						//ctx_shipscan.strokeStyle = colorToRGBA(color_shipscan, alpha_shipscan);
  571. 						//ctx_shipscan.lineWidth = 3;
  572. 						ctx_shipscan.fillStyle = colorToRGBA(color_shipscan, alpha_shipscan);
  573. 						ctx_shipscan.beginPath();
  574. 						ctx_shipscan.arc(vgap.map.screenX(planet.x), vgap.map.screenY(planet.y), vgap.settings.shipscanrange * vgap.map.zoom, 0, Math.PI * 2, false);
  575. 						ctx_shipscan.closePath();
  576. 						ctx_shipscan.fill();
  577. 						//ctx_shipscan.stroke();							
  578. 					}					
  579. 				}
  580. 								
  581. 				vgap.map.ctx.globalAlpha = 0.2;
  582. 			
  583. 				if ( vgap.settings.planetscanrange == 10000 ) {
  584. 					vgap.map.ctx.drawImage(this.canvas_shipscan, 0, 0);						
  585. 				} else if (vgap.settings.shipscanrange > vgap.settings.planetscanrange) {
  586. 					ctx_shipscan.drawImage(this.canvas_planetscan, 0, 0);
  587. 					vgap.map.ctx.drawImage(this.canvas_shipscan, 0, 0);					
  588. 				} else {
  589. 					ctx_planetscan.drawImage(this.canvas_shipscan, 0, 0);
  590. 					vgap.map.ctx.drawImage(this.canvas_planetscan, 0, 0);					
  591. 				}
  592. 						
  593. 				vgap.map.ctx.globalAlpha = 1.0;
  594. 							    
  595. 			}, 
  596. 			
  597. 			/**
  598. 			 * Draw the mine detection range circles around own ships that have mission 'mine sweep' set.
  599. 			 */
  600. 			showMineDetectRange: function () {
  601. 				//console.log("show mine detect range");
  602. 				
  603. 				var ctx = vgap.map.ctx; 
  604. 				
  605. 				var minefield_detect_range = 200;
  606. 				
  607. 				for (var i = 0; i < vgap.ships.length; i++) {
  608. 					var ship = vgap.ships[i];
  609. 												        
  610. 					//skip ship if not owned by player 
  611. 					if (ship.ownerid != vgap.player.id) { // && !(vgap.allied(ship.ownerid) && vgap.alliedTo(ship.ownerid))) {
  612. 						continue;	
  613. 					}
  614. 					
  615. 					var alpha = 0.2;
  616. 					var color = "#81F7F3";
  617. 					
  618. 					//negative ship ids come from sphere addon. Mission changes are only stored in their positive 
  619. 					//id counter part
  620. 					if (ship.id < 0) {
  621. 					   var ship_pos = vgap.getShip(-ship.id);
  622. 					   if (ship_pos == null || ship_pos.mission != 1) {
  623. 					       continue;
  624. 					   }					
  625. 					} else {					
  626. 					   if (ship.mission != 1) {
  627. 					       continue;	
  628.                             //alpha = 0.05;
  629. 		                    //color = "#F7FE2E";
  630. 					   }
  631. 					}
  632. 					//draw a circle for ship visibility around each ship
  633. 					
  634. 					//check if area is visible
  635. 					if (vgap.map.isVisible(ship.x, ship.y, minefield_detect_range)) {						
  636. 						
  637. 						//console.log("ship #" + ship.id + " mine range");
  638. 											
  639. 						ctx.strokeStyle = colorToRGBA(color, 0.4);
  640. 						ctx.lineWidth = 2;
  641. 						ctx.fillStyle = colorToRGBA(color, alpha);
  642. 						ctx.beginPath();
  643. 						ctx.arc(vgap.map.screenX(ship.x), vgap.map.screenY(ship.y), minefield_detect_range * vgap.map.zoom, 0, Math.PI * 2, false);
  644. 						ctx.closePath();
  645. 						//ctx.fill();
  646. 						ctx.stroke();							
  647. 					}					
  648. 				}				
  649. 			},
  650. 			
  651. 			/**
  652. 			 * Draw the dark sense range circles around own ships that have mission 'dark sense' set.
  653. 			 */
  654. 			showDarkSenseRange: function () {
  655. 				//console.log("show dark sense range");
  656. 				
  657.                 if (vgap.player.raceid != 8) { return; }
  658.                 
  659. 				var ctx = vgap.map.ctx; 
  660. 				
  661. 				var darksense_range = 200;
  662. 				
  663. 				for (var i = 0; i < vgap.ships.length; i++) {
  664. 					var ship = vgap.ships[i];	        
  665. 					//skip ship if not owned by player 
  666. 					if (ship.ownerid != vgap.player.id) { // && !(vgap.allied(ship.ownerid) && vgap.alliedTo(ship.ownerid))) {
  667. 						continue;	
  668. 					}
  669. 					
  670. 					var alpha = 0.2;
  671. 					var color = "#909090";
  672. 					
  673. 					//negative ship ids come from sphere addon. Mission changes are only stored in their positive 
  674. 					//id counter part
  675. 					if (ship.id < 0) {
  676. 					   var ship_pos = vgap.getShip(-ship.id);
  677. 					   if (ship_pos == null || ship_pos.mission != 8) {
  678. 					       continue;
  679. 					   }					
  680. 					} else {
  681. 					   if (ship.mission != 8) {
  682. 						  continue;
  683. 					   }
  684.                     }
  685. 					
  686. 					//draw a circle for ship visibility around each ship
  687. 					
  688. 					//check if area is visible
  689. 					if (vgap.map.isVisible(ship.x, ship.y, darksense_range)) {						
  690. 						
  691. 						//console.log("ship #" + ship.id + " mine range");
  692. 											
  693. 						ctx.strokeStyle = colorToRGBA(color, 0.4);
  694. 						ctx.lineWidth = 2;
  695. 						ctx.fillStyle = colorToRGBA(color, alpha);
  696. 						ctx.beginPath();
  697. 						ctx.arc(vgap.map.screenX(ship.x), vgap.map.screenY(ship.y), darksense_range * vgap.map.zoom, 0, Math.PI * 2, false);
  698. 						ctx.closePath();
  699. 						//ctx.fill();
  700. 						ctx.stroke();							
  701. 					}					
  702. 				}				
  703. 			}
  704. 						
  705. 	};
  706. 	
  707. 	// register your plugin with NU
  708. 	vgap.registerPlugin(sensorRangePlugin, "sensorRangePlugin");
  709.  
  710. 	
  711. 	/**
  712. 	 * Overload the clearTools function in order to be able to
  713. 	 * disable the sensor range map through hotkey 'x' 
  714. 	 */	
  715. 	vgap.plugins["sensorRangePlugin"].oldClearTools = vgapMap.prototype.clearTools;
  716. 	
  717. 	vgapMap.prototype.clearTools = function(result) {
  718. 		
  719. 		vgap.plugins["sensorRangePlugin"].enabled = false;
  720. 		vgap.plugins["sensorRangePlugin"].syncButtons();
  721. 		
  722. 		//execute the normal clearTools function
  723. 		vgap.plugins["sensorRangePlugin"].oldClearTools.apply(this,arguments);
  724. 				
  725. 	};
  726. 	
  727. } //wrapper for injection
  728.  
  729. var script = document.createElement("script");
  730. script.type = "application/javascript";
  731. script.textContent = "(" + wrapper + ")();";
  732.  
  733. document.body.appendChild(script);
  734. document.body.removeChild(script);