mirror of
https://github.com/InfinityLoader/IL-GSC.git
synced 2025-06-10 10:27:55 -05:00
1071 lines
27 KiB
Plaintext
1071 lines
27 KiB
Plaintext
|
||
#include clientscripts\_utility;
|
||
#include clientscripts\_audio;
|
||
#include clientscripts\_ambientpackage;
|
||
#using_animtree("player");
|
||
settings()
|
||
{
|
||
level._swimming = SpawnStruct();
|
||
level._swimming.swim_times[0] = 0;
|
||
level._swimming.swim_times[1] = 15;
|
||
level._swimming.swim_times[2] = 25;
|
||
level._swimming.swim_times[3] = 32;
|
||
level._swimming.swim_times[4] = 37;
|
||
level._swimming.num_phases = level._swimming.swim_times.size - 1;
|
||
level._swimming.drown_reset_times[0] = 1;
|
||
level._swimming.drown_reset_times[1] = 2;
|
||
level._swimming.drown_reset_times[2] = 2;
|
||
level._swimming.drown_reset_times[3] = 4;
|
||
level._swimming.drown_reset_times[4] = 4;
|
||
self._swimming.is_swimming_enabled = true;
|
||
level._swimming.is_overriding_swim_movement = false;
|
||
level._swimming.override_swim_movement = (0,0,0);
|
||
level._swimming.swim_anim_rate = 1.0;
|
||
}
|
||
main()
|
||
{
|
||
if ( IsDefined( level.swimmingFeature ) && !level.swimmingFeature )
|
||
return;
|
||
if(level.createFX_enabled)
|
||
{
|
||
return;
|
||
}
|
||
settings();
|
||
fx();
|
||
anims();
|
||
set_default_water_for_settings();
|
||
OnPlayerConnect_Callback(::on_player_connect);
|
||
level thread underwater_ambient_package_setup();
|
||
}
|
||
set_default_vision_set(vision_set)
|
||
{
|
||
}
|
||
set_swimming_vision_set(vision_set)
|
||
{
|
||
VisionSetUnderWater(self GetLocalClientNumber(), vision_set);
|
||
if (!IsDefined(self._swimming))
|
||
{
|
||
self waittill("swimming_init");
|
||
}
|
||
self._swimming.swimming_vision_set = vision_set;
|
||
}
|
||
fx()
|
||
{
|
||
level._effect["underwater"] = LoadFX( "env/water/fx_water_particles_surface_fxr" );
|
||
level._effect["deep"] = LoadFX( "env/water/fx_water_particle_dp_spawner" );
|
||
level._effect["drowning"] = LoadFX( "bio/player/fx_player_underwater_bubbles_drowning" );
|
||
level._effect["exhale"] = LoadFX( "bio/player/fx_player_underwater_bubbles_exhale" );
|
||
level._effect["hands_bubbles_left"] = LoadFX( "bio/player/fx_player_underwater_bubbles_hand_fxr" );
|
||
level._effect["hands_bubbles_right"] = LoadFX( "bio/player/fx_player_underwater_bubbles_hand_fxr_right" );
|
||
level._effect["hands_debris_left"] = LoadFX( "bio/player/fx_player_underwater_hand_emitter");
|
||
level._effect["hands_debris_right"] = LoadFX( "bio/player/fx_player_underwater_hand_emitter_right");
|
||
level._effect["sediment"] = LoadFX( "bio/player/fx_player_underwater_sediment_spawner");
|
||
level._effect["wake"] = LoadFX( "bio/player/fx_player_water_swim_wake" );
|
||
level._effect["ripple"] = LoadFX( "bio/player/fx_player_water_swim_ripple" );
|
||
}
|
||
anims()
|
||
{
|
||
level._swimming.anims["breaststroke"][0] = %viewmodel_swim_breaststroke_a;
|
||
level._swimming.anims["breaststroke"][1] = %viewmodel_swim_breaststroke_b;
|
||
level._swimming.anims["breaststroke"][2] = %viewmodel_swim_breaststroke_c;
|
||
level._swimming.anims["backwards"][0] = %viewmodel_swim_backwards_a;
|
||
level._swimming.anims["backwards"][1] = %viewmodel_swim_backwards_b;
|
||
level._swimming.anims["backwards"][2] = %viewmodel_swim_backwards_c;
|
||
level._swimming.anims["left"][0] = %viewmodel_swim_to_left;
|
||
level._swimming.anims["right"][0] = %viewmodel_swim_to_right;
|
||
level._swimming.anims["tread"][0] = %viewmodel_swim_tread_water;
|
||
}
|
||
on_player_connect(clientNum)
|
||
{
|
||
while ( !ClientHasSnapshot(clientNum) )
|
||
{
|
||
wait 0.05;
|
||
}
|
||
wait( 0.05 );
|
||
self init_player();
|
||
self thread on_save_restore();
|
||
PrintLn("^4_swimming - client: client player connect");
|
||
self thread enable_swimming();
|
||
self thread disable_swimming();
|
||
self thread toggle_arms();
|
||
self thread swimmingDrown();
|
||
self thread waterLevelTag( clientNum );
|
||
self thread dive_and_surface_audio();
|
||
self thread dry_land_tracker();
|
||
self thread toggle_swimming();
|
||
if( self Swimming() )
|
||
{
|
||
self notify("swimming_begin");
|
||
}
|
||
}
|
||
on_save_restore()
|
||
{
|
||
while (true)
|
||
{
|
||
level waittill("save_restore");
|
||
self._swimming.is_underwater = false;
|
||
self notify("surface");
|
||
PrintLn("^4_swimming - client: save restore");
|
||
if( self Swimming() )
|
||
{
|
||
self notify("swimming_begin");
|
||
}
|
||
}
|
||
}
|
||
init_player()
|
||
{
|
||
if( !isdefined( self._swimming ) )
|
||
{
|
||
PrintLn("^4_swimming - client: defining self._swimming.");
|
||
self._swimming = SpawnStruct();
|
||
}
|
||
self._swimming.is_arms_enabled = true;
|
||
self._swimming.is_swimming = false;
|
||
self._swimming.is_drowning = false;
|
||
self._swimming.is_underwater = false;
|
||
self._swimming.resetting_vision = false;
|
||
self._swimming.surface_vox = "chr_swimming_vox_surface_default";
|
||
self._swimming.vec_movement = (0, 0, 0);
|
||
self notify("swimming_init");
|
||
}
|
||
disable_swimming()
|
||
{
|
||
self endon("disconnect");
|
||
while (true)
|
||
{
|
||
level waittill("_swimming:disable");
|
||
PrintLn("^4_swimming - client: swimming disabled");
|
||
self notify("swimming_end");
|
||
level._swimming.is_swimming_enabled = false;
|
||
}
|
||
}
|
||
enable_swimming()
|
||
{
|
||
self endon("disconnect");
|
||
while (true)
|
||
{
|
||
level waittill("_swimming:enable");
|
||
PrintLn("^4_swimming - client: swimming enabled");
|
||
if (self Swimming())
|
||
{
|
||
self notify("swimming_begin");
|
||
}
|
||
level._swimming.is_swimming_enabled = true;
|
||
}
|
||
}
|
||
hide_arms()
|
||
{
|
||
self endon("disconnect");
|
||
while (true)
|
||
{
|
||
level waittill("_swimming:hide_arms");
|
||
self._swimming.is_arms_enabled = false;
|
||
self notify("_swimming:hide_arms");
|
||
PrintLn("^4_swimming - client: hide arms");
|
||
}
|
||
}
|
||
show_arms()
|
||
{
|
||
self endon("disconnect");
|
||
while (true)
|
||
{
|
||
level waittill("_swimming:show_arms");
|
||
self._swimming.is_arms_enabled = true;
|
||
self notify("_swimming:show_arms");
|
||
PrintLn("^4_swimming - client: show arms");
|
||
}
|
||
}
|
||
set_default_water_for_settings()
|
||
{
|
||
SetWaterFog(
|
||
0,
|
||
119.8,
|
||
0,
|
||
-70.13,
|
||
0.149,
|
||
0.145,
|
||
0.118,
|
||
1.33,
|
||
0.212,
|
||
0.2,
|
||
0.157,
|
||
-0.269,
|
||
-0.506,
|
||
0.82,
|
||
0,
|
||
91.86,
|
||
0.994
|
||
);
|
||
}
|
||
toggle_swimming()
|
||
{
|
||
self endon("disconnect");
|
||
while (true)
|
||
{
|
||
self waittill("swimming_begin");
|
||
self._swimming.is_swimming = true;
|
||
PrintLn("^4_swimming - client: swimming begin");
|
||
self thread swimmingTracker();
|
||
self swimmingFX();
|
||
self waittill("swimming_end");
|
||
self._swimming.is_swimming = false;
|
||
PrintLn("^4_swimming - client: swimming end");
|
||
}
|
||
}
|
||
toggle_arms()
|
||
{
|
||
self endon("disconnect");
|
||
self thread show_arms();
|
||
self thread hide_arms();
|
||
while (true)
|
||
{
|
||
waitforclient(0);
|
||
self waittill_any("underwater", "_swimming:show_arms");
|
||
self thread swimmingArms();
|
||
self waittill_any("surface", "swimming_end", "_swimming:hide_arms");
|
||
}
|
||
}
|
||
swimmingTracker()
|
||
{
|
||
self endon("disconnect");
|
||
self endon("swimming_end");
|
||
while (true)
|
||
{
|
||
waitforclient(0);
|
||
if (level._swimming.is_swimming_enabled)
|
||
{
|
||
self._swimming.current_depth = get_swimming_depth();
|
||
}
|
||
else
|
||
{
|
||
self._swimming.current_depth = 0;
|
||
}
|
||
wait .05;
|
||
}
|
||
}
|
||
underwater()
|
||
{
|
||
if (!self._swimming.is_underwater)
|
||
{
|
||
self._swimming.reset_time = 0;
|
||
self._swimming.is_underwater = true;
|
||
self._swimming.surface_vox = "chr_swimming_vox_surface_default";
|
||
self notify("underwater");
|
||
PrintLn("^4_swimming - client: underwater");
|
||
}
|
||
}
|
||
surface()
|
||
{
|
||
if (self._swimming.is_underwater)
|
||
{
|
||
self._swimming.is_underwater = false;
|
||
self notify("surface");
|
||
PrintLn("^4_swimming - client: surface");
|
||
}
|
||
}
|
||
get_swimming_depth()
|
||
{
|
||
eye_height = self get_eye()[2];
|
||
water_height = GetWaterHeight( self.origin );
|
||
return (water_height - eye_height);
|
||
}
|
||
swimmingDrown()
|
||
{
|
||
self endon("disconnect");
|
||
phase = 0;
|
||
last_phase = 0;
|
||
self._swimming.swim_time = 0;
|
||
self._swimming.reset_time = 0;
|
||
while (true)
|
||
{
|
||
wait(.01);
|
||
waitforclient(0);
|
||
if (!self._swimming.is_underwater && !self._swimming.resetting_vision)
|
||
{
|
||
self._swimming.resetting_vision = true;
|
||
self thread swimmingDrownVision(0, last_phase);
|
||
}
|
||
phase = self advance_drowning_phase(last_phase);
|
||
if (phase != last_phase)
|
||
{
|
||
self notify( "drowning" );
|
||
self thread swimming_drown_vox();
|
||
self thread swimmingDrownDamage(phase);
|
||
self thread swimmingDrownVision(phase, last_phase);
|
||
self thread swimmingDrownFX(phase);
|
||
self.drowning_phase = phase;
|
||
last_phase = phase;
|
||
PrintLn("^4_swimming - client: phase " + phase);
|
||
}
|
||
}
|
||
}
|
||
advance_drowning_phase(phase)
|
||
{
|
||
if( IsDefined(level._disable_drowning) && level._disable_drowning )
|
||
{
|
||
return 0;
|
||
}
|
||
t_delta = swimming_get_time();
|
||
if (self._swimming.is_underwater)
|
||
{
|
||
self._swimming.swim_time += t_delta;
|
||
for (phase = level._swimming.num_phases; phase >= 0; phase--)
|
||
{
|
||
if (self._swimming.swim_time >= get_phase_time(phase))
|
||
{
|
||
return(phase);
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
self._swimming.reset_time += t_delta;
|
||
if (self._swimming.reset_time >= get_reset_time(phase))
|
||
{
|
||
self._swimming.swim_time = 0;
|
||
return 0;
|
||
}
|
||
}
|
||
return phase;
|
||
}
|
||
swimming_get_time()
|
||
{
|
||
t_now = GetRealTime();
|
||
t_delta = 0;
|
||
if (IsDefined(self._swimming.last_get_time))
|
||
{
|
||
t_delta = t_now - self._swimming.last_get_time;
|
||
if (t_delta >= 500)
|
||
{
|
||
PrintLn("^4_swimming - client: IGNORING TIME (" + t_delta + ")");
|
||
t_delta = 0;
|
||
}
|
||
}
|
||
self._swimming.last_get_time = t_now;
|
||
return t_delta;
|
||
}
|
||
get_phase_time(phase)
|
||
{
|
||
return (level._swimming.swim_times[phase] * 1000);
|
||
}
|
||
get_reset_time(phase)
|
||
{
|
||
return (level._swimming.drown_reset_times[phase] * 1000);
|
||
}
|
||
swimmingDrownDamage(phase)
|
||
{
|
||
self endon("disconnect");
|
||
self notify("stop_swimming_drown_damage");
|
||
self endon("stop_swimming_drown_damage");
|
||
self endon("surface");
|
||
self endon("swimming_end");
|
||
pause = 1;
|
||
rumble = undefined;
|
||
if (phase == 1 || phase == 2)
|
||
{
|
||
pause = 3;
|
||
rumble = "damage_light";
|
||
}
|
||
else if (phase == 3)
|
||
{
|
||
rumble = "damage_heavy";
|
||
}
|
||
while (IsDefined(rumble))
|
||
{
|
||
self PlayRumbleOnEntity(self GetLocalClientNumber(), rumble);
|
||
wait pause;
|
||
}
|
||
}
|
||
swimmingDrownVision(phase, last_phase)
|
||
{
|
||
if (phase == 0)
|
||
{
|
||
PrintLn("^4_swimming - client: resetting client-side blur.");
|
||
self SetBlur(0, level._swimming.drown_reset_times[last_phase]);
|
||
if (self._swimming.is_drowning)
|
||
{
|
||
VisionSetUnderWater(self GetLocalClientNumber(), self._swimming.swimming_vision_set, 0);
|
||
self._swimming.is_drowning = false;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
self._swimming.resetting_vision = false;
|
||
if (phase == 2)
|
||
{
|
||
PrintLn("^4_swimming - client: setting client-side blur.");
|
||
self SetBlur(10, level._swimming.swim_times[4] - level._swimming.swim_times[2]);
|
||
}
|
||
else if (phase == 3)
|
||
{
|
||
PrintLn("^4_swimming - client: setting drowning vision set.");
|
||
VisionSetUnderWater(self GetLocalClientNumber(), "drown", level._swimming.swim_times[4] - level._swimming.swim_times[3]);
|
||
self._swimming.is_drowning = true;
|
||
}
|
||
}
|
||
}
|
||
swimmingFX()
|
||
{
|
||
self thread underWaterFX();
|
||
}
|
||
waterLevelTag( clientNum )
|
||
{
|
||
self endon("disconnect");
|
||
self._swimming.water_level_fx_tag = Spawn(clientNum, self.origin, "script_model");
|
||
self._swimming.water_level_fx_tag SetModel("tag_origin");
|
||
while (true)
|
||
{
|
||
while( !ClientHasSnapshot(clientNum))
|
||
{
|
||
wait(0.1);
|
||
}
|
||
last_org = (0, 0, 0);
|
||
while (self._swimming.is_swimming)
|
||
{
|
||
while( !ClientHasSnapshot(clientNum))
|
||
{
|
||
wait(0.1);
|
||
}
|
||
self._swimming.water_level_fx_tag.origin = ( self.origin[0], self.origin[1], GetWaterHeight( self.origin ) );
|
||
new_org = self._swimming.water_level_fx_tag.origin;
|
||
if ((last_org != (0, 0, 0)) && (new_org != last_org))
|
||
{
|
||
self._swimming.vec_movement = new_org - last_org;
|
||
self._swimming.water_level_fx_tag.angles = VectorToAngles(self._swimming.vec_movement * -1);
|
||
}
|
||
else
|
||
{
|
||
self._swimming.is_stationary = true;
|
||
}
|
||
wait .01;
|
||
last_org = new_org;
|
||
}
|
||
wait .01;
|
||
}
|
||
}
|
||
underWaterFX()
|
||
{
|
||
self endon("swimming_end");
|
||
fx_handle_underwater = undefined;
|
||
fx_handle_deep = undefined;
|
||
fx_handle_hand_le = undefined;
|
||
fx_handle_hand_rt = undefined;
|
||
while( true )
|
||
{
|
||
self waittill("swim_arms_spawned");
|
||
self thread exhaleFX();
|
||
self thread debrisFX();
|
||
self thread sedimentFX();
|
||
fx_handle_hand_le = PlayFXOnTag(self GetLocalClientNumber(), level._effect["hands_bubbles_left"], self._swimming_arms, "J_WristTwist_LE");
|
||
fx_handle_hand_rt = PlayFXOnTag(self GetLocalClientNumber(), level._effect["hands_bubbles_right"], self._swimming_arms, "J_WristTwist_RI");
|
||
if( self._swimming.current_depth > 500)
|
||
{
|
||
if (IsDefined(fx_handle_underwater))
|
||
{
|
||
DeleteFx( self GetLocalClientNumber(), fx_handle_underwater, true );
|
||
}
|
||
fx_handle_deep = PlayFXOnTag(self GetLocalClientNumber(), level._effect["deep"], self._swimming_arms, "tag_origin");
|
||
PrintLn("^4_swimming - client: deep fx");
|
||
}
|
||
else
|
||
{
|
||
if (IsDefined(fx_handle_deep))
|
||
{
|
||
DeleteFx( self GetLocalClientNumber(), fx_handle_deep, false );
|
||
}
|
||
fx_handle_underwater = PlayFXOnTag(self GetLocalClientNumber(), level._effect["underwater"], self._swimming.water_level_fx_tag, "tag_origin");
|
||
PrintLn("^4_swimming - client: underwater fx");
|
||
}
|
||
self thread underWaterFXDelete(fx_handle_underwater, fx_handle_deep, fx_handle_hand_le, fx_handle_hand_rt);
|
||
}
|
||
}
|
||
underWaterFXDelete(fx_handle_underwater, fx_handle_deep, fx_handle_hand_le, fx_handle_hand_rt)
|
||
{
|
||
self waittill_any("surface", "swimming_end");
|
||
waitforclient(0);
|
||
if (IsDefined(fx_handle_underwater))
|
||
{
|
||
DeleteFx( self GetLocalClientNumber(), fx_handle_underwater, true );
|
||
}
|
||
if (IsDefined(fx_handle_deep))
|
||
{
|
||
DeleteFx( self GetLocalClientNumber(), fx_handle_deep, false );
|
||
}
|
||
if (IsDefined(fx_handle_hand_le))
|
||
{
|
||
DeleteFx( self GetLocalClientNumber(), fx_handle_hand_le, true );
|
||
}
|
||
if (IsDefined(fx_handle_hand_rt))
|
||
{
|
||
DeleteFx( self GetLocalClientNumber(), fx_handle_hand_rt, true );
|
||
}
|
||
}
|
||
exhaleFX()
|
||
{
|
||
self endon("disconnect");
|
||
self endon("surface");
|
||
self endon("swimming_end");
|
||
self endon("drowning");
|
||
wait 3;
|
||
while (IsDefined(self._swimming_arms))
|
||
{
|
||
waitforclient(0);
|
||
PlayFXOnTag(self GetLocalClientNumber(), level._effect["exhale"], self._swimming_arms, "tag_origin");
|
||
wait RandomFloatRange(2.5,3.5);
|
||
}
|
||
}
|
||
swimmingDrownFX(phase)
|
||
{
|
||
if (phase == 3)
|
||
{
|
||
if (IsDefined(self._swimming_arms))
|
||
{
|
||
PlayFXOnTag(self GetLocalClientNumber(), level._effect["drowning"], self._swimming_arms, "tag_origin");
|
||
}
|
||
}
|
||
}
|
||
debrisFX()
|
||
{
|
||
self endon("disconnect");
|
||
self endon("surface");
|
||
self endon("swimming_end");
|
||
while (IsDefined(self._swimming_arms))
|
||
{
|
||
fx_handle_hand_le = PlayFXOnTag(self GetLocalClientNumber(), level._effect["hands_debris_left"], self._swimming_arms, "J_WristTwist_LE");
|
||
fx_handle_hand_rt = PlayFXOnTag(self GetLocalClientNumber(), level._effect["hands_debris_right"], self._swimming_arms, "J_WristTwist_RI");
|
||
self thread killUnderWaterFX(fx_handle_hand_le, 3);
|
||
self thread killUnderWaterFX(fx_handle_hand_rt, 3);
|
||
wait 1.5;
|
||
}
|
||
}
|
||
sedimentFX()
|
||
{
|
||
self endon("disconnect");
|
||
self endon("surface");
|
||
self endon("swimming_end");
|
||
while (true)
|
||
{
|
||
player_angles = self GetPlayerAngles();
|
||
player_forward = AnglesToForward(player_angles);
|
||
fx_pos = self GetOrigin();
|
||
fx_handle = PlayFx(self GetLocalClientNumber(), level._effect["sediment"], fx_pos );
|
||
self thread killUnderWaterFX(fx_handle, 10);
|
||
wait 1;
|
||
}
|
||
}
|
||
killUnderWaterFX(fx_handle, time_out)
|
||
{
|
||
self endon("disconnect");
|
||
endon_string = get_kill_fx_endon();
|
||
self endon(endon_string);
|
||
self thread notify_delay(endon_string, time_out);
|
||
self waittill_any("surface", "swimming_end");
|
||
waitforclient(0);
|
||
if (IsDefined(fx_handle))
|
||
{
|
||
DeleteFx( self GetLocalClientNumber(), fx_handle, true );
|
||
}
|
||
}
|
||
get_kill_fx_endon()
|
||
{
|
||
if (!IsDefined(level._swimming.fx_num))
|
||
{
|
||
level._swimming.fx_num = 0;
|
||
}
|
||
else
|
||
{
|
||
level._swimming.fx_num++;
|
||
}
|
||
endon_string = "swimmin_fx_" + level._swimming.fx_num;
|
||
return(endon_string);
|
||
}
|
||
onWaterFX()
|
||
{
|
||
self endon("disconnect");
|
||
self endon("swimming_end");
|
||
while( true )
|
||
{
|
||
if (!self._swimming.is_underwater)
|
||
{
|
||
if (Length(self._swimming.vec_movement) > .4)
|
||
{
|
||
self onWaterWakeFXSpawn();
|
||
self onWaterRippleFXDelete();
|
||
}
|
||
else
|
||
{
|
||
self onWaterWakeFXDelete();
|
||
self onWaterRippleFXSpawn();
|
||
}
|
||
}
|
||
wait .01;
|
||
}
|
||
}
|
||
onWaterWakeFXSpawn()
|
||
{
|
||
if (!IsDefined(self._swimming.fx_handle_wake))
|
||
{
|
||
self notify("new_on_water_fx");
|
||
PrintLn("^4_swimming - client: spawning wake");
|
||
self._swimming.fx_handle_wake = PlayFXOnTag(self GetLocalClientNumber(), level._effect["wake"], self._swimming.water_level_fx_tag, "tag_origin");
|
||
self thread onWaterWakeFXDeleteWhenDone();
|
||
}
|
||
}
|
||
onWaterWakeFXDeleteWhenDone()
|
||
{
|
||
self endon("new_on_water_fx");
|
||
self waittill_any("underwater", "swimming_end");
|
||
self onWaterWakeFXDelete();
|
||
}
|
||
onWaterWakeFXDelete()
|
||
{
|
||
if( IsDefined(self._swimming.fx_handle_wake) )
|
||
{
|
||
PrintLn("^4_swimming - client: deleting wake");
|
||
DeleteFx( self GetLocalClientNumber(), self._swimming.fx_handle_wake, 0 );
|
||
self._swimming.fx_handle_wake = undefined;
|
||
}
|
||
}
|
||
onWaterRippleFXSpawn()
|
||
{
|
||
if (!IsDefined(self._swimming.fx_handle_ripple))
|
||
{
|
||
self notify("new_on_water_fx");
|
||
PrintLn("^4_swimming - client: spawning ripple");
|
||
self._swimming.fx_handle_ripple = PlayFXOnTag(self GetLocalClientNumber(), level._effect["ripple"], self._swimming.water_level_fx_tag, "tag_origin");
|
||
self thread onWaterRippleFXDeleteWhenDone();
|
||
}
|
||
}
|
||
onWaterRippleFXDeleteWhenDone()
|
||
{
|
||
self endon("new_on_water_fx");
|
||
self waittill_any("underwater", "swimming_end");
|
||
self onWaterRippleFXDelete();
|
||
}
|
||
onWaterRippleFXDelete()
|
||
{
|
||
if( IsDefined(self._swimming.fx_handle_ripple) )
|
||
{
|
||
PrintLn("^4_swimming - client: deleting ripple");
|
||
DeleteFx( self GetLocalClientNumber(), self._swimming.fx_handle_ripple, 0 );
|
||
self._swimming.fx_handle_ripple = undefined;
|
||
}
|
||
}
|
||
swimmingArmsSpawn()
|
||
{
|
||
self endon("disconnect");
|
||
self endon("swimming_end");
|
||
self endon("surface");
|
||
PrintLn("^4_swimming - client: swimmingArmsSpawn");
|
||
if (!self._swimming.is_underwater)
|
||
{
|
||
self waittill("underwater");
|
||
}
|
||
if (!self._swimming.is_arms_enabled)
|
||
{
|
||
self waittill("_swimming:show_arms");
|
||
}
|
||
self thread swimmingArmsHide();
|
||
PrintLn("^4_swimming - client: spawning arms");
|
||
self._swimming_arms = spawn_player_arms();
|
||
wait( 0.2 );
|
||
PrintLn("^4_swimming - client: linking arms");
|
||
self._swimming_arms UseAnimTree( #animtree );
|
||
self._swimming_arms LinkToCamera();
|
||
self notify("swim_arms_spawned");
|
||
}
|
||
swimmingArmsHide()
|
||
{
|
||
self endon("disconnect");
|
||
msg = self waittill_any_return("swimming_end", "surface", "_swimming:hide_arms");
|
||
if (msg == "_swimming:hide_arms")
|
||
{
|
||
self endon("_swimming:show_arms");
|
||
}
|
||
else
|
||
{
|
||
self endon("underwater");
|
||
}
|
||
self._swimming_arms waittillmatch("swimming_anim", "end");
|
||
self._swimming_arms Delete();
|
||
}
|
||
swimmingArms()
|
||
{
|
||
self endon("disconnect");
|
||
self endon("swimming_end");
|
||
self endon("surface");
|
||
self swimmingArmsSpawn();
|
||
self._swimming_arms endon("death");
|
||
blendtime = 0.3;
|
||
new_swim_state = 100;
|
||
new_rate = 1.0;
|
||
while( 1 )
|
||
{
|
||
waitforclient(0);
|
||
move = self GetNormalizedMovement();
|
||
if (level._swimming.is_overriding_swim_movement)
|
||
{
|
||
move = level._swimming.override_swim_movement;
|
||
}
|
||
len = Length( move );
|
||
old_swim_state = new_swim_state;
|
||
if( len < 0.5 )
|
||
{
|
||
new_swim_state = 0;
|
||
}
|
||
else
|
||
{
|
||
if( abs( move[0] ) > abs( move[1] ) )
|
||
{
|
||
if( move[0] > 0 )
|
||
{
|
||
new_swim_state = 1;
|
||
}
|
||
else
|
||
{
|
||
new_swim_state = 2;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if( move[1] < 0 )
|
||
{
|
||
new_swim_state = 3;
|
||
}
|
||
else
|
||
{
|
||
new_swim_state = 4;
|
||
}
|
||
}
|
||
}
|
||
rand_anim = random(level._swimming.anims["tread"]);
|
||
switch( new_swim_state )
|
||
{
|
||
case 100:
|
||
break;
|
||
case 0:
|
||
PrintLn( "_swimming: swim idle" );
|
||
rand_anim = random(level._swimming.anims["tread"]);
|
||
break;
|
||
case 1:
|
||
PrintLn( "_swimming: swim forward" );
|
||
rand_anim = random(level._swimming.anims["breaststroke"]);
|
||
break;
|
||
case 2:
|
||
PrintLn( "_swimming: swim backwards" );
|
||
rand_anim = random(level._swimming.anims["backwards"]);
|
||
break;
|
||
case 3:
|
||
PrintLn( "_swimming: swim left" );
|
||
rand_anim = random(level._swimming.anims["left"]);
|
||
break;
|
||
case 4:
|
||
PrintLn( "_swimming: swim right" );
|
||
rand_anim = random(level._swimming.anims["right"]);
|
||
break;
|
||
}
|
||
self._swimming_arms.current_anim = rand_anim;
|
||
self._swimming_arms SetFlaggedAnim("swimming_anim", rand_anim, 1, 0.2, level._swimming.swim_anim_rate);
|
||
self._swimming_arms waittillmatch("swimming_anim", "end");
|
||
self._swimming_arms ClearAnim(rand_anim, 0.0);
|
||
}
|
||
}
|
||
dive_and_surface_audio()
|
||
{
|
||
self endon( "death" );
|
||
if( !IsDefined( level.underwater_snapshot_override ) )
|
||
level.underwater_snapshot_override = false;
|
||
while (true)
|
||
{
|
||
self waittill( "underwater" );
|
||
activateAmbientRoom( 0, "underwater", 50 );
|
||
snd_set_snapshot( "underwater" );
|
||
self PlaySound( 0, "chr_swimming_dive_start_plr" );
|
||
self PlaySound( 0, "chr_ear_fill" );
|
||
self waittill( "surface" );
|
||
deactivateAmbientRoom( 0, "underwater", 50 );
|
||
snd_set_snapshot( "default" );
|
||
self PlaySound( 0, self._swimming.surface_vox );
|
||
self PlaySound( 0, "chr_swimming_surface_plr" );
|
||
self PlaySound( 0, "chr_ear_drain" );
|
||
}
|
||
}
|
||
swimming_loops_plr()
|
||
{
|
||
self endon( "death" );
|
||
swim_ent1 = Spawn( 0, (0,0,0), "script_origin" );
|
||
swim_ent2 = Spawn( 0, (0,0,0), "script_origin" );
|
||
while(1)
|
||
{
|
||
while( !self.is_on_dryland && !self._swimming.is_underwater && level._swimming.is_swimming_enabled )
|
||
{
|
||
if( self GetSpeed() > 50 )
|
||
{
|
||
swim_ent1 StopLoopSound( 1 );
|
||
swim_ent2 PlayLoopSound( "chr_swimming_swim_loop_plr", 1 );
|
||
}
|
||
else
|
||
{
|
||
swim_ent2 StopLoopSound( 1 );
|
||
swim_ent1 PlayLoopSound( "chr_swimming_float_loop_plr", 1 );
|
||
}
|
||
wait(.25);
|
||
}
|
||
swim_ent1 StopLoopSound( 1 );
|
||
swim_ent2 StopLoopSound( 1 );
|
||
wait(.25);
|
||
}
|
||
}
|
||
swimming_loops_ai()
|
||
{
|
||
self endon( "death" );
|
||
self endon( "entityshutdown" );
|
||
level endon( "save_restore" );
|
||
while(1)
|
||
{
|
||
while( self.is_on_dryland == true || !level._swimming.is_swimming_enabled )
|
||
{
|
||
wait( 0.25 );
|
||
}
|
||
real_ent1 = Spawn( 0, (0,0,0), "script_origin" );
|
||
real_ent2 = Spawn( 0, (0,0,0), "script_origin" );
|
||
real_ent1 LinkTo( self, "tag_origin" );
|
||
real_ent2 LinkTo( self, "tag_origin" );
|
||
self thread swimming_loop_delete( real_ent1, real_ent2 );
|
||
self thread save_restore_ent_delete( real_ent1, real_ent2 );
|
||
while( !self.is_on_dryland && level._swimming.is_swimming_enabled && IsDefined( real_ent1 ) && IsDefined( real_ent2 ) )
|
||
{
|
||
if( !IsDefined( self ) )
|
||
{
|
||
return;
|
||
}
|
||
if( self GetSpeed() > 50 )
|
||
{
|
||
real_ent2 StopLoopSound( 1 );
|
||
real_ent1 PlayLoopSound( "chr_swimming_swim_loop_npc", 1 );
|
||
}
|
||
else
|
||
{
|
||
real_ent1 StopLoopSound( 1 );
|
||
real_ent2 PlayLoopSound( "chr_swimming_float_loop_npc", 1 );
|
||
}
|
||
wait(.25);
|
||
}
|
||
wait(.25);
|
||
}
|
||
}
|
||
dry_land_tracker()
|
||
{
|
||
self endon( "death" );
|
||
self endon( "entityshutdown" );
|
||
self.is_on_dryland = true;
|
||
active_on_ai = true;
|
||
if( !IsDefined( level._swimming ) )
|
||
return;
|
||
if( !level._swimming.is_swimming_enabled )
|
||
return;
|
||
if( self IsPlayer() == false )
|
||
{
|
||
if( active_on_ai )
|
||
{
|
||
PrintLn( "***Swimming Threaded On AI***" );
|
||
self thread swimming_loops_ai();
|
||
self thread disable_ai_swimming();
|
||
level endon( "save_restore" );
|
||
}
|
||
else
|
||
{
|
||
return;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
self thread swimming_loops_plr();
|
||
}
|
||
while(1)
|
||
{
|
||
while( level._swimming.is_swimming_enabled )
|
||
{
|
||
if( !IsDefined( self ) )
|
||
{
|
||
return;
|
||
}
|
||
waitforclient(0);
|
||
eye_height = self get_eye();
|
||
self.foot_depth = (eye_height[2] - GetWaterHeight( self.origin )) - 40;
|
||
if( self.foot_depth > 0 )
|
||
{
|
||
if ( self.is_on_dryland == false )
|
||
{
|
||
self.is_on_dryland = true;
|
||
self notify( "on_dryland" );
|
||
}
|
||
}
|
||
else if ( self.is_on_dryland == true )
|
||
{
|
||
self.is_on_dryland = false;
|
||
self notify( "!on_dryland" );
|
||
}
|
||
wait(.25);
|
||
}
|
||
wait(.25);
|
||
}
|
||
}
|
||
swimming_loop_delete( ent1, ent2 )
|
||
{
|
||
level endon( "save_restore" );
|
||
self waittill_any( "entityshutdown", "on_dryland", "swimming_end", "death" );
|
||
ent1 delete();
|
||
ent2 delete();
|
||
}
|
||
save_restore_ent_delete( ent1, ent2 )
|
||
{
|
||
level waittill( "save_restore" );
|
||
if( !IsDefined( ent1 ) || !IsDefined( ent2 ) )
|
||
return;
|
||
PrintLn( "*#*#*#*#* Deleting Ents on Save Restore" );
|
||
ent1 delete();
|
||
ent2 delete();
|
||
}
|
||
underwater_ambient_package_setup()
|
||
{
|
||
declareAmbientRoom( "underwater" );
|
||
setAmbientRoomTone( "underwater", "chr_swimming_underwater_amb", .25, .1 );
|
||
setAmbientRoomReverb ("underwater","UNDERWATER", 1, 1, 1 );
|
||
}
|
||
disable_ai_swimming()
|
||
{
|
||
level endon( "save_restore" );
|
||
while (true)
|
||
{
|
||
level waittill("_swimming:disable");
|
||
if( !IsDefined( self ) )
|
||
return;
|
||
self notify("swimming_end");
|
||
}
|
||
}
|
||
disable_underwater_snapshot( value )
|
||
{
|
||
if( !IsDefined( level.underwater_snapshot_override ) )
|
||
level.underwater_snapshot_override = false;
|
||
level.underwater_snapshot_override = value;
|
||
}
|
||
swimming_drown_vox()
|
||
{
|
||
self endon( "death" );
|
||
self endon( "disconnect" );
|
||
if( !IsDefined( level.is_drowning ) )
|
||
level.is_drowning = false;
|
||
if( level.is_drowning || !self._swimming.is_underwater )
|
||
return;
|
||
level.is_drowning = true;
|
||
self thread audio_drowning_counter();
|
||
self thread audio_drowning_loopers();
|
||
self thread audio_drowning_vox();
|
||
self waittill( "surface" );
|
||
level.is_drowning = false;
|
||
snd_set_snapshot( "default" );
|
||
}
|
||
audio_drowning_vox()
|
||
{
|
||
self endon( "surface" );
|
||
self endon( "death" );
|
||
drown_vox = undefined;
|
||
surface_vox = undefined;
|
||
drown_time_change = 12;
|
||
while( self._swimming.is_underwater )
|
||
{
|
||
if( level.audio_swimming_counter <= drown_time_change )
|
||
{
|
||
drown_vox = "chr_swimming_vox_gulp_small";
|
||
surface_vox = "chr_swimming_vox_surface_medium";
|
||
waittime = RandomFloatRange( 2, 4 );
|
||
}
|
||
else
|
||
{
|
||
drown_vox = "chr_swimming_vox_gulp_large";
|
||
surface_vox = "chr_swimming_vox_surface_large";
|
||
waittime = RandomFloatRange( .5, 2 );
|
||
}
|
||
self PlaySound( 0, drown_vox );
|
||
self._swimming.surface_vox = surface_vox;
|
||
wait waittime;
|
||
}
|
||
}
|
||
audio_drowning_loopers()
|
||
{
|
||
self endon( "surface" );
|
||
self endon( "death" );
|
||
if( !self._swimming.is_underwater )
|
||
return;
|
||
snd_set_snapshot( "drowning" );
|
||
ent1 = Spawn( 0, (0,0,0), "script_origin" );
|
||
ent2 = Spawn( 0, (0,0,0), "script_origin" );
|
||
self thread delete_ents_on_surface( ent1, ent2 );
|
||
self thread drowning_heartbeat();
|
||
ent1 playloopsound( "chr_swimming_drowning_loop", 10 );
|
||
while( level.audio_swimming_counter < 14 )
|
||
{
|
||
wait(.1);
|
||
}
|
||
ent2 PlayLoopSound( "chr_shock_hfq", 1 );
|
||
}
|
||
audio_drowning_counter()
|
||
{
|
||
self endon( "surface" );
|
||
self endon( "death" );
|
||
self endon( "disconnect" );
|
||
if( !self._swimming.is_underwater )
|
||
return;
|
||
for( i=0; i<30; i++ )
|
||
{
|
||
level.audio_swimming_counter = i;
|
||
realWait(1);
|
||
}
|
||
}
|
||
delete_ents_on_surface( ent1, ent2 )
|
||
{
|
||
self waittill_any( "surface", "death" );
|
||
ent1 stoploopsound( .25 );
|
||
ent2 stoploopsound( .25 );
|
||
wait(.25);
|
||
ent1 Delete();
|
||
ent2 Delete();
|
||
}
|
||
drowning_heartbeat()
|
||
{
|
||
self endon( "surface" );
|
||
self endon( "death" );
|
||
self endon( "disconnect" );
|
||
wait1 = undefined;
|
||
wait2 = undefined;
|
||
while( self._swimming.is_underwater )
|
||
{
|
||
if( level.audio_swimming_counter >= 18 )
|
||
{
|
||
wait1 = .2;
|
||
wait2 = .4;
|
||
}
|
||
else if( level.audio_swimming_counter >= 12 )
|
||
{
|
||
wait1 = .3;
|
||
wait2 = .6;
|
||
}
|
||
else if( level.audio_swimming_counter > 6 )
|
||
{
|
||
wait1 = .4;
|
||
wait2 = .8;
|
||
}
|
||
else if( level.audio_swimming_counter <= 6 )
|
||
{
|
||
wait1 = .5;
|
||
wait2 = 1;
|
||
}
|
||
PlaySound( 0, "chr_shock_hb1", (0,0,0) );
|
||
wait( wait1 );
|
||
PlaySound( 0, "chr_shock_hb2", (0,0,0) );
|
||
wait( wait2 );
|
||
}
|
||
}
|
||
|
||
|
||
|
||
|