371 lines
7.8 KiB
Plaintext
371 lines
7.8 KiB
Plaintext
#include maps\_utility;
|
|
#include common_scripts\utility;
|
|
#include maps\_mgTurret;
|
|
|
|
gunner_think( turret )
|
|
{
|
|
self endon( "death" );
|
|
self notify( "end_mg_behavior" );
|
|
self endon( "end_mg_behavior" );
|
|
|
|
self.can_fire_turret = true;
|
|
self.wants_to_fire = false;
|
|
|
|
if ( !use_the_turret( turret ) )
|
|
{
|
|
self notify( "continue_cover_script" );
|
|
return;
|
|
}
|
|
|
|
// clear it so that it can be set by record_enemy_sightings fresh
|
|
self.last_enemy_sighting_position = undefined;
|
|
thread record_enemy_sightings();
|
|
|
|
forward = anglestoforward( turret.angles );
|
|
|
|
ent = spawn( "script_origin", ( 0, 0, 0 ) );
|
|
thread target_ent_cleanup( ent );
|
|
|
|
// ent setmodel( "temp" );
|
|
ent.origin = turret.origin + vector_multiply( forward, 500 );
|
|
|
|
if ( isdefined( self.last_enemy_sighting_position ) )
|
|
{
|
|
// jump to the enemy sight position so we start "on target"
|
|
ent.origin = self.last_enemy_sighting_position;
|
|
}
|
|
|
|
turret setTargetEntity( ent );
|
|
|
|
enemy = undefined;
|
|
|
|
for ( ;; )
|
|
{
|
|
if ( !isalive( self.current_enemy ) )
|
|
{
|
|
self stop_firing();
|
|
self waittill( "new_enemy" );
|
|
}
|
|
|
|
self start_firing();
|
|
shoot_enemy_until_he_hides_then_shoot_wall( ent );
|
|
|
|
// do we still have an enemy?
|
|
if ( !isalive( self.current_enemy ) )
|
|
continue;
|
|
|
|
// is he hiding from us?
|
|
if ( self canSee( self.current_enemy ) )
|
|
continue;
|
|
|
|
// if so then try to find a new angle on him
|
|
// find_a_new_turret_spot( ent );
|
|
self waittill( "saw_enemy" );
|
|
}
|
|
}
|
|
|
|
target_ent_cleanup( ent )
|
|
{
|
|
waittill_either( "death", "end_mg_behavior" );
|
|
ent delete();
|
|
}
|
|
|
|
|
|
shoot_enemy_until_he_hides_then_shoot_wall( ent )
|
|
{
|
|
self endon( "death" );
|
|
self endon( "new_enemy" );
|
|
self.current_enemy endon( "death" );
|
|
enemy = self.current_enemy;
|
|
|
|
// shoot at the enemy while we can see him
|
|
while ( self canSee( enemy ) )
|
|
{
|
|
// line ( enemy geteye(), ent.origin, (1,0,1), 1, 10 );
|
|
angles = vectortoangles( enemy geteye() - ent.origin );
|
|
angles = anglestoforward( angles );
|
|
ent moveto( ent.origin + vector_multiply( angles, 12 ), 0.1 );
|
|
wait( 0.1 );
|
|
}
|
|
|
|
if ( isplayer( enemy ) )
|
|
{
|
|
// shoot into the wall in the direction he exited our vision, then bring it back
|
|
|
|
self endon( "saw_enemy" );
|
|
|
|
eye = enemy geteye();
|
|
angles = vectortoangles( eye - ent.origin );
|
|
angles = anglestoforward( angles );
|
|
|
|
units_per_second = 150;
|
|
timer = distance( ent.origin, self.last_enemy_sighting_position ) / units_per_second;
|
|
if ( timer > 0 )
|
|
{
|
|
ent moveto( self.last_enemy_sighting_position, timer );
|
|
wait( timer );
|
|
}
|
|
|
|
// oldOrigin = get_suppress_point( self geteye(), ent.origin, ent.origin + vector_multiply( angles, 80 ) );
|
|
org = ent.origin + vector_multiply( angles, 180 );
|
|
oldOrigin = get_suppress_point( self geteye(), ent.origin, org );
|
|
if ( !isdefined( oldOrigin ) )
|
|
oldOrigin = ent.origin;
|
|
|
|
ent moveto( ent.origin + vector_multiply( angles, 80 ) + ( 0, 0, randomfloatrange( 15, 50 ) * - 1 ), 3, 1, 1 );
|
|
wait( 3.5 );
|
|
ent moveto( oldOrigin + vector_multiply( angles, -20 ), 3, 1, 1 );
|
|
}
|
|
|
|
wait( randomfloatrange( 2.5, 4 ) );
|
|
self stop_firing();
|
|
}
|
|
|
|
set_firing( val )
|
|
{
|
|
if ( val )
|
|
{
|
|
self.can_fire_turret = true;
|
|
if ( self.wants_to_fire )
|
|
{
|
|
self.turret notify( "startfiring" );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
self.can_fire_turret = false;
|
|
self.turret notify( "stopfiring" );
|
|
}
|
|
}
|
|
|
|
stop_firing()
|
|
{
|
|
self.wants_to_fire = false;
|
|
|
|
self.turret notify( "stopfiring" );
|
|
}
|
|
|
|
start_firing()
|
|
{
|
|
self.wants_to_fire = true;
|
|
if ( self.can_fire_turret )
|
|
{
|
|
self.turret notify( "startfiring" );
|
|
}
|
|
}
|
|
|
|
create_mg_team()
|
|
{
|
|
// the guys that spawn on the same frame and have "mgpair" get put together
|
|
// when one dies, the other gets ANGRY
|
|
|
|
if ( isdefined( level.mg_gunner_team ) )
|
|
{
|
|
level.mg_gunner_team[ level.mg_gunner_team.size ] = self;
|
|
return;
|
|
}
|
|
|
|
level.mg_gunner_team = [];
|
|
level.mg_gunner_team[ level.mg_gunner_team.size ] = self;
|
|
waittillframeend;// so everybody who spawns in this frame can get in the team
|
|
|
|
ent = spawnstruct();
|
|
array_thread( level.mg_gunner_team, ::mg_gunner_death_notify, ent );
|
|
|
|
array = level.mg_gunner_team;
|
|
level.mg_gunner_team = undefined;// for the next team that spawns
|
|
|
|
ent waittill( "gunner_died" );
|
|
|
|
for ( i = 0; i < array.size; i++ )
|
|
{
|
|
if ( !isalive( array[ i ] ) )
|
|
continue;
|
|
|
|
array[ i ] notify( "stop_using_built_in_burst_fire" );
|
|
array[ i ] thread solo_fires();
|
|
}
|
|
}
|
|
|
|
mg_gunner_death_notify( ent )
|
|
{
|
|
self waittill( "death" );
|
|
ent notify( "gunner_died" );
|
|
}
|
|
|
|
|
|
|
|
|
|
mgTeam_take_turns_firing( mgTeam )
|
|
{
|
|
wait( 1 );// wait for the guy to get on the turret
|
|
level notify( "new_mg_firing_team" + mgTeam[ 0 ].script_noteworthy );
|
|
level endon( "new_mg_firing_team" + mgTeam[ 0 ].script_noteworthy );
|
|
|
|
for ( ;; )
|
|
{
|
|
dual_firing( mgTeam );
|
|
solo_firing( mgTeam );
|
|
}
|
|
}
|
|
|
|
solo_firing( mgTeam )
|
|
{
|
|
mgGunner = undefined;
|
|
for ( i = 0; i < mgTeam.size; i++ )
|
|
{
|
|
if ( !isalive( mgTeam[ i ] ) )
|
|
continue;
|
|
mgGunner = mgTeam[ i ];
|
|
break;
|
|
}
|
|
if ( !isdefined( mgGunner ) )
|
|
return;
|
|
|
|
// mgGunner solo_fires(); changed solo fires
|
|
}
|
|
|
|
solo_fires()
|
|
{
|
|
self endon( "death" );
|
|
for ( ;; )
|
|
{
|
|
//self set_firing( true );
|
|
self.turret startFiring();
|
|
wait( randomfloatrange( 0.3, 0.7 ) );
|
|
|
|
//self set_firing( false );
|
|
self.turret stopFiring();
|
|
wait( randomfloatrange( 0.1, 1.1 ) );
|
|
}
|
|
}
|
|
|
|
dual_firing( mgTeam )
|
|
{
|
|
for ( i = 0;i < mgTeam.size; i++ )
|
|
mgTeam[ i ] endon( "death" );
|
|
|
|
a = 0;
|
|
b = 1;
|
|
|
|
for ( ;; )
|
|
{
|
|
if ( isalive( mgTeam[ a ] ) )
|
|
mgTeam[ a ] set_firing( true );
|
|
|
|
if ( isalive( mgTeam[ b ] ) )
|
|
mgTeam[ b ] set_firing( false );
|
|
|
|
c = a;
|
|
a = b;
|
|
b = c;
|
|
wait( randomfloatrange( 2.3, 3.5 ) );
|
|
}
|
|
}
|
|
|
|
|
|
spotted_an_enemy( ent, enemy )
|
|
{
|
|
self start_firing();
|
|
// saw a new enemy
|
|
self endon( "death" );
|
|
self endon( "new_enemy" );
|
|
enemy endon( "death" );
|
|
|
|
while ( self canSee( enemy ) )
|
|
{
|
|
// line ( enemy geteye(), ent.origin, (1,0,1), 1, 10 );
|
|
angles = vectortoangles( enemy geteye() - ent.origin );
|
|
angles = anglestoforward( angles );
|
|
ent moveto( ent.origin + vector_multiply( angles, 10 ), 0.2 );
|
|
wait( 0.2 );
|
|
}
|
|
|
|
angles = vectortoangles( enemy geteye() - ent.origin );
|
|
angles = anglestoforward( angles );
|
|
|
|
units_per_second = 150;
|
|
timer = distance( ent.origin, self.last_enemy_sighting_position ) / units_per_second;
|
|
ent moveto( self.last_enemy_sighting_position, timer );
|
|
wait( timer );
|
|
oldOrigin = ent.origin;
|
|
ent moveto( ent.origin + vector_multiply( angles, 80 ) + ( 0, 0, -25 ), 3, 1, 1 );
|
|
wait( 3.5 );
|
|
ent moveto( oldOrigin + vector_multiply( angles, -20 ), 3, 1, 1 );
|
|
wait( 1 );
|
|
self stop_firing();
|
|
}
|
|
|
|
|
|
get_suppress_point( origin, trace_start, trace_end )
|
|
{
|
|
traces = distance( trace_start, trace_end ) * 0.05;
|
|
|
|
if ( traces < 5 )
|
|
traces = 5;
|
|
if ( traces > 20 )
|
|
traces = 20;// cap it
|
|
|
|
vectorDif = trace_end - trace_start;
|
|
vectorDif = ( vectorDif[ 0 ] / traces, vectorDif[ 1 ] / traces, vectorDif[ 2 ] / traces );
|
|
|
|
// print3d( origin, "*", (0,1,1), 1, 5, 240 );
|
|
// print3d( trace_end, "*", (0,1,0), 1, 5, 240 );
|
|
// print3d( trace_start, "*", (0,0,1), 1, 5, 240 );
|
|
|
|
offset = ( 0, 0, 0 );
|
|
|
|
hit_pos = undefined;
|
|
for ( i = 0; i < traces + 2; i++ )
|
|
{
|
|
// print3d( trace_end + offset, "*", (1,0,0), 1, 5, 40 );
|
|
|
|
trace = bullettrace( origin, trace_start + offset, false, undefined );
|
|
if ( trace[ "fraction" ] < 1 )
|
|
{
|
|
// thread linetime( origin, trace["position"], ( 1,0,0 ), 10 );
|
|
hit_pos = trace[ "position" ];
|
|
break;
|
|
}
|
|
// thread linetime( origin, trace["position"], ( 0,1,0 ), 10 );
|
|
|
|
// print3d( trace[ "position" ], "*", (1,1,0), 1, 5, 40 );
|
|
offset += vectorDif;
|
|
}
|
|
|
|
return hit_pos;
|
|
}
|
|
|
|
record_enemy_sightings()
|
|
{
|
|
self endon( "death" );
|
|
self endon( "end_mg_behavior" );
|
|
|
|
self.current_enemy = undefined;
|
|
for ( ;; )
|
|
{
|
|
record_sighting();
|
|
wait( 0.05 );
|
|
}
|
|
}
|
|
|
|
record_sighting()
|
|
{
|
|
if ( !isalive( self.enemy ) )
|
|
return;
|
|
|
|
if ( !( self canSee( self.enemy ) ) )
|
|
return;
|
|
|
|
self.last_enemy_sighting_position = self.enemy geteye();
|
|
|
|
self notify( "saw_enemy" );
|
|
if ( !isalive( self.current_enemy ) || self.current_enemy != self.enemy )
|
|
{
|
|
self.current_enemy = self.enemy;
|
|
self notify( "new_enemy" );
|
|
}
|
|
}
|
|
|
|
|