API tools faq
paste
Advertisement
Guest User

Tagpro Timers

a guest
Feb 13th, 2018
227
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 47.18 KB | None | 0 0
raw download clone embed print report
  1. // ==UserScript==
  2. // @name Ta2Pro Sup3r Hax0r Scr1pt Ultr4
  3. // @version 0.666n
  4. // @include http://tagpro-*.koalabeast.com:*
  5. // @include http://*.jukejuice.com:*
  6. // @include http://*.newcompte.fr:*
  7. // @author Despair
  8. // ==/UserScript==
  9.  
  10. var Config = {
  11. // - tile display - possible values :
  12. // 0 - timeleft largetext , timeat smalltext
  13. // 1 - timeleft largetext
  14. // 2 - timeat largetext , timeleft smalltext
  15. // 3 - timeat largetext
  16. // 4 - timeat largetext and timeleft smalltext , timeleft largetext and timeat smalltext when 10 sec left
  17. // 5 - timeat largetext , timeleft largetext and timeat smalltext when 10 sec left
  18. // 6 - timeat largetext , timeleft largetext when 10 sec left
  19. tileDisplay : 0,
  20.  
  21. // - warning type - possible values :
  22. // 0 - fill
  23. // 1 - border
  24. // 2 - none
  25. warningType : 1,
  26.  
  27. // - show timeAt for timers less than 20 sec
  28. alwaysAt : false,
  29.  
  30. // - small text position changes at halfway-point instead of near bottom
  31. centerBoundText : false,
  32.  
  33.  
  34.  
  35. // - show global timers under your ball
  36. showGlobal : true,
  37.  
  38. // - show offscreen powerup timers at edge of screen
  39. showFloaters : true,
  40.  
  41. // - show powerup time remaining estimate on each player
  42. showPlayerTimers : true,
  43.  
  44. // - show powerup count for each player
  45. showPlayerPupCount : false,
  46. };
  47.  
  48. var Helper = {
  49. setValue : function(target, prop, value, action){
  50. if( target[prop] != value ){
  51. target[prop] = value;
  52. if(action) action();
  53. }
  54. },
  55. setValueDelta : function(target, prop, value, delta, action){
  56. if( Math.abs( target[prop] - value ) >= delta ){
  57. target[prop] = value;
  58. if(action) action();
  59. }
  60. },
  61. isValueReady : function(value){
  62. if( 6 < value && value < 7 ){
  63. //console.log(value, true);
  64. return true;
  65. }
  66.  
  67. switch(value){
  68. case 5: case 10: case 13: case 14: case 15:{
  69. //console.log(value, true);
  70. return true;
  71. }
  72. default:{
  73. //console.log(value, false);
  74. return false;
  75. }
  76. }
  77. },
  78. isStandardMapUpdate : function(value){
  79. var valid = [500,510,600,610,620,630,640,1000,1010,1300,1310,1400,1410,1500,1510];
  80.  
  81. return valid.indexOf( Math.round( value * 100 ) ) != -1;
  82. },
  83. isWarningMapUpdate : function(value){
  84. var warn = [511,611,621,631,641,1011,1311,1411,1511];
  85.  
  86. return warn.indexOf( Math.round( value * 100 ) ) != -1;
  87. },
  88. standardizeWarning : function(value){
  89. return Math.round( value * 10 ) / 10;
  90. },
  91. getTimeSince : function(ts){
  92. return Date.now() - ts;
  93. },
  94. getTimeLeftText : function(ms){
  95. if( ms === 0 ) return '';
  96. return '' + ms > 9999 ? Math.floor( ms / 1000 ) : ( Math.floor( ms / 100 ) / 10 ).toFixed(1) ;
  97. },
  98. getTimeAtText : function(n){
  99. return ( n > 9 ? '' : '0' ) + n;
  100. },
  101. // camera can see tile
  102. tileOnScreen : function(x, y, f){
  103. var player = Database.position, delta = 20 / tagpro.zoom;
  104.  
  105. if( tagpro.spectator ) return true;
  106.  
  107. if( f === true && Config.showFloaters ) delta *= -1;
  108.  
  109. return (
  110. Math.abs( ( player.x - x ) * ( 40 / tagpro.zoom ) ) < ( tagpro.renderer.canvas.width / 2 ) + delta &&
  111. Math.abs( ( player.y - y ) * ( 40 / tagpro.zoom ) ) < ( tagpro.renderer.canvas.height / 2 ) + delta
  112. );
  113. },
  114. // check if map update was live
  115. wasLiveUpdate : function(x, y, p){
  116. if( tagpro.spectator ) return true;
  117.  
  118. return Math.abs( p.x - x ) < 16.25 && Math.abs( p.y - y ) < 10.25;
  119. },
  120. // if tile is near bottom
  121. tileNearBottom : function(y){
  122. if( tagpro.spectator ) return false;
  123.  
  124. return ( Database.position.y - y ) < ( Config.centerBoundText ? 0 : ( -8 / tagpro.zoom ) );
  125. },
  126. // player can see tile(in update range)
  127. tileLiveForPlayer : function(x, y){
  128. var player = Database.position;
  129.  
  130. if( tagpro.spectator ) return true;
  131.  
  132. return Math.abs( player.x - x ) < 16.25 && Math.abs( player.y - y ) < 10.25;
  133. },
  134. // get display container
  135. getPixiContainer : function(){
  136. if( Database.legacyRender ){
  137. return new PIXI.DisplayObjectContainer();
  138. }else{
  139. return new PIXI.Container();
  140. }
  141. },
  142. };
  143.  
  144. var Logic = {
  145. readMapData : function(map){
  146. Logic.parseMapData( map );
  147. Database.state = 1;
  148. },
  149. parseMapData : function(data){
  150. var i, j;
  151.  
  152. // go through every tile
  153. for(i = 0; i < data.length; i++){
  154. for(j = 0; j < data[i].length; j++){
  155. // check if tile is something we should have timers on
  156. Logic.parseTileData( i , j , data[i][j] );
  157. }
  158. }
  159. },
  160. parseTileData : function(x, y, data){
  161. var prop;
  162.  
  163. switch( Math.floor(data) ){
  164. case 5 : prop = ['boost', 10000, 0xffff00]; break;
  165. case 6 : prop = ['powerup', 60000, 0x00ff00]; break;
  166. case 10: prop = ['bomb', 30000, 0x3f3f3f]; break;
  167. case 13: prop = ['portal', false, 0x7f00ff]; break;
  168. case 14: prop = ['boostred', 10000, 0xff0000]; break;
  169. case 15: prop = ['boostblue', 10000, 0x0000ff]; break;
  170.  
  171. default: return;
  172. }
  173.  
  174. Logic.createPOI(x, y, prop, data);
  175. },
  176. createPOI : function(x, y, prop, data){
  177. var POI = Database.createPOIEntry( x , y , prop , data );
  178. },
  179.  
  180.  
  181.  
  182. readSocketMessage : function(data){
  183. Database.socketQueue.push( data );
  184. },
  185.  
  186.  
  187.  
  188. tick : function(){
  189. // handle state
  190. if( !Logic.handleState() ) return;
  191.  
  192. // create renderer layers
  193. Logic.handleRendererLayers();
  194.  
  195. // update player camera position
  196. // - not used durring map update socket events as they already contain player position
  197. Logic.updatePlayerPosition();
  198.  
  199. // process socket queue
  200. Logic.handleQueuedSocketMessages();
  201.  
  202. // handle tile timers
  203. Logic.updateAllPOI();
  204. Logic.updateAllTemp();
  205.  
  206. // create player data
  207. Logic.handlePlayerData();
  208.  
  209. // handle global timers
  210. Logic.processGlobalQueue();
  211. Logic.updateAllGlobal();
  212. Logic.updateAllPlayers();
  213. },
  214.  
  215.  
  216.  
  217. handleState : function(){
  218. switch( Database.state ){
  219. case 0 : {// init
  220.  
  221. return false;
  222. }
  223. case 1 : {// map
  224. Database.state = 2;
  225. console.log( 'TSHSU - start tick');
  226.  
  227. return false;
  228. }
  229. case 2 : {// tick
  230. Logic.updateState();
  231.  
  232. return false;
  233. }
  234. case 3 : {// pre game
  235. Logic.updateState();
  236.  
  237. return true;
  238. }
  239. case 4 : {// in game
  240. Logic.updateState();
  241.  
  242. return true;
  243. }
  244. case 5 : {// post game
  245.  
  246.  
  247. return false;
  248. }
  249. default: {// invalid
  250. console.log( 'TSHSU - invalid state ('+Database.state+')' );
  251. Database.state = 5;
  252.  
  253. return false;
  254. }
  255. }
  256. },
  257. updateState : function(){
  258. switch( tagpro.state ){
  259. case 3 : {
  260. Database.state = 3;
  261. Database.preGame = true;
  262. break;
  263. }
  264. case 1 : {
  265. if( Database.state == 4 ) break;
  266.  
  267. Logic.getEndTime();
  268.  
  269. if( Database.endTime ){
  270. // activate all non-ready timers
  271. Logic.gameStartActivation();
  272.  
  273. Database.state = 4;
  274. }
  275.  
  276. break;
  277. }
  278. case 2 : {
  279. Database.state = 5;
  280. break;
  281. }
  282. default: {
  283.  
  284. }
  285. }
  286. },
  287. getEndTime : function(){
  288. if( !tagpro.gameEndsAt ) return;
  289.  
  290. // game ends more than 3 seconds from now
  291. // maybe gameEndsAt has not updated
  292. if( tagpro.gameEndsAt - Date.now() > 3000 ){
  293. Database.endTime = tagpro.gameEndsAt;
  294. }
  295. },
  296. gameStartActivation : function(){
  297. var i, count;
  298.  
  299. i = 0; count = Database.tiles.length;
  300.  
  301. // activate all non-ready timers
  302. while(i < count){
  303. if( !Database.tiles[i].ready ){
  304. Logic.startPOI( Database.tiles[i] , true );
  305. Database.tiles[i].timeStamp = Date.now();
  306. Database.tiles[i].known = Database.preGame;
  307.  
  308. // was in pregame and is pup
  309. if( Database.preGame && Database.tiles[i].pupId > -1 ){
  310. Database.global.push( [ Date.now() , 60000 , [Database.tiles[i].pupId] ] );
  311. }
  312. }
  313.  
  314. i++;
  315. }
  316. },
  317.  
  318.  
  319.  
  320. handleRendererLayers : function(){
  321. if( Database.state >= 2 ){
  322. if( !Renderer.timerLayer ){
  323. Renderer.timerLayer = Helper.getPixiContainer();
  324.  
  325. tagpro.renderer.layers.TSHSU_timers = Renderer.timerLayer;
  326. tagpro.renderer.gameContainer.addChildAt( tagpro.renderer.layers.TSHSU_timers , 3 );
  327. }
  328. if( !Renderer.floaterLayer ){
  329. Renderer.floaterLayer = Helper.getPixiContainer();
  330.  
  331. tagpro.renderer.layers.ui.TSHSU_floaters = Renderer.floaterLayer;
  332. tagpro.renderer.layers.ui.addChild( tagpro.renderer.layers.ui.TSHSU_floaters );
  333. }
  334. if( !Renderer.isReady ){
  335. if( Renderer.timerLayer && Renderer.floaterLayer ) Renderer.isReady = true;
  336. console.log( 'TSHSU - renderer ready');
  337. }
  338. }
  339. },
  340.  
  341.  
  342.  
  343. handleQueuedSocketMessages : function(){
  344. while( Database.socketQueue.length ){
  345. // process front of queue
  346. Logic.handleSocketMessage( Database.socketQueue[0] );
  347.  
  348. // remove first in queue
  349. Database.socketQueue.shift();
  350. }
  351. },
  352. handleSocketMessage : function(data){
  353. switch( data.type ){
  354. case 'mapupdate' : {
  355. Logic.handleMapUpdate( data );
  356. return;
  357. }
  358. case 'spawn' : {
  359. Logic.handleSpawn( data );
  360. return;
  361. }
  362. case 'end' : {
  363. Logic.handleEnd( data );
  364. return;
  365. }
  366. case 'p' : {
  367. Logic.handleP( data );
  368. return;
  369. }
  370. default : return;
  371. }
  372. },
  373. handleMapUpdate : function(data){
  374. var i, c, x, y, warn;
  375.  
  376. i = 0; c = data.data.length;
  377.  
  378. p = data.pos; t = data.time;
  379.  
  380. // loop through all tiles that are updating
  381. while(i < c){
  382. x = parseInt( data.data[i].x );
  383. y = parseInt( data.data[i].y );
  384.  
  385. // check if POI at location
  386. if( !Database.locate[x] || !Database.locate[x][y] ){
  387. i++; continue;
  388. }
  389.  
  390. v = parseFloat( data.data[i].v );
  391.  
  392. warn = Helper.isWarningMapUpdate( v );
  393.  
  394. // - check if valid value
  395. if( Helper.isStandardMapUpdate( v ) || warn ){
  396. // update POI values
  397. Logic.mapUpdatePOI( x , y , { v : v , p : data.pos , t : data.time } , warn );
  398. }
  399.  
  400. i++;
  401. }
  402. },
  403. handleSpawn : function(data){
  404. if( Database.state != 4 ) return;
  405. Database.createTempEntry( data.data , data );
  406. },
  407. handleEnd : function(data){
  408. Database.state = 5;
  409. },
  410. handleP : function(data){
  411. var i, count;
  412.  
  413. i = 0; count = data.data.u.length;
  414.  
  415. while(i < count){
  416. Logic.updatePlayerP( data.data.u[i] , data.time );
  417.  
  418. i++;
  419. }
  420. },
  421.  
  422. mapUpdatePOI : function(x, y, data, warn){
  423. var POI = Database.locate[x][y];
  424.  
  425. if( !warn ){
  426. // standard update
  427. POI.inWarnState = false;
  428.  
  429. // flag for update
  430. POI.updateNeeded = true;
  431.  
  432. // push curr values as prev values
  433. POI.prev.ts = POI.curr.ts;
  434. POI.prev.v = POI.curr.v;
  435. POI.prev.k = POI.curr.k;
  436.  
  437. // apply update to curr values
  438. POI.curr.ts = data.t;
  439. POI.curr.v = data.v;
  440. POI.curr.k = Helper.wasLiveUpdate(x, y, data.p);
  441. }else{
  442. // warning update
  443. POI.lastWarnAt = data.t;
  444. POI.inWarnState = true;
  445.  
  446. if( !POI.ready ){
  447. // sync and warn
  448.  
  449. // is live update
  450. if( Helper.wasLiveUpdate(x, y, data.p) && POI.timeMax ){
  451. POI.timeStamp = ( data.t + Math.min( 3000 , POI.timeMax ) - POI.timeMax );
  452. POI.timeAtText = false;
  453. POI.known = true;
  454. }
  455. }else{
  456. // switch ready state
  457.  
  458. // flag for update
  459. POI.updateNeeded = true;
  460.  
  461. // push curr values as prev values
  462. POI.prev.ts = POI.curr.ts;
  463. POI.prev.v = POI.curr.v;
  464. POI.prev.k = POI.curr.k;
  465.  
  466. // apply update to curr values
  467. POI.curr.ts = POI.timeMax ? ( data.t + Math.min( 3000 , POI.timeMax ) - POI.timeMax ) : data.t;
  468. POI.curr.v = Helper.standardizeWarning( data.v );
  469. POI.curr.k = Helper.wasLiveUpdate(x, y, data.p);
  470. }
  471. }
  472. },
  473. updatePlayerP : function(data, ts){
  474. // powerup update
  475. if( data['s-powerups'] ){
  476. Database.globalQueue.push( [ data.id , data['s-powerups'] , ts ] );
  477. }
  478. },
  479.  
  480.  
  481.  
  482. updatePlayerPosition : function(){
  483. var player = tagpro.players[ tagpro.playerId ];
  484.  
  485. Database.position.x = player.x / 40;
  486. Database.position.y = player.y / 40;
  487. },
  488.  
  489.  
  490.  
  491. updateAllPOI : function(){
  492. var i = 0, count = Database.tiles.length;
  493.  
  494. while(i < count){
  495. Logic.updatePOI( Database.tiles[i] );
  496.  
  497. i++;
  498. }
  499.  
  500. Logic.globalCapPupTiles();
  501. },
  502. updatePOI : function(POI){
  503. // update POI state
  504. Logic.statePOI( POI );
  505. // update POI graphics
  506. Logic.graphicsPOI( POI );
  507. // update POI tracking
  508. Logic.trackingPOI( POI );
  509. },
  510.  
  511. statePOI : function(POI){
  512. // recent update
  513. if( POI.updateNeeded ){
  514. POI.updateNeeded = false;
  515.  
  516. // set values to curr values and state
  517. POI.value = POI.curr.v;
  518. POI.ready = Helper.isValueReady( POI.value );
  519.  
  520. if( POI.ready ){
  521. // tile is ready to use, reset
  522. Logic.resetPOI( POI );
  523.  
  524. // remove ready pup from globals
  525. if( POI.pupId > -1 ) Logic.removeKnownFromGlobal( POI.pupId , true );
  526. }else{
  527. // tile is not ready, start timer
  528. Logic.startPOI( POI , POI.curr.k );
  529. }
  530. }
  531.  
  532. // set time left
  533. Logic.timeLeftPOI( POI );
  534.  
  535. // time is up
  536. Logic.timeOutPOI( POI );
  537.  
  538. // set time at
  539. Logic.timeAtPOI( POI );
  540.  
  541. // set if timer should be displayed
  542. POI.active = POI.timeLeft > 0;
  543. },
  544. graphicsPOI : function(POI){
  545. // create sprites
  546. Logic.spritePOI( POI );
  547.  
  548. // set visible
  549. Logic.setVisibility( POI );
  550.  
  551. // stop if not active
  552. if( !POI.active ){
  553. if( !POI.debug.timeStamp ) return;
  554. }
  555.  
  556. // update graphics
  557. Renderer.updateDebug( POI );
  558.  
  559. Renderer.updateText( POI );
  560. Renderer.updateCircle( POI );
  561. Renderer.updateFloater( POI );
  562. },
  563. trackingPOI : function(POI){
  564. var isLive = Helper.tileLiveForPlayer( POI.x , POI.y );
  565.  
  566. // track live state
  567. Logic.liveStatePOI( POI , isLive );
  568.  
  569. // get POI timeMax
  570. Logic.getTimeMax( POI );
  571.  
  572. // fix POI state
  573. if( Database.state == 4 ) Logic.fixStatePOI( POI );
  574. },
  575.  
  576. timeLeftPOI : function(POI){
  577. POI.timeLeft = POI.timeStamp ? Math.max( 0 , POI.timeMax - Helper.getTimeSince( POI.timeStamp ) ) : 0;
  578. POI.timeLeftText = Helper.getTimeLeftText( POI.timeLeft );
  579.  
  580. if( POI.debug.timeStamp ){
  581. POI.debug.timeLeft = POI.debug.timeStamp ? Math.max( 0 , POI.debug.timeMax - Helper.getTimeSince( POI.debug.timeStamp ) ) : 0;
  582. }
  583. },
  584. timeOutPOI : function(POI){
  585. if( POI.timeStamp && POI.timeLeft === 0 ){
  586. Logic.resetPOI( POI );
  587. }
  588.  
  589. if( POI.debug.timeStamp && POI.debug.timeLeft === 0 ){
  590. POI.debug.timeStamp = false;
  591. }
  592. },
  593. timeAtPOI : function(POI){
  594. var timeAt;
  595.  
  596. if( !POI.timeAtText && POI.timeStamp ){
  597. timeAt = Math.floor( ( ( Database.endTime - POI.timeStamp - POI.timeMax + 60000 ) % 60000 ) / 1000 );
  598. POI.timeAtText = Helper.getTimeAtText( timeAt );
  599. }
  600. },
  601.  
  602. resetPOI : function (POI){
  603. POI.timeStamp = false;
  604. POI.timeAtText = false;
  605.  
  606. POI.known = false;
  607. },
  608. startPOI : function(POI, known){
  609. known = typeof known == 'undefined' ? true : known;
  610.  
  611. if( !POI.timeMax ) return;
  612.  
  613. if( !POI.ready ) POI.timeStamp = POI.curr.ts;
  614. else POI.timeStamp = Date.now();
  615.  
  616. POI.timeAtText = false;
  617.  
  618. POI.known = known;
  619. },
  620. forceActivePOI : function(POI){
  621. POI.known = false;
  622. POI.timeStamp = Date.now();
  623. POI.timeAtText = false;
  624. POI.timeLeft = POI.timeMax;
  625. },
  626.  
  627. spritePOI : function(POI){
  628. if( !POI.sprite ) POI.sprite = Renderer.timerSprite(POI);
  629. if( POI.type == 'powerup' && !POI.floater ){
  630. POI.floater = Renderer.floaterSprite(POI);
  631. }
  632. },
  633. // set POI and floater visibility
  634. setVisibility : function(POI){
  635. if( !POI.active ){
  636. // hide inactive POI
  637. if( POI.sprite.visible ) POI.sprite.visible = false;
  638. if( POI.floater && POI.floater.visible ) POI.floater.visible = false;
  639. }else{
  640. if( Helper.tileOnScreen( POI.x , POI.y , !!POI.floater ) ){
  641. // tile is on screen
  642. if( !POI.sprite.visible ) POI.sprite.visible = true;
  643. if( POI.floater && POI.floater.visible ) POI.floater.visible = false;
  644. }else{
  645. // tile not on screen
  646. if( POI.sprite.visible ) POI.sprite.visible = false;
  647. if( POI.floater && !POI.floater.visible ) POI.floater.visible = true;
  648. }
  649. }
  650.  
  651. if( POI.debug.timeStamp ){
  652. if( !POI.sprite.visible ) POI.sprite.visible = true;
  653. }
  654.  
  655. // config disables floaters
  656. if( POI.floater && !Config.showFloaters ) POI.floater.visible = false;
  657. },
  658.  
  659. liveStatePOI : function(POI, isLive){
  660. Helper.setValue( POI , 'live' , isLive , function(){
  661. // POI just became live
  662. if( POI.live ){
  663. POI.changedSinceLive = false;
  664. POI.liveSince = Date.now();
  665. POI.wasReadyOnLoad = Helper.isValueReady( POI.value );
  666.  
  667. // remove ready pup from globals
  668. if( POI.pupId > -1 && POI.ready ) Logic.removeKnownFromGlobal( POI.pupId , true );
  669. }
  670. // POI just unloaded
  671. else{
  672. POI.changedSinceLive = false;
  673. }
  674. });
  675.  
  676. if( POI.live ){
  677. // POI has changed state while loaded
  678. if( POI.ready != POI.wasReadyOnLoad && !POI.changedSinceLive ){
  679. POI.changedSinceLive = true;
  680. }
  681.  
  682. // set last seen state
  683. Helper.setValue( POI , 'liveReady' , POI.ready , function(){
  684. if( POI.ready ){
  685. POI.switchedReady = Date.now();
  686. }else{
  687. POI.switchedUnready = Date.now();
  688. }
  689. });
  690. }else{
  691. if( POI.liveReady != -1 ){
  692. POI.liveReady = -1;
  693. POI.switchedReady = false;
  694. POI.switchedUneady = false;
  695. }
  696. }
  697. },
  698. getTimeMax : function(POI){
  699. if( POI.timeMax ) return;
  700.  
  701. // is live - track progress
  702. if( POI.live ){
  703. // progress if ready
  704. if( POI.progress === 0 ){
  705. if( POI.ready ){
  706. POI.progress = 1;
  707. }
  708. }
  709.  
  710. // progress if poi was used
  711. else if( POI.progress === 1 ){
  712. if( !POI.ready ){
  713. POI.progress = 2;
  714. }
  715. }
  716.  
  717. // progress if poi is ready
  718. else if( POI.progress == 2 ){
  719. if( POI.ready ){
  720. POI.progress = 0;
  721.  
  722. POI.timeMax = POI.curr.ts - POI.prev.ts;
  723. }
  724. }
  725. }
  726.  
  727. // is not live - reset progress
  728. else{
  729. if( POI.progress !== 0 ){
  730. POI.progress = 0;
  731. }
  732. }
  733. },
  734. fixStatePOI : function(POI){
  735. if( !POI.timeMax || !POI.live ) return;
  736.  
  737. if( POI.ready ){
  738. // POI is ready and has a timer
  739. if( POI.active ){
  740. Logic.resetPOI( POI );
  741. }
  742. }else{
  743. // POI not ready and has no timer
  744. if( !POI.active ){
  745. Logic.startPOI( POI , false );
  746.  
  747. // set timestamp
  748. // sometimes triggers on frame where timer expires but tile hasnt spawned yet
  749.  
  750. // set to livesince
  751. if( Helper.getTimeSince( POI.liveSince ) < POI.timeMax ){
  752. POI.timeStamp = POI.liveSince;
  753. // set to now
  754. }else{
  755. POI.timeStamp = Date.now();
  756. }
  757. }
  758. }
  759.  
  760. // is warning - set to max 3 sec
  761. if( POI.inWarnState && POI.timeLeft > 3000 ){
  762. //POI.debug.timeStamp = Date.now();
  763. POI.timeStamp = Date.now() + Math.min( 3000 , POI.timeMax ) - POI.timeMax;
  764. }
  765. },
  766.  
  767. // truncate pupTiles timestamp
  768. globalCapPupTiles : function(){
  769. var validGlobals = 0, invalidCount = 0, i, count, POI;
  770.  
  771. // no globals
  772. if( Database.global.length === 0 ) return;
  773.  
  774. // more than 1 pup
  775. if( Database.pupCount <= 1 ) return;
  776.  
  777. // last global is too recent
  778. if( Database.global[ Database.global.length - 1 ][1] > 59000 ) return;
  779.  
  780. // count valid globals
  781. i = 0; count = Database.global.length;
  782.  
  783. while( i < count ){
  784. if( Database.global[i][2].length > 0 ) validGlobals++;
  785. else invalidCount++;
  786.  
  787. i++;
  788. }
  789.  
  790. // invalid global detected - return
  791. if( invalidCount > 0 ) return;
  792.  
  793. // liveready + valid = pupcount
  794. if( Logic.countReadyLivePupTiles() + validGlobals == Database.pupCount ){
  795. // cap pupTiles unknown to last global
  796. Logic.autoSetUnknownTimePupTiles();
  797. }
  798. },
  799. countReadyLivePupTiles : function(){
  800. var out = 0, i = 0, tile;
  801.  
  802. while( i < Database.pupCount ){
  803. tile = Database.pupTiles[i];
  804.  
  805. if( tile.live && tile.ready ) out++;
  806.  
  807. i++;
  808. }
  809.  
  810. return out;
  811. },
  812. autoSetUnknownTimePupTiles : function(){
  813. var i = 0, POI;
  814.  
  815. while( i < Database.pupCount ){
  816. POI = Database.pupTiles[i];
  817.  
  818. // skip live ready
  819. if( POI.live && POI.ready ){ i++; continue; }
  820.  
  821. // activate inactive POI
  822. if( !POI.active ) Logic.forceActivePOI( POI );
  823.  
  824. // POI is unknown
  825. if( !POI.known ) Logic.autoSetUnknownTimePupTile( POI );
  826.  
  827. i++;
  828. }
  829. },
  830. autoSetUnknownTimePupTile : function(POI){
  831. var i, glo;
  832.  
  833. // loop : all global timers
  834. i = Database.global.length - 1;
  835.  
  836. // go through and find the global timestamp that POI timestamp can 'round down' to
  837. while( i > -1 ){
  838. glo = Database.global[i];
  839.  
  840. // timestamp matches global timer
  841. // POI already rounded down
  842. if( POI.timeStamp == glo[0] ) break;
  843.  
  844. // round down POI timestamp to global timestamp
  845.  
  846. // POI timestamp > glo timestamp
  847. if( POI.timeStamp > glo[0] ){
  848. // set POI timestamp
  849. POI.timeStamp = glo[0];
  850. POI.timeAtText = false;
  851.  
  852. break;
  853. }
  854.  
  855. // timestamp is less than global[0]
  856. if( i === 0 && POI.timeStamp < glo[0] ){
  857. // set POI timestamp
  858. POI.timeStamp = glo[0];
  859. POI.timeAtText = false;
  860.  
  861. break;
  862. }
  863.  
  864. i--;
  865. }
  866. },
  867.  
  868.  
  869.  
  870. updateAllTemp : function(){
  871. var i;
  872.  
  873. if( !Database.temp.length ) return;
  874.  
  875. for(i = 0; i < Database.temp.length; i++){
  876. if( !Database.temp.length ) break;
  877.  
  878. // update temp
  879. Logic.updateTemp( Database.temp[i] );
  880.  
  881. // remove expired temp
  882. if( Logic.removeTemp( i ) ){
  883. i--; continue;
  884. }
  885. }
  886. },
  887. removeTemp : function(index){
  888. var temp = Database.temp[ index ];
  889.  
  890. if( temp.timeLeft !== 0 ) return false;
  891.  
  892. Renderer.timerLayer.removeChild( temp.sprite );
  893. Database.temp.splice( index , 1 );
  894.  
  895. return true;
  896. },
  897. updateTemp : function(temp){
  898. // update POI state
  899. Logic.stateTemp( temp );
  900. // update POI graphics
  901. Logic.graphicsTemp( temp );
  902. },
  903.  
  904. stateTemp : function(temp){
  905. temp.timeLeft = Math.max( 0 , temp.timeMax - Helper.getTimeSince( temp.timeStamp ) );
  906. temp.text = Helper.getTimeLeftText( temp.timeLeft );
  907. },
  908. graphicsTemp : function(temp){
  909. Renderer.updateTempText( temp );
  910. Renderer.updateTempCircle( temp );
  911. },
  912.  
  913.  
  914.  
  915. handlePlayerData : function(){
  916. var id;
  917.  
  918. // loop through all players
  919. for(id in tagpro.players){
  920. // create player data
  921. if( !Database.player[id] ){
  922. Database.createPlayerData( id );
  923. Database.player[id].pups = tagpro.players[id]['s-powerups'] || 0;
  924. }
  925. // get ready
  926. if( !Database.player[id].ready ){
  927. // player data has existed for over 1 second
  928. if( Helper.getTimeSince( Database.player[id].init ) > 1000 ){
  929. Database.player[id].ready = true;
  930. }
  931. }
  932. }
  933. },
  934.  
  935.  
  936.  
  937. processGlobalQueue : function(){
  938. while( Database.globalQueue.length ){
  939. // process front of queue
  940. Logic.updatePlayerPowerupState( Database.globalQueue[0] );
  941.  
  942. // remove first in queue
  943. Database.globalQueue.shift();
  944. }
  945. },
  946. updatePlayerPowerupState : function(data){
  947. var id = data[0], count = data[1], ts = data[2];
  948.  
  949. // no player database entry
  950. if( !Database.player[id] ){
  951. console.log( 'TSHSU - No player data for id '+id );
  952. return;
  953. }
  954.  
  955. var player = Database.player[id], p;
  956.  
  957. // create timer for each increment using current timestamp
  958. while(player.pups < count){
  959. if( player.ready ){
  960. p = Logic.getPossibleTiles(ts);
  961.  
  962. player.timers.push( [ ts , 20000 ] );
  963. Database.global.push( [ ts , 60000 , p ] );
  964.  
  965. if( p.length === 1 ) Logic.removeKnownFromGlobal( p[0] );
  966. }
  967.  
  968. player.pups++;
  969. }
  970. },
  971. getPossibleTiles : function(ts){
  972. var tile, i, output = [], recent = [];
  973.  
  974. for(i = 0; i < Database.pupCount; i++){
  975. tile = Database.pupTiles[i];
  976.  
  977. // check if known and grabbed recently
  978. //if( tile.timeLeft > 59900 && tile.known ) return [ tile.pupId ];
  979. if( tile.known && ts - tile.timeStamp <= 75 && ts - tile.timeStamp >= -25 ) recent.push( tile.pupId );
  980.  
  981. // get unknown and offscreen pups
  982. if( !tile.live && !tile.known ) output.push( tile.pupId );
  983. }
  984.  
  985. if( recent.length ) return recent;
  986. return output;
  987. },
  988. removeKnownFromGlobal : function(n, kill){
  989. var i, timer;
  990.  
  991. if( typeof kill == 'undefined' ) kill = false;
  992.  
  993. // remove known pup id from all global timers
  994. for(i = 0; i < Database.global.length ; i++){
  995. timer = Database.global[i];
  996.  
  997. // timer has multiple possible tiles or guarantee remove and not recent
  998. if( timer[2].length > 1 || ( kill && timer[1] < 59500 ) ){
  999. // timer has known in possible tiles
  1000. if( timer[2].indexOf(n) != -1 ){
  1001. // remove known from possible tiles
  1002. timer[2].splice( timer[2].indexOf(n) , 1 );
  1003. }
  1004. }
  1005. }
  1006. },
  1007.  
  1008.  
  1009.  
  1010. updateAllGlobal : function(){
  1011. var i;
  1012.  
  1013. for(i = 0; i < Database.global.length; i++){
  1014. if( !Database.global.length ) break;
  1015.  
  1016. // update global
  1017. Logic.updateStateGlobal( Database.global[i] );
  1018.  
  1019. // remove expired global
  1020. if( Logic.removeGlobal( i ) ){
  1021. i--; continue;
  1022. }
  1023. }
  1024.  
  1025. Logic.updateGraphicsGlobal();
  1026. },
  1027. removeGlobal : function(index){
  1028. var glo = Database.global[ index ];
  1029.  
  1030. if( glo[1] > 100 ) return false;
  1031.  
  1032. // 1 possible , set offscreen poi unknown
  1033. if( glo[2].length === 1 ){
  1034. if( !Database.pupTiles[ glo[2][0] ].live ) Database.pupTiles[ glo[2][0] ].known = false;
  1035. }
  1036.  
  1037. Database.global.splice( index , 1 );
  1038.  
  1039. return true;
  1040. },
  1041. updateStateGlobal : function(glo){
  1042. var tile;
  1043.  
  1044. // if 1 possible
  1045. if( glo[2].length === 1 ){
  1046. tile = Database.pupTiles[ glo[2] ];
  1047.  
  1048. // if possible is unknown set known
  1049. if( !tile.known ){
  1050. tile.known = true;
  1051. tile.timeAtText = false;
  1052. tile.timeStamp = glo[0];
  1053. }
  1054. }
  1055.  
  1056. // set time left
  1057. glo[1] = Math.max( 0 , 59900 - Helper.getTimeSince( glo[0] ) );
  1058. },
  1059. updateGraphicsGlobal : function(){
  1060. var gl;
  1061.  
  1062. // create global list sprite
  1063. if( !Renderer.floaterLayer.globalList ) Renderer.floaterLayer.globalList = Renderer.globalSprite();
  1064.  
  1065. gl = Renderer.floaterLayer.globalList;
  1066.  
  1067. // set visibility
  1068. Helper.setValue( gl , 'V_visible' , Config.showGlobal , function(){
  1069. gl.visible = Config.showGlobal;
  1070. });
  1071.  
  1072. if( !gl.visible ) return;
  1073.  
  1074. // set text
  1075. Renderer.setGlobalText();
  1076.  
  1077. // set position
  1078. gl.x = Math.round( tagpro.renderer.canvas.width / 2 - 20 );
  1079.  
  1080. if( !tagpro.spectator ){
  1081. gl.y = Math.round( tagpro.renderer.canvas.height / 2 + 30 );
  1082. }else{
  1083. gl.y = Math.round( tagpro.renderer.canvas.height - 80 );
  1084. }
  1085. },
  1086.  
  1087.  
  1088.  
  1089. updateAllPlayers : function(){
  1090. var id;
  1091.  
  1092. // loop through all players
  1093. for(id in tagpro.players){
  1094. Logic.updatePlayer( tagpro.players[id] );
  1095. }
  1096. },
  1097. updatePlayer : function(player){
  1098. // update player state
  1099. Logic.statePlayer( player );
  1100. // update player graphics
  1101. Logic.graphicsPlayer( player );
  1102. },
  1103.  
  1104. statePlayer : function(player){
  1105. // update all database timers for player
  1106. Logic.updateAllPlayerTimers( player );
  1107. },
  1108. graphicsPlayer : function(player){
  1109. // create sprites for player timers
  1110. Logic.handlePlayerSprites( player );
  1111.  
  1112. // create sprite for player pup count
  1113. Logic.createCountSprite( player );
  1114.  
  1115. // set text of timer slots
  1116. Renderer.setTextPlayerSlots( player );
  1117.  
  1118. // set text of powerup count
  1119. Renderer.setTextPlayerPupCount( player );
  1120. },
  1121.  
  1122. updateAllPlayerTimers : function(player){
  1123. var i, pd = Database.player[ player.id ];
  1124.  
  1125. // update all player timers
  1126. for(i = 0; i < pd.timers.length; i++){
  1127. if( !pd.timers.length ) break;
  1128.  
  1129. // update timer
  1130. Logic.updatePlayerTimer( pd.timers[i] );
  1131.  
  1132. // remove expired timer
  1133. if( Logic.removePlayerTimer( player.id , i ) ){
  1134. i--; continue;
  1135. }
  1136. }
  1137. },
  1138. removePlayerTimer : function(id, index){
  1139. var temp = Database.player[id].timers[index],
  1140. player = tagpro.players[id];
  1141.  
  1142. // timer is 0
  1143. if( temp[1] === 0 ){
  1144. Database.player[id].timers.splice( index , 1 );
  1145. return true;
  1146. }
  1147.  
  1148. // visible and has no pups
  1149. if( player.draw && !( player.bomb || player.tagpro || player.grip ) ){
  1150. Database.player[id].timers.splice( index , 1 );
  1151. return true;
  1152. }
  1153.  
  1154. return false;
  1155. },
  1156.  
  1157. updatePlayerTimer : function(timer){
  1158. timer[1] = Math.max( 0 , 20000 - Helper.getTimeSince( timer[0] ) );
  1159. },
  1160.  
  1161. handlePlayerSprites : function(player){
  1162. var slotUse = Math.min( 8 , Database.player[ player.id ].timers.length ), AP;
  1163.  
  1164. // create container
  1165. if( !player.sprites.activePups ){
  1166. player.sprites.activePups = Renderer.playerTimerSprite();
  1167. player.sprites.info.addChild( player.sprites.activePups );
  1168. }
  1169.  
  1170. AP = player.sprites.activePups;
  1171.  
  1172. // create timer slots
  1173. while( slotUse > AP.V_slots ){
  1174. AP[ 's_' + AP.V_slots ] = tagpro.renderer.prettyText('', '#ffffff');
  1175. AP.addChild( AP[ 's_' + AP.V_slots ] );
  1176. AP[ 's_' + AP.V_slots ].position.y = AP.V_slots * 10;
  1177. AP[ 's_' + AP.V_slots ].V_text = '';
  1178.  
  1179. AP.V_slots++;
  1180. }
  1181. },
  1182. createCountSprite : function(player){
  1183. var AP;
  1184.  
  1185. if( !Config.showPlayerPupCount || !player.sprites.activePups ) return;
  1186.  
  1187. AP = player.sprites.activePups;
  1188.  
  1189. // create counter
  1190. if( !AP.counter ){
  1191. AP.counter = tagpro.renderer.prettyText('', '#ffff00');
  1192. AP.addChild( AP.counter );
  1193. AP.counter.position.x = 30;
  1194. AP.counter.position.y = 0;
  1195. AP.counter.V_text = '';
  1196. }
  1197. }
  1198. };
  1199.  
  1200. var Database = {
  1201. // legacy renderer
  1202. legacyRender : false,
  1203.  
  1204. // gamestate 0-init, 1-map, 2-ticking, 3-pregame, 4-ingame, 5-postgame
  1205. state : 0,
  1206.  
  1207. // joined before game start
  1208. preGame : false,
  1209.  
  1210. // countdown to
  1211. endTime : 0,
  1212.  
  1213. // pup count
  1214. pupCount : 0,
  1215.  
  1216. // queued socket events
  1217. socketQueue : [],
  1218.  
  1219. // timer locations
  1220. locate : {},
  1221.  
  1222. // list of timers
  1223. tiles : [],
  1224.  
  1225. // list of pup timers
  1226. pupTiles : [],
  1227.  
  1228. // list of temporary timers
  1229. temp : [],
  1230.  
  1231. // queued global updates
  1232. globalQueue : [],
  1233.  
  1234. // list of global timers
  1235. global : [],
  1236.  
  1237. // player pup data
  1238. player : {},
  1239.  
  1240. // player position
  1241. position : {x: 0, y: 0},
  1242.  
  1243.  
  1244.  
  1245. // time for each object
  1246. timeTable : {
  1247. pup : 60000,
  1248. bomb : 30000,
  1249. boost : 10000
  1250. },
  1251.  
  1252.  
  1253.  
  1254. createPOIEntry : function(x, y, prop, data){
  1255. var POI = {
  1256. // position
  1257. x: x, y: y,
  1258.  
  1259. // sprites
  1260. sprite: false, floater: false,
  1261.  
  1262. // text
  1263. timeLeftText: '', timeAtText: false,
  1264.  
  1265. // properties
  1266. fillColor: prop[2], type: prop[0], value: data,
  1267.  
  1268. // timer
  1269. timeStamp: false, timeMax: prop[1], timeLeft: 0,
  1270.  
  1271. // state
  1272. pupId: -1, updateNeeded: false,
  1273. ready: Helper.isValueReady(data), active: false,
  1274.  
  1275. // tracking
  1276. live: false, liveSince: false, wasReadyOnLoad: false, changedSinceLive: false,
  1277. known: false, progress: 0, priority: 0,
  1278. liveReady: -1, switchedReady: false, switchedUnready: false,
  1279.  
  1280. // warning
  1281. lastWarnAt: false, inWarnState: false,
  1282.  
  1283. // updates
  1284. curr : { ts: 0, v: 0, k: false },
  1285. prev : { ts: 0, v: 0, k: false },
  1286.  
  1287. // debug
  1288. debug : {
  1289. timeStamp: false, timeMax: 5000, timeLeft: 0,
  1290. },
  1291. };
  1292.  
  1293. // add POI to database
  1294. if( !Database.locate[x] ) Database.locate[x] = {};
  1295. Database.locate[x][y] = POI;
  1296. Database.tiles.push( POI );
  1297.  
  1298. if( POI.type == 'powerup' ){
  1299. // set pupId and add to pupTiles
  1300. POI.pupId = Database.pupCount + 0;
  1301. Database.pupCount++;
  1302. Database.pupTiles.push( POI );
  1303. }
  1304.  
  1305. return POI;
  1306. },
  1307. createTempEntry : function(prop, data){
  1308. var temp = {
  1309. color: 0xcc00cc,
  1310. timeStamp : data.time || Date.now(),
  1311. timeMax : prop.w || 3000,
  1312. timeLeft : -1, text : '',
  1313. sprite : false,
  1314. };
  1315.  
  1316. if( prop.t == 1 ) temp.color = 0xcc6600;
  1317. if( prop.t == 2 ) temp.color = 0x0066cc;
  1318.  
  1319. temp.sprite = Renderer.tempSprite();
  1320.  
  1321. temp.sprite.position.x = prop.x;
  1322. temp.sprite.position.y = prop.y;
  1323.  
  1324. // add temp to database
  1325. Database.temp.push( temp );
  1326.  
  1327. return temp;
  1328. },
  1329. createPlayerData : function(id){
  1330. if( Database.player[id] ) return;
  1331.  
  1332. var player = {
  1333. init: Date.now(), ready: false,
  1334. pups: 0, timers : []
  1335. };
  1336.  
  1337. Database.player[id] = player;
  1338. }
  1339. };
  1340.  
  1341. var Renderer = {
  1342. isReady : false,
  1343.  
  1344. // layers for graphics
  1345. timerLayer : false, floaterLayer : false,
  1346.  
  1347.  
  1348.  
  1349. // - main sprite types
  1350. timerSprite : function(POI){
  1351. var base = Helper.getPixiContainer();
  1352. base.position.x = POI.x * 40; base.position.y = POI.y * 40;
  1353.  
  1354. // progress circle
  1355. base.circle = Renderer.circleSprite();
  1356. base.addChild( base.circle );
  1357.  
  1358. // large text
  1359. base.largeText = Renderer.largeTextSprite( true );
  1360. base.addChild( base.largeText );
  1361.  
  1362. // small text
  1363. base.smallText = Renderer.smallTextSprite( true );
  1364. base.addChild( base.smallText );
  1365.  
  1366. Renderer.timerLayer.addChild( base );
  1367.  
  1368. return base;
  1369. },
  1370. floaterSprite : function(){
  1371. var base = Helper.getPixiContainer();
  1372.  
  1373. base.V_scale = 1;
  1374. base.V_visible = true;
  1375.  
  1376. // large text
  1377. base.largeText = Renderer.largeTextSprite();
  1378. base.addChild( base.largeText );
  1379.  
  1380. // small text
  1381. base.smallText = Renderer.smallTextSprite();
  1382. base.addChild( base.smallText );
  1383.  
  1384. Renderer.floaterLayer.addChild( base );
  1385.  
  1386. return base;
  1387. },
  1388. tempSprite : function(){
  1389. var base = Helper.getPixiContainer();
  1390.  
  1391. // progress circle
  1392. base.circle = Renderer.circleSprite();
  1393. base.addChild( base.circle );
  1394.  
  1395. // large text
  1396. base.largeText = Renderer.largeTextSprite( true );
  1397. base.addChild( base.largeText );
  1398.  
  1399. Renderer.timerLayer.addChild( base );
  1400.  
  1401. return base;
  1402. },
  1403. globalSprite : function(){
  1404. var base = Helper.getPixiContainer();
  1405.  
  1406. base.V_visible = true;
  1407.  
  1408. // poss timers
  1409. base.poss = tagpro.renderer.prettyText('', '#ffffff');
  1410. base.poss.V_text = '';
  1411. base.addChild( base.poss );
  1412.  
  1413. // nill timers
  1414. base.nill = tagpro.renderer.prettyText('', '#ffcc99');
  1415. base.nill.V_text = '';
  1416. base.nill.y = 10;
  1417. base.addChild( base.nill );
  1418.  
  1419. Renderer.floaterLayer.addChild( base );
  1420.  
  1421. return base;
  1422. },
  1423. playerTimerSprite : function(){
  1424. var base = Helper.getPixiContainer();
  1425.  
  1426. base.position.x = -25;
  1427. base.V_slots = 0;
  1428.  
  1429. return base;
  1430. },
  1431.  
  1432.  
  1433.  
  1434. // - subsprites
  1435. circleSprite : function(){
  1436. var base = new PIXI.Graphics();
  1437.  
  1438. base.x = 20; base.y = 20;
  1439. base.alpha = 0.75;
  1440.  
  1441. base.V_radius = 0;
  1442. base.V_state = true;
  1443.  
  1444. return base;
  1445. },
  1446. borderSprite : function(){
  1447. var base = new PIXI.Graphics();
  1448.  
  1449. base.x = 20; base.y = 20;
  1450. base.alpha = 0.75;
  1451.  
  1452. base.V_drawn = false;
  1453. base.V_visible = true;
  1454.  
  1455. return base;
  1456. },
  1457. largeTextSprite : function(val){
  1458. var base;
  1459.  
  1460. if( Database.legacyRender ){
  1461. base = new PIXI.Text('',{font: 'bold 16pt Arial', fill: 'black', stroke: 'white', strokeThickness: 5});
  1462. }else{
  1463. base = new PIXI.Text('',{fontFamily: 'Arial', fontSize: '16pt', fontWeight: 'bold', fill: 'black', stroke: 'white', strokeThickness: 5});
  1464. }
  1465.  
  1466. base.x = 20; base.y = 20;
  1467.  
  1468. if( Database.legacyRender ){
  1469. base.anchor.x = 0.45; base.anchor.y = 0.45;
  1470. }else{
  1471. base.anchor.x = 0.5; base.anchor.y = 0.5;
  1472. }
  1473.  
  1474. base.alpha = 0.75;
  1475.  
  1476. if( val ){
  1477. base.V_text = '';
  1478. base.V_color = 'black';
  1479. }
  1480.  
  1481. return base;
  1482. },
  1483. smallTextSprite : function(val){
  1484. var base;
  1485.  
  1486. if( Database.legacyRender ){
  1487. base = new PIXI.Text('',{font: 'bold 12pt Arial', fill: '#ffff66', stroke: 'black', strokeThickness: 3});
  1488. }else{
  1489. base = new PIXI.Text('',{fontFamily: 'Arial', fontSize: '12pt', fontWeight: 'bold', fill: '#ffff66', stroke: 'black', strokeThickness: 3});
  1490. }
  1491.  
  1492. base.x = 20; base.y = 40;
  1493.  
  1494. if( Database.legacyRender ){
  1495. base.anchor.x = 0.45; base.anchor.y = 0.45;
  1496. }else{
  1497. base.anchor.x = 0.5; base.anchor.y = 0.5;
  1498. }
  1499.  
  1500. base.alpha = 0.75;
  1501.  
  1502. if( val ){
  1503. base.V_text = '';
  1504. base.V_yPos = 40;
  1505. }
  1506.  
  1507. return base;
  1508. },
  1509.  
  1510.  
  1511.  
  1512. updateDebug : function(POI){
  1513. Renderer.setDebugBorder( POI );
  1514. },
  1515.  
  1516. updateText : function(POI){
  1517. Renderer.setText( POI );
  1518. Renderer.setTextColor( POI );
  1519. Renderer.setTextPosition( POI );
  1520. },
  1521. updateCircle : function(POI){
  1522. Renderer.setCircleGraphics( POI );
  1523. },
  1524. updateFloater : function(POI){
  1525. if( !( POI.floater && POI.floater.visible ) ) return;
  1526.  
  1527. Renderer.setFloaterScale( POI );
  1528. Renderer.setFloaterPosition( POI );
  1529. },
  1530.  
  1531. setText : function(POI){
  1532. var largeText, smallText, timeLeft, timeAt, dispAt;
  1533.  
  1534. timeLeft = POI.timeLeftText;
  1535. timeAt = POI.timeAtText;
  1536.  
  1537. if( !( POI.timeMax >= 20000 || Config.alwaysAt ) ) timeAt = '';
  1538.  
  1539. // get text based on tileDisplay
  1540. switch( Config.tileDisplay ){
  1541. case 0 : {
  1542. largeText = timeLeft;
  1543. smallText = timeAt;
  1544.  
  1545. break;
  1546. }
  1547. case 1 : {
  1548. largeText = timeLeft;
  1549. smallText = '';
  1550.  
  1551. break;
  1552. }
  1553. case 2 : {
  1554. largeText = timeAt;
  1555. smallText = timeLeft;
  1556.  
  1557. break;
  1558. }
  1559. case 3 : {
  1560. largeText = timeAt;
  1561. smallText = '';
  1562.  
  1563. break;
  1564. }
  1565. case 4 : {
  1566. if( POI.timeLeft > 10000 ){
  1567. largeText = timeAt;
  1568. smallText = timeLeft;
  1569. }else{
  1570. largeText = timeLeft;
  1571. smallText = timeAt;
  1572. }
  1573.  
  1574. break;
  1575. }
  1576. case 5 : {
  1577. if( POI.timeLeft > 10000 ){
  1578. largeText = timeAt;
  1579. smallText = '';
  1580. }else{
  1581. largeText = timeLeft;
  1582. smallText = timeAt;
  1583. }
  1584.  
  1585. break;
  1586. }
  1587. case 6 : {
  1588. if( POI.timeLeft > 10000 ){
  1589. largeText = timeAt;
  1590. smallText = '';
  1591. }else{
  1592. largeText = timeLeft;
  1593. smallText = '';
  1594. }
  1595.  
  1596. break;
  1597. }
  1598. default : {
  1599. largeText = timeLeft;
  1600. smallText = timeAt;
  1601. }
  1602. }
  1603.  
  1604. // set large text
  1605. Helper.setValue( POI.sprite.largeText , 'V_text' , largeText , function(){
  1606. if( Database.legacyRender ){
  1607. POI.sprite.largeText.setText( largeText );
  1608. if( POI.floater ) POI.floater.largeText.setText( largeText );
  1609. }else{
  1610. POI.sprite.largeText.text = largeText;
  1611. if( POI.floater ) POI.floater.largeText.text = largeText;
  1612. }
  1613. });
  1614. // set small text
  1615. Helper.setValue( POI.sprite.smallText , 'V_text' , smallText , function(){
  1616. if( Database.legacyRender ){
  1617. POI.sprite.smallText.setText( smallText );
  1618. if( POI.floater ) POI.floater.smallText.setText( smallText );
  1619. }else{
  1620. POI.sprite.smallText.text = smallText;
  1621. if( POI.floater ) POI.floater.smallText.text = smallText;
  1622. }
  1623. });
  1624. },
  1625. setTextColor : function(POI){
  1626. var color = POI.known ? 'black' : 'brown';
  1627.  
  1628. Helper.setValue( POI.sprite.largeText , 'V_color' , color , function(){
  1629. POI.sprite.largeText.style.fill = color;
  1630. if( POI.floater ) POI.floater.largeText.style.fill = color;
  1631. });
  1632. },
  1633. setTextPosition : function(POI){
  1634. var yPos = Helper.tileNearBottom(POI.y) ? 0 : 40;
  1635.  
  1636. Helper.setValue( POI.sprite.smallText , 'V_yPos' , yPos , function(){
  1637. POI.sprite.smallText.y = yPos;
  1638. if( POI.floater ) POI.floater.smallText.y = yPos;
  1639. });
  1640. },
  1641.  
  1642. setCircleGraphics : function(POI){
  1643. var circle = POI.sprite.circle;
  1644.  
  1645. var state, radius;
  1646.  
  1647. if( !POI.timeMax ) return;
  1648.  
  1649. // get state
  1650. if( POI.inWarnState ){
  1651. if( Config.warningType === 0 ){
  1652. state = 'fill';
  1653. }else if( Config.warningType === 1 ){
  1654. state = 'stroke';
  1655. }else{
  1656. state = 'hidden';
  1657. }
  1658. }else{
  1659. if( POI.known ){
  1660. state = 'fill';
  1661. }else{
  1662. state = 'hidden';
  1663. }
  1664. }
  1665.  
  1666. if( POI.timeLeft === 0 ) state = 'hidden';
  1667.  
  1668. // set state
  1669. Helper.setValue( POI.sprite.circle , 'V_state' , state , function(){
  1670. if( state == 'hidden' ){
  1671. circle.visible = false;
  1672. }else{
  1673. circle.V_radius = 0;
  1674. circle.visible = true;
  1675. }
  1676. });
  1677.  
  1678. if( !( state == 'stroke' || state == 'fill' ) ) state = 'hidden';
  1679.  
  1680. if( state == 'hidden' ) return;
  1681.  
  1682. // get radius
  1683. radius = POI.type == 'portal' ? 15 : 13;
  1684. if( state == 'fill' ) radius *= Math.min( 1 , 1 - ( POI.timeLeft - POI.timeMax * 0.1 ) / POI.timeMax );
  1685. radius = 2 + radius;
  1686.  
  1687. // redraw if radius difference is 0.25
  1688. Helper.setValueDelta( POI.sprite.circle , 'V_radius' , radius , 0.25 , function(){
  1689. if( state == 'fill' ){
  1690. circle.clear().beginFill( POI.fillColor ).drawCircle( 0 , 0 , radius ).endFill();
  1691. }else{
  1692. circle.clear().lineStyle( 2 , 0x333333 ).drawCircle( 0 , 0 , radius - 1 );
  1693. }
  1694. });
  1695. },
  1696.  
  1697. setCircleGraphicsOld : function(POI){
  1698. var circle = POI.sprite.circle, radius = 2, visible;
  1699.  
  1700. if( !POI.timeMax ) return;
  1701.  
  1702. // get visibility
  1703. if( POI.known ){
  1704. if( POI.inWarnState ){
  1705. if( POI.fillOnWarn ){
  1706. visible = true;
  1707. }else{
  1708. visible = false;
  1709. }
  1710. }else {
  1711. visible = true;
  1712. }
  1713. }else{
  1714. visible = false;
  1715. }
  1716.  
  1717. if( POI.timeLeft === 0 ) visible = false;
  1718.  
  1719. // set visibility
  1720. Helper.setValue( POI.sprite.circle , 'V_visible' , visible , function(){
  1721. circle.visible = visible;
  1722. });
  1723.  
  1724. if( !visible ) return;
  1725.  
  1726. // get radius
  1727. radius += ( POI.type == 'portal' ? 15 : 13 ) * Math.min( 1 , 1 - ( POI.timeLeft - POI.timeMax * 0.1 ) / POI.timeMax );
  1728.  
  1729. // redraw if radius difference is 0.25
  1730. Helper.setValueDelta( POI.sprite.circle , 'V_fillRadius' , radius , 0.25 , function(){
  1731. circle.clear().beginFill( POI.fillColor ).drawCircle( 0 , 0 , radius ).endFill();
  1732. });
  1733. },
  1734.  
  1735. setFloaterScale : function(POI){
  1736. Helper.setValue( POI.floater , 'V_scale', 1 / tagpro.zoom , function(){
  1737. POI.floater.scale.x = POI.floater.scale.y = 1 / tagpro.zoom;
  1738. });
  1739. },
  1740. setFloaterPosition : function(POI){
  1741. var player = Database.position;
  1742.  
  1743. POI.floater.position.x = Math.max( 0 , Math.min( tagpro.renderer.canvas.width - 40 * POI.floater.V_scale ,
  1744. ( tagpro.renderer.canvas.width / 2 ) + ( ( POI.x * 40 - player.x * 40 - 20 ) / tagpro.zoom )
  1745. ));
  1746. POI.floater.position.y = Math.max( 0 , Math.min( tagpro.renderer.canvas.height - 40 * POI.floater.V_scale ,
  1747. ( tagpro.renderer.canvas.height / 2 ) + ( ( POI.y * 40 - player.y * 40 - 20 ) / tagpro.zoom )
  1748. ));
  1749. },
  1750.  
  1751. setDebugBorder : function(POI){
  1752. var border, visible;
  1753.  
  1754. // create border sprite
  1755. if( !POI.sprite.border ){
  1756. POI.sprite.border = Renderer.borderSprite();
  1757. POI.sprite.addChild( POI.sprite.border );
  1758. }
  1759.  
  1760. border = POI.sprite.border;
  1761.  
  1762. // get visibility
  1763. visible = !!(POI.debug.timeStamp);
  1764.  
  1765. // set visibility
  1766. Helper.setValue( POI.sprite.border , 'V_visible' , visible , function(){
  1767. border.visible = visible;
  1768. });
  1769.  
  1770. if( !visible ) return;
  1771.  
  1772. // draw border
  1773. Helper.setValue( POI.sprite.border , 'V_drawn' , true , function(){
  1774. border.clear().lineStyle( 4 , 0xff00ff ).drawRect( -20 , -20 , 40 , 40 );
  1775. });
  1776. },
  1777.  
  1778.  
  1779.  
  1780. updateTempText : function(temp){
  1781. Renderer.setTempText( temp );
  1782. },
  1783. updateTempCircle : function(temp){
  1784. Renderer.setTempCircleRadius( temp );
  1785. },
  1786.  
  1787. setTempText : function(temp){
  1788. Helper.setValue( temp.sprite.largeText , 'V_text' , temp.text , function(){
  1789. if( Database.legacyRender ){
  1790. temp.sprite.largeText.setText( temp.text );
  1791. }else{
  1792. temp.sprite.largeText.text = temp.text;
  1793. }
  1794. });
  1795. },
  1796. setTempCircleRadius : function(temp){
  1797. var circle = temp.sprite.circle, radius = 2;
  1798.  
  1799. radius += 17 * Math.min( 1 , 1 - ( temp.timeLeft - temp.timeMax * 0.1 ) / temp.timeMax );
  1800.  
  1801. // redraw if radius difference is 0.25
  1802. Helper.setValueDelta( temp.sprite.circle , 'V_radius' , radius , 0.25 , function(){
  1803. circle.clear().beginFill( temp.color ).drawCircle( 0 , 0 , radius ).endFill();
  1804. });
  1805. },
  1806.  
  1807. setGlobalText : function(){
  1808. var poss = '', nill = '', i;
  1809.  
  1810. for(i = 0; i < Database.global.length; i++){
  1811. if( Database.global[i][2].length > 0 ){
  1812. poss += Helper.getTimeLeftText( Database.global[i][1] ) + ' ';
  1813. }else{
  1814. nill += Helper.getTimeLeftText( Database.global[i][1] ) + ' ';
  1815. }
  1816. }
  1817.  
  1818. Helper.setValue( Renderer.floaterLayer.globalList.poss , 'V_text' , poss , function(){
  1819. if( Database.legacyRender ){
  1820. Renderer.floaterLayer.globalList.poss.setText( poss );
  1821. }else{
  1822. Renderer.floaterLayer.globalList.poss.text = poss;
  1823. }
  1824. });
  1825.  
  1826. Helper.setValue( Renderer.floaterLayer.globalList.nill , 'V_text' , nill , function(){
  1827. if( Database.legacyRender ){
  1828. Renderer.floaterLayer.globalList.nill.setText( nill );
  1829. }else{
  1830. Renderer.floaterLayer.globalList.nill.text = nill;
  1831. }
  1832. });
  1833. },
  1834. setTextPlayerSlots : function(player){
  1835. var i, count, text, db;
  1836.  
  1837. // player is drawable
  1838. if ( !( player.draw && !player.dead ) ) return;
  1839.  
  1840. i = 0; count = player.sprites.activePups.V_slots;
  1841. db = Database.player[ player.id ];
  1842.  
  1843. while( i < count ){
  1844. // get text of timers
  1845. if( i < db.timers.length ){
  1846. // has timer set text
  1847. text = Helper.getTimeLeftText( db.timers[i][1] );
  1848. }else{
  1849. // no timer
  1850. text = '';
  1851. }
  1852.  
  1853. // config disables activePups
  1854. if( !Config.showPlayerTimers ) text = '';
  1855.  
  1856. Helper.setValue( player.sprites.activePups[ 's_' + i ] , 'V_text' , text , function(){
  1857. if( Database.legacyRender ){
  1858. player.sprites.activePups[ 's_' + i ].setText( text );
  1859. }else{
  1860. player.sprites.activePups[ 's_' + i ].text = text;
  1861. }
  1862. });
  1863.  
  1864. i++;
  1865. }
  1866. },
  1867. setTextPlayerPupCount : function(player){
  1868. var db, text;
  1869.  
  1870. // player is drawable
  1871. if ( !( player.draw && !player.dead ) ) return;
  1872.  
  1873. // has sprite to draw to
  1874. if( !player.sprites.activePups || !player.sprites.activePups.counter ) return;
  1875.  
  1876. db = Database.player[ player.id ];
  1877.  
  1878. text = '' + db.pups;
  1879.  
  1880. Helper.setValue( player.sprites.activePups.counter , 'V_text' , text , function(){
  1881. if( Database.legacyRender ){
  1882. player.sprites.activePups.counter.setText( text );
  1883. }else{
  1884. player.sprites.activePups.counter.text = text;
  1885. }
  1886. });
  1887. }
  1888. };
  1889.  
  1890. tagpro.ready(function(){
  1891.  
  1892. // legacy renderer
  1893. if( !PIXI.Container ) Database.legacyRender = true;
  1894.  
  1895. // read map data
  1896. var getMapData = setInterval(function(){
  1897.  
  1898. if( tagpro.map ){
  1899. Logic.readMapData( tagpro.map );
  1900. console.log( 'TSHSU - map data loaded');
  1901. clearInterval( getMapData );
  1902. }
  1903.  
  1904. }, 50);
  1905.  
  1906.  
  1907.  
  1908. // socket handler
  1909. var socketListener = function(socket, handler){
  1910. tagpro.socket.on(socket, function(data){
  1911. var ts = Date.now();
  1912. try{ handler( ts, data ); }
  1913. catch(error){ console.log( 'Socket IO Error', error , data ); }
  1914. });
  1915. };
  1916.  
  1917.  
  1918.  
  1919. // socket listeners
  1920. socketListener('mapupdate', function(ts, data){
  1921. if(!(data instanceof Array)) data = [data];
  1922.  
  1923. var pos = tagpro.players[ tagpro.playerId ];
  1924. pos = { x : pos.x / 40 , y : pos.y / 40 };
  1925.  
  1926. Logic.readSocketMessage( { type : 'mapupdate', time : ts, pos : pos, data : data } );
  1927. });
  1928.  
  1929. socketListener('spawn', function(ts, data){
  1930. data.w = parseFloat(data.w);
  1931. data.x = parseInt(data.x);
  1932. data.y = parseInt(data.y);
  1933.  
  1934. Logic.readSocketMessage( { type : 'spawn', time : ts, data : data } );
  1935. });
  1936.  
  1937. socketListener('end', function(ts, data){
  1938. Logic.readSocketMessage( { type : 'end', time : ts, data : data } );
  1939. });
  1940.  
  1941. socketListener('p', function(ts, data){
  1942. if( !data.t ) data = { t: 0, u: data };
  1943.  
  1944. Logic.readSocketMessage( { type : 'p', time : ts, data : data } );
  1945. });
  1946.  
  1947.  
  1948.  
  1949. // render hook
  1950. var preInitUpdate = setInterval(function(){
  1951.  
  1952. // map is loaded and renderer ready
  1953. if( Database.state !== 0 && tagpro.renderer.updateGraphics ){
  1954. renderHook(); return;
  1955. }
  1956.  
  1957. Logic.tick();
  1958.  
  1959. }, 50);
  1960.  
  1961. var renderHook = function(){
  1962. var OLD_RENDER = tagpro.renderer.updateGraphics;
  1963.  
  1964. // overide render function to include update
  1965. tagpro.renderer.updateGraphics = function(){
  1966. // call tagpro render code
  1967. OLD_RENDER();
  1968.  
  1969. // call script update code
  1970. Logic.tick();
  1971. };
  1972.  
  1973. clearInterval(preInitUpdate);
  1974. console.log( 'TSHSU - render hook established' );
  1975. };
  1976.  
  1977.  
  1978. // debug
  1979. if( false ){
  1980.  
  1981. tagpro.tilmer = {
  1982. config : Config,
  1983. helper : Helper,
  1984. logic : Logic,
  1985. database : Database,
  1986. renderer : Renderer
  1987. };
  1988.  
  1989. }
  1990.  
  1991. });
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!