#include common_scripts\utility;
#include animscripts\utility;
#include maps\_utility;

#using_animtree( "dog" );

main()
{
	self endon( "killanimscript" );

	assert( isdefined( self.enemy ) );
	if ( !isalive( self.enemy ) )
	{
		combatIdle();
		return;
	}

	if ( isplayer( self.enemy ) )
		self meleeBiteAttackPlayer();
	else
		self meleeStruggleVsAI();
}

killplayer()
{
	self endon( "pvd_melee_interrupted" );
		
	if ( !isdefined( self.meleeingPlayer.player_view ) ) 
		return;
	
	player_view = self.meleeingPlayer.player_view;
	
	if ( isdefined( player_view.player_killed ) )
		return;

	player_view.player_killed = true;
	
	if ( is_coop() && !is_other_player_downed( self.meleeingPlayer ) )
	{
		knock_down_player_coop( self.meleeingPlayer, self );
		return;
	}

	self.meleeingPlayer.specialDeath = true;
	self.meleeingPlayer setcandamage( true );

	PlayFXOnTag( level._effect[ "dog_bite_blood" ], player_view, "tag_torso" );

	wait 1;
	self.meleeingPlayer enableHealthShield( false );

	if ( !isalive( self.meleeingPlayer ) )
		return;

	self.meleeingPlayer dog_player_kill( self );
	self.meleeingPlayer shellshock( "default", 5 );
	waittillframeend;// so quote gets set after _quotes sets it
	//setDvar( "ui_deadquote", level.dog_death_quote );
	setDvar( "ui_deadquote", "" );
	thread dog_death_hud( self.meleeingPlayer );
}

knock_down_player_coop( player, dog )
{
	player.coop_downed = true;
	
	rate = dog_vs_player_anim_rate();
	self setflaggedanimknobrestart( "meleeanim", %german_shepherd_player_getoff, 1, 0.1, rate );
	
	assert( isdefined( player.player_view ) );
	player.player_view notify( "pvd_melee_interrupted" );
	player.player_view notify( "pvd_melee_done" );
	player.player_view PlayerView_EndSequence( player );
	
	if ( is_coop() && is_other_player_downed( player ) )
	{
		// if the other player died during the "dog leaves" anim then die.
		player dog_player_kill( dog );
	}
}

dog_player_kill( killer )
{
	if ( is_coop() )
		self enableDeathShield( false );

	self DisableInvulnerability();
	if ( isalive( killer ) )
		self kill( self.origin, killer );
	else
		self kill( self.origin );
}

dog_death_hud( player )
{
	// SO does death hints differently from SP.
	if ( is_specialop() )
		return;
		
	wait( 1.5 );

	thread dog_deathquote( player );
	overlay = newClientHudElem( player );
	overlay.x = 0;
	overlay.y = 50;
	overlay setshader( "hud_dog_melee", 96, 96 );
	overlay.alignX = "center";
	overlay.alignY = "middle";
	overlay.horzAlign = "center";
	overlay.vertAlign = "middle";
	overlay.foreground = true;
	overlay.alpha = 0;
	overlay fadeOverTime( 1 );
	overlay.alpha = 1;
}

dog_deathquote( player )
{
	textOverlay = player maps\_hud_util::createClientFontString( "default", 1.75 );
	textOverlay.color = ( 1, 1, 1 );
	textOverlay setText( level.dog_death_quote );
	textOverlay.x = 0;
	textOverlay.y = -30;
	textOverlay.alignX = "center";
	textOverlay.alignY = "middle";
	textOverlay.horzAlign = "center";
	textOverlay.vertAlign = "middle";
	textOverlay.foreground = true;
	textOverlay.alpha = 0;
	textOverlay fadeOverTime( 1 );
	textOverlay.alpha = 1;
}

attackMiss()
{
	self clearanim( %root, 0.1 );
	missAnim = %german_shepherd_attack_player_miss;

	if ( isdefined( self.enemy ) )
	{
		forward	 = anglestoforward( ( 0, self.desiredAngle, 0 ) );
		dirToEnemy = vectorNormalize( self.enemy.origin - self.origin );
		landPosToEnemy = self.enemy.origin - ( self.origin + vector_multiply( forward, 40 ) );
		
		if ( vectordot( dirToEnemy, forward ) > 0.707 || vectordot( landPosToEnemy, forward ) > 0 )
		{
			self thread animscripts\dog\dog_stop::lookAtTarget( "normal" );
		}
		else
		{
			self.skipStartMove = true;
			self thread attackMissTrackTargetThread();

			if ( ( dirToEnemy[ 0 ] * forward[ 1 ] - dirToEnemy[ 1 ] * forward[ 0 ] ) > 0 )
				missAnim = %german_shepherd_attack_player_miss_turnR;
			else
				missAnim = %german_shepherd_attack_player_miss_turnL;
		}
	}

	self setflaggedanimrestart( "miss_anim", missAnim, 1, 0, 1 );
	animLength = getAnimLength( missAnim );
	self animscripts\shared::DoNoteTracksForTime( animLength - 0.1, "miss_anim" );
	self notify( "stop tracking" );
}


attackMissTrackTargetThread()
{
	self endon( "killanimscript" );

	wait 0.6;
	self OrientMode( "face enemy" );
}


KnockOutOfADS( player )
{
	player endon( "death" );
	player AllowAds( false );
	wait 0.75;
	player AllowAds( true );
}

dogMelee()
{
	/#
	if ( isgodmode( self.meleeingPlayer ) )
	{
		println( "Player in god mode, aborting dog attack" );
		return;
	}
	#/

	if ( isdefined( self.meleeingPlayer ) )
	{
		if ( self.meleeingPlayer isLinked() )
			return undefined;

		if ( self.meleeingPlayer isMantling() )
			return undefined;
			
		if ( self.meleeingPlayer.lastStand && self.meleeingPlayer.ignoreMe )
			return undefined;
	}

	if ( isdefined( self.enemy ) )
	{
		if ( distance2D( self.origin, self.enemy.origin ) < 32 )
			return self melee();
	}
	
	return self melee( anglesToForward( self.angles ) );
}


handleMeleeBiteAttackNoteTracks( note )
{
	switch( note )
	{
		case "dog_melee":
		{
			hitEnt = self dogMelee();

			if ( isdefined( hitEnt ) )
			{
				if ( isplayer( hitEnt ) )
				{
					hitEnt shellshock( "dog_bite", 1 );
					thread KnockOutOfADS( hitEnt );
				}
			}
			else
			{
				attackMiss();
				return true;
			}
		}
		break;

		case "stop_tracking":
			self OrientMode( "face current" );
			break;
	}
}

// to prevent the player from dying from the intial dog jump bite attack
addSafetyHealth()
{
	healthFrac = self.meleeingPlayer getnormalhealth();
	if ( healthFrac == 0 )
		return false;

	if ( healthFrac < 0.25 )
	{
		self.meleeingPlayer setnormalhealth( healthFrac + 0.25 );
		return true;
	}
	return false;
}

removeSafetyHealth()
{
	healthFrac = self.meleeingPlayer getnormalhealth();
	if ( healthFrac > 0.25 )
		self.meleeingPlayer setnormalhealth( healthFrac - 0.25 );
	else
		self.meleeingPlayer setnormalhealth( 0.01 );
}

handleMeleeFinishAttackNoteTracks( note )
{
	switch( note )
	{
		case "dog_melee":

			healthAdded = addSafetyHealth();

			hitEnt = self dogMelee();
			if ( isdefined( hitEnt ) && isplayer( hitEnt ) && isalive( self.meleeingPlayer ) )
			{
				if ( healthAdded )
					removeSafetyHealth();

				self.skipStartMove = undefined;

				assert( !isdefined( self.meleeingPlayer.player_view ) );
				self.meleeingPlayer.player_view = PlayerView_Spawn( self );

				if ( self.meleeingPlayer.player_view PlayerView_StartSequence( self ) )
					self setcandamage( false );
			}
			else
			{
				if ( healthAdded )
					removeSafetyHealth();

				attackMiss();
				return true;
			}
			break;

		case "dog_early":
			self notify( "dog_early_notetrack" );

			rate = 0.45 + 0.8 * level.dog_melee_timing_array[ level.dog_melee_index ];
			rate = rate * dog_vs_player_anim_rate();

			//println( "rate " + rate );
			level.dog_melee_index++ ;
			if ( level.dog_melee_index >= level.dog_melee_timing_array.size )
			{
				level.dog_melee_index = 0;
				// randomize the array for variety in dog attack timing
				level.dog_melee_timing_array = maps\_utility::array_randomize( level.dog_melee_timing_array );
			}

			self setflaggedanimlimited( "meleeanim", %german_shepherd_attack_player, 1, 0.2, rate );
			self setflaggedanimlimited( "meleeanim", %german_shepherd_attack_player_late, 1, 0.2, rate );

			self.meleeingPlayer.player_view PlayerView_PlayKnockDownAnimLimited( rate );
			break;

		case "dog_lunge":
			thread set_melee_timer();
			rate = dog_vs_player_anim_rate();
			self setflaggedanim( "meleeanim", %german_shepherd_attack_player, 1, 0.2, rate );

			self.meleeingPlayer.player_view PlayerView_PlayKnockDownAnim( rate );
			break;

		case "dogbite_damage":
			 /#
			if ( isgodmode( self.meleeingPlayer ) )
				break;
			#/

			self thread killplayer();
			break;

		case "stop_tracking":
			self OrientMode( "face current" );
			break;
	}
}

handle_dogbite_notetrack( note )
{
	switch( note )
	{
		case "dogbite_damage":
			 /#
			if ( isgodmode( self.meleeingPlayer ) )
				break;
			#/

			self thread killplayer();
			break;
	}
}

set_melee_timer()
{
	wait( 0.1 ); // used to be 0.15

	// Have the dog_hint show up 50ms before the timer is set 
	// because it takes 50ms for the clienthudelem to start drawing
	self thread dog_hint();

	wait( 0.05 );
	self.melee_able_timer = gettime();

	 /#
	if ( getdebugdvar( "dog_hint" ) == "on" )
	{
		introblack = newHudElem();
		introblack.x = 50;
		introblack.y = 50;
		introblack.horzAlign = "fullscreen";
		introblack.vertAlign = "fullscreen";
		introblack.foreground = true;
		introblack setShader( "black", 100, 100 );
		wait( 0.25 );
		introblack destroy();
	}
	#/
}

playerDogInit()
{
	assert( isPlayer( self ) );
	self.lastDogMeleePlayerTime = 0;
	self.dogMeleePlayerCounter = 0;
}

meleeBiteAttackPlayer()
{
	assert( isPlayer( self.enemy ) );
	self.meleeingPlayer = self.enemy;

	if ( !isdefined( self.meleeingPlayer.dogInited ) )
		self.meleeingPlayer playerDogInit();

	attackRangeBuffer = 30;
	meleeRange = self.meleeAttackDist + attackRangeBuffer;

	for ( ;; )
	{
		if ( !isalive( self.enemy ) )
			break;

		if ( ( isdefined( self.meleeingPlayer.syncedMeleeTarget ) && self.meleeingPlayer.syncedMeleeTarget != self ) ||
			( isdefined( self.meleeingPlayer.player_view ) && isdefined( self.meleeingPlayer.player_view.inSeq ) ) )
		{
			if ( checkEndCombat( meleeRange ) )
			{
				break;
			}
			else
			{
				combatIdle();
				continue;
			}
		}

		if ( self shouldWaitInCombatIdle() )
		{
			combatIdle();
			continue;
		}

		self OrientMode( "face enemy" );
		self animMode( "zonly_physics" );

		self.safeToChangeScript = false;

		prepareAttackPlayer();

		self clearanim( %root, 0.1 );
		self clearpitchorient();

 /#
		if ( getdebugdvar( "debug_dog_sound" ) != "" )
			iprintln( "dog " + ( self getentnum() ) + " attack player " + getTime() );

#/
		//self thread play_sound_on_tag( "anml_dog_growl", "tag_eye" );

		self.meleeingPlayer setNextDogAttackAllowTime( 500 );
		
		yawToEnemy = vectorToYaw( self.enemy.origin - self.origin );
		if ( AbsAngleClamp180( yawToEnemy - self.angles[1] ) > 120 )
		{
			enemy = self.enemy;
			wait 0.25;
			if ( !isAlive( self.enemy ) || self.enemy != enemy )
				continue;
		}

		if ( dog_cant_kill_in_one_hit() )
		{
			self.meleeingPlayer.lastDogMeleePlayerTime = getTime();
			self.meleeingPlayer.dogMeleePlayerCounter++ ;

			self setflaggedanimrestart( "meleeanim", %german_shepherd_run_attack, 1, 0.2, 1 );
			self animscripts\shared::DoNoteTracks( "meleeanim", ::handleMeleeBiteAttackNoteTracks );
		}
		else
		{
			self thread dog_melee_death();
			self.meleeingPlayer.attacked_by_dog = true;
			self.meleeingPlayer.laststand = false;
			self.meleeingPlayer.achieve_downed_kills = undefined;
			self thread clear_player_attacked_by_dog_on_death();
			self setflaggedanimrestart( "meleeanim", %german_shepherd_attack_player, 1, 0.2, 1 );
			self setflaggedanimrestart( "meleeanim", %german_shepherd_attack_player_late, 1, 0, 1 );
			self setanimlimited( %attack_player, 1, 0, 1 );
			self setanimlimited( %attack_player_late, 0.01, 0, 1 );

			self animscripts\shared::DoNoteTracks( "meleeanim", ::handleMeleeFinishAttackNoteTracks );
			self notify( "dog_no_longer_melee_able" );
			self setcandamage( true );
			self unlink();
		}

		self.safeToChangeScript = true;
		wait 0.05;	// give code chance to react

		if ( checkEndCombat( meleeRange ) )
			break;
	}

	self.safeToChangeScript = true;
	self animMode( "none" );
}

clear_player_attacked_by_dog_on_death()
{
	self waittill( "death" );
	self.meleeingPlayer.attacked_by_dog = undefined;
}


dog_cant_kill_in_one_hit()
{
	if ( isdefined( self.meleeingPlayer.dogs_dont_instant_kill ) )
	{
		assertex( self.meleeingPlayer.dogs_dont_instant_kill, "Dont set self.meleeingPlayer.dogs_dont_instant_kill to false, set to undefined" );
		return true;
	}
	
	if ( self.meleeingPlayer isPlayerDown() )
		return true;

	if ( isdefined( self.meleeingPlayer.slideModel ) )
		return true;

	if ( getTime() - self.meleeingPlayer.lastDogMeleePlayerTime > 8000 )
		self.meleeingPlayer.dogMeleePlayerCounter = 0;

	return self.meleeingPlayer.dogMeleePlayerCounter < self.meleeingPlayer.gs.dog_hits_before_kill &&
		   self.meleeingPlayer.health > 25;	// little more than the damage one melee dog bite hit will do
}


// prevent multiple dogs attacking at the same time and overlapping
shouldWaitInCombatIdle()
{
	assert( isdefined( self.enemy ) && isalive( self.enemy ) );

	return isdefined( self.enemy.dogAttackAllowTime ) && ( gettime() < self.enemy.dogAttackAllowTime );
}

// call on target
setNextDogAttackAllowTime( time )
{
	self.dogAttackAllowTime = gettime() + time;
}


meleeStruggleVsAI()
{
	if ( !isalive( self.enemy ) )
		return;
		
	if ( isdefined( self.enemy.syncedMeleeTarget ) || self shouldWaitInCombatIdle() || !isAI( self.enemy ) )
	{
		combatIdle();
		return;
	}

	self.enemy setNextDogAttackAllowTime( 500 );

	self.safeToChangeScript = false;
	self animMode( "zonly_physics" );
	self.pushable = false;

	self clearpitchorient();

	self.meleeKillTarget = !isdefined( self.enemy.magic_bullet_shield ) &&
						  ( isdefined( self.enemy.a.doingLongDeath ) || randomint( 100 ) > 50 );

	meleeSeqAnims = [];
	meleeSeqAnim[ 0 ] = %root;
	meleeSeqAnim[ 1 ] = %german_shepherd_attack_AI_01_start_a;
	meleeSeqAnim[ 2 ] = %german_shepherd_attack_AI_02_idle_a;
	if ( self.meleeKillTarget )
	{
		meleeSeqAnim[ 3 ] = %german_shepherd_attack_AI_03_pushed_a;
		meleeSeqAnim[ 4 ] = %german_shepherd_attack_AI_04_middle_a;
		meleeSeqAnim[ 5 ] = %german_shepherd_attack_AI_05_kill_a;
		numMeleeStage = 5;
	}
	else
	{
		meleeSeqAnim[ 3 ] = %german_shepherd_attack_AI_03_shot_a;
		numMeleeStage = 3;
	}

	angles = vectorToAngles( self.origin - self.enemy.origin );

	self.originalTarget = self.enemy;

	self setcandamage( false );
	self clearanim( meleeSeqAnim[ 0 ], 0.1 );
	self animrelative( "meleeanim", self.enemy.origin, angles, meleeSeqAnim[ 1 ] );
	self animscripts\shared::DoNoteTracks( "meleeanim", ::handleStartAIPart );

	self setcandamage( true );
	self animMode( "zonly_physics" );

	for ( meleeSeq = 1; meleeSeq < numMeleeStage; meleeSeq++ )
	{
		self clearanim( meleeSeqAnim[ meleeSeq ], 0 );

		if ( !inSyncMeleeWithTarget() )
			break;

		// get ready to die
		if ( !self.meleeKillTarget && meleeSeq + 1 == numMeleeStage )
			self.health = 1;

		self setflaggedanimrestart( "meleeanim", meleeSeqAnim[ meleeSeq + 1 ], 1, 0, 1 );
		self animscripts\shared::DoNoteTracks( "meleeanim" );
	}
	
	self unlink();

	if ( !self.meleeKillTarget )
	{
		self kill();
	}
	else
	{
		self.pushable = true;
		self.safeToChangeScript = true;
		self.flashBangImmunity = false;
	}
}

combatIdle()
{
	self OrientMode( "face enemy" );
	self clearanim( %root, 0.1 );
	self animMode( "zonly_physics" );

	idleAnims = [];
	idleAnims[ 0 ] = %german_shepherd_attackidle;
	idleAnims[ 1 ] = %german_shepherd_attackidle_bark;
	idleAnims[ 2 ] = %german_shepherd_attackidle_growl;

	idleAnim = random( idleAnims );

	self thread combatIdlePreventOverlappingPlayer();

	self setflaggedanimrestart( "combat_idle", idleAnim, 1, 0.2, 1 );
	self animscripts\shared::DoNoteTracks( "combat_idle" );

	self notify( "combatIdleEnd" );
}


// when player is in melee sequence, other dogs need to move away
combatIdlePreventOverlappingPlayer()
{
	self endon( "killanimscript" );
	self endon( "combatIdleEnd" );

	while ( 1 )
	{
		wait 0.1;

		players = getentarray( "player", "classname" );
		for ( i = 0; i < players.size; i++ )
		{
			player = players[ i ];
			if ( !isdefined( player.syncedMeleeTarget ) || player.syncedMeleeTarget == self )
				continue;

			offsetVec = player.origin - self.origin;

			if ( offsetVec[ 2 ] * offsetVec[ 2 ] > 6400 )
				continue;

			offsetVec = ( offsetVec[ 0 ], offsetVec[ 1 ], 0 );

			offset = length( offsetVec );

			if ( offset < 1 )
				offsetVec = anglestoforward( self.angles );

			if ( offset < 30 )
			{
				offsetVec = vector_multiply( offsetVec, 3 / offset );
				self safeTeleport( self.origin - offsetVec, ( 0, 30, 0 ) );
			}
		}
	}
}


inSyncMeleeWithTarget()
{
	return( isdefined( self.enemy ) && isdefined( self.enemy.syncedMeleeTarget ) && self.enemy.syncedMeleeTarget == self );
}

handleStartAIPart( note )
{
	if ( note != "ai_attack_start" )
		return false;

	if ( !isdefined( self.enemy ) )
		return true;

	if ( self.enemy != self.originalTarget )
		return true;

	// enemy already has a synced melee target
	if ( isdefined( self.enemy.syncedMeleeTarget ) )
		return true;

	// self.enemy thread draw_tag( "tag_sync" );

	self.flashBangImmunity = true;
	self.enemy.syncedMeleeTarget = self;
	self.enemy animcustom( ::meleeStruggleVsDog );
}

checkEndCombat( meleeRange )
{
	if ( !isdefined( self.enemy ) )
		return false;

	distToTargetSq = distanceSquared( self.origin, self.enemy.origin );

	return( distToTargetSq > meleeRange * meleeRange );
}

prepareAttackPlayer()
{
	// [{+melee}] Melee the dog right when it bites to grab its throat.
	// Watch for the ^3[{+melee}]^7 hint to grab a dog.
	level.dog_death_quote = &"NEW_DOG_DEATH_DO_NOTHING_ALT";
	level.dog_death_type = "nothing";
	distanceToTarget = distance( self.origin, self.enemy.origin );

	if ( distanceToTarget > self.meleeAttackDist )
	{
		offset = self.enemy.origin - self.origin;

		length = ( distanceToTarget - self.meleeAttackDist ) / distanceToTarget;
		offset = ( offset[ 0 ] * length, offset[ 1 ] * length, offset[ 2 ] * length );

		self thread attackTeleportThread( offset );
	}
}

// make up for error in intial attack jump position
attackTeleportThread( offset )
{
	self endon( "death" );
	self endon( "killanimscript" );
	reps = 5;
	increment = ( offset[ 0 ] / reps, offset[ 1 ] / reps, offset[ 2 ] / reps );
	for ( i = 0; i < reps; i++ )
	{
		self teleport( self.origin + increment );
		wait( 0.05 );
	}
}

player_attacked()
{
	return isalive( self.meleeingPlayer ) && ( self.meleeingPlayer MeleeButtonPressed() );
}



dog_hint()
{
	press_time = self.meleeingPlayer.gs.dog_presstime / 1000 / dog_vs_player_anim_rate();
	level endon( "clearing_dog_hint" );
	if ( isDefined( self.meleeingPlayer.dogHintElem ) )
		self.meleeingPlayer.dogHintElem maps\_hud_util::destroyElem();

	self.meleeingPlayer.dogHintElem = self.meleeingPlayer maps\_hud_util::createClientFontString( "default", 3 );
	self.meleeingPlayer.dogHintElem.color = ( 1, 1, 1 );
	// [{+melee}]
	self.meleeingPlayer.dogHintElem setText( &"SCRIPT_PLATFORM_DOG_HINT" );
	self.meleeingPlayer.dogHintElem.x = 0;
	self.meleeingPlayer.dogHintElem.y = 20;
	self.meleeingPlayer.dogHintElem.alignX = "center";
	self.meleeingPlayer.dogHintElem.alignY = "middle";
	self.meleeingPlayer.dogHintElem.horzAlign = "center";
	self.meleeingPlayer.dogHintElem.vertAlign = "middle";
	self.meleeingPlayer.dogHintElem.foreground = true;
	self.meleeingPlayer.dogHintElem.alpha = 1;
	self.meleeingPlayer.dogHintElem endon( "death" );

	wait( press_time );
	thread dog_hint_fade();
}

dog_hint_fade()
{
	level notify( "clearing_dog_hint" );
	if ( isDefined( self.meleeingPlayer.dogHintElem ) )
	{
		hud = self.meleeingPlayer.dogHintElem;
		if ( IsDefined( self.meleeingPlayer.player_view.neckSnapped ) && self.meleeingPlayer.player_view.neckSnapped )
		{
			time = 0.5;
			hud ChangeFontScaleOvertime( time );
			hud.fontScale = hud.fontScale * 1.5;
			hud.glowColor = ( 0.3, 0.6, 0.3 );
			hud.glowAlpha = 1;
			hud FadeOverTime( time );
			hud.color = ( 0, 0, 0 );
			hud.alpha = 0;
			wait( time );
			hud maps\_hud_util::destroyElem();
		}
		else
		{
			hud maps\_hud_util::destroyElem();
		}
	}
}

dog_delayed_unlink()
{
	wait 0.7;
	if ( isdefined( self ) )
		self unlink();
}

// for safety
dog_delayed_allow_damage()
{
	self endon( "death" );
	
	wait 1.5;
	if ( isdefined( self ) )
		self setCanDamage( true );
}

dog_melee_death()
{
	self endon( "killanimscript" );
	self endon( "dog_no_longer_melee_able" );
	pressed = false;

	// change this number for difficulty level:
	press_time = self.meleeingPlayer.gs.dog_presstime / dog_vs_player_anim_rate();

	self waittill( "dog_early_notetrack" );

	while ( player_attacked() )
	{
		// wait until the player lets go of the button, if he's holding it
		wait( 0.05 );
	}

	pressed_too_soon = false;
	for ( ;; )
	{
		if ( !pressed )
		{
			if ( self player_attacked() )
			{
				pressed = true;
				if ( isdefined( self.melee_able_timer ) && isalive( self.meleeingPlayer ) )
				{
					if ( gettime() - self.melee_able_timer <= press_time )
					{
						self.meleeingPlayer set_melee_early( pressed_too_soon );

						self.meleeingPlayer.player_view.neckSnapped = true;
						self notify( "melee_stop" );
						self setflaggedanimknobrestart( "dog_death_anim", %german_shepherd_player_neck_snap, 1, 0.2, 1 );
						self thread dog_delayed_allow_damage();
						self setcandamage( false );
						
						//maps\_utility::giveachievement_wrapper( "DOWN_BOY_DOWN" );
						self waittillmatch( "dog_death_anim", "dog_death" );
						self thread play_sound_in_space( "dog_neckbreak", self getEye() );
						self setcandamage( true );
						self.a.nodeath = true;
						dif = self.meleeingPlayer.origin - self.origin;
						dif = ( dif[ 0 ], dif [ 1 ], 0 );
						arcadeMode_kill( self.origin, "melee", 50 );
						self thread dog_delayed_unlink();
						self kill( self geteye() - dif, self.meleeingPlayer );
						self notify( "killanimscript" );
					}
					else
					{
						self.meleeingPlayer set_melee_early( pressed_too_soon );

						self.meleeingPlayer.player_view PlayerView_KnockDownLate();

						self setanimlimited( %attack_player, 0.01, 0.2, 1 );
						self setanimlimited( %attack_player_late, 1, 0.2, 1 );
						// [{+melee}] Melee the dog before it bites to grab its throat.
						// Too late. Watch for the ^3[{+melee}]^7 hint to grab a dog.
						level.dog_death_quote = &"NEW_DOG_DEATH_TOO_LATE_ALT";
						level.dog_death_type = "late";
					}

					return;
				}

				pressed_too_soon = true;
				if ( self.meleeingPlayer can_early_melee() )
				{
					// [{+melee}] Wait for the dog to bite to grab its throat.
					// Too early. Wait for the ^3[{+melee}]^7 hint to grab a dog.
					level.dog_death_quote = &"NEW_DOG_DEATH_TOO_SOON_ALT";
					level.dog_death_type = "soon";
	
					rate = dog_vs_player_anim_rate();
					self setflaggedanimknobrestart( "meleeanim", %german_shepherd_player_neck_miss, 1, 0.2, rate );
					
					self.meleeingPlayer.player_view PlayerView_PlayMissAnim( rate );
	
					// once player clicks, if it is at the wrong time, he does not get another chance.
					return;
				}
			}
		}
		else
		{
			if ( !self player_attacked() )
			{
				pressed = false;
			}
		}

		wait( 0.05 );
	}
}

can_early_melee()
{
	if ( self.gameskill == 3 )
	{
		return true;
	}

	if ( IsDefined( self.dogMeleeEarly ) && self.dogMeleeEarly )
	{
		return true;
	}

	return false;
}

set_melee_early( pressed_too_soon )
{
	if ( !pressed_too_soon )
	{
		return;
	}

	// Hardened will return false the first time, but after that
	// the player can melee too early and be penalized
	if ( level.gameskill > 1 && !IsDefined( self.dogMeleeEarly ) )
	{
		self.dogMeleeEarly = true;
	}
}

// -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
// 
// -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
#using_animtree( "generic_human" );

meleeStruggleVsDog()
{
	self endon( "killanimscript" );
	self endon( "death" );
	self endon( "end_melee_struggle" );
	self endon( "end_melee_all" );

	if ( !isdefined( self.syncedMeleeTarget ) )
		return;

	// self.syncedMeleeTarget = self;

	self OrientMode( "face point", self.syncedMeleeTarget.origin, 1 );
	self animMode( "gravity" );

	self.a.pose = "stand";
	self.a.special = "none";

	if ( usingSidearm() )
		self animscripts\shared::placeWeaponOn( self.primaryweapon, "right" );

	meleeSeqAnim = [];
	meleeSeqAnim[ 0 ] = %root;
	meleeSeqAnim[ 1 ] = %AI_attacked_german_shepherd_01_start_a;
	meleeSeqAnim[ 2 ] = %AI_attacked_german_shepherd_02_idle_a;
	if ( self.syncedMeleeTarget.meleeKillTarget )
	{
		meleeSeqAnim[ 3 ] = %AI_attacked_german_shepherd_03_push_a;
		meleeSeqAnim[ 4 ] = %AI_attacked_german_shepherd_04_middle_a;
		meleeSeqAnim[ 5 ] = %AI_attacked_german_shepherd_05_death_a;
		numMeleeStage = 5;
	}
	else
	{
		meleeSeqAnim[ 3 ] = %AI_attacked_german_shepherd_03_shoot_a;
		numMeleeStage = 3;
	}

	self.meleeSeq = 0;

	self thread meleeStruggleVsDog_interruptedCheck();

	self clearanim( meleeSeqAnim[ 0 ], 0.1 );

	self setflaggedanimrestart( "aianim", meleeSeqAnim[ 1 ], 1, 0.1, 1 );

	// this needs to happen here and not when the dog starts, because "tag_sync" won't be correct at that point
	wait 0.15;// also wait a bit before tag_sync in AI animation to settle to right spot
	self.syncedMeleeTarget linkto( self, "tag_sync", ( 0, 0, 0 ), ( 0, 0, 0 ) );

	self waittillmatch( "aianim", "end" );

	for ( self.meleeSeq = 1; self.meleeSeq < numMeleeStage; )
	{
		self clearanim( meleeSeqAnim[ self.meleeSeq ], 0 );

		self.meleeSeq++ ;

		// if starting the pistol pull out to shoot, don't let any other dog attack me for a bit
		if ( numMeleeStage == 3 && self.meleeSeq == 3 )
			self setNextDogAttackAllowTime( getAnimLength( meleeSeqAnim[ self.meleeSeq ] ) * 1000 - 1000 );

		self setflaggedanimrestart( "aianim", meleeSeqAnim[ self.meleeSeq ], 1, 0, 1 );
		self animscripts\shared::DoNoteTracks( "aianim" );

		// hack to let %AI_attacked_german_shepherd_03_push_a play to end when interrupted
		if ( !isdefined( self.syncedMeleeTarget ) || !isAlive( self.syncedMeleeTarget ) )
		{
			if ( self.meleeSeq == 3 && numMeleeStage == 5 )
			{
				meleeSeqAnim[ 4 ] = %AI_attacked_german_shepherd_04_getup_a;
				numMeleeStage = 4;
			}
		}

		if ( self.meleeSeq == 5 )
		{
			if ( !isdefined( self.magic_bullet_shield ) )
			{
				self.a.nodeath = true;
				self animscripts\shared::DropAllAIWeapons();
				self kill();
			}
		}
	}

	meleeStruggleVsDog_End();
}


// check for premature termination from dog being shot by another AI or player
meleeStruggleVsDog_interruptedCheck()
{
	self endon( "killanimscript" );
	self endon( "death" );
	self endon( "end_melee_all" );

	meleeSeqAnim = [];
	meleeSeqAnim[ 1 ] = %AI_attacked_german_shepherd_02_getup_a;
	meleeSeqAnim[ 2 ] = %AI_attacked_german_shepherd_02_getup_a;

	if ( self.syncedMeleeTarget.meleeKillTarget )
	{
		// meleeSeqAnim[ 3 ] = %AI_attacked_german_shepherd_04_getup_a;	// handle this in meleeStruggleVsDog()
		meleeSeqAnim[ 4 ] = %AI_attacked_german_shepherd_04_getup_a;
	}

	while ( 1 )
	{
		if ( !isdefined( self.syncedMeleeTarget ) || !isAlive( self.syncedMeleeTarget ) )
			break;

		wait 0.1;
	}

	if ( self.meleeSeq > 0 )
	{
		if ( !isdefined( meleeSeqAnim[ self.meleeSeq ] ) )
			return;	// don't call meleeStruggleVsDog_End()

		self clearanim( %melee_dog, 0.1 );
		self setflaggedanimrestart( "getupanim", meleeSeqAnim[ self.meleeSeq ], 1, 0.1, 1 );
		self animscripts\shared::DoNoteTracks( "getupanim" );
	}

	meleeStruggleVsDog_End();
}


// this should kill both meleeStruggleVsDog() and meleeStruggleVsDog_endCheck() threads
meleeStruggleVsDog_End()
{
	self orientmode( "face default" );
	self.syncedMeleeTarget = undefined;
	self.meleeSeq = undefined;
	self.allowPain = true;
	self setNextDogAttackAllowTime( 1000 );

	self notify( "end_melee_all" );
}


//////////////////////////////////////////////////////////
#using_animtree( "player_3rd_person" );

playerDrone_create( player )
{
	playerDrone = spawn( "script_model", player.origin );
	
	assert( isdefined( player.last_modelfunc ) );
	playerDrone [[ player.last_modelfunc ]]();
	playerDrone useAnimTree( #animtree );
	return playerDrone;
}

playerDrone_anim_knockdown( rate )
{
	self endon( "death" );
	
	time = getAnimLength( %player_3rd_dog_knockdown );
	
	self setanim( %player_3rd_dog_knockdown, 1, 0, rate );
}

playerDone_anim_neck_snap()
{
	self setanimknobrestart( %player_3rd_dog_knockdown_neck_snap, 1, 0, 1 );
}


playerDone_anim_saved()
{
	self setanimknobrestart( %player_3rd_dog_knockdown_saved, 1, 0, 1 );
}

playerDone_anim_laststand()
{
	self setanimknobrestart( %player_3rd_dog_knockdown_laststand, 1, 0, 1 );
}


// -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
// 
// -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
#using_animtree( "player" );

PlayerView_Spawn( dog )
{
	playerView = spawn( "script_model", dog.meleeingPlayer.origin );
	playerView.angles = dog.meleeingPlayer.angles;
	playerView setModel( level.player_viewhand_model );	// Add to level initialization maps\_load::set_player_viewhand_model;
	playerView useAnimTree( #animtree );
	playerView hide();

	return playerView;
}


handlePlayerKnockDownNotetracks( note )
{
	switch( note )
	{
		case "allow_player_save":
		{
			if ( isdefined( self.dog ) )
			{
				wait 1;
				self.dog setcandamage( true );
			}
		}
		break;

		case "blood_pool":
		{
			if ( !isdefined( self.dog.meleeingPlayer ) )
				break;
				
			if ( is_coop() && !is_other_player_downed( self.dog.meleeingPlayer ) )
				break;
				
			tagPos = self gettagorigin( "tag_torso" );	// rough tag to play fx on
			tagAngles = self gettagangles( "tag_torso" );
			forward = anglestoforward( tagAngles );
			up = anglestoup( tagAngles );
			right = anglestoright( tagAngles );

			tagPos = tagPos + vector_multiply( forward, -8.5 ) + vector_multiply( up, 5 ) + vector_multiply( right, 0 );
			playfx( level._effect[ "deathfx_bloodpool" ], tagPos, forward, up );	// Add to level initialization animscripts\dog\dog_init::initDogAnimations();
		}
		break;
	}
}


PlayerView_KnockDownAnim( dog )
{
	self endon( "pvd_melee_interrupted" );

	player = dog.meleeingPlayer;
	self.dog = dog;
	self thread PlayerView_CheckInterrupted( player );

	self setflaggedanimrestart( "viewanim", %player_view_dog_knockdown );
	self setflaggedanimrestart( "viewanim", %player_view_dog_knockdown_late );

	self setanimlimited( %knockdown, 1, 0, 1 );
	self setanimlimited( %knockdown_late, 0.01, 0, 1 );

	self animscripts\shared::DoNoteTracks( "viewanim", ::handlePlayerKnockDownNotetracks );

	self dontInterpolate();

	self.dog = undefined;
	PlayerView_EndSequence( player );
	self notify( "pvd_melee_done" );
}


PlayerView_CheckInterrupted( player )
{
	self endon( "pvd_melee_done" );

	self.dog waittill_any( "death", "pain", "melee_stop" );

	if ( !isdefined( player.specialDeath ) && isAlive( player ) )
	{
		self notify( "pvd_melee_interrupted" );
		self.dog notify( "pvd_melee_interrupted" );
		PlayerView_EndSequence( player );
	}
}


PlayerView_StartSequence( dog )
{
	if ( isdefined( self.inSeq ) )
		return false;

	player = dog.meleeingPlayer;

	player notify( "dog_attacks_player" );
	self.inSeq = true;

	if ( isalive( player ) )
		player hideHud();

	player setstance( "stand" );
	player.syncedMeleeTarget = dog;
	player.player_view PlayerView_Show( player );
	player.coop_downed = undefined;

	direction = dog.origin - player.origin;
	self.angles = vectortoangles( direction );
	self.angles = ( 0, self.angles[ 1 ], 0 );
	self.startAngles = self.angles;

	playerpos = player.origin;

	newOrigin = player getDropToFloorPosition( player.origin );
	if ( isdefined( newOrigin ) )
		self.origin = newOrigin;
	else
		self.origin = player.origin;

	self thread PlayerView_KnockDownAnim( dog );
	self dontInterpolate();

	player playerLinkToAbsolute( self, "tag_player" );
	dog linkto( self, "tag_sync", ( 0, 0, 0 ), ( 0, 0, 0 ) );

	syncTagAngles = self gettagangles( "tag_sync" );
	dog orientmode( "face angle", syncTagAngles[ 1 ] );
	dog orientmode( "face default" );

	//self thread draw_tag( "tag_player" );
	//self thread draw_tag( "tag_camera" );
	//self thread draw_tag( "tag_origin" );

	player allowLean( false );
	player allowCrouch( false );
	player allowProne( false );
	player freezeControls( true );

	player setcandamage( false );

	return true;
}

SavedNotify( player )
{
	wait 0.5;
	player playsound( "saved_from_dog" );
}

player_gets_weapons_back()
{
	self endon( "death" );
	self showViewModel();
	self enableweapons();
}

PlayerView_EndSequence( player )
{
	player showHud();

	if ( isalive( player ) )
	{
		self clearanim( %player_view_dog_knockdown, 0.1 );
		if ( isdefined( self.neckSnapped ) )
		{
			self setflaggedanimrestart( "viewanim", %player_view_dog_knockdown_neck_snap, 1, 0.2, 1 );
			
			if ( isdefined( self.playerDrone ) )
				self.playerDrone playerDone_anim_neck_snap();
		}
		else if ( isdefined( player.coop_downed ) )
		{
			self setflaggedanimknobrestart( "viewanim", %player_view_dog_knockdown_laststand, 1, 0.1, 1 );
	
			if ( isdefined( self.playerDrone ) )
				self.playerDrone playerDone_anim_laststand();
		}
		else
		{
			thread SavedNotify( player );
			self setflaggedanimrestart( "viewanim", %player_view_dog_knockdown_saved );
			
			if ( isdefined( self.playerDrone ) )
				self.playerDrone playerDone_anim_saved();
		}

		if ( !isdefined( player.coop_downed ) )
		{
			player delaythread( 2.5, ::player_gets_weapons_back );
			self animscripts\shared::DoNoteTracks( "viewanim" );
			player notify( "player_saved_from_dog" );
		}
		else
		{
			self animscripts\shared::DoNoteTracks( "viewanim" );
			player notify( "deathshield", 1000000, self.dog );
			if ( player isPlayerDown() )
				player.laststand = true;	

			player showViewModel();
		}

		PlayerView_UnlinkPlayerAndDelete( player );
	}
	else
	{
		setsaveddvar( "compass", 0 );
	}

	player.syncedMeleeTarget = undefined;

	RestorePlayerControls( player );
}


PlayerView_UnlinkPlayerAndDelete( player )
{
	player show();
	player unlink();
	player setOrigin( self.origin );
	player setplayerangles( self.startAngles );
	player setcandamage( true );

	player_view = player.player_view;
	if ( isdefined( player_view ) )
	{
		if ( isdefined( player_view.playerDrone ) )
			player_view.playerDrone delete();
	
		player_view delete();
		player.player_view = undefined;
	}
}

RestorePlayerControls( player )
{
	player allowLean( true );
	player allowCrouch( true );
	player allowProne( true );
	player freezeControls( false );
	player.attacked_by_dog = undefined;
}


PlayerView_Show( player )
{
	self showOnClient( player );
	
	if ( is_coop() )
	{
		playerDrone = playerDrone_create( player );
		playerDrone linkto( self, "tag_origin", ( 0, 0, 0 ), ( 0, 0, 0 ) );
		playerDrone thread playerDrone_anim_knockdown( 1 );

		self.playerDrone = playerDrone;

		if ( level.player == player && isdefined( level.player2 )  )
		{
			player hideOnClient( level.player2 );
			playerDrone hideOnClient( level.player );
		}
		else
		{
			player hideOnClient( level.player );
			playerDrone hideOnClient( level.player2 );
		}
	}
		
	player hideViewModel();
	player disableweapons();
}


PlayerView_PlayKnockDownAnimLimited( rate )
{
	self setflaggedanimlimited( "viewanim", %player_view_dog_knockdown, 1, 0.2, rate );
	self setflaggedanimlimited( "viewanim", %player_view_dog_knockdown_late, 1, 0.2, rate );
	
	if ( isdefined( self.playerDrone ) )
		self.playerDrone playerDrone_anim_knockdown( rate );
}


PlayerView_PlayKnockDownAnim( rate )
{
	self setflaggedanimlimited( "viewanim", %player_view_dog_knockdown, 1, 0.2, rate );
	self setflaggedanimlimited( "viewanim", %player_view_dog_knockdown_late, 1, 0.2, rate );

	if ( isdefined( self.playerDrone ) )
		self.playerDrone playerDrone_anim_knockdown( rate );
}


PlayerView_PlayMissAnim( rate )
{
	self setflaggedanimknobrestart( "viewanim", %player_view_dog_knockdown_neck_miss, 1, 0.2, rate );
}


PlayerView_KnockDownLate()
{
	self setanimlimited( %knockdown, 0.01, 0.2, 1 );
	self setanimlimited( %knockdown_late, 1, 0.2, 1 );
}

/*draw_tag( tagname )
{
	self endon( "death" );
	
	range = 25;
	
	while ( 1 )
	{
		angles = self gettagangles( tagname );	
		origin = self gettagorigin( tagname );
		
		forward = anglestoforward( angles );
		forward = vector_multiply( forward, range );
		right = anglestoright( angles );
		right = vector_multiply( right, range );
		up = anglestoup( angles );
		up = vector_multiply( up, range );
		line( origin, origin + forward, ( 1, 0, 0 ), 1 );
		line( origin, origin + up, ( 0, 1, 0 ), 1 );
		line( origin, origin + right, ( 0, 0, 1 ), 1 );
		wait 0.05;
	}
}*/


dog_vs_player_anim_rate()
{
	//if ( is_coop() )
	//	return 0.25;
	return 1;
}