_proximity_grenade.gsc

Go to the documentation of this file.

#using scripts\codescripts\struct;
 
#using scripts\shared\callbacks_shared;
#using scripts\shared\challenges_shared;
#using scripts\shared\clientfield_shared;
#using scripts\shared\scoreevents_shared;
#using scripts\shared\system_shared;
#using scripts\shared\weapons\_weaponobjects;
#using scripts\shared\util_shared;
 
#insert scripts\shared\shared.gsh;
#insert scripts\shared\version.gsh;
 
#precache( "fx", "weapon/fx_prox_grenade_scan_blue" );
#precache( "fx", "weapon/fx_prox_grenade_wrn_grn" );
#precache( "fx", "weapon/fx_prox_grenade_scan_orng" );
#precache( "fx", "weapon/fx_prox_grenade_wrn_red" );
#precache( "fx", "weapon/fx_prox_grenade_impact_player_spwner" );
#precache( "fx", "weapon/fx_prox_grenade_elec_jump" );
 
#namespace proximity_grenade;
 
function ‪init_shared()
{
    level._effect["prox_grenade_friendly_default"] = "weapon/fx_prox_grenade_scan_blue";
    level._effect["prox_grenade_friendly_warning"] = "weapon/fx_prox_grenade_wrn_grn";
    level._effect["prox_grenade_enemy_default"] = "weapon/fx_prox_grenade_scan_orng";
    level._effect["prox_grenade_enemy_warning"] = "weapon/fx_prox_grenade_wrn_red";
    level._effect["prox_grenade_player_shock"] = "weapon/fx_prox_grenade_impact_player_spwner";
    level._effect["prox_grenade_chain_bolt"] = "weapon/fx_prox_grenade_elec_jump";
 
    level.proximityGrenadeDetectionRadius = GetDvarInt( "scr_proximityGrenadeDetectionRadius", 180 );
    level.proximityGrenadeDuration = GetDvarFloat( "scr_proximityGrenadeDuration", 1.2 );
    level.proximityGrenadeGracePeriod = GetDvarFloat( "scr_proximityGrenadeGracePeriod", 0.05 );
    level.proximityGrenadeDOTDamageAmount = GetDvarInt( "scr_proximityGrenadeDOTDamageAmount", 1 );
    level.proximityGrenadeDOTDamageAmountHardcore = GetDvarInt( "scr_proximityGrenadeDOTDamageAmountHardcore", 1 );
    level.proximityGrenadeDOTDamageTime = GetDvarFloat( "scr_proximityGrenadeDOTDamageTime", 0.2 );
    level.proximityGrenadeDOTDamageInstances = GetDvarInt( "scr_proximityGrenadeDOTDamageInstances", 4 );
    level.proximityGrenadeActivationTime = GetDvarFloat( "scr_proximityGrenadeActivationTime", .1 );
    level.proximityChainDebug = GetDvarInt( "scr_proximityChainDebug", 0 );
    level.proximityChainGracePeriod = GetDvarInt( "scr_proximityChainGracePeriod", 2500 );
    level.proximityChainBoltSpeed = GetDvarFloat( "scr_proximityChainBoltSpeed", 400.0 );
    level.proximityGrenadeProtectedTime = GetDvarFloat( "scr_proximityGrenadeProtectedTime", 0.45 );
 
    level.poisonFXDuration = 6;
    
    level thread register();
    
    ‪callback::on_spawned( &‪on_player_spawned );
    
    ‪callback::add_weapon_damage( GetWeapon( "proximity_grenade" ), &‪on_damage );
 
    /#
    level thread ‪updateDvars();
    #/
}
 
//******************************************************************
//                                                                 *s
//                                                                 *
//******************************************************************
function register()
{
    ‪clientfield::register( "toplayer", "tazered", ‪VERSION_SHIP, 1, "int" );
}
 
function ‪updateDvars()
{
    while(1)
    {
        level.proximityGrenadeDetectionRadius = GetDvarInt( "scr_proximityGrenadeDetectionRadius", level.proximityGrenadeDetectionRadius );
        level.proximityGrenadeDuration = GetDvarFloat( "scr_proximityGrenadeDuration", 1.5 );
        level.proximityGrenadeGracePeriod = GetDvarFloat( "scr_proximityGrenadeGracePeriod", level.proximityGrenadeGracePeriod );
        level.proximityGrenadeDOTDamageAmount = GetDvarInt( "scr_proximityGrenadeDOTDamageAmount", level.proximityGrenadeDOTDamageAmount );
        level.proximityGrenadeDOTDamageAmountHardcore = GetDvarInt( "scr_proximityGrenadeDOTDamageAmountHardcore", level.proximityGrenadeDOTDamageAmountHardcore );
        level.proximityGrenadeDOTDamageTime = GetDvarFloat( "scr_proximityGrenadeDOTDamageTime", level.proximityGrenadeDOTDamageTime );
        level.proximityGrenadeDOTDamageInstances = GetDvarInt( "scr_proximityGrenadeDOTDamageInstances", level.proximityGrenadeDOTDamageInstances );
        level.proximityGrenadeActivationTime = GetDvarFloat( "scr_proximityGrenadeActivationTime", level.proximityGrenadeActivationTime );
        level.proximityChainDebug = GetDvarInt( "scr_proximityChainDebug", level.proximityChainDebug );
        level.proximityChainGracePeriod = GetDvarInt( "scr_proximityChainGracePeriod", level.proximityChainGracePeriod );
        level.proximityChainBoltSpeed = GetDvarFloat( "scr_proximityChainBoltSpeed", level.proximityChainBoltSpeed );
        level.proximityGrenadeProtectedTime = GetDvarFloat( "scr_proximityGrenadeProtectedTime", level.proximityGrenadeProtectedTime );
 
        wait(1.0);
    }
}
 
function ‪createProximityGrenadeWatcher() // self == player
{
    watcher = self ‪weaponobjects::createProximityWeaponObjectWatcher( "proximity_grenade", self.team );
    watcher.watchForFire = true;
    watcher.hackable = true;
    watcher.hackerToolRadius = level.equipmentHackerToolRadius;
    watcher.hackerToolTimeMs = level.equipmentHackerToolTimeMs;
    watcher.headIcon = false;
    watcher.activateFx = true;
    watcher.ownerGetsAssist = true;
    watcher.ignoreDirection = true;
    watcher.immediateDetonation = true;
    watcher.detectionGracePeriod = level.proximityGrenadeGracePeriod;
    watcher.detonateRadius = level.proximityGrenadeDetectionRadius;
    watcher.onStun = &‪weaponobjects::weaponStun;
    watcher.stunTime = 1;
    watcher.onDetonateCallback =&‪proximityDetonate;
    watcher.activationDelay = level.proximityGrenadeActivationTime;
    watcher.activateSound = "wpn_claymore_alert";
    watcher.immunespecialty = "specialty_immunetriggershock";
    
    watcher.onSpawn =&‪onSpawnProximityGrenadeWeaponObject;
}
 
function ‪createGadgetProximityGrenadeWatcher() // self == player
{
    watcher = self ‪weaponobjects::createProximityWeaponObjectWatcher( "gadget_sticky_proximity", self.team );
    watcher.watchForFire = true;
    watcher.hackable = true;
    watcher.hackerToolRadius = level.equipmentHackerToolRadius;
    watcher.hackerToolTimeMs = level.equipmentHackerToolTimeMs;
    watcher.headIcon = false;
    watcher.activateFx = true;
    watcher.ownerGetsAssist = true;
    watcher.ignoreDirection = true;
    watcher.immediateDetonation = true;
    watcher.detectionGracePeriod = level.proximityGrenadeGracePeriod;
    watcher.detonateRadius = level.proximityGrenadeDetectionRadius;
    watcher.onStun = &‪weaponobjects::weaponStun;
    watcher.stunTime = 1;
    watcher.onDetonateCallback =&‪proximityDetonate;
    watcher.activationDelay = level.proximityGrenadeActivationTime;
    watcher.activateSound = "wpn_claymore_alert";
 
    watcher.onSpawn =&‪onSpawnProximityGrenadeWeaponObject;
}
 
function ‪onSpawnProximityGrenadeWeaponObject( watcher, owner ) // self == weapon object
{
    self thread ‪setupKillCamEnt();
    owner AddWeaponStat( self.weapon, "used", 1 );
    
    if ( IsDefined( self.weapon ) && self.weapon.proximityDetonation > 0 )
    {
        watcher.detonateRadius = self.weapon.proximityDetonation;
    }
    
    ‪weaponobjects::onSpawnProximityWeaponObject( watcher, owner );
    
    self ‪trackOnOwner( self.owner );
}
 
function ‪trackOnOwner( owner )
{
    if ( level.trackProximityGrenadesOnOwner === true )
    {
        if ( !isdefined( owner ) )
            return;
        
        if ( !isdefined( owner.activeProximityGrenades ) )
        {
            owner.activeProximityGrenades = [];
        }
        else
        {
            ArrayRemoveValue( owner.activeProximityGrenades, undefined );
        }
        
        owner.activeProximityGrenades[ owner.activeProximityGrenades.size ] = self;
    }
}
 
function ‪setupKillCamEnt() // self == grenade
{
    self endon( "death" );
 
    self ‪util::waitTillNotMoving();
 
    self.killCamEnt = ‪spawn( "script_model", self.origin + (0,0,8 ) );
    self thread ‪cleanupKillCamEntOnDeath();
}
 
function ‪cleanupKillCamEntOnDeath() // self == grenade
{
    self waittill( "death" );
 
    self.killCamEnt ‪util::deleteAfterTime( 4 + level.proximityGrenadeDOTDamageTime * level.proximityGrenadeDOTDamageInstances );
}
 
function ‪proximityDetonate( attacker, weapon, target )
{
    if ( isdefined( weapon ) && weapon.isValid )
    {
        if ( isdefined( attacker ) )
        {
            if ( self.owner ‪util::IsEnemyPlayer( attacker ) )
            {
                attacker ‪challenges::destroyedExplosive( weapon );
                ‪scoreevents::processScoreEvent( "destroyed_proxy", attacker, self.owner, weapon );
            }
        }
    }
    
    ‪weaponobjects::weaponDetonate( attacker, weapon );
}
 
function ‪proximityGrenadeDamagePlayer( eAttacker, eInflictor, killCamEnt, weapon, meansOfDeath, ‪damage, proximityChain )
{   
    // eAttacker is the owner of the charge
    // eInflictor is originally the charge, and when on a chain, it;s the player that passed on the chain to us
    // killCamEnt is the killCam placed at the charge   
    self thread ‪damagePlayerInRadius( eInflictor.origin, eAttacker, killCamEnt );
    
    if ( weapon.chainEventRadius > 0 && !self hasPerk ("specialty_proximityprotection") )
    {
        self thread ‪proximityGrenadeChain( eAttacker, eInflictor, killCamEnt, weapon, meansOfDeath, ‪damage, proximityChain, 0 );
    }
}
 
function ‪getProximityChain()
{
    if ( !isdefined( level.proximityChains ) )
    {
        level.proximityChains = [];
    }
    
    // we use level.proximityChains because we need them to survive players and the on_damage callback
    foreach( chain in level.proximityChains )
    {
        if ( !‪chainIsActive( chain ) )
        {
            return chain;
        }
    }
    
    chain = spawnstruct();
    level.proximityChains[level.proximityChains.size] = chain;
    
    return chain;
}
 
function ‪chainIsActive( chain )
{
    // a chain is active as long as it is still being used
    if ( isdefined( chain.activeEndTime ) && chain.activeEndTime > GetTime() )
    {
        return true;
    }
    
    return false;
}
 
function ‪cleanUpProximityChainEnt() // self is a temp entity to keep track of the original chain. it goes away when all chains are finished.
{
    self.cleanUp = true;
    
    any_active = true;
    
    while( any_active )
    {
        wait( 1 );
        
        if ( !isdefined( self ) )
        {
            return;
        }
        
        any_active = false;
        
        foreach( proximityChain in self.chains )
        {           
            if ( proximityChain.activeEndTime > GetTime() )
            {
                any_active = true;
                break;
            }
        }       
    }
    
    if ( isdefined( self ) )
    {
        self delete();
    }   
}
 
function ‪isInChain( player )
{
    player_num = player GetEntityNumber();
    
    return isdefined( self.chain_players[player_num] ); 
}
 
function ‪addPlayerToChain( player )
{
    player_num = player GetEntityNumber();
    
    self.chain_players[player_num] = player;
}
 
function ‪proximityGrenadeChain( eAttacker, eInflictor, killCamEnt, weapon, meansOfDeath, ‪damage, proximityChain, ‪delay )
{
    self endon( "disconnect" );
    self endon( "death" );  
    
    eAttacker endon( "disconnect" );    
    
    if ( !isdefined( proximityChain ) )
    {   
        // this is a new chain started at the on_damage callback
        proximityChain = ‪getProximityChain();
        proximityChain.chainEventNum = 0;       
        
        if ( !isdefined( eInflictor.proximityChainEnt ) )
        {
            // this is the first chain from proximity grenade explosion started at the on_damage callback
            eInflictor.proximityChainEnt = ‪spawn( "script_origin", self.origin );
            eInflictor.proximityChainEnt.chains = [];
            eInflictor.proximityChainEnt.chain_players = [];            
        }
        
        proximityChain.proximityChainEnt = eInflictor.proximityChainEnt;
        proximityChain.proximityChainEnt.chains[proximityChain.proximityChainEnt.chains.size] = proximityChain;     
    }
    
    proximityChain.chainEventNum += 1;  
    
    if ( proximityChain.chainEventNum >= weapon.chainEventMax )
    {
        // this chain is maxed
        return;
    }
    
    chainEventRadiusSq = weapon.chainEventRadius * weapon.chainEventRadius;
    
    endTime = GetTime() + weapon.chainEventTime;
    
    proximityChain.proximityChainEnt ‪addPlayerToChain( self );
    proximityChain.activeEndTime = endTime + (‪delay * 1000) + level.proximityChainGracePeriod; // allow an interval to avoid reusing this proximityChain, in case it's still being used.
    
    ‪if ( ‪delay > 0 )
    {
        // yield after incrementing chainEventNum, and updating the chain active state  
        wait( ‪delay );
    }
    
    if( !isdefined( proximityChain.proximityChainEnt.cleanUp ) )
    {
        proximityChain.proximityChainEnt thread ‪cleanUpProximityChainEnt();
    }
    
    // we just been chain shocked, we will look for other players to continue the chain
    while( 1 )
    {
        currentTime = GetTime();
        
        if ( endTime < currentTime )
        {
            return;
        }
        
        closestPlayers = ArraySort( level.players, self.origin, true );
        
        foreach( player in closestPlayers )
        {
            ‪WAIT_SERVER_FRAME;
            
            if ( proximityChain.chainEventNum >= weapon.chainEventMax )
            {
                // this chain is maxed
                return;
            }
            
            if ( !isdefined( player ) || !IsAlive( player ) || player == self )
            {
                continue;
            }
            
            if ( player.sessionstate != "playing" )
            {
                continue;
            }
            
            distanceSq = DistanceSquared( player.origin, self.origin );
            
            if ( distanceSq > chainEventRadiusSq )
            {
                break;
            }
            
            if ( proximityChain.proximityChainEnt ‪isInChain( player ) )
            {
                continue;
            }
            
            if ( level.proximityChainDebug || ‪weaponobjects::friendlyFireCheck( eAttacker, player ) )
            {
                if ( level.proximityChainDebug || !player hasPerk ("specialty_proximityprotection") )
                {
                    // found a player to pass the chain to                  
                    
                    self thread ‪chainPlayer( eAttacker, killCamEnt, weapon, meansOfDeath, ‪damage, proximityChain, player, distanceSq );                 
                }
            }           
        }
        
        ‪WAIT_SERVER_FRAME;
    }
}
 
function ‪chainPlayer( eAttacker, killCamEnt, weapon, meansOfDeath, ‪damage, proximityChain, player, distanceSq )
{
    waitTime = 0.25;
    
    speedSq = level.proximityChainBoltSpeed * level.proximityChainBoltSpeed;
    if ( speedSq > 100 && distanceSq > 1 )
    {
        waitTime = distanceSq / speedSq;
    }
    
    player thread ‪proximityGrenadeChain( eAttacker, self, killCamEnt, weapon, meansOfDeath, ‪damage, proximityChain, waitTime );
    
    ‪WAIT_SERVER_FRAME;
    
    if ( level.proximityChainDebug )
    {
        /#
            color = (1, 1, 1);
            alpha = 1;
            depth = 0;
            time = 200;
            ‪util::debug_line(self.origin + (0,0,50), player.origin + (0,0,50), color, alpha, depth, time );
        #/                      
    }
    
    self ‪tesla_play_arc_fx( player, waitTime );
    
    player thread ‪damagePlayerInRadius( self.origin, eAttacker, killCamEnt );   
}
 
function ‪tesla_play_arc_fx( target, waitTime )
{
    if ( !IsDefined( self ) || !IsDefined( target ) )
    {   
        return;
    }
    
    tag = "J_SpineUpper";
    target_tag = "J_SpineUpper";
        
    origin = self GetTagOrigin( tag );
    target_origin = target GetTagOrigin( target_tag );
    
    distance_squared = 128 * 128;
 
    if ( DistanceSquared( origin, target_origin ) < distance_squared )
    {
        //( "TESLA: Not playing arcing FX. Enemies too close." );       
        return;
    }
    
    fxOrg = ‪spawn( "script_model", origin );
    fxOrg SetModel( "tag_origin" );
 
    fx = PlayFxOnTag( level._effect["prox_grenade_chain_bolt"], fxOrg, "tag_origin" );
    playsoundatposition( "wpn_tesla_bounce", fxOrg.origin );
    
    fxOrg MoveTo( target_origin, waitTime );
    fxOrg waittill( "movedone" );
    fxOrg delete();
}
 
/#
function ‪debugChainSphere()
{
    ‪util::debug_sphere( self.origin + (0,0,50), 20, (1,1,1), 1, 0 );
}
#/
    
function ‪watchProximityGrenadeHitPlayer( owner ) // self = grenade
{   
    self endon( "death" );
    
    self SetOwner( owner );
    self SetTeam( owner.team );
 
    while( 1 )
    {
        self waittill("grenade_bounce", pos, normal, ent, surface);
    
        if ( isdefined(ent) && isplayer( ent ) && surface != "riotshield" )
        {
            if ( ( level.teambased && ent.team == self.owner.team )) 
            {
                continue;
            }
 
            self ‪proximityDetonate(self.owner, self.weapon );
            return;
        }
    }
}   
 
function ‪performHudEffects( position, distanceToGrenade )
{
    forwardVec = VectorNormalize( AnglesToForward( self.angles ) );
    rightVec = VectorNormalize( AnglesToRight( self.angles ) );
    explosionVec = VectorNormalize( position - self.origin );
    
    fDot = VectorDot( explosionVec, forwardVec );
    rDot = VectorDot( explosionVec, rightVec );
 
    fAngle = ACos( fDot );
    rAngle = ACos( rDot );
}
 
function ‪damagePlayerInRadius( position, eAttacker, killCamEnt ) // self = player in radius
{
    self notify( "proximityGrenadeDamageStart" );
    self endon( "proximityGrenadeDamageStart" );
    self endon( "disconnect" );
    self endon( "death" );
    eAttacker endon( "disconnect" );    
    
    PlayFxOnTag( level._effect["prox_grenade_player_shock"], self, "J_SpineUpper" );    
    g_time = GetTime();
 
    if ( self ‪util::mayApplyScreenEffect() )
    {
        if ( !self hasPerk ("specialty_proximityprotection") )
        {
            self.lastShockedBy = eAttacker;
            self.shockEndTime = getTime() + ( level.proximityGrenadeDuration * 1000 );
            self shellshock("proximity_grenade", level.proximityGrenadeDuration, false );
        }
        
        self ‪clientfield::set_to_player( "tazered", ‪PROXY_PLAYER_TAZERED );
    }
    
    self playrumbleonentity("proximity_grenade");
    self PlaySound( "wpn_taser_mine_zap" );
 
    if ( !self hasPerk ("specialty_proximityprotection") )
    {
        self thread ‪watch_death();
        
        if ( !isdefined( killCamEnt )  )
        {
            killCamEnt = ‪spawn( "script_model", position + (0,0,8) );       
        }
        
        killCamEnt.soundMod = "taser_spike";
        killCamEnt ‪util::deleteAfterTime( 3 + level.proximityGrenadeDOTDamageTime * level.proximityGrenadeDOTDamageInstances);  
        self ‪util::show_hud( 0 );
        
        ‪damage = level.proximityGrenadeDOTDamageAmount;
        
        if( level.hardcoreMode )
        {
            ‪damage = level.proximityGrenadeDOTDamageAmountHardcore;
        }
 
        for ( i = 0; i < level.proximityGrenadeDOTDamageInstances; i++ )
        {       
            assert( isdefined( eAttacker ) );
            
            if ( !isdefined( killCamEnt )  )
            {
                killCamEnt = ‪spawn( "script_model", position + (0,0,8) );       
                killCamEnt.soundMod = "taser_spike";
                killCamEnt ‪util::deleteAfterTime( 3 + level.proximityGrenadeDOTDamageTime * ( level.proximityGrenadeDOTDamageInstances - i ) );
            }       
    
            self DoDamage( ‪damage, position, eAttacker, killCamEnt, "none", "MOD_GAS", 0, GetWeapon( "proximity_grenade_aoe" ) );
            
            wait( level.proximityGrenadeDOTDamageTime );
        }
        
        if (GetTime() - g_time < (level.proximityGrenadeDuration*1000) )
        {
            wait ( ( GetTime() - g_time) / 1000);
        }
    
        //self shellshock("proximity_grenade_exit", 0.6, false );
        self ‪util::show_hud( 1 );
    }
    else
    {
        wait( level.proximityGrenadeProtectedTime );
    }
    
    self ‪clientfield::set_to_player( "tazered", ‪PROXY_PLAYER_NOT_TAZERED );
}
 
function ‪proximityDeathWait( owner )
{
    self waittill( "death" );
    
    self notify( "deleteSound" );
}
 
function ‪deleteEntOnOwnerDeath( owner )
{
    self thread ‪deleteEntOnTimeout();
    self thread ‪deleteEntAfterTime();
    self endon( "delete" );
    owner waittill( "death" );
    self notify( "deleteSound" );
}
 
function ‪deleteEntAfterTime()
{
    self endon( "delete" );
    wait( 10.0 );
    self notify( "deleteSound" );
}
 
function ‪deleteEntOnTimeout()
{
    self endon( "delete" );
    self waittill( "deleteSound" );
    self delete();
}
 
function ‪watch_death() // self == player
{   
    self endon( "disconnect" );
    self notify( "proximity_cleanup" ); 
    self endon( "proximity_cleanup" );
    
    // fail safe stuff for if the player dies
    self waittill("death");
    self StopRumble( "proximity_grenade" );
    self setblur(0,0);
    self ‪util::show_hud( 1 );
    self ‪clientfield::set_to_player( "tazered", ‪PROXY_PLAYER_NOT_TAZERED );
    //self setEMPJammed( false );
}
 
function ‪on_player_spawned()
{
    self thread ‪createProximityGrenadeWatcher();
    self thread ‪createGadgetProximityGrenadeWatcher();
    self thread ‪begin_other_grenade_tracking();
}
 
function ‪begin_other_grenade_tracking()
{
    self endon( "death" );
    self endon( "disconnect" );
    
    self notify( "proximityTrackingStart" );    
    self endon( "proximityTrackingStart" );
    
    for (;;)
    {
        self waittill ( "grenade_fire", grenade, weapon, cookTime );
 
        if ( grenade ‪util::isHacked() )
        {
            continue;
        }
        
        if ( weapon.rootWeapon.name == "proximity_grenade" )
        {
            grenade thread ‪watchProximityGrenadeHitPlayer( self );
        }
    }
}
 
function ‪on_damage( eAttacker, eInflictor, weapon, meansOfDeath, ‪damage )
{   
    self thread ‪proximityGrenadeDamagePlayer( eAttacker, eInflictor, eInflictor.killCamEnt, weapon, meansOfDeath, ‪damage, undefined );
}