mirror of
https://github.com/reaaLx/nx1-gsc-dump.git
synced 2025-04-22 00:55:46 +00:00
231 lines
6.6 KiB
Plaintext
231 lines
6.6 KiB
Plaintext
#include maps\_utility;
|
|
#include common_scripts\utility;
|
|
|
|
/*
|
|
=============
|
|
Using Crowds for Fun and Profit
|
|
|
|
INCLUDING:
|
|
-In your .csv, add the following line:
|
|
include, nx_crowd_controller
|
|
-In your .gsc, add the following line to your main() function:
|
|
maps\nx_crowd_controller::main();
|
|
|
|
//////////////////////
|
|
SETTING UP A CROWD:
|
|
|
|
Crowds are created by calling the function maps\nx_crowd_controller::new_crowd( name, count, spawners, starts, ends, <minInterval>, <maxInterval> )
|
|
|
|
When the crowd is done spawning, the level will notify with the name you supplied.
|
|
For example, if you named your crowd "dudes" the level will notify "dudes".
|
|
|
|
|
|
Required args:
|
|
name: A name that can be used to identify this crowd.
|
|
count: The number of drones to spawn in this crowd.
|
|
spawners: An array of spawner entities to populate this crowd.
|
|
starts: An array of entities that the spawners can spawn at.
|
|
ends: An array of entities that the spawners will travel to once they are spawned in. If these entities have targets, the spawned drone will follow
|
|
each target like a chain until it reaches an entity with no targets. See map nx_crowd for an example.
|
|
minInterval: The minimum amount of time to wait between each actor spawn (defaults to 0.5 seconds).
|
|
maxInterval: The maximum amount of time to wait between each actor spawn (defaults to minInterval).
|
|
The interval time will be a random value between minInterval and maxInterval.
|
|
|
|
Example:
|
|
maps\nx_crowd_controller::new_crowd( "ewoks", 12, ewok_spawners, start_nodes, end_nodes, 0.5, 2.0 );
|
|
|
|
//////////////////////
|
|
SPAWNING A CROWD:
|
|
Once you have created a crowd with new_crowd, call maps\nx_crowd_controller::spawn_crowd( name ) to spawn the crowd and let it run.
|
|
|
|
Required args:
|
|
name: The name of the crowd (should match the name supplied to new_crowd).
|
|
|
|
Example:
|
|
maps\nx_crowd_controller::spawn_crowd( "ewoks" );
|
|
//Now, you can wait for the crowd to finish spawning by calling:
|
|
level waittill( "ewoks" );
|
|
|
|
//////////////////////
|
|
|
|
=============
|
|
*/
|
|
|
|
|
|
main( attributes )
|
|
{
|
|
level.crowds = [];
|
|
}
|
|
|
|
init_crowd( name, count, spawners, starts, minInterval, maxInterval )
|
|
{
|
|
if( !IsDefined( name ) || !IsDefined( count ) || !IsDefined( spawners ) || !IsDefined( starts ) )
|
|
return;
|
|
|
|
level.crowds[ name ] = [];
|
|
level.crowds[ name ][ "count" ] = count;
|
|
level.crowds[ name ][ "spawner" ] = spawners;
|
|
level.crowds[ name ][ "start" ] = starts;
|
|
level.crowds[ name ][ "number" ] = 0;
|
|
|
|
minTime = 0.5;
|
|
if( IsDefined( minInterval ) && minInterval >= 0.5 )
|
|
minTime = minInterval;
|
|
level.crowds[ "minInterval" ] = minTime;
|
|
|
|
maxTime = level.crowds[ "minInterval" ];
|
|
if( IsDefined( maxInterval ) && maxInterval >= level.crowds[ "minInterval" ] )
|
|
maxTime = maxInterval;
|
|
level.crowds[ "maxInterval" ] = maxTime;
|
|
|
|
foreach( spawner in level.crowds[ name ][ "spawner" ] )
|
|
{
|
|
spawner add_spawn_function( ::crowd_actor_update, name );
|
|
}
|
|
|
|
return name;
|
|
}
|
|
|
|
new_crowd( name, count, spawners, starts, ends, minInterval, maxInterval )
|
|
{
|
|
// NOTE: use init_crowd() from now on
|
|
|
|
// if( !IsDefined( name ) || !IsDefined( count ) || !IsDefined( spawners ) || !IsDefined( starts ) || !IsDefined( ends ) )
|
|
// return;
|
|
//
|
|
// level.crowds[ name ] = [];
|
|
// level.crowds[ name ][ "count" ] = count;
|
|
// level.crowds[ name ][ "spawner" ] = spawners;
|
|
// level.crowds[ name ][ "start" ] = starts;
|
|
// level.crowds[ name ][ "end" ] = ends;
|
|
//
|
|
//
|
|
// minTime = 0.5;
|
|
// if( IsDefined( minInterval ) && minInterval >= 0.5 )
|
|
// minTime = minInterval;
|
|
// level.crowds[ "minInterval" ] = minTime;
|
|
//
|
|
// maxTime = level.crowds[ "minInterval" ];
|
|
// if( IsDefined( maxInterval ) && maxInterval >= level.crowds[ "minInterval" ] )
|
|
// maxTime = maxInterval;
|
|
// level.crowds[ "maxInterval" ] = maxTime;
|
|
//
|
|
// foreach( spawner in level.crowds[ name ][ "spawner" ] )
|
|
// {
|
|
// spawner add_spawn_function( ::crowd_actor_update );
|
|
// }
|
|
//
|
|
// return name;
|
|
}
|
|
|
|
crowd_actor_update( name )
|
|
{
|
|
self endon( "death" );
|
|
|
|
level.crowds[ name ][ "number" ]++;
|
|
thread crowd_actor_death( name );
|
|
|
|
while( 1 )
|
|
{
|
|
self waittill( "goal" );
|
|
|
|
// AI treat each node in the path as a separate goal
|
|
// Drones only treat the last node in the path as a goal.
|
|
curTarget = GetEnt( self.target, "targetname" );
|
|
if( IsAI( self ) && IsDefined( curTarget.target ) && IsDefined( GetEnt( curTarget.target, "targetname" ) ) )
|
|
self.target = curTarget.target;
|
|
else
|
|
self Delete();
|
|
}
|
|
}
|
|
|
|
crowd_actor_death( name )
|
|
{
|
|
self waittill( "death" );
|
|
|
|
level.crowds[ name ][ "number" ]--;
|
|
}
|
|
|
|
spawn_crowd( name, kill_flag )
|
|
{
|
|
if( !IsDefined( level.crowds[ name ] ) )
|
|
return;
|
|
|
|
level thread spawn_crowd_actors( name, kill_flag );
|
|
}
|
|
|
|
spawn_crowd_actors( name, kill_flag )
|
|
{
|
|
// tagBR< note >: It was possible, because of the wait at the end of this script, for crowds to spawn
|
|
// after they've been deleted. This kill_flag insures this won't happen.
|
|
if ( IsDefined( kill_flag ) )
|
|
{
|
|
level endon( kill_flag );
|
|
}
|
|
|
|
crowd = level.crowds[ name ];
|
|
|
|
for( i = 0; i < crowd[ "count" ]; i++ )
|
|
{
|
|
start = random( crowd[ "start" ] );
|
|
spawner = random( crowd[ "spawner" ] );
|
|
spawner.target = start.targetname;
|
|
spawner.count = -1;
|
|
|
|
ai = spawner spawn_ai( true );
|
|
|
|
if( IsDefined( ai ) )
|
|
{
|
|
if( IsAI( ai ) )
|
|
ai ForceTeleport( start.origin, start.angles );
|
|
else
|
|
ai.origin = start.origin;
|
|
}
|
|
|
|
if( level.crowds[ "maxInterval" ] > level.crowds[ "minInterval" ] )
|
|
wait RandomFloatRange( level.crowds[ "minInterval" ], level.crowds[ "maxInterval" ] );
|
|
else
|
|
wait level.crowds[ "minInterval" ];
|
|
}
|
|
|
|
level notify ( name );
|
|
}
|
|
|
|
//spawn_crowd_actors( name, kill_flag )
|
|
//{
|
|
// // tagBR< note >: It was possible, because of the wait at the end of this script, for crowds to spawn
|
|
// // after they've been deleted. This kill_flag insures this won't happen.
|
|
// if ( IsDefined( kill_flag ) )
|
|
// {
|
|
// level endon( kill_flag );
|
|
// }
|
|
//
|
|
// crowd = level.crowds[ name ];
|
|
//
|
|
// for( i = 0; i < crowd[ "count" ]; i++ )
|
|
// {
|
|
// start = random( crowd[ "start" ] );
|
|
// end = random( crowd[ "end" ] );
|
|
// spawner = random( crowd[ "spawner" ] );
|
|
// spawner.target = end.targetname;
|
|
// spawner.count = -1;
|
|
//
|
|
// ai = spawner spawn_ai( true );
|
|
//
|
|
// if( IsDefined( ai ) )
|
|
// {
|
|
// if( IsAI( ai ) )
|
|
// ai ForceTeleport( start.origin, start.angles );
|
|
// else
|
|
// ai.origin = start.origin;
|
|
// }
|
|
//
|
|
// if( level.crowds[ "maxInterval" ] > level.crowds[ "minInterval" ] )
|
|
// wait RandomFloatRange( level.crowds[ "minInterval" ], level.crowds[ "maxInterval" ] );
|
|
// else
|
|
// wait level.crowds[ "minInterval" ];
|
|
// }
|
|
//
|
|
// level notify ( name );
|
|
//}
|