API tools faq
paste
Guest User

Untitled

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