API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Sep 16th, 2011
285
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C# 27.02 KB | None | 0 0
raw download clone embed print report
  1.  
  2. array(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z)
  3. {
  4.     array = [];
  5.     if ( IsDefined( a ) ) array[ 0] = a; else return array;
  6.     if ( IsDefined( b ) ) array[ 1] = b; else return array;
  7.     if ( IsDefined( c ) ) array[ 2] = c; else return array;
  8.     if ( IsDefined( d ) ) array[ 3] = d; else return array;
  9.     if ( IsDefined( e ) ) array[ 4] = e; else return array;
  10.     if ( IsDefined( f ) ) array[ 5] = f; else return array;
  11.     if ( IsDefined( g ) ) array[ 6] = g; else return array;
  12.     if ( IsDefined( h ) ) array[ 7] = h; else return array;
  13.     if ( IsDefined( i ) ) array[ 8] = i; else return array;
  14.     if ( IsDefined( j ) ) array[ 9] = j; else return array;
  15.     if ( IsDefined( k ) ) array[10] = k; else return array;
  16.     if ( IsDefined( l ) ) array[11] = l; else return array;
  17.     if ( IsDefined( m ) ) array[12] = m; else return array;
  18.     if ( IsDefined( n ) ) array[13] = n; else return array;
  19.     if ( IsDefined( o ) ) array[14] = o; else return array;
  20.     if ( IsDefined( p ) ) array[15] = p; else return array;
  21.     if ( IsDefined( q ) ) array[16] = q; else return array;
  22.     if ( IsDefined( r ) ) array[17] = r; else return array;
  23.     if ( IsDefined( s ) ) array[18] = s; else return array;
  24.     if ( IsDefined( t ) ) array[19] = t; else return array;
  25.     if ( IsDefined( u ) ) array[20] = u; else return array;
  26.     if ( IsDefined( v ) ) array[21] = v; else return array;
  27.     if ( IsDefined( w ) ) array[22] = w; else return array;
  28.     if ( IsDefined( x ) ) array[23] = x; else return array;
  29.     if ( IsDefined( y ) ) array[24] = y; else return array;
  30.     if ( IsDefined( z ) ) array[25] = z;
  31.     return array;
  32. }
  33.  
  34. add_to_array( array, item, allow_dupes )
  35. {
  36.     if( !IsDefined( item ) )
  37.     {
  38.         return array;
  39.     }
  40.     if (!IsDefined(allow_dupes))
  41.     {
  42.         allow_dupes = true;
  43.     }
  44.     if( !IsDefined( array ) )
  45.     {
  46.         array[ 0 ] = item;
  47.     }
  48.     else if (allow_dupes || !is_in_array(array, item))
  49.     {
  50.         array[ array.size ] = item;
  51.     }
  52.     return array;
  53. }
  54. array_add( array, item )
  55. {
  56.     array[ array.size ] = item;
  57.     return array;
  58. }
  59.  
  60. array_delete( array )
  61. {
  62.     for( i = 0; i < array.size; i++ )
  63.     {
  64.         if(isDefined(array[i]))
  65.         {
  66.             array[ i ] delete();
  67.         }
  68.     }
  69. }
  70.  
  71. array_randomize( array )
  72. {
  73.     for( i = 0; i < array.size; i++ )
  74.     {
  75.         j = RandomInt( array.size );
  76.         temp = array[ i ];
  77.         array[ i ] = array[ j ];
  78.         array[ j ] = temp;
  79.     }
  80.     return array;
  81. }
  82.  
  83. array_reverse( array )
  84. {
  85.     array2 = [];
  86.     for( i = array.size - 1; i >= 0; i-- )
  87.     {
  88.         array2[ array2.size ] = array[ i ];
  89.     }
  90.     return array2;
  91. }
  92.  
  93. array_removeUndefined( array )
  94. {
  95.     newArray = [];
  96.     for( i = 0; i < array.size; i++ )
  97.     {
  98.         if( !IsDefined( array[ i ] ) )
  99.         {
  100.             continue;
  101.         }
  102.         newArray[ newArray.size ] = array[ i ];
  103.     }
  104.     return newArray;
  105. }
  106.  
  107. array_insert( array, object, index )
  108. {
  109.     if( index == array.size )
  110.     {
  111.         temp = array;
  112.         temp[ temp.size ] = object;
  113.         return temp;
  114.     }
  115.     temp = [];
  116.     offset = 0;
  117.     for( i = 0; i < array.size; i++ )
  118.     {
  119.         if( i == index )
  120.         {
  121.             temp[ i ] = object;
  122.             offset = 1;
  123.         }
  124.         temp[ i + offset ] = array[ i ];
  125.     }
  126.     return temp;
  127. }
  128.  
  129. array_remove( ents, remover, keepArrayKeys )
  130. {
  131.     newents = [];
  132.    
  133.    
  134.    
  135.     keys = getArrayKeys( ents );
  136.    
  137.     if(IsDefined(keepArrayKeys))
  138.     {
  139.         for( i = keys.size - 1; i >= 0; i-- )
  140.         {
  141.             if( ents[ keys[ i ] ] != remover )
  142.             {
  143.                 newents[ keys[i] ] = ents[ keys[ i ] ];
  144.             }
  145.         }
  146.         return newents;
  147.     }
  148.    
  149.     for( i = keys.size - 1; i >= 0; i-- )
  150.     {
  151.         if( ents[ keys[ i ] ] != remover )
  152.         {
  153.             newents[ newents.size ] = ents[ keys[ i ] ];
  154.         }
  155.     }
  156.     return newents;
  157. }
  158. array_remove_nokeys( ents, remover )
  159. {
  160.     newents = [];
  161.     for ( i = 0; i < ents.size; i++ )
  162.     {
  163.         if( ents[ i ] != remover )
  164.         {
  165.             newents[ newents.size ] = ents[ i ];
  166.         }
  167.     }
  168.     return newents;
  169. }
  170. array_remove_index( array, index )
  171. {
  172.     newArray = [];
  173.     keys = getArrayKeys( array );
  174.     for( i = ( keys.size - 1 );i >= 0 ; i-- )
  175.     {
  176.         if( keys[ i ] != index )
  177.         {
  178.             newArray[ newArray.size ] = array[ keys[ i ] ];
  179.         }
  180.     }
  181.     return newArray;
  182. }
  183.  
  184. array_combine( array1, array2 )
  185. {
  186.     if( !array1.size )
  187.     {
  188.         return array2;
  189.     }
  190.     array3 = [];
  191.     keys = GetArrayKeys( array1 );
  192.     for( i = 0;i < keys.size;i++ )
  193.     {
  194.         key = keys[ i ];
  195.         array3[ array3.size ] = array1[ key ];
  196.     }  
  197.     keys = GetArrayKeys( array2 );
  198.     for( i = 0;i < keys.size;i++ )
  199.     {
  200.         key = keys[ i ];
  201.         array3[ array3.size ] = array2[ key ];
  202.     }
  203.     return array3;
  204. }
  205.  
  206. array_merge( array1, array2 )
  207. {
  208.     if( array1.size == 0 )
  209.     {
  210.         return array2;
  211.     }
  212.     if( array2.size == 0 )
  213.     {
  214.         return array1;
  215.     }
  216.     newarray = array1;
  217.     for( i = 0;i < array2.size;i++ )
  218.     {
  219.         foundmatch = false;
  220.         for( j = 0;j < array1.size;j++ )
  221.         {
  222.             if( array2[ i ] == array1[ j ] )
  223.             {
  224.                 foundmatch = true;
  225.                 break;
  226.             }
  227.         }
  228.         if( foundmatch )
  229.         {
  230.             continue;
  231.         }
  232.         else
  233.         {
  234.             newarray[ newarray.size ] = array2[ i ];
  235.         }
  236.     }
  237.     return newarray;
  238. }
  239.  
  240. array_exclude( array, arrayExclude )
  241. {
  242.     newarray = array;
  243.    
  244.     if( IsArray( arrayExclude ) )
  245.     {
  246.         for( i = 0;i < arrayExclude.size;i++ )
  247.         {
  248.             if( is_in_array( array, arrayExclude[ i ] ) )
  249.             {
  250.                 newarray = array_remove( newarray, arrayExclude[ i ] );
  251.             }
  252.         }
  253.     }
  254.     else
  255.     {
  256.             if( is_in_array( array, arrayExclude ) )
  257.             {
  258.                 newarray = array_remove( newarray, arrayExclude );
  259.             }
  260.   }
  261.  
  262.     return newarray;
  263. }
  264. array_notify( ents, notifier )
  265. {
  266.     for( i = 0;i < ents.size;i++ )
  267.     {
  268.         ents[ i ] notify( notifier );
  269.     }
  270. }
  271. array_wait(array, msg, timeout)
  272. {  
  273.     keys = getarraykeys(array);
  274.     structs = [];
  275.     for (i = 0; i < keys.size; i++)
  276.     {
  277.         key = keys[i];
  278.         structs[ key ] = spawnstruct();
  279.         structs[ key ]._array_wait = true; 
  280.         structs[ key ] thread array_waitlogic1( array[ key ], msg, timeout );
  281.     }
  282.     for (i = 0; i < keys.size; i++)
  283.     {
  284.         key = keys[i];
  285.         if( IsDefined( array[ key ] ) && structs[ key ]._array_wait)
  286.         {
  287.             structs[ key ] waittill( "_array_wait" );  
  288.         }
  289.     }
  290. }
  291. array_wait_any(array, msg, timeout)
  292. {
  293.     if (array.size == 0)
  294.     {
  295.         return undefined;
  296.     }
  297.     keys = getarraykeys(array);
  298.     structs = [];
  299.     internal_msg = msg + "array_wait";
  300.     for (i = 0; i < keys.size; i++)
  301.     {
  302.         key = keys[i];
  303.         structs[ key ] = spawnstruct();
  304.         structs[ key ]._array_wait = true; 
  305.         structs[ key ] thread array_waitlogic3( array[ key ], msg, internal_msg, timeout );
  306.     }
  307.     level waittill(internal_msg, ent);
  308.     return ent;
  309. }
  310. array_waitlogic1( ent, msg, timeout )
  311. {
  312.     self array_waitlogic2( ent, msg, timeout );
  313.     self._array_wait = false;
  314.     self notify( "_array_wait" );
  315. }
  316. array_waitlogic2( ent, msg, timeout )
  317. {
  318.     ent endon( msg );
  319.     ent endon( "death" );
  320.     if( isdefined( timeout ) )
  321.     {
  322.         wait timeout;
  323.     }
  324.     else
  325.     {
  326.         ent waittill( msg );
  327.     }
  328. }
  329. array_waitlogic3(ent, msg, internal_msg, timeout)
  330. {
  331.    
  332.     if(msg !="death")
  333.     {
  334.         ent endon("death");
  335.     }  
  336.     level endon(internal_msg);
  337.    
  338.     self array_waitlogic2(ent, msg, timeout);
  339.     level notify(internal_msg, ent);
  340. }
  341. array_check_for_dupes( array, single )
  342. {
  343.     for( i = 0; i < array.size; i++ )
  344.     {
  345.         if( array[i] == single )
  346.         {
  347.             return false;
  348.         }
  349.     }
  350.     return true;
  351. }
  352. array_swap( array, index1, index2 )
  353. {
  354.     assertEx( index1 < array.size, "index1 to swap out of range" );
  355.     assertEx( index2 < array.size, "index2 to swap out of range" );
  356.     temp = array[index1];
  357.     array[index1] = array[index2];
  358.     array[index2] = temp;
  359.     return array;
  360. }
  361. array_average( array )
  362. {
  363.     assert( IsArray( array ) );
  364.     assert( array.size > 0 );
  365.     total = 0;
  366.     for ( i = 0; i < array.size; i++ )
  367.     {
  368.         total += array[i];
  369.     }
  370.     return ( total / array.size );
  371. }
  372. array_std_deviation( array, mean )
  373. {
  374.     assert( IsArray( array ) );
  375.     assert( array.size > 0 );
  376.     tmp = [];
  377.     for ( i = 0; i < array.size; i++ )
  378.     {
  379.         tmp[i] = ( array[i] - mean ) * ( array[i] - mean );
  380.     }
  381.     total = 0;
  382.     for ( i = 0; i < tmp.size; i++ )
  383.     {
  384.         total = total + tmp[i];
  385.     }
  386.     return Sqrt( total / array.size );
  387. }
  388. random_normal_distribution( mean, std_deviation, lower_bound, upper_bound )
  389. {
  390.    
  391.    
  392.     x1 = 0;
  393.     x2 = 0;
  394.     w = 1;
  395.     y1 = 0;
  396.     while ( w >= 1 )
  397.     {
  398.         x1 = 2 * RandomFloatRange( 0, 1 ) - 1;
  399.         x2 = 2 * RandomFloatRange( 0, 1 ) - 1;
  400.         w = x1 * x1 + x2 * x2;
  401.     }
  402.     w = Sqrt( ( -2.0 * Log( w ) ) / w );
  403.     y1 = x1 * w;
  404.     number = mean + y1 * std_deviation;
  405.     if ( IsDefined( lower_bound ) && number < lower_bound )
  406.     {
  407.         number = lower_bound;
  408.     }
  409.     if ( IsDefined( upper_bound ) && number > upper_bound )
  410.     {
  411.         number = upper_bound;
  412.     }
  413.    
  414.     return( number );
  415. }
  416.  
  417. random( array )
  418. {
  419.     keys = GetArrayKeys(array);
  420.     return array[ keys[RandomInt( keys.size )] ];
  421. }
  422.  
  423. is_in_array( aeCollection, eFindee )
  424. {
  425.     for( i = 0; i < aeCollection.size; i++ )
  426.     {
  427.         if( aeCollection[ i ] == eFindee )
  428.         {
  429.             return( true );
  430.         }
  431.     }
  432.     return( false );
  433. }
  434. vector_compare(vec1, vec2)
  435. {
  436.     return (abs(vec1[0] - vec2[0]) < .001) && (abs(vec1[1] - vec2[1]) < .001) && (abs(vec1[2] - vec2[2]) < .001);
  437. }
  438.  
  439. vector_scale(vec, scale)
  440. {
  441.     vec = (vec * scale);
  442.     return vec;
  443. }
  444.  
  445. vector_multiply( vec, vec2 )
  446. {
  447.     vec = (vec * vec2);
  448.     return vec;
  449. }
  450. draw_debug_line(start, end, timer)
  451. {
  452.     for (i=0;i<timer*20;i++)
  453.     {
  454.         line (start, end, (1,1,0.5));
  455.         wait (0.05);
  456.     }
  457. }
  458. waittillend(msg)
  459. {
  460.     self waittillmatch (msg, "end");
  461. }
  462. randomvector(num)
  463. {
  464.     return (RandomFloat(num) - num*0.5, RandomFloat(num) - num*0.5,RandomFloat(num) - num*0.5);
  465. }
  466. angle_dif(oldangle, newangle)
  467. {
  468.    
  469.     if (oldangle == newangle)
  470.         return 0;
  471.    
  472.     while (newangle > 360)
  473.         newangle -=360;
  474.    
  475.     while (newangle < 0)
  476.         newangle +=360;
  477.    
  478.     while (oldangle > 360)
  479.         oldangle -=360;
  480.    
  481.     while (oldangle < 0)
  482.         oldangle +=360;
  483.    
  484.     olddif = undefined;
  485.     newdif = undefined;
  486.    
  487.     if (newangle > 180)
  488.         newdif = 360 - newangle;
  489.     else
  490.         newdif = newangle;
  491.    
  492.     if (oldangle > 180)
  493.         olddif = 360 - oldangle;
  494.     else
  495.         olddif = oldangle;
  496.    
  497.     outerdif = newdif + olddif;
  498.     innerdif = 0;
  499.    
  500.     if (newangle > oldangle)
  501.         innerdif = newangle - oldangle;
  502.     else
  503.         innerdif = oldangle - newangle;
  504.    
  505.     if (innerdif < outerdif)
  506.         return innerdif;
  507.     else
  508.         return outerdif;
  509. }
  510. sign( x )
  511. {
  512.     if ( x >= 0 )
  513.         return 1;
  514.     return -1;
  515. }
  516. track(spot_to_track)
  517. {
  518.     if(IsDefined(self.current_target))
  519.     {
  520.         if(spot_to_track == self.current_target)
  521.             return;
  522.     }
  523.     self.current_target = spot_to_track;   
  524. }
  525. clear_exception( type )
  526. {
  527.     assert( IsDefined( self.exception[ type ] ) );
  528.     self.exception[ type ] = anim.defaultException;
  529. }
  530. set_exception( type, func )
  531. {
  532.     assert( IsDefined( self.exception[ type ] ) );
  533.     self.exception[ type ] = func;
  534. }
  535. set_all_exceptions( exceptionFunc )
  536. {
  537.     keys = getArrayKeys( self.exception );
  538.     for ( i=0; i < keys.size; i++ )
  539.     {
  540.         self.exception[ keys[ i ] ] = exceptionFunc;
  541.     }
  542. }
  543. cointoss()
  544. {
  545.     return RandomInt( 100 ) >= 50 ;
  546. }
  547. waittill_string( msg, ent )
  548. {
  549.     if ( msg != "death" )
  550.         self endon ("death");
  551.        
  552.     ent endon ( "die" );
  553.     self waittill ( msg );
  554.     ent notify ( "returned", msg );
  555. }
  556. waittill_multiple( string1, string2, string3, string4, string5 )
  557. {
  558.     self endon ("death");
  559.     ent = SpawnStruct();
  560.     ent.threads = 0;
  561.     if (IsDefined (string1))
  562.     {
  563.         self thread waittill_string (string1, ent);
  564.         ent.threads++;
  565.     }
  566.     if (IsDefined (string2))
  567.     {
  568.         self thread waittill_string (string2, ent);
  569.         ent.threads++;
  570.     }
  571.     if (IsDefined (string3))
  572.     {
  573.         self thread waittill_string (string3, ent);
  574.         ent.threads++;
  575.     }
  576.     if (IsDefined (string4))
  577.     {
  578.         self thread waittill_string (string4, ent);
  579.         ent.threads++;
  580.     }
  581.     if (IsDefined (string5))
  582.     {
  583.         self thread waittill_string (string5, ent);
  584.         ent.threads++;
  585.     }
  586.     while (ent.threads)
  587.     {
  588.         ent waittill ("returned");
  589.         ent.threads--;
  590.     }
  591.     ent notify ("die");
  592. }
  593. waittill_multiple_ents( ent1, string1, ent2, string2, ent3, string3, ent4, string4 )
  594. {
  595.     self endon ("death");
  596.     ent = SpawnStruct();
  597.     ent.threads = 0;
  598.     if ( IsDefined( ent1 ) )
  599.     {
  600.         assert( IsDefined( string1 ) );
  601.         ent1 thread waittill_string( string1, ent );
  602.         ent.threads++;
  603.     }
  604.     if ( IsDefined( ent2 ) )
  605.     {
  606.         assert( IsDefined( string2 ) );
  607.         ent2 thread waittill_string ( string2, ent );
  608.         ent.threads++;
  609.     }
  610.     if ( IsDefined( ent3 ) )
  611.     {
  612.         assert( IsDefined( string3 ) );
  613.         ent3 thread waittill_string ( string3, ent );
  614.         ent.threads++;
  615.     }
  616.     if ( IsDefined( ent4 ) )
  617.     {
  618.         assert( IsDefined( string4 ) );
  619.         ent4 thread waittill_string ( string4, ent );
  620.         ent.threads++;
  621.     }
  622.     while (ent.threads)
  623.     {
  624.         ent waittill ("returned");
  625.         ent.threads--;
  626.     }
  627.     ent notify ("die");
  628. }
  629. waittill_any_return( string1, string2, string3, string4, string5, string6 )
  630. {
  631.     if ((!IsDefined (string1) || string1 != "death") &&
  632.         (!IsDefined (string2) || string2 != "death") &&
  633.         (!IsDefined (string3) || string3 != "death") &&
  634.         (!IsDefined (string4) || string4 != "death") &&
  635.         (!IsDefined (string5) || string5 != "death") &&
  636.         (!IsDefined (string6) || string6 != "death"))
  637.         self endon ("death");
  638.        
  639.     ent = SpawnStruct();
  640.     if (IsDefined (string1))
  641.         self thread waittill_string (string1, ent);
  642.     if (IsDefined (string2))
  643.         self thread waittill_string (string2, ent);
  644.     if (IsDefined (string3))
  645.         self thread waittill_string (string3, ent);
  646.     if (IsDefined (string4))
  647.         self thread waittill_string (string4, ent);
  648.     if (IsDefined (string5))
  649.         self thread waittill_string (string5, ent);
  650.     if (IsDefined (string6))
  651.         self thread waittill_string (string6, ent);
  652.     ent waittill ("returned", msg);
  653.     ent notify ("die");
  654.     return msg;
  655. }
  656. waittill_any( string1, string2, string3, string4, string5 )
  657. {
  658.     assert( IsDefined( string1 ) );
  659.    
  660.     if ( IsDefined( string2 ) )
  661.         self endon( string2 );
  662.     if ( IsDefined( string3 ) )
  663.         self endon( string3 );
  664.     if ( IsDefined( string4 ) )
  665.         self endon( string4 );
  666.     if ( IsDefined( string5 ) )
  667.         self endon( string5 );
  668.    
  669.     self waittill( string1 );
  670. }
  671. waittill_any_ents( ent1, string1, ent2, string2, ent3, string3, ent4, string4, ent5, string5, ent6, string6, ent7, string7 )
  672. {
  673.     assert( IsDefined( ent1 ) );
  674.     assert( IsDefined( string1 ) );
  675.    
  676.     if ( ( IsDefined( ent2 ) ) && ( IsDefined( string2 ) ) )
  677.         ent2 endon( string2 );
  678.     if ( ( IsDefined( ent3 ) ) && ( IsDefined( string3 ) ) )
  679.         ent3 endon( string3 );
  680.    
  681.     if ( ( IsDefined( ent4 ) ) && ( IsDefined( string4 ) ) )
  682.         ent4 endon( string4 );
  683.    
  684.     if ( ( IsDefined( ent5 ) ) && ( IsDefined( string5 ) ) )
  685.         ent5 endon( string5 );
  686.    
  687.     if ( ( IsDefined( ent6 ) ) && ( IsDefined( string6 ) ) )
  688.         ent6 endon( string6 );
  689.    
  690.     if ( ( IsDefined( ent7 ) ) && ( IsDefined( string7 ) ) )
  691.         ent7 endon( string7 );
  692.    
  693.     ent1 waittill( string1 );
  694. }
  695. isFlashed()
  696. {
  697.     if ( !IsDefined( self.flashEndTime ) )
  698.         return false;
  699.    
  700.     return GetTime() < self.flashEndTime;
  701. }
  702.  
  703. flag( message )
  704. {
  705.     assertEx( IsDefined( message ), "Tried to check flag but the flag was not defined." );
  706.     assertEx( IsDefined( level.flag[ message ] ), "Tried to check flag " + message + " but the flag was not initialized." );
  707.     if ( !level.flag[ message ] )
  708.         return false;
  709.     return true;
  710. }
  711.  
  712. flag_init( message, val )
  713. {
  714.     if ( !IsDefined( level.flag ) )
  715.     {
  716.         level.flag = [];
  717.         level.flags_lock = [];
  718.     }
  719.     if ( !IsDefined( level.sp_stat_tracking_func ) )
  720.     {
  721.         level.sp_stat_tracking_func = ::empty_init_func;
  722.     }
  723.     if ( !IsDefined( level.first_frame ) )
  724.     {
  725.         assertEx( !IsDefined( level.flag[ message ] ), "Attempt to reinitialize existing flag: " + message );
  726.     }
  727.    
  728.     if (is_true(val))
  729.     {
  730.         level.flag[ message ] = true;
  731.        
  732.     }
  733.     else
  734.     {
  735.         level.flag[ message ] = false;
  736.        
  737.     }
  738.  
  739.     if ( !IsDefined( level.trigger_flags ) )
  740.     {
  741.         init_trigger_flags();
  742.         level.trigger_flags[ message ] = [];
  743.     }
  744.     else if ( !IsDefined( level.trigger_flags[ message ] ) )
  745.     {
  746.         level.trigger_flags[ message ] = [];
  747.     }
  748.    
  749.     if ( issuffix( message, "aa_" ) )
  750.     {
  751.         thread [[ level.sp_stat_tracking_func ]]( message );
  752.     }
  753. }
  754. empty_init_func( empty )
  755. {
  756. }
  757. issuffix( msg, suffix )
  758. {
  759.     if ( suffix.size > msg.size )
  760.         return false;
  761.    
  762.     for ( i = 0; i < suffix.size; i++ )
  763.     {
  764.         if ( msg[ i ] != suffix[ i ] )
  765.             return false;
  766.     }
  767.     return true;
  768. }
  769.  
  770. flag_set( message )
  771. {
  772.    
  773.     level.flag[ message ] = true;
  774.     level notify( message );
  775.     set_trigger_flag_permissions( message );
  776. }
  777.  
  778. flag_toggle( message )
  779. {
  780.     if (flag(message))
  781.     {
  782.         flag_clear(message);
  783.     }
  784.     else
  785.     {
  786.         flag_set(message);
  787.     }
  788. }
  789.  
  790. flag_wait( msg )
  791. {
  792.     while( !level.flag[ msg ] )
  793.         level waittill( msg );
  794. }
  795.  
  796. flag_clear( message )
  797. {
  798.    
  799.    
  800.     if (    level.flag[ message ] )
  801.     {
  802.         level.flag[ message ] = false;
  803.         level notify( message );
  804.         set_trigger_flag_permissions( message );
  805.     }
  806. }
  807. flag_waitopen( msg )
  808. {
  809.     while( level.flag[ msg ] )
  810.         level waittill( msg );
  811. }
  812. flag_exists( msg )
  813. {
  814.     if( self == level )
  815.     {
  816.         if( !IsDefined( level.flag ) )
  817.             return false;
  818.         if( IsDefined( level.flag[ msg ] ) )
  819.             return true;
  820.     }
  821.     else
  822.     {
  823.         if( !IsDefined( self.ent_flag ) )
  824.             return false;
  825.         if( IsDefined( self.ent_flag[ msg ] ) )
  826.             return true;
  827.     }
  828.    
  829.     return false;
  830. }
  831. script_gen_dump_addline( string, signature )
  832. {
  833.    
  834.     if ( !IsDefined( string ) )
  835.         string = "nowrite";
  836.        
  837.     if ( !IsDefined( level._loadstarted ) )
  838.     {
  839.            
  840.             if ( !IsDefined( level.script_gen_dump_preload ) )
  841.                 level.script_gen_dump_preload = [];
  842.             struct = SpawnStruct();
  843.             struct.string = string;
  844.             struct.signature = signature;
  845.             level.script_gen_dump_preload[ level.script_gen_dump_preload.size ] = struct;
  846.             return;
  847.     }
  848.        
  849.        
  850.     if ( !IsDefined( level.script_gen_dump[ signature ] ) )
  851.         level.script_gen_dump_reasons[ level.script_gen_dump_reasons.size ] = "Added: " + string;
  852.     level.script_gen_dump[ signature ] = string;
  853.     level.script_gen_dump2[ signature ] = string;
  854. }
  855.  
  856. array_func(entities, func, arg1, arg2, arg3, arg4, arg5)
  857. {
  858.     if (!IsDefined( entities ))
  859.     {
  860.         return;
  861.     }
  862.     if (IsArray(entities))
  863.     {
  864.         if (entities.size)
  865.         {
  866.             keys = GetArrayKeys( entities );
  867.             for (i = 0; i < keys.size; i++)
  868.             {
  869.                 single_func(entities[keys[i]], func, arg1, arg2, arg3, arg4, arg5);
  870.             }
  871.         }
  872.     }
  873.     else
  874.     {
  875.         single_func(entities, func, arg1, arg2, arg3, arg4, arg5);
  876.     }
  877. }
  878.  
  879. single_func(entity, func, arg1, arg2, arg3, arg4, arg5)
  880. {
  881.     if(!IsDefined(entity))
  882.     {
  883.         entity = level;
  884.     }
  885.     if (IsDefined(arg5))
  886.     {
  887.         entity [[ func ]](arg1, arg2, arg3, arg4, arg5);
  888.     }
  889.     else if (IsDefined(arg4))
  890.     {
  891.         entity [[ func ]](arg1, arg2, arg3, arg4);
  892.     }
  893.     else if (IsDefined(arg3))
  894.     {
  895.         entity [[ func ]](arg1, arg2, arg3);
  896.     }
  897.     else if (IsDefined(arg2))
  898.     {
  899.         entity [[ func ]](arg1, arg2);
  900.     }
  901.     else if (IsDefined(arg1))
  902.     {
  903.         entity [[ func ]](arg1);
  904.     }
  905.     else
  906.     {
  907.         entity [[ func ]]();
  908.     }
  909. }
  910.  
  911. array_thread( entities, func, arg1, arg2, arg3, arg4, arg5 )
  912. {
  913.     AssertEX(IsDefined(entities), "Undefined array passed to common_scripts\utility::array_thread()");
  914.     if (IsArray(entities))
  915.     {
  916.         if (entities.size)
  917.         {
  918.             keys = GetArrayKeys( entities );
  919.             for (i = 0; i < keys.size; i++)
  920.             {
  921.                 single_thread(entities[keys[i]], func, arg1, arg2, arg3, arg4, arg5);
  922.             }
  923.         }
  924.     }
  925.     else
  926.     {
  927.         single_thread(entities, func, arg1, arg2, arg3, arg4, arg5);
  928.     }
  929. }
  930.  
  931. single_thread(entity, func, arg1, arg2, arg3, arg4, arg5)
  932. {
  933.     AssertEX(IsDefined(entity), "Undefined entity passed to common_scripts\utility::single_thread()");
  934.     if (IsDefined(arg5))
  935.     {
  936.         entity thread [[ func ]](arg1, arg2, arg3, arg4, arg5);
  937.     }
  938.     else if (IsDefined(arg4))
  939.     {
  940.         entity thread [[ func ]](arg1, arg2, arg3, arg4);
  941.     }
  942.     else if (IsDefined(arg3))
  943.     {
  944.         entity thread [[ func ]](arg1, arg2, arg3);
  945.     }
  946.     else if (IsDefined(arg2))
  947.     {
  948.         entity thread [[ func ]](arg1, arg2);
  949.     }
  950.     else if (IsDefined(arg1))
  951.     {
  952.         entity thread [[ func ]](arg1);
  953.     }
  954.     else
  955.     {
  956.         entity thread [[ func ]]();
  957.     }
  958. }
  959. remove_undefined_from_array( array )
  960. {
  961.     newarray = [];
  962.     for( i = 0; i < array.size; i ++ )
  963.     {
  964.         if ( !IsDefined( array[ i ] ) )
  965.             continue;
  966.         newarray[ newarray.size ] = array[ i ];
  967.     }
  968.     return newarray;
  969. }
  970. realWait(seconds)
  971. {
  972.     start = GetTime();
  973.    
  974.     while(GetTime() - start < seconds * 1000)
  975.     {
  976.        
  977.         wait(.05);
  978.     }
  979.    
  980. }
  981.  
  982. trigger_on( name, type )
  983. {
  984.     if ( IsDefined ( name ) && IsDefined( type ) )
  985.     {
  986.         ents = getentarray( name, type );
  987.         array_thread( ents, ::trigger_on_proc );
  988.     }
  989.     else
  990.         self trigger_on_proc();
  991. }
  992. trigger_on_proc()
  993. {
  994.     if ( IsDefined( self.realOrigin ) )
  995.         self.origin = self.realOrigin;
  996.     self.trigger_off = undefined;
  997. }
  998.  
  999. trigger_off( name, type )
  1000. {
  1001.     if ( IsDefined ( name ) && IsDefined( type ) )
  1002.     {
  1003.         ents = getentarray( name, type );
  1004.         array_thread( ents, ::trigger_off_proc );
  1005.     }
  1006.     else
  1007.         self trigger_off_proc();   
  1008. }
  1009.  
  1010. trigger_off_proc()
  1011. {
  1012.     if ( !IsDefined( self.realOrigin ) )
  1013.         self.realOrigin = self.origin;
  1014.     if ( self.origin == self.realorigin )
  1015.         self.origin += ( 0, 0, -10000 );
  1016.     self.trigger_off = true;
  1017. }
  1018.  
  1019. trigger_wait( strName, strKey )
  1020. {
  1021.     if( !IsDefined( strKey ) )
  1022.     {
  1023.         strKey = "targetname";
  1024.     }
  1025.     triggers = GetEntArray( strName, strKey );
  1026.     AssertEX( IsDefined(triggers) && triggers.size > 0, "trigger not found: " + strName + " key: " + strKey );
  1027.    
  1028.     ent = spawnstruct();
  1029.     array_thread( triggers, ::trigger_wait_think, ent );
  1030.     ent waittill( "trigger", eOther, trigger_hit );
  1031.     level notify( strName, eOther );
  1032.    
  1033.    
  1034.     if(IsDefined(trigger_hit))
  1035.     {
  1036.         trigger_hit.who = eother;
  1037.         return trigger_hit;
  1038.     }
  1039.     else
  1040.     {
  1041.         return eOther;
  1042.     }
  1043. }
  1044. trigger_wait_think( ent )
  1045. {
  1046.     self endon( "death" );
  1047.     ent endon( "trigger" );
  1048.     self waittill( "trigger", eother );
  1049.     ent notify( "trigger", eother, self );
  1050. }
  1051. set_trigger_flag_permissions( msg )
  1052. {
  1053.    
  1054.    
  1055.     if ( !IsDefined( level.trigger_flags ) )
  1056.         return;
  1057.    
  1058.     level.trigger_flags[ msg ] = remove_undefined_from_array( level.trigger_flags[ msg ] );
  1059.     array_thread( level.trigger_flags[ msg ], ::update_trigger_based_on_flags );
  1060. }
  1061. update_trigger_based_on_flags()
  1062. {
  1063.     true_on = true;
  1064.     if ( IsDefined( self.script_flag_true ) )
  1065.     {
  1066.         true_on = false;
  1067.         tokens = create_flags_and_return_tokens( self.script_flag_true );
  1068.        
  1069.        
  1070.         for( i=0; i < tokens.size; i++ )
  1071.         {
  1072.             if ( flag( tokens[ i ] ) )
  1073.             {
  1074.                 true_on = true;
  1075.                 break;
  1076.             }
  1077.         }  
  1078.     }
  1079.    
  1080.     false_on = true;
  1081.     if ( IsDefined( self.script_flag_false ) )
  1082.     {
  1083.         tokens = create_flags_and_return_tokens( self.script_flag_false );
  1084.        
  1085.        
  1086.         for( i=0; i < tokens.size; i++ )
  1087.         {
  1088.             if ( flag( tokens[ i ] ) )
  1089.             {
  1090.                 false_on = false;
  1091.                 break;
  1092.             }
  1093.         }  
  1094.     }
  1095.    
  1096.     [ [ level.trigger_func[ true_on && false_on ] ] ]();
  1097. }
  1098. create_flags_and_return_tokens( flags )
  1099. {
  1100.     tokens = strtok( flags, " " ); 
  1101.    
  1102.     for( i=0; i < tokens.size; i++ )
  1103.     {
  1104.         if ( !IsDefined( level.flag[ tokens[ i ] ] ) )
  1105.         {
  1106.             flag_init( tokens[ i ] );
  1107.         }
  1108.     }
  1109.    
  1110.     return tokens;
  1111. }
  1112. init_trigger_flags()
  1113. {
  1114.     level.trigger_flags = [];
  1115.     level.trigger_func[ true ] = ::trigger_on;
  1116.     level.trigger_func[ false ] = ::trigger_off;
  1117. }
  1118.  
  1119. getstruct( name, type )
  1120. {
  1121.     assertEx( IsDefined( level.struct_class_names ), "Tried to getstruct before the structs were init" );
  1122.     if (!IsDefined(type))
  1123.     {
  1124.         type = "targetname";
  1125.     }
  1126.     array = level.struct_class_names[ type ][ name ];
  1127.     if( !IsDefined( array ) )
  1128.     {
  1129.         return undefined;
  1130.     }
  1131.     if( array.size > 1 )
  1132.     {
  1133.         assertMsg( "getstruct used for more than one struct of type " + type + " called " + name + "." );
  1134.         return undefined;
  1135.     }
  1136.     return array[ 0 ];
  1137. }
  1138.  
  1139. getstructarray( name, type )
  1140. {
  1141.     assertEx( IsDefined( level.struct_class_names ), "Tried to getstruct before the structs were init" );
  1142.     if (!IsDefined(type))
  1143.     {
  1144.         type = "targetname";
  1145.     }
  1146.    
  1147.     array = level.struct_class_names[ type ][ name ];
  1148.     if ( !IsDefined( array ) )
  1149.         return [];
  1150.     return array;
  1151. }
  1152. struct_class_init()
  1153. {
  1154.     assertEx( !IsDefined( level.struct_class_names ), "level.struct_class_names is being initialized in the wrong place! It shouldn't be initialized yet." );
  1155.    
  1156.     level.struct_class_names = [];
  1157.     level.struct_class_names[ "target" ] = [];
  1158.     level.struct_class_names[ "targetname" ] = [];
  1159.     level.struct_class_names[ "script_noteworthy" ] = [];
  1160.     level.struct_class_names[ "script_linkname" ] = [];
  1161.    
  1162.     for ( i=0; i < level.struct.size; i++ )
  1163.     {
  1164.         if ( IsDefined( level.struct[ i ].targetname ) )
  1165.         {
  1166.             if ( !IsDefined( level.struct_class_names[ "targetname" ][ level.struct[ i ].targetname ] ) )
  1167.                 level.struct_class_names[ "targetname" ][ level.struct[ i ].targetname ] = [];
  1168.            
  1169.             size = level.struct_class_names[ "targetname" ][ level.struct[ i ].targetname ].size;
  1170.             level.struct_class_names[ "targetname" ][ level.struct[ i ].targetname ][ size ] = level.struct[ i ];
  1171.         }
  1172.         if ( IsDefined( level.struct[ i ].target ) )
  1173.         {
  1174.             if ( !IsDefined( level.struct_class_names[ "target" ][ level.struct[ i ].target ] ) )
  1175.                 level.struct_class_names[ "target" ][ level.struct[ i ].target ] = [];
  1176.            
  1177.             size = level.struct_class_names[ "target" ][ level.struct[ i ].target ].size;
  1178.             level.struct_class_names[ "target" ][ level.struct[ i ].target ][ size ] = level.struct[ i ];
  1179.         }
  1180.         if ( IsDefined( level.struct[ i ].script_noteworthy ) )
  1181.         {
  1182.             if ( !IsDefined( level.struct_class_names[ "script_noteworthy" ][ level.struct[ i ].script_noteworthy ] ) )
  1183.                 level.struct_class_names[ "script_noteworthy" ][ level.struct[ i ].script_noteworthy ] = [];
  1184.            
  1185.             size = level.struct_class_names[ "script_noteworthy" ][ level.struct[ i ].script_noteworthy ].size;
  1186.             level.struct_class_names[ "script_noteworthy" ][ level.struct[ i ].script_noteworthy ][ size ] = level.struct[ i ];
  1187.         }
  1188.         if ( IsDefined( level.struct[ i ].script_linkname ) )
  1189.         {
  1190.             assertex( !IsDefined( level.struct_class_names[ "script_linkname" ][ level.struct[ i ].script_linkname ] ), "Two structs have the same linkname" );
  1191.             level.struct_class_names[ "script_linkname" ][ level.struct[ i ].script_linkname ][ 0 ] = level.struct[ i ];
  1192.         }
  1193.     }
  1194.    
  1195.     for( i = 0; i < level.struct.size; i++ )
  1196.     {
  1197.         if( !IsDefined( level.struct[i].target ) )
  1198.         {
  1199.             continue;
  1200.         }
  1201.         level.struct[i].targeted = level.struct_class_names["targetname"][level.struct[i].target];
  1202.     }
  1203. }
  1204. fileprint_start( file )
  1205. {
  1206.      
  1207. }
  1208.  
  1209. fileprint_map_start( file )
  1210. {
  1211.      
  1212.    
  1213. }
  1214. fileprint_chk( file , str )
  1215. {
  1216.    
  1217. }
  1218. fileprint_map_header( bInclude_blank_worldspawn )
  1219. {
  1220.     if ( !IsDefined( bInclude_blank_worldspawn ) )
  1221.         bInclude_blank_worldspawn = false;
  1222.        
  1223.    
  1224.     assert( IsDefined( level.fileprint ) );
  1225.      
  1226. }
  1227.  
  1228. fileprint_map_keypairprint( key1, key2 )
  1229. {
  1230.      
  1231. }
  1232.  
  1233. fileprint_map_entity_start()
  1234. {
  1235.      
  1236. }
  1237.  
  1238. fileprint_map_entity_end()
  1239. {
  1240.      
  1241. }
  1242.  
  1243.  
  1244. fileprint_end()
  1245. {
  1246.      
  1247. }
  1248.  
  1249. fileprint_radiant_vec( vector )
  1250. {
  1251.      
  1252. }
  1253. is_mature()
  1254. {
  1255.     if ( level.onlineGame )
  1256.         return true;
  1257.     return GetDvarInt( #"cg_mature" );
  1258. }
  1259. is_german_build()
  1260. {
  1261.     if( GetDvar( #"language" ) == "german" )
  1262.     {
  1263.         return true;
  1264.     }
  1265.     return false;
  1266. }
  1267. is_gib_restricted_build()
  1268. {
  1269.     if( GetDvar( #"language" ) == "german" )
  1270.     {
  1271.         return true;
  1272.     }
  1273.     if( GetDvar( #"language" ) == "japanese" )
  1274.     {
  1275.         return true;
  1276.     }
  1277.     return false;
  1278. }
  1279. is_true(check)
  1280. {
  1281.     return(IsDefined(check) && check);
  1282. }
  1283. is_false(check)
  1284. {
  1285.     return(IsDefined(check) && !check);
  1286. }
  1287.  
  1288. has_spawnflag(spawnflags)
  1289. {
  1290.     if (IsDefined(self.spawnflags))
  1291.     {
  1292.         return ((self.spawnflags & spawnflags) == spawnflags);
  1293.     }
  1294.     return false;
  1295. }
  1296.  
  1297. clamp(val, val_min, val_max)
  1298. {
  1299.     if (val < val_min)
  1300.     {
  1301.         val = val_min;
  1302.     }
  1303.     else if (val > val_max)
  1304.     {
  1305.         val = val_max;
  1306.     }
  1307.     return val;
  1308. }
  1309.  
  1310. linear_map(num, min_a, max_a, min_b, max_b)
  1311. {
  1312.     return clamp(( (num - min_a) / (max_a - min_a) * (max_b - min_b) + min_b ), min_b, max_b);
  1313. }
  1314. death_notify_wrapper( attacker, damageType )
  1315. {
  1316.     level notify( "face", "death", self );
  1317.     self notify( "death", attacker, damageType );
  1318. }
  1319. damage_notify_wrapper( damage, attacker, direction_vec, point, type, modelName, tagName, partName, iDFlags )
  1320. {
  1321.     level notify( "face", "damage", self );
  1322.     self notify( "damage", damage, attacker, direction_vec, point, type, modelName, tagName, partName, iDFlags );
  1323. }
  1324. explode_notify_wrapper()
  1325. {
  1326.     level notify( "face", "explode", self );
  1327.     self notify( "explode" );
  1328. }
  1329. alert_notify_wrapper()
  1330. {
  1331.     level notify( "face", "alert", self );
  1332.     self notify( "alert" );
  1333. }
  1334. shoot_notify_wrapper()
  1335. {
  1336.     level notify( "face", "shoot", self );
  1337.     self notify( "shoot" );
  1338. }
  1339. melee_notify_wrapper()
  1340. {
  1341.     level notify( "face", "melee", self );
  1342.     self notify( "melee" );
  1343. }
  1344. isUsabilityEnabled()
  1345. {
  1346.     return ( !self.disabledUsability );
  1347. }
  1348. _disableUsability()
  1349. {
  1350.     self.disabledUsability++;
  1351.     self DisableUsability();
  1352. }
  1353. _enableUsability()
  1354. {
  1355.     self.disabledUsability--;
  1356.    
  1357.     assert( self.disabledUsability >= 0 );
  1358.    
  1359.     if ( !self.disabledUsability )
  1360.         self EnableUsability();
  1361. }
  1362. resetUsability()
  1363. {
  1364.     self.disabledUsability = 0;
  1365.     self EnableUsability();
  1366. }
  1367. _disableWeapon()
  1368. {
  1369.     self.disabledWeapon++;
  1370.     self disableWeapons();
  1371. }
  1372. _enableWeapon()
  1373. {
  1374.     self.disabledWeapon--;
  1375.    
  1376.     assert( self.disabledWeapon >= 0 );
  1377.    
  1378.     if ( !self.disabledWeapon )
  1379.         self enableWeapons();
  1380. }
  1381. isWeaponEnabled()
  1382. {
  1383.     return ( !self.disabledWeapon );
  1384. }
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!