1065 lines
30 KiB
Plaintext
1065 lines
30 KiB
Plaintext
#using scripts\codescripts\struct;
|
|
|
|
#using scripts\shared\array_shared;
|
|
#using scripts\shared\flag_shared;
|
|
#using scripts\shared\flagsys_shared;
|
|
#using scripts\shared\util_shared;
|
|
|
|
|
|
|
|
#namespace array;
|
|
|
|
/@
|
|
@/
|
|
function filter( &array, b_keep_keys, func_filter, arg1, arg2, arg3, arg4, arg5 )
|
|
{
|
|
a_new = [];
|
|
|
|
foreach ( key, val in array )
|
|
{
|
|
if ( util::single_func( self, func_filter, val, arg1, arg2, arg3, arg4, arg5 ) )
|
|
{
|
|
if ( IsString( key ) || IsWeapon( key ) )
|
|
{
|
|
// by default, string keys are kept
|
|
if ( isdefined( b_keep_keys ) && !b_keep_keys )
|
|
{
|
|
a_new[ a_new.size ] = val;
|
|
}
|
|
else
|
|
{
|
|
a_new[ key ] = val;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// by default, int keys are not kept
|
|
if ( ( isdefined( b_keep_keys ) && b_keep_keys ) )
|
|
{
|
|
a_new[ key ] = val;
|
|
}
|
|
else
|
|
{
|
|
a_new[ a_new.size ] = val;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return a_new;
|
|
}
|
|
|
|
/@
|
|
@/
|
|
function remove_undefined( array, b_keep_keys )
|
|
{
|
|
if ( IsDefined( b_keep_keys ) )
|
|
{
|
|
ArrayRemoveValue( array, undefined, b_keep_keys );
|
|
}
|
|
else
|
|
{
|
|
ArrayRemoveValue( array, undefined );
|
|
}
|
|
|
|
return array;
|
|
}
|
|
|
|
function get_touching( &array, b_keep_keys )
|
|
{
|
|
return filter( array, b_keep_keys, &IsTouching );
|
|
}
|
|
|
|
/@
|
|
"Name: array::remove_index( <array>, <index>, [b_keep_keys] )"
|
|
"Summary: Removes a specified index from an array, returns a new array with the specified index removed."
|
|
"Module: Array"
|
|
"MandatoryArg: <array> : The array we will remove an index from."
|
|
"MandatoryArg: <index> : The index we will remove from the array."
|
|
"OptionalArg: [b_keep_keys] : If true, retain existing keys. If false or undefined, existing keys of original array will be replaced by ints."
|
|
"Example: a_new = array::remove_index( array, 3 );"
|
|
"SPMP: both"
|
|
@/
|
|
function remove_index( array, index, b_keep_keys )
|
|
{
|
|
a_new = [];
|
|
|
|
foreach ( key, val in array )
|
|
{
|
|
if( key == index )
|
|
{
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
if ( ( isdefined( b_keep_keys ) && b_keep_keys ) )
|
|
{
|
|
a_new[ key ] = val;
|
|
}
|
|
else
|
|
{
|
|
a_new[ a_new.size ] = val;
|
|
}
|
|
}
|
|
}
|
|
|
|
return a_new;
|
|
}
|
|
|
|
/@
|
|
"Name: array::delete_all( <array> )"
|
|
"Summary: Delete all the elements in an array"
|
|
"Module: Array"
|
|
"MandatoryArg: <array> : The array whose elements to delete."
|
|
"Example: array::delete_all( GetAITeamArray( "axis" ) );"
|
|
"SPMP: both"
|
|
@/
|
|
function delete_all( &array, is_struct )
|
|
{
|
|
foreach ( ent in array )
|
|
{
|
|
if ( isdefined( ent ) )
|
|
{
|
|
if ( ( isdefined( is_struct ) && is_struct ) )
|
|
{
|
|
ent struct::delete();
|
|
}
|
|
else if ( isdefined( ent.__vtable ) )
|
|
{
|
|
ent notify( "death" ); ent = undefined; // class
|
|
}
|
|
else
|
|
{
|
|
ent Delete();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/@
|
|
"Name: array::notify_all( <array>, <notify> )"
|
|
"Summary: Sends a notify to every element within the array"
|
|
"Module: Utility"
|
|
"MandatoryArg: <array>: the array of entities to wait on"
|
|
"MandatoryArg: <notify>: the string notify sent to the elements"
|
|
"Example: array::notify_all( soldiers, "fire" );"
|
|
"SPMP: both"
|
|
@/
|
|
function notify_all( &array, str_notify )
|
|
{
|
|
foreach ( elem in array )
|
|
{
|
|
elem notify( str_notify );
|
|
}
|
|
}
|
|
|
|
/@
|
|
"Name: thread_all( <entities>, <func>, [arg1], [arg2], [arg3], [arg4], [arg5], [arg6] )"
|
|
"Summary: Threads the < func > function on every entity in the < entities > array. The entity will become "self" in the specified function."
|
|
"Module: Array"
|
|
"CallOn: "
|
|
"MandatoryArg: entities : array of entities to thread the function"
|
|
"MandatoryArg: func : pointer to a script function"
|
|
"OptionalArg: arg1: parameter 1 to pass to the func"
|
|
"OptionalArg: arg2 : parameter 2 to pass to the func"
|
|
"OptionalArg: arg3 : parameter 3 to pass to the func"
|
|
"OptionalArg: arg4 : parameter 4 to pass to the func"
|
|
"OptionalArg: arg5 : parameter 5 to pass to the func"
|
|
"OptionalArg: arg6 : parameter 6 to pass to the func"
|
|
"Example: array::thread_all( GetAITeamArray( "allies" ), &set_ignoreme, false );"
|
|
"SPMP: both"
|
|
@/
|
|
function thread_all( &entities, func, arg1, arg2, arg3, arg4, arg5, arg6 )
|
|
{
|
|
Assert( isdefined( entities ), "Undefined entity array passed to array::thread_all" );
|
|
Assert( isdefined( func ), "Undefined function passed to array::thread_all" );
|
|
|
|
if ( IsArray( entities ) )
|
|
{
|
|
if ( isdefined( arg6 ) )
|
|
{
|
|
foreach ( ent in entities )
|
|
{
|
|
ent thread [[ func ]]( arg1, arg2, arg3, arg4, arg5, arg6 );
|
|
}
|
|
}
|
|
else if ( isdefined( arg5 ) )
|
|
{
|
|
foreach ( ent in entities )
|
|
{
|
|
ent thread [[ func ]]( arg1, arg2, arg3, arg4, arg5 );
|
|
}
|
|
}
|
|
else if ( isdefined( arg4 ) )
|
|
{
|
|
foreach ( ent in entities )
|
|
{
|
|
ent thread [[ func ]]( arg1, arg2, arg3, arg4 );
|
|
}
|
|
}
|
|
else if ( isdefined( arg3 ) )
|
|
{
|
|
foreach ( ent in entities )
|
|
{
|
|
ent thread [[ func ]]( arg1, arg2, arg3 );
|
|
}
|
|
}
|
|
else if ( isdefined( arg2 ) )
|
|
{
|
|
foreach ( ent in entities )
|
|
{
|
|
ent thread [[ func ]]( arg1, arg2 );
|
|
}
|
|
}
|
|
else if ( isdefined( arg1 ) )
|
|
{
|
|
foreach ( ent in entities )
|
|
{
|
|
ent thread [[ func ]]( arg1 );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
foreach ( ent in entities )
|
|
{
|
|
ent thread [[ func ]]();
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
util::single_thread( entities, func, arg1, arg2, arg3, arg4, arg5, arg6 );
|
|
}
|
|
}
|
|
|
|
/@
|
|
"Name: thread_all_ents( <entities>, <func>, [arg1], [arg2], [arg3], [arg4], [arg5] )"
|
|
"Summary: Threads the <func> function on self for every entity in the <entities> array, passing the entity has the first argument."
|
|
"Module: Array"
|
|
"CallOn: NA"
|
|
"MandatoryArg: entities : array of entities to thread the function"
|
|
"MandatoryArg: func : pointer to a script function"
|
|
"OptionalArg: arg1 : parameter 1 to pass to the func (after the entity)"
|
|
"OptionalArg: arg2 : parameter 2 to pass to the func (after the entity)"
|
|
"OptionalArg: arg3 : parameter 3 to pass to the func (after the entity)"
|
|
"OptionalArg: arg4 : parameter 4 to pass to the func (after the entity)"
|
|
"OptionalArg: arg5 : parameter 5 to pass to the func (after the entity)"
|
|
"Example: array::thread_all_ents( GetAITeamArray( "allies" ), &do_something, false );"
|
|
"SPMP: both"
|
|
@/
|
|
function thread_all_ents( &entities, func, arg1, arg2, arg3, arg4, arg5 )
|
|
{
|
|
Assert( isdefined( entities ), "Undefined entity array passed to util::array_ent_thread" );
|
|
Assert( isdefined( func ), "Undefined function passed to util::array_ent_thread" );
|
|
|
|
if ( IsArray( entities ) )
|
|
{
|
|
if ( entities.size )
|
|
{
|
|
keys = GetArrayKeys( entities );
|
|
for ( i = 0; i < keys.size; i++ )
|
|
{
|
|
util::single_thread( self, func, entities[keys[i]], arg1, arg2, arg3, arg4, arg5 );
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
util::single_thread( self, func, entities, arg1, arg2, arg3, arg4, arg5 );
|
|
}
|
|
}
|
|
|
|
/@
|
|
"Name: run_all( <entities>, <func>, [arg1], [arg2], [arg3], [arg4], [arg5], [arg6] )"
|
|
"Summary: Runs the < func > function on every entity in the < entities > array. The entity will become "self" in the specified function."
|
|
"Module: Array"
|
|
"CallOn: "
|
|
"MandatoryArg: entities : array of entities to run the function"
|
|
"MandatoryArg: func : pointer to a script function"
|
|
"OptionalArg: arg1: parameter 1 to pass to the func"
|
|
"OptionalArg: arg2 : parameter 2 to pass to the func"
|
|
"OptionalArg: arg3 : parameter 3 to pass to the func"
|
|
"OptionalArg: arg4 : parameter 4 to pass to the func"
|
|
"OptionalArg: arg5 : parameter 5 to pass to the func"
|
|
"OptionalArg: arg6 : parameter 6 to pass to the func"
|
|
"Example: array::run_all( GetAITeamArray( "allies" ), &set_ignoreme, false );"
|
|
"SPMP: both"
|
|
@/
|
|
function run_all( &entities, func, arg1, arg2, arg3, arg4, arg5, arg6 )
|
|
{
|
|
Assert( isdefined( entities ), "Undefined entity array passed to array::run_all" );
|
|
Assert( isdefined( func ), "Undefined function passed to array::run_all" );
|
|
|
|
if ( IsArray( entities ) )
|
|
{
|
|
if ( isdefined( arg6 ) )
|
|
{
|
|
foreach ( ent in entities )
|
|
{
|
|
ent [[ func ]]( arg1, arg2, arg3, arg4, arg5, arg6 );
|
|
}
|
|
}
|
|
else if ( isdefined( arg5 ) )
|
|
{
|
|
foreach ( ent in entities )
|
|
{
|
|
ent [[ func ]]( arg1, arg2, arg3, arg4, arg5 );
|
|
}
|
|
}
|
|
else if ( isdefined( arg4 ) )
|
|
{
|
|
foreach ( ent in entities )
|
|
{
|
|
ent [[ func ]]( arg1, arg2, arg3, arg4 );
|
|
}
|
|
}
|
|
else if ( isdefined( arg3 ) )
|
|
{
|
|
foreach ( ent in entities )
|
|
{
|
|
ent [[ func ]]( arg1, arg2, arg3 );
|
|
}
|
|
}
|
|
else if ( isdefined( arg2 ) )
|
|
{
|
|
foreach ( ent in entities )
|
|
{
|
|
ent [[ func ]]( arg1, arg2 );
|
|
}
|
|
}
|
|
else if ( isdefined( arg1 ) )
|
|
{
|
|
foreach ( ent in entities )
|
|
{
|
|
ent [[ func ]]( arg1 );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
foreach ( ent in entities )
|
|
{
|
|
ent [[ func ]]();
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
util::single_func( entities, func, arg1, arg2, arg3, arg4, arg5, arg6 );
|
|
}
|
|
}
|
|
|
|
/@
|
|
"Name: array::exclude( <array> , <array_exclude> )"
|
|
"Summary: Returns an array excluding all members of < array_exclude > "
|
|
"Module: Array"
|
|
"CallOn: "
|
|
"MandatoryArg: <array> : Array containing all items"
|
|
"MandatoryArg: <array_exclude> : Array containing all items to remove or individual entity"
|
|
"Example: newArray = array::exclude( array1, array2 );"
|
|
"SPMP: both"
|
|
@/
|
|
function exclude( array, array_exclude )// returns "array" minus all members of array_exclude
|
|
{
|
|
newarray = array;
|
|
|
|
if ( IsArray( array_exclude ) )
|
|
{
|
|
for ( i = 0; i < array_exclude.size; i++ )
|
|
{
|
|
ArrayRemoveValue( newarray, array_exclude[ i ] );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ArrayRemoveValue( newarray, array_exclude );
|
|
}
|
|
|
|
return newarray;
|
|
}
|
|
|
|
/@
|
|
"Name: array::add( <array> , <item>, <allow_dupes> )"
|
|
"Summary: Adds <item> to <array>. Will not add the new value if undefined."
|
|
"Module: Array"
|
|
"MandatoryArg: <array> The array to add <item> to."
|
|
"MandatoryArg: <item> The item to be added. This can be anything."
|
|
"OptionalArg: <allow_dupes> If true, will add the new value if it already exists."
|
|
"Example: array::add( nodes, new_node );"
|
|
"SPMP: both"
|
|
@/
|
|
function add( &array, item, allow_dupes = true )
|
|
{
|
|
if ( isdefined( item ) )
|
|
{
|
|
if ( allow_dupes || !IsInArray( array, item ) )
|
|
{
|
|
array[ array.size ] = item;
|
|
}
|
|
}
|
|
|
|
return array;
|
|
}
|
|
|
|
/@
|
|
"Name: array::add_sorted( <array> , <item>, <allow_dupes> )"
|
|
"Summary: Adds <item> to <array> in sorted order from smallest to biggest. Will not add the new value if undefined."
|
|
"Module: Array"
|
|
"CallOn: "
|
|
"MandatoryArg: <array> The array to add <item> to."
|
|
"MandatoryArg: <item> The item to be added. This can be anything."
|
|
"OptionalArg: <allow_dupes> If true, will add the new value if it already exists."
|
|
"Example: array::add_sorted( a_numbers, 4 );"
|
|
"SPMP: both"
|
|
@/
|
|
function add_sorted( &array, item, allow_dupes = true )
|
|
{
|
|
if ( isdefined( item ) )
|
|
{
|
|
if ( allow_dupes || !IsInArray( array, item ) )
|
|
{
|
|
for ( i = 0; i <= array.size; i++ )
|
|
{
|
|
if ( ( i == array.size ) || ( item <= array[i] ) )
|
|
{
|
|
ArrayInsert( array, item, i );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/@
|
|
"Name: array::wait_till( <array>, <msg>, <n_timeout> )"
|
|
"Summary: waits for every entry in the <array> to recieve the <msg> notify, die, or n_timeout"
|
|
"Module: Utility"
|
|
"MandatoryArg: <array>: the array of entities to wait on"
|
|
"MandatoryArg: <msg>: the msg each array entity will wait on"
|
|
"OptionalArg: <n_timeout>: n_timeout to kill the wait prematurely"
|
|
"Example: array::wait_till( guys, "at the hq" );"
|
|
"SPMP: both"
|
|
@/
|
|
function wait_till( &array, msg, n_timeout )
|
|
{
|
|
if ( isdefined( n_timeout ) ) { __s = SpawnStruct(); __s endon( "timeout" ); __s util::delay_notify( n_timeout, "timeout" ); };
|
|
|
|
s_tracker = SpawnStruct();
|
|
s_tracker._wait_count = 0;
|
|
|
|
foreach ( ent in array )
|
|
{
|
|
if ( isdefined( ent ) )
|
|
{
|
|
ent thread util::timeout( n_timeout, &util::_waitlogic, s_tracker, msg );
|
|
}
|
|
}
|
|
|
|
if ( s_tracker._wait_count > 0 )
|
|
{
|
|
s_tracker waittill( "waitlogic_finished" );
|
|
}
|
|
}
|
|
|
|
/@
|
|
@/
|
|
function flag_wait( &array, str_flag )
|
|
{
|
|
for ( i = 0; i < array.size; i++ )
|
|
{
|
|
ent = array[i];
|
|
if ( !ent flag::get( str_flag ) )
|
|
{
|
|
ent waittill( str_flag );
|
|
i = -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
/@
|
|
@/
|
|
function flagsys_wait( &array, str_flag )
|
|
{
|
|
for ( i = 0; i < array.size; i++ )
|
|
{
|
|
ent = array[i];
|
|
if ( !ent flagsys::get( str_flag ) )
|
|
{
|
|
ent waittill( str_flag );
|
|
i = -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
/@
|
|
@/
|
|
function flagsys_wait_any_flag( &array, ... )
|
|
{
|
|
for ( i = 0; i < array.size; i++ )
|
|
{
|
|
ent = array[i];
|
|
|
|
if ( isdefined( ent ) )
|
|
{
|
|
b_flag_set = false;
|
|
foreach ( str_flag in vararg )
|
|
{
|
|
if ( ent flagsys::get( str_flag ) )
|
|
{
|
|
b_flag_set = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( !b_flag_set )
|
|
{
|
|
ent util::waittill_any_array( vararg );
|
|
i = -1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/@
|
|
@/
|
|
function flag_wait_clear( &array, str_flag )
|
|
{
|
|
for ( i = 0; i < array.size; i++ )
|
|
{
|
|
ent = array[i];
|
|
if ( ent flag::get( str_flag ) )
|
|
{
|
|
ent waittill( str_flag );
|
|
i = -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
/@
|
|
@/
|
|
function flagsys_wait_clear( &array, str_flag )
|
|
{
|
|
for ( i = 0; i < array.size; i++ )
|
|
{
|
|
ent = array[i];
|
|
if ( ent flagsys::get( str_flag ) )
|
|
{
|
|
ent waittill( str_flag );
|
|
i = -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
/@
|
|
"Name: wait_any( <array>, <msg>, <n_timeout> )"
|
|
"Summary: waits for any entry in the <array> to recieve the <msg> notify, die, or n_timeout"
|
|
"Module: Utility"
|
|
"MandatoryArg: <array>: the array of entities to wait on"
|
|
"MandatoryArg: <msg>: the msg each array entity will wait on"
|
|
"OptionalArg: <n_timeout>: n_timeout to kill the wait prematurely"
|
|
"Example: array_wait_any( guys, "at the hq" );"
|
|
"SPMP: both"
|
|
@/
|
|
function wait_any( array, msg, n_timeout )
|
|
{
|
|
if ( isdefined( n_timeout ) ) { __s = SpawnStruct(); __s endon( "timeout" ); __s util::delay_notify( n_timeout, "timeout" ); };
|
|
|
|
s_tracker = SpawnStruct();
|
|
|
|
a_structs = [];
|
|
foreach ( ent in array )
|
|
{
|
|
if ( isdefined( ent ) )
|
|
{
|
|
s = SpawnStruct();
|
|
s thread util::timeout( n_timeout, &_waitlogic2, s_tracker, ent, msg );
|
|
if ( !isdefined( a_structs ) ) a_structs = []; else if ( !IsArray( a_structs ) ) a_structs = array( a_structs ); a_structs[a_structs.size]=s;;
|
|
}
|
|
}
|
|
|
|
s_tracker endon( "array_wait" );
|
|
|
|
wait_till( array, "death" );
|
|
}
|
|
|
|
function _waitlogic2( s_tracker, ent, msg )
|
|
{
|
|
s_tracker endon( "array_wait" );
|
|
ent endon( "death" );
|
|
|
|
ent waittill( msg );
|
|
s_tracker notify( "array_wait" );
|
|
}
|
|
|
|
function flag_wait_any( array, str_flag )
|
|
{
|
|
self endon( "death" );
|
|
|
|
foreach ( ent in array )
|
|
{
|
|
if ( ent flag::get( str_flag ) )
|
|
{
|
|
return ent;
|
|
}
|
|
}
|
|
|
|
wait_any( array, str_flag );
|
|
}
|
|
|
|
/@
|
|
"Name: random( <array> )"
|
|
"Summary: returns a random element from the passed in array "
|
|
"Module: Array"
|
|
"Example: random_spawner = random( event_1_spawners );"
|
|
"MandatoryArg: <array> : the array from which to pluck a random element"
|
|
"SPMP: both"
|
|
@/
|
|
function random( array )
|
|
{
|
|
keys = GetArrayKeys( array );
|
|
return array[ keys[RandomInt( keys.size )] ];
|
|
}
|
|
|
|
/@
|
|
@/
|
|
function randomize( array )
|
|
{
|
|
for ( i = 0; i < array.size; i++ )
|
|
{
|
|
j = RandomInt( array.size );
|
|
temp = array[ i ];
|
|
array[ i ] = array[ j ];
|
|
array[ j ] = temp;
|
|
}
|
|
|
|
return array;
|
|
}
|
|
|
|
/@
|
|
"Name: array::reverse( <array> )"
|
|
"Summary: Reverses the order of the array and returns the new array."
|
|
"Module: Array"
|
|
"CallOn: "
|
|
"MandatoryArg: <array> : Array to be reversed."
|
|
"Example: patrol_nodes = array::reverse( patrol_nodes );"
|
|
"SPMP: both"
|
|
@/
|
|
function reverse( array )
|
|
{
|
|
a_array2 = [];
|
|
for ( i = array.size - 1; i >= 0; i-- )
|
|
{
|
|
a_array2[ a_array2.size ] = array[ i ];
|
|
}
|
|
|
|
return a_array2;
|
|
}
|
|
|
|
/@
|
|
@/
|
|
function remove_keys( array )
|
|
{
|
|
a_new = [];
|
|
|
|
foreach ( _, val in array )
|
|
{
|
|
if ( isdefined( val ) )
|
|
{
|
|
a_new[ a_new.size ] = val;
|
|
}
|
|
}
|
|
|
|
return a_new;
|
|
}
|
|
|
|
/@
|
|
@/
|
|
function swap( &array, index1, index2 )
|
|
{
|
|
assert( index1 < array.size, "index1 to swap out of range" );
|
|
assert( index2 < array.size, "index2 to swap out of range" );
|
|
|
|
temp = array[index1];
|
|
array[index1] = array[index2];
|
|
array[index2] = temp;
|
|
}
|
|
|
|
function pop( &array, index, b_keep_keys = true )
|
|
{
|
|
if ( array.size > 0 )
|
|
{
|
|
if ( !isdefined( index ) )
|
|
{
|
|
keys = GetArrayKeys( array );
|
|
index = keys[ 0 ];
|
|
}
|
|
|
|
if ( isdefined( array[index] ) )
|
|
{
|
|
ret = array[ index ];
|
|
|
|
ArrayRemoveIndex( array, index, b_keep_keys );
|
|
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
|
|
function pop_front( &array, b_keep_keys = true )
|
|
{
|
|
keys = GetArrayKeys( array );
|
|
index = keys[ keys.size - 1 ];
|
|
return pop( array, index, b_keep_keys );
|
|
}
|
|
|
|
function push( &array, val, index )
|
|
{
|
|
if ( !isdefined( index ) )
|
|
{
|
|
// use max free integer as index
|
|
index = 0;
|
|
foreach ( key in GetArrayKeys( array ) )
|
|
{
|
|
if ( IsInt( key ) && ( key >= index ) )
|
|
{
|
|
index = key + 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
ArrayInsert( array, val, index );
|
|
}
|
|
|
|
function push_front( &array, val )
|
|
{
|
|
push( array, val, 0 );
|
|
}
|
|
|
|
/@
|
|
"Name: get_closest( <org> , <array> , <dist> )"
|
|
"Summary: Returns the closest entity in < array > to location < org > "
|
|
"Module: Distance"
|
|
"CallOn: "
|
|
"MandatoryArg: <org> : Origin to be closest to."
|
|
"MandatoryArg: <array> : Array of entities to check distance on"
|
|
"OptionalArg: <dist> : Minimum distance to check"
|
|
"Example: friendly = util::get_closest( GetPlayers( localclientnum )[0].origin, allies );"
|
|
"SPMP: singleplayer"
|
|
@/
|
|
function get_closest( org, &array, dist = undefined)
|
|
{
|
|
assert( 0, "Deprecated function. Use 'ArrayGetClosest' instead." );
|
|
}
|
|
|
|
/@
|
|
"Name: getFarthest( <org> , <array> , <dist> )"
|
|
"Summary: Returns the farthest entity in < array > to location < org > "
|
|
"Module: Distance"
|
|
"CallOn: "
|
|
"MandatoryArg: <org> : Origin to be farthest from."
|
|
"MandatoryArg: <array> : Array of entities to check distance on"
|
|
"OptionalArg: <dist> : Maximum distance to check"
|
|
"Example: target = getFarthest( level.player.origin, targets );"
|
|
"SPMP: singleplayer"
|
|
@/
|
|
function get_farthest( org, &array, dist = undefined )
|
|
{
|
|
assert( 0, "Deprecated function. Use 'ArrayGetFarthest' instead." );
|
|
}
|
|
|
|
function closerFunc( dist1, dist2 )
|
|
{
|
|
return dist1 >= dist2;
|
|
}
|
|
|
|
function fartherFunc( dist1, dist2 )
|
|
{
|
|
return dist1 <= dist2;
|
|
}
|
|
|
|
/@
|
|
"Name: get_all_farthest( <org> , <array> , <excluders> , <max> )"
|
|
"Summary: Returns an array of all the entities in < array > sorted in order of farthest to closest."
|
|
"MandatoryArg: <org> : Origin to be farthest from."
|
|
"MandatoryArg: <array> : Array of entities (anything that contain .origin) to check distance on."
|
|
"OptionalArg: <excluders> : Array of entities to exclude from the check."
|
|
"OptionalArg: <max> : Max size of the array to return"
|
|
"Example: allies_sort = get_all_farthest( originFC1.origin, allies );"
|
|
"SPMP: singleplayer"
|
|
@/
|
|
function get_all_farthest( org, &array, excluders, max )
|
|
{
|
|
sorted_array = get_closest( org, array, excluders );
|
|
|
|
if(isdefined( max ))
|
|
{
|
|
temp_array = [];
|
|
for( i=0; i < sorted_array.size; i++)
|
|
{
|
|
temp_array[temp_array.size] = sorted_array[sorted_array.size - i];
|
|
}
|
|
sorted_array = temp_array;
|
|
}
|
|
|
|
sorted_array = array::reverse( sorted_array );
|
|
|
|
return( sorted_array );
|
|
}
|
|
|
|
/@
|
|
"Name: get_all_closest( <org> , <array> , <excluders> , <max>, <maxdist> )"
|
|
"Summary: Returns an array of all the entities in < array > sorted in order of closest to farthest."
|
|
"Module: Distance"
|
|
"CallOn: "
|
|
"MandatoryArg: <org> : Origin to be closest to."
|
|
"MandatoryArg: <array> : Array of entities to check distance on."
|
|
"OptionalArg: <excluders> : Array of entities to exclude from the check."
|
|
"OptionalArg: <max> : Max size of the array to return"
|
|
"OptionalArg: <maxdist> : Max distance from the origin to return acceptable entities"
|
|
"Example: allies_sort = get_all_closest( originFC1.origin, allies );"
|
|
"SPMP: singleplayer"
|
|
@/
|
|
function get_all_closest( org, &array, excluders, max, maxdist )
|
|
{
|
|
// pass an array of entities to this function and it will return them in the order of closest
|
|
// to the origin you pass, you can also set max to limit how many ents get returned
|
|
if( !isdefined( max ) )
|
|
max = array.size;
|
|
if( !isdefined( excluders ) )
|
|
excluders = [];
|
|
|
|
maxdists2rd = undefined;
|
|
if( isdefined( maxdist ) )
|
|
maxdists2rd = maxdist * maxdist;
|
|
|
|
// return the array, reordered from closest to farthest
|
|
dist = [];
|
|
index = [];
|
|
for( i = 0;i < array.size;i ++ )
|
|
{
|
|
if(!isdefined(array[i]))
|
|
continue;
|
|
|
|
excluded = false;
|
|
for( p = 0;p < excluders.size;p ++ )
|
|
{
|
|
if( array[ i ] != excluders[ p ] )
|
|
continue;
|
|
excluded = true;
|
|
break;
|
|
}
|
|
if( excluded )
|
|
continue;
|
|
|
|
length = distancesquared( org, array[ i ].origin );
|
|
|
|
if( isdefined( maxdists2rd ) && maxdists2rd < length )
|
|
continue;
|
|
|
|
dist[ dist.size ] = length;
|
|
|
|
|
|
index[ index.size ] = i;
|
|
}
|
|
|
|
for( ;; )
|
|
{
|
|
change = false;
|
|
for( i = 0;i < dist.size - 1;i ++ )
|
|
{
|
|
if( dist[ i ] <= dist[ i + 1 ] )
|
|
continue;
|
|
change = true;
|
|
temp = dist[ i ];
|
|
dist[ i ] = dist[ i + 1 ];
|
|
dist[ i + 1 ] = temp;
|
|
temp = index[ i ];
|
|
index[ i ] = index[ i + 1 ];
|
|
index[ i + 1 ] = temp;
|
|
}
|
|
if( !change )
|
|
break;
|
|
}
|
|
|
|
newArray = [];
|
|
if( max > dist.size )
|
|
max = dist.size;
|
|
for( i = 0;i < max;i ++ )
|
|
newArray[ i ] = array[ index[ i ] ];
|
|
return newArray;
|
|
}
|
|
|
|
function alphabetize( &array )
|
|
{
|
|
return sort_by_value( array, true );
|
|
}
|
|
|
|
/@
|
|
function Name: sort_by_value( array, b_lowest_first = true )
|
|
Summary: sorts a list of ents by their value
|
|
Module: Utility
|
|
CallOn: n/a
|
|
ManditoryArg: <array>: array of values to sort
|
|
OptionalArg: [b_lowest_first]: sort from lowest to highest
|
|
function Example: list = array::sort_by_value( array );
|
|
SPMP: singleplayer
|
|
@/
|
|
//Use ArraySort for distance based sorting of entities
|
|
function sort_by_value( &array, b_lowest_first = false )
|
|
{
|
|
return merge_sort( array, &_sort_by_value_compare_func, b_lowest_first );
|
|
}
|
|
|
|
function _sort_by_value_compare_func( val1, val2, b_lowest_first )
|
|
{
|
|
if ( b_lowest_first )
|
|
{
|
|
return val1 < val2;
|
|
}
|
|
else
|
|
{
|
|
return val1 > val2;
|
|
}
|
|
}
|
|
|
|
/@
|
|
function Name: sort_by_script_int( a_ents, b_lowest_first = true )
|
|
Summary: sorts a list of ents by their script_int value
|
|
Module: Utility
|
|
CallOn: n/a
|
|
ManditoryArg: <a_ents>: array of entities to sort
|
|
OptionalArg: [b_lowest_first]: sort from lowest to highest
|
|
function Example: list = array::sort_by_script_int( a_ents );
|
|
SPMP: singleplayer
|
|
@/
|
|
//Use ArraySort for distance based sorting of entities
|
|
function sort_by_script_int( &a_ents, b_lowest_first = false )
|
|
{
|
|
return merge_sort( a_ents, &_sort_by_script_int_compare_func, b_lowest_first );
|
|
}
|
|
|
|
function _sort_by_script_int_compare_func( e1, e2, b_lowest_first )
|
|
{
|
|
if ( b_lowest_first )
|
|
{
|
|
return e1.script_int < e2.script_int;
|
|
}
|
|
else
|
|
{
|
|
return e1.script_int > e2.script_int;
|
|
}
|
|
}
|
|
|
|
function merge_sort( ¤t_list, func_sort, param )
|
|
{
|
|
if ( current_list.size <= 1 )
|
|
{
|
|
return current_list;
|
|
}
|
|
|
|
left = [];
|
|
right = [];
|
|
|
|
middle = current_list.size / 2;
|
|
|
|
for ( x = 0; x < middle; x++ )
|
|
{
|
|
if ( !isdefined( left ) ) left = []; else if ( !IsArray( left ) ) left = array( left ); left[left.size]=current_list[ x ];;
|
|
}
|
|
|
|
for ( ; x < current_list.size; x++ )
|
|
{
|
|
if ( !isdefined( right ) ) right = []; else if ( !IsArray( right ) ) right = array( right ); right[right.size]=current_list[ x ];;
|
|
}
|
|
|
|
left = merge_sort( left, func_sort, param );
|
|
right = merge_sort( right, func_sort, param );
|
|
|
|
result = merge( left, right, func_sort, param );
|
|
|
|
return result;
|
|
}
|
|
|
|
function merge( left, right, func_sort, param )
|
|
{
|
|
result = [];
|
|
|
|
li = 0;
|
|
ri = 0;
|
|
while ( li < left.size && ri < right.size )
|
|
{
|
|
b_result = undefined;
|
|
|
|
if ( isdefined( param ) )
|
|
{
|
|
b_result = [[ func_sort ]]( left[ li ], right[ ri ], param );
|
|
}
|
|
else
|
|
{
|
|
b_result = [[ func_sort ]]( left[ li ], right[ ri ] );
|
|
}
|
|
|
|
if ( b_result )
|
|
{
|
|
result[ result.size ] = left[ li ];
|
|
li++;
|
|
}
|
|
else
|
|
{
|
|
result[ result.size ] = right[ ri ];
|
|
ri++;
|
|
}
|
|
}
|
|
|
|
while ( li < left.size )
|
|
{
|
|
result[ result.size ] = left[ li ];
|
|
li++;
|
|
}
|
|
|
|
while ( ri < right.size )
|
|
{
|
|
result[ result.size ] = right[ ri ];
|
|
ri++;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/@
|
|
"Name: spread_all( <entities> , <process> , <var1> , <var2> , <var3> )"
|
|
"Summary: Threads the < process > function on every entity in the < entities > array. Each thread is started 1 network frame apart from the next."
|
|
"Module: Array"
|
|
"CallOn: "
|
|
"MandatoryArg: <entities> : array of entities to thread the process"
|
|
"MandatoryArg: <process> : pointer to a script function"
|
|
"OptionalArg: <var1> : parameter 1 to pass to the process"
|
|
"OptionalArg: <var2> : parameter 2 to pass to the process"
|
|
"OptionalArg: <var3> : parameter 3 to pass to the process"
|
|
"Example: array::spread_all( GetAITeamArray( "allies" ),&set_ignoreme, false );"
|
|
"SPMP: Both"
|
|
@/
|
|
|
|
function spread_all( &entities, func, arg1, arg2, arg3, arg4, arg5 )
|
|
{
|
|
Assert( isdefined( entities ), "Undefined entity array passed to array::spread_all_ents" );
|
|
Assert( isdefined( func ), "Undefined function passed to array::spread_all_ents" );
|
|
|
|
if ( IsArray( entities ) )
|
|
{
|
|
foreach ( ent in entities )
|
|
{
|
|
util::single_thread( ent, func, arg1, arg2, arg3, arg4, arg5 );
|
|
wait randomfloatrange(.1-.1/3,.1+.1/3);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
util::single_thread( entities, func, arg1, arg2, arg3, arg4, arg5 );
|
|
wait randomfloatrange(.1-.1/3,.1+.1/3);
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|