BO2-Reimagined/scripts/zm/replaced/_zm_chugabud.gsc

#include maps\mp\zombies\_zm_chugabud;
#include maps\mp\_utility;
#include common_scripts\utility;
#include maps\mp\zombies\_zm_utility;
#include maps\mp\gametypes_zm\_hud_util;

chugabud_laststand()
{
	self endon( "player_suicide" );
	self endon( "disconnect" );
	self endon( "chugabud_bleedout" );

	if ( isdefined( self.e_chugabud_corpse ) )
	{
		self notify( "chugabud_handle_multiple_instances" );
		return;
	}

	self maps\mp\zombies\_zm_laststand::increment_downed_stat();
	self.ignore_insta_kill = 1;
	self.health = self.maxhealth;
	self chugabud_save_loadout();
	self chugabud_fake_death();
	wait 3;

	if ( isdefined( self.insta_killed ) && self.insta_killed || isdefined( self.disable_chugabud_corpse ) )
		create_corpse = 0;
	else
		create_corpse = 1;

	if ( create_corpse == 1 )
	{
		if ( isdefined( level._chugabug_reject_corpse_override_func ) )
		{
			reject_corpse = self [[ level._chugabug_reject_corpse_override_func ]]( self.origin );

			if ( reject_corpse )
				create_corpse = 0;
		}
	}

	if ( create_corpse == 1 )
	{
		self thread activate_chugabud_effects_and_audio();
		corpse = self chugabud_spawn_corpse();
		self.e_chugabud_corpse = corpse;
		corpse.e_chugabud_player = self;
		corpse thread chugabud_corpse_revive_icon( self );
		corpse thread chugabud_corpse_cleanup_on_spectator( self );
		corpse thread chugabud_corpse_cleanup_on_disconnect( self );

		if ( isdefined( level.whos_who_client_setup ) )
			corpse setclientfield( "clientfield_whos_who_clone_glow_shader", 1 );
	}

	self thread chugabud_fake_revive();
	wait 0.1;
	self.ignore_insta_kill = undefined;
	self.disable_chugabud_corpse = undefined;

	if ( create_corpse == 0 )
	{
		if ( is_player_valid( self ) )
		{
			self.statusicon = "";
		}

		self notify( "chugabud_effects_cleanup" );
		return;
	}

	bleedout_time = 30;
	self thread chugabud_bleed_timeout( bleedout_time, corpse );
	self thread chugabud_handle_multiple_instances( corpse );

	corpse waittill( "player_revived", e_reviver );

	if ( isdefined( e_reviver ) && e_reviver == self )
		self notify( "whos_who_self_revive" );

	self perk_abort_drinking( 0.1 );
	self maps\mp\zombies\_zm_perks::perk_set_max_health_if_jugg( "health_reboot", 1, 0 );
	self setorigin( corpse.origin );
	self setplayerangles( corpse.angles );

	if ( self player_is_in_laststand() )
	{
		self thread chugabud_laststand_cleanup( corpse, "player_revived" );
		self enableweaponcycling();
		self enableoffhandweapons();
		self auto_revive( self, 1 );
		return;
	}

	self chugabud_laststand_cleanup( corpse, undefined );
}

chugabud_save_loadout()
{
	primaries = self getweaponslistprimaries();
	currentweapon = self getcurrentweapon();
	self.loadout = spawnstruct();
	self.loadout.player = self;
	self.loadout.weapons = [];
	self.loadout.score = self.score;
	self.loadout.current_weapon = -1;

	foreach ( index, weapon in primaries )
	{
		self.loadout.weapons[index] = maps\mp\zombies\_zm_weapons::get_player_weapondata( self, weapon );

		if ( weapon == currentweapon || self.loadout.weapons[index]["alt_name"] == currentweapon )
			self.loadout.current_weapon = index;
	}

	self.loadout.equipment = self get_player_equipment();

	if ( isdefined( self.loadout.equipment ) )
		self equipment_take( self.loadout.equipment );

	self.loadout save_weapons_for_chugabud( self );

	if ( self hasweapon( "claymore_zm" ) )
	{
		self.loadout.hasclaymore = 1;
		self.loadout.claymoreclip = self getweaponammoclip( "claymore_zm" );
	}

	self.loadout.perks = chugabud_save_perks( self );
	self chugabud_save_grenades();

	if ( maps\mp\zombies\_zm_weap_cymbal_monkey::cymbal_monkey_exists() )
		self.loadout.zombie_cymbal_monkey_count = self getweaponammoclip( "cymbal_monkey_zm" );
}

chugabud_save_perks( ent )
{
	perk_array = ent get_perk_array( 1 );

	foreach ( perk in perk_array )
	{
		if ( perk == "specialty_additionalprimaryweapon" )
		{
			ent maps\mp\zombies\_zm::take_additionalprimaryweapon();
		}

		ent unsetperk( perk );
	}

	return perk_array;
}

chugabud_fake_death()
{
	level notify( "fake_death" );
	self notify( "fake_death" );
	self takeallweapons();
	self allowstand( 0 );
	self allowcrouch( 0 );
	self allowprone( 1 );
	self setstance( "prone" );
	self.ignoreme = 1;
	self enableinvulnerability();

	if ( self is_jumping() )
	{
		while ( self is_jumping() )
			wait 0.05;
	}

	self freezecontrols( 1 );
}

chugabud_fake_revive()
{
	level notify( "fake_revive" );
	self notify( "fake_revive" );
	playsoundatposition( "evt_ww_disappear", self.origin );
	playfx( level._effect["chugabud_revive_fx"], self.origin );
	spawnpoint = chugabud_get_spawnpoint();

	if ( isdefined( level._chugabud_post_respawn_override_func ) )
		self [[ level._chugabud_post_respawn_override_func ]]( spawnpoint.origin );

	if ( isdefined( level.chugabud_force_corpse_position ) )
	{
		if ( isdefined( self.e_chugabud_corpse ) )
			self.e_chugabud_corpse forceteleport( level.chugabud_force_corpse_position );

		level.chugabud_force_corpse_position = undefined;
	}

	if ( isdefined( level.chugabud_force_player_position ) )
	{
		spawnpoint.origin = level.chugabud_force_player_position;
		level.chugabud_force_player_position = undefined;
	}

	self allowstand( 1 );
	self allowcrouch( 1 );
	self allowprone( 1 );
	self setstance( "stand" );
	self chugabud_give_loadout();
	self seteverhadweaponall( 1 );
	self.score = self.loadout.score;
	self.pers["score"] = self.loadout.score;

	self setorigin( spawnpoint.origin );
	self setplayerangles( spawnpoint.angles );
	playsoundatposition( "evt_ww_appear", spawnpoint.origin );
	playfx( level._effect["chugabud_revive_fx"], spawnpoint.origin );

	wait 0.5;

	self freezecontrols( 0 );

	wait 0.5;

	self.ignoreme = 0;

	wait 1;

	self disableinvulnerability();
}

chugabud_give_loadout()
{
	self takeallweapons();
	loadout = self.loadout;
	primaries = self getweaponslistprimaries();

	if ( loadout.weapons.size > 1 || primaries.size > 1 )
	{
		foreach ( weapon in primaries )
			self takeweapon( weapon );
	}

	weapons_given = 0;
	for ( i = 0; i < loadout.weapons.size; i++ )
	{
		if ( !isdefined( loadout.weapons[i] ) )
			continue;

		if ( loadout.weapons[i]["name"] == "none" )
			continue;

		self maps\mp\zombies\_zm_weapons::weapondata_give( loadout.weapons[i] );

		weapons_given++;
		if (weapons_given >= 2)
		{
			break;
		}
	}

	if ( loadout.current_weapon >= 0 && isdefined( loadout.weapons[loadout.current_weapon]["name"] ) )
		self switchtoweapon( loadout.weapons[loadout.current_weapon]["name"] );

	self giveweapon( "knife_zm" );
	self.do_not_display_equipment_pickup_hint = 1;
	self maps\mp\zombies\_zm_equipment::equipment_give( self.loadout.equipment );
	self.do_not_display_equipment_pickup_hint = undefined;
	loadout restore_weapons_for_chugabud( self );
	self chugabud_restore_claymore();
	self.score = loadout.score;
	self.pers["score"] = loadout.score;

	self chugabud_restore_grenades();

	if ( maps\mp\zombies\_zm_weap_cymbal_monkey::cymbal_monkey_exists() )
	{
		if ( loadout.zombie_cymbal_monkey_count )
		{
			self maps\mp\zombies\_zm_weap_cymbal_monkey::player_give_cymbal_monkey();
			self setweaponammoclip( "cymbal_monkey_zm", loadout.zombie_cymbal_monkey_count );
		}
	}

	self.loadout.weapons = undefined;
}

chugabud_give_perks()
{
	loadout = self.loadout;

	if ( isdefined( loadout.perks ) && loadout.perks.size > 0 )
	{
		for ( i = 0; i < loadout.perks.size; i++ )
		{
			if ( self hasperk( loadout.perks[i] ) )
				continue;

			if ( loadout.perks[i] == "specialty_quickrevive" && flag( "solo_game" ) )
				level.solo_game_free_player_quickrevive = 1;

			if ( loadout.perks[i] == "specialty_finalstand" )
				continue;

			maps\mp\zombies\_zm_perks::give_perk( loadout.perks[i] );
		}
	}
	self.loadout.perks = undefined;
}

chugabud_spawn_corpse()
{
	corpse = maps\mp\zombies\_zm_clone::spawn_player_clone( self, self.origin, undefined, self.whos_who_shader );
	corpse.angles = self.angles;
	corpse maps\mp\zombies\_zm_clone::clone_give_weapon( "m1911_zm" );
	corpse maps\mp\zombies\_zm_clone::clone_animate( "laststand" );
	corpse thread maps\mp\zombies\_zm_laststand::revive_trigger_spawn();
	return corpse;
}

chugabud_bleed_timeout_hud_create( delay )
{
	hud = self createbar((0.25, 0.25, 1), level.secondaryprogressbarwidth * 2, level.secondaryprogressbarheight);
	hud setpoint("CENTER", undefined, level.secondaryprogressbarx, -2.25 * level.secondaryprogressbary);
	hud.hidewheninmenu = 1;
	hud.bar.hidewheninmenu = 1;
	hud.barframe.hidewheninmenu = 1;
	hud.foreground = 1;
	hud.bar.foreground = 1;
	hud.barframe.foreground = 1;
	hud.sort = 1;
	hud.bar.sort = 2;
	hud.barframe.sort = 3;
	hud.barframe destroy();
	hud thread scripts\zm\_zm_reimagined::destroy_on_intermission();

	hud updatebar(1);
	hud.bar scaleovertime(delay, 1, hud.height);

	return hud;
}

chugabud_corpse_revive_icon( player )
{
	self endon( "death" );
	height_offset = 30;
	index = player.clientid;
	self.revive_waypoint_origin = spawn( "script_model", self.origin + (0, 0, height_offset) );
	self.revive_waypoint_origin setmodel( "tag_origin" );
	self.revive_waypoint_origin linkto( self );

	hud_elem = newhudelem();
	self.revive_hud_elem = hud_elem;
	hud_elem.alpha = 1;
	hud_elem.archived = 1;
	hud_elem.hidewheninmenu = 1;
	hud_elem.immunetodemogamehudsettings = 1;
	hud_elem setwaypoint( 1, "specialty_chugabud_zombies" );
	hud_elem settargetent( self.revive_waypoint_origin );
}

chugabud_corpse_cleanup( corpse, was_revived )
{
	self notify( "chugabud_effects_cleanup" );

	if ( was_revived )
	{
		playsoundatposition( "evt_ww_appear", corpse.origin );
		playfx( level._effect["chugabud_revive_fx"], corpse.origin );
	}
	else
	{
		playsoundatposition( "evt_ww_disappear", corpse.origin );
		playfx( level._effect["chugabud_bleedout_fx"], corpse.origin );
		self notify( "chugabud_bleedout" );
	}

	if ( isdefined( corpse.revivetrigger ) )
	{
		corpse notify( "stop_revive_trigger" );
		corpse.revivetrigger delete();
		corpse.revivetrigger = undefined;
	}

	if ( isdefined( corpse.revive_hud_elem ) )
	{
		corpse.revive_hud_elem destroy();
		corpse.revive_hud_elem = undefined;
	}

	if ( isdefined( corpse.revive_waypoint_origin ) )
	{
		corpse.revive_waypoint_origin delete();
		corpse.revive_waypoint_origin = undefined;
	}

	if ( isdefined( self.chugabud_bleed_timeout_hud ) )
	{
		self.chugabud_bleed_timeout_hud destroy();
		self.chugabud_bleed_timeout_hud.bar destroy();
		self.chugabud_bleed_timeout_hud.barframe destroy();
		self.chugabud_bleed_timeout_hud = undefined;
	}

	self.loadout = undefined;
	wait 0.1;
	corpse delete();
	self.e_chugabud_corpse = undefined;

	if ( is_player_valid( self ) )
	{
		self.statusicon = "";
	}
}

chugabud_handle_multiple_instances( corpse )
{
	corpse endon( "death" );

	self waittill( "chugabud_handle_multiple_instances" );

	self thread chugabud_laststand_wait( corpse );
	self chugabud_corpse_cleanup( corpse, 0 );
}

chugabud_laststand_wait( corpse )
{
	corpse waittill( "death" );

	self chugabud_laststand();
}

chugabud_corpse_cleanup_on_disconnect( player )
{
	self endon( "death" );

	player waittill( "disconnect" );

	player chugabud_corpse_cleanup( self, 0 );
}

chugabud_laststand_cleanup( corpse, str_notify )
{
	if ( isdefined( str_notify ) )
		self waittill( str_notify );

	self setstance( "stand" );
	self thread chugabud_leave_freeze();
	self thread chugabud_revive_invincible();
	self chugabud_give_perks();
	self chugabud_corpse_cleanup( corpse, 1 );
}

chugabud_leave_freeze()
{
	self endon( "disconnect" );
	level endon( "end_game" );

	self freezecontrols( 1 );

	wait 0.5;

	if ( !is_true( self.hostmigrationcontrolsfrozen ) )
		self freezecontrols( 0 );
}

chugabud_revive_invincible()
{
	self endon( "disconnect" );
	level endon( "end_game" );

	self.health = self.maxhealth;
	self enableinvulnerability();

	wait 2;

	self disableinvulnerability();
}

chugabud_bleed_timeout( delay, corpse )
{
	self endon( "player_suicide" );
	self endon( "disconnect" );
	corpse endon( "death" );

	self.chugabud_bleed_timeout_hud = self chugabud_bleed_timeout_hud_create( delay );

	wait delay;

	if ( isDefined( corpse.revivetrigger ) )
	{
		while ( corpse.revivetrigger.beingrevived )
		{
			wait 0.01;
		}
	}

	self chugabud_corpse_cleanup( corpse, 0 );
}