U2.Gib

//=============================================================================
// Gib.uc
//=============================================================================
class Gib extends U2Decoration;

#exec OBJ LOAD File=..\Textures\VertexT.utx
#exec OBJ LOAD File=..\StaticMeshes\VertexM.usx
//#exec AUDIO IMPORT FILE=Sounds\Landed.wav

//-----------------------------------------------------------------------------

const CheckForFadingChunkTimer		= 'CheckForFadingChunk';
const CheckForDestroyingChunkTimer	= 'CheckForDestroyingChunk';
const CheckForSinkingChunkTimer		= 'CheckForSinkingChunk';

//-----------------------------------------------------------------------------

// damage
var() bool bSpawnsBlood;
var() bool bTakesDamage;
var() ParticleGenerator DamageEffect;

// cleanup
var() float DestroyChunkInitialDelaySecs;
var() float DestroyChunkCheckAgainDelaySecs;

// blood
var() bool bLeavesBloodTrail;
var() ParticleSalamander BloodTrail;

// sounds
var() sound BounceSound;
var() sound DamageSound; // tbd
var() sound TrailSound; // tbd

// fading
var() bool  bShouldFade;							// whether to fade out gib or just destroy it
var() float StartFadingInitialDelaySecondsMin;		// when to start checking if we can fade (min)
var() float StartFadingInitialDelaySecondsMax;		// when to start checking if we can fade (max)
var() float StartFadingCheckAgainDelaySeconds;		// next time to check for fade if player can see gib
var() float FadeDurationSeconds;					// how long to take before fading out completely
var() float InitialScaleGlow;						// starting fade brightness
var() float FinalScaleGlow;							// starting fade brightness

// sinking
var() bool  bShouldSink;							// whether excess gib should sink or be destroyed
var() float StartSinkingInitialDelaySecondsMin;		// time to start sinking gib (min)
var() float StartSinkingInitialDelaySecondsMax;		// time to start sinking gib (max)
var() float StartSinkingCheckAgainDelaySecs;		// next time to check for sinking gib if player can see gib
var() float BaseSinkRatePerSecMin; 					// min rate at which chunk sinks into ground
var() float BaseSinkRatePerSecMax; 					// max rate at which chunk sinks into ground
var() float TotalSinkDistance;
var bool  bSinking;									// once set to true, gib starts to disappear into the ground
var float SinkRatePerSec;
var float MinTimeBoundSoundDelay;					// time b/w bounce sounds
var float GLastBounceSoundTime;						//!!FIXME class-wide property

//-----------------------------------------------------------------------------

function SetupEffects( U2Pawn U2P )
{
	if( bLeavesBloodTrail )
		SpawnBloodTrail( U2P.GibSetClass.default.BloodTrailType,
						 U2P.GibSetClass.default.BloodTrailVolumeMultiplier,
						 U2P.GibSetClass.default.BloodTrailLifeSpanMultiplier );

	if( bSpawnsBlood && U2P.bOverridesDamageEffect )
		DamageEffect = U2P.ParticleHitEffect;
}

//-----------------------------------------------------------------------------

function SetupTimers()
{
	if(  bShouldFade				 ) AddTimer( CheckForFadingChunkTimer,  RandRange( StartFadingInitialDelaySecondsMin, StartFadingInitialDelaySecondsMax ) );
	if(  bShouldSink				 ) AddTimer( CheckForSinkingChunkTimer, RandRange( StartSinkingInitialDelaySecondsMin, StartSinkingInitialDelaySecondsMax ) );
	if( !bShouldFade &&	!bShouldSink ) AddTimer( CheckForDestroyingChunkTimer, DestroyChunkInitialDelaySecs );
}

//-----------------------------------------------------------------------------

function SpawnBloodTrail( ParticleGenerator EffectType, float VolumeMultiplier, float LifespanMultiplier )
{
	if( EffectType == None )
		return;

	if( !bLeavesBloodTrail )
		return;

	if( BloodTrail == None )
		BloodTrail = ParticleSalamander( class'ParticleGenerator'.static.CreateNew( Self, EffectType, Location ) );

	if( BloodTrail != None )
	{
		BloodTrail.SetRotation( Rotation );
		BloodTrail.SetBase( Self );
		BloodTrail.Trigger(Self,None);
		BloodTrail.TimerDuration *= LifespanMultiplier;
		BloodTrail.ParticleLifeSpan = BloodTrail.GetMaxLifeSpan() + BloodTrail.TimerDuration;
		BloodTrail.Volume *= VolumeMultiplier;
	}
}

//-----------------------------------------------------------------------------

function StopBloodTrail()
{
	if( BloodTrail != None )
	{
		BloodTrail.ParticleDestroy();
		BloodTrail = None;
	}
}

//-----------------------------------------------------------------------------

event CheckForDestroyingChunk()
{
	if( DestroyChunkCheckAgainDelaySecs ~= 0.0 || !PlayerCanSeeMe() )
		Destroy();
	else
		AddTimer( CheckForDestroyingChunkTimer, class'util'.static.PerturbFloatPercent( DestroyChunkCheckAgainDelaySecs, 50.0 ), false );
}

//-----------------------------------------------------------------------------

event CheckForSinkingChunk()
{
	if( StartSinkingCheckAgainDelaySecs ~= 0.0 || !PlayerCanSeeMe() )
		StartSinking();
	else
		AddTimer( CheckForSinkingChunkTimer, class'util'.static.PerturbFloatPercent( StartSinkingCheckAgainDelaySecs, 50.0 ), false );
}

//-----------------------------------------------------------------------------

function CheckForFadingChunk()
{
	if( StartFadingCheckAgainDelaySeconds ~= 0.0 || !PlayerCanSeeMe() ) 
	{
		bUnlit = true;
		class'LegendUtil'.static.Fade( Self, FadeDurationSeconds, false, InitialScaleGlow, FinalScaleGlow );
	}
	else
	{ 
		AddTimer( CheckForFadingChunkTimer, class'util'.static.PerturbFloatPercent( StartFadingCheckAgainDelaySeconds, 50.0 ), false );
	}
}

//-----------------------------------------------------------------------------

function TakeDamage( int Damage, Pawn instigatedBy, vector HitLocation, vector Momentum, class<DamageType> DamageType )
{
	if( Level.NetMode == NM_Standalone )
	{
		// this doesn't work with ROLE_SimulatedProxy and with ROLE_DumbProxy, the decals break
		SetPhysics( PHYS_Falling );
		Velocity += Momentum/Mass;
	}

	if( bSpawnsBlood )
	{
		if( DamageEffect == None )
		{
			if( class<DamageTypeImpl>(DamageType) != None )
				DamageEffect = class<DamageTypeImpl>(DamageType).default.ParticleEffect;
		}

		//SpawnBlood( HitLocation, DamageCarcassBloodClassStr );
	}

	if( Health <= 0 )
		ChunkUp();

	//mib-tbd:
/*
	if( bTakesDamage )
	{
		CumulativeDamage += Damage;

		if( Damage > FMin(15, Mass) || CumulativeDamage > Mass )
		{
			ChunkUp();
		}
	}
*/
}

//-----------------------------------------------------------------------------

event PhysicsVolumeChange( PhysicsVolume NewVolume )
{
	Super.PhysicsVolumeChange( NewVolume );
	if( NewVolume.bWaterVolume )
	{
		RotationRate.Roll=1000;
		RotationRate.Pitch=1000;
		RotationRate.Yaw=1000;
		StopBloodTrail();
	}
}

//-----------------------------------------------------------------------------

simulated event HitWall( vector HitNormal, Actor Wall )
{
	Super.HitWall( HitNormal, Wall );

	//!!FIXME - shouldn't use default properties since they don't serialize
	if( default.GLastBounceSoundTime ~= 0 ||
		Level.TimeSeconds - default.GLastBounceSoundTime > MinTimeBoundSoundDelay )
	{
		PlaySound( BounceSound );
		default.GLastBounceSoundTime = Level.TimeSeconds;
	}
}

//-----------------------------------------------------------------------------

simulated function ChunkUp()
{
	//tbd: play splatter effect and sound
	Destroy();
}

//-----------------------------------------------------------------------------

event Landed( vector HitNormal )
{
	SetupTimers();
	Super.Landed( HitNormal );
	StopBloodTrail();
}

//-----------------------------------------------------------------------------

event Destroyed()
{
	RemoveAllTimers();
	StopBloodTrail();
	Super.Destroyed();
}

//-----------------------------------------------------------------------------

function StartSinking()
{
	local vector CCOffset;
	
	if( bShouldSink && !PhysicsVolume.bWaterVolume )
	{
		SetPhysics( Phys_None );
		SetCollision( false, false, false );
		bCollideWorld = false;
		SinkRatePerSec = RandRange( BaseSinkRatePerSecMin, BaseSinkRatePerSecMax );
		bSinking = true;
	}
	else
	{
		Destroy();
	}
}

//-----------------------------------------------------------------------------

event Tick( float DeltaTime )
{
	local float AmountToSink;

	Super.Tick( DeltaTime );

	if( bSinking )
	{
		AmountToSink = DeltaTime*SinkRatePerSec;
		// NOTE: increasing the prepivot.Z causes       Meshes to rise
		//       increasing the prepivot.Z causes StaticMeshes to sink
		if( DrawType == DT_StaticMesh )
			PrePivot.Z += AmountToSink;
		else
			PrePivot.Z -= AmountToSink;
		ClearRenderData();
		
		TotalSinkDistance += AmountToSink;
		if( TotalSinkDistance > 4*CollisionHeight )
			Destroy();
	}
}

//-----------------------------------------------------------------------------

defaultproperties
{
	bSpawnsBlood=true
	bTakesDamage=true
	DestroyChunkInitialDelaySecs=10.000000
	DestroyChunkCheckAgainDelaySecs=4.000000
	bLeavesBloodTrail=true
	BounceSound=Sound'U2A.Landed.Mud'
	StartFadingInitialDelaySecondsMin=4.000000
	StartFadingInitialDelaySecondsMax=5.000000
	FadeDurationSeconds=1.000000
	InitialScaleGlow=0.250000
	bShouldSink=true
	StartSinkingInitialDelaySecondsMin=4.000000
	StartSinkingInitialDelaySecondsMax=5.000000
	BaseSinkRatePerSecMin=1.000000
	BaseSinkRatePerSecMax=4.000000
	MinTimeBoundSoundDelay=0.500000
	DamageFilterClass=Class'U2.DamageFilterDefault'
	MinDamageVelocityZ=100
	bBounceable=true
	MinBounceSpeed=20.000000
	Physics=PHYS_Falling
	DrawType=DT_StaticMesh
	StaticMesh=StaticMesh'VertexM.Decorations.BarrelA'
	bStatic=false
	bStasis=false
	RemoteRole=ROLE_SimulatedProxy
	bCollideWorld=true
	bBlockActors=false
	bBlockPlayers=false
	bProjTarget=true
	bNoStaticMeshCollide=true
	bBounce=true
	bFixedRotationDir=true
     UseReticleOnEvents(0)="UseReticleText"
     UseReticleOnEvents(1)="UseReticleCorners"
     UseReticleOnEvents(2)="UseReticleTopBars"
     ProximityReticleOnEvents(0)="ProximityReticleCorners"
     ProximityReticleOnEvents(1)="ProximityReticleTopBars"
}