U2.U2Decoration

//=============================================================================
// U2Decoration.uc
//=============================================================================
class U2Decoration extends Decoration
	abstract;

#exec OBJ LOAD FILE=..\Sounds\U2DecorationsA.uax

var() class<DamageFilter> DamageFilterClass;

//var(Animation) name AnimSequence; // CDH: commented out, already exists in Actor (override is unnecessary & problematic)
var(Animation) float MinAnimRate, MaxAnimRate;
//CDH...
var(Animation) bool bMultiAnimEnabled;
var(Animation) name MultiAnimSequence[4];
var(Animation) float MultiAnimMinRate[4];
var(Animation) float MultiAnimMaxRate[4];
//...CDH

var(Breakable) int HitPoints;						// if > 0, decoration is breakable
var(Breakable) class<Fragment> FragmentClass;
var(Breakable) Texture FragmentSkin;
var(Breakable) float FragmentSize;
var(Breakable) int FragmentCount;
var(Breakable) int MinDamageVelocityZ;

var(Bounceable) bool bBounceable;				// if true, decoration bounces
var(Bounceable) float HitDamage;
var(Bounceable) float HitMomentum;
var(Bounceable) class<DamageType> HitDamageType;
var(Bounceable) sound LandSound1;
var(Bounceable) float MinBounceSoundSpeed;
var(Bounceable) float MinFirstHitSpeed;
var(Bounceable) float MinBounceSpeed;
var(Bounceable) float BounceDamping;
var(Bounceable) float RotationDamping;
var(Bounceable) float VolumePerturbPercent;
var(Bounceable) float PitchPerturbPercent;
var(Bounceable) float BaseBounceVolume;
var(Bounceable) float BaseBouncePitch;
var(Bounceable) float LandedYaw;				// if > 0, final (landed) yaw is set to this
var(Bounceable) float LandedRoll;				// if > 0, final (landed) roll is set to this
var(Bounceable) float LandedPitch;				// if > 0, final (landed) pitch is set to this
var bool bFirstHit;

simulated function PostEditChange()
{
	if( HitPoints != 0 || bBounceable )
	{
		// Fix ARL: Figure out a way to pop up a dialog (or use the rebuild error log).
		if( bStatic ) Log( "WARNING: bStatic should be false!" );
		bPushable = true;
		bProjTarget = true;
		bCollideWorld=true;
	}
	else
	{
		// Fix ARL: Figure out a way to pop up a dialog (or use the rebuild error log).
		if( !bStatic ) Log( "WARNING: bStatic should be true!" );
		bPushable = false;
		bProjTarget = false;
		bCollideWorld=false;
	}
}


simulated event PreBeginPlay()
{
//CDH...
	local int i;
//...CDH
	
	Super.PreBeginPlay();

//CDH...
	if( bMultiAnimEnabled )
	{
		for( i = 0; i < 4; i++ )
		{
			if( MultiAnimSequence[i] != '' )
			{
				LoopAnim( MultiAnimSequence[i], RandRange( MultiAnimMinRate[i], MultiAnimMaxRate[i] ), , i );
			}
		}
	}
	else
//...CDH
	if( AnimSequence != '' )
	{
		LoopAnim( AnimSequence, RandRange( MinAnimRate, MaxAnimRate ) );
	}
}


// lets us control minimum drop needed for decorations to take damage
// the base version in Decoration cuts off at -500 (hard-coded value)
singular event BaseChange()
{
	local float decorMass, decorMass2;

	decormass= FMax(1, Mass);
	if( Velocity.Z <= -MinDamageVelocityZ )
	{
		TakeDamage( (1-Velocity.Z/30),Instigator,Location,vect(0,0,0) , class'Crushed' );
	}
	if( base == None && bPushable && Physics == PHYS_None )
	{
		SetPhysics( PHYS_Falling );
	}
	else if( Pawn(base) != None )
	{
		Base.TakeDamage( ( 1 - Velocity.Z / 400 )* decormass / Base.Mass,Instigator, Location,0.5 * Velocity, class'Crushed' );
		Velocity.Z = 100;
		if( FRand() < 0.5)
		{
			Velocity.X += 70;
		}
		else
		{
			Velocity.Y += 70;
		}
		SetPhysics( PHYS_Falling );
	}
	else if( Decoration(Base) != None && Velocity.Z < -500 )
	{
		decorMass2 = FMax(Decoration(Base).Mass, 1);
		Base.TakeDamage( ( 1 - decorMass / decorMass2 * Velocity.Z / 30 ), Instigator, Location, 0.2 * Velocity, class'Crushed' );
		Velocity.Z = 100;
		if( FRand() < 0.5 )
		{
			Velocity.X += 70;
		}
		else
		{
			Velocity.Y += 70;
		}
		SetPhysics( PHYS_Falling );
	}
	else
	{
		Instigator = None;
	}
}


function SetupBounce()
{
	SetPhysics( PHYS_Falling );
	bBounce = true;
	RotationRate.Yaw = 128000 * FRand() - 64000;
	RotationRate.Pitch = 128000 * FRand() - 64000;
	RotationRate.Roll = 128000 * FRand() - 64000;	
	DesiredRotation = RotRand();
	bRotateToDesired = false;
	bFixedRotationDir = true;
	bFirstHit = true;
}


function InitFor( Actor Other )
{
	local int i;

	// If Other is a weapon attached to a weapon triangle, the decoration
	// probably won't be initially positioned the same as the weapon was.
	// We can inherit the velocity though.
	
	Velocity = Other.Velocity;
	Tag	= Other.Tag;
	
	if( Pawn(Other) != None || Weapon(Other) != None )
	{
		// make sure any damage skins are inherited
		for( i=0; i<Skins.length; i++ )
			Skins[i] = Other.Skins[i];
		Texture = Other.Texture;
	}

	// make sure decoration bounces/makes a noise at least once
	SetupBounce();
}


simulated event Landed( vector HitNormal )
{
	local rotator FinalRot;
	local float Delta, Speed;
	local rotator SurfaceRotator;
	local float Volume, Pitch;

	Speed = VSize( Velocity );
	FinalRot = Rotation;

	if( LandedYaw >= 0 )
	{
		class'util'.static.SetLandedRotParam( FinalRot.Yaw, LandedYaw );
	}
	else
	{
		// allow any Yaw
	}
	if( LandedRoll >= 0 )
	{
		class'util'.static.SetLandedRotParam( FinalRot.Roll, LandedRoll );
	}
	else
	{
		// force vertical Roll (upside-down or rightside-up)
		Delta = FinalRot.Roll & 32767;
		if( Delta < 16384 )
			FinalRot.Roll -= Delta;
		else
			FinalRot.Roll += Delta;
	}
	if( LandedPitch >= 0 )
	{
		class'util'.static.SetLandedRotParam( FinalRot.Pitch, LandedPitch );
	}
	else
	{
		// allow any orthogonal Pitch
		Delta = FinalRot.Pitch & 16383;
		if( Delta < 8192 )
			FinalRot.Pitch -= Delta;
		else
			FinalRot.Pitch += Delta;
	}

	SurfaceRotator = Rotator( Normal(vect(0,0,1) - HitNormal) );
	FinalRot += SurfaceRotator;

	SetRotation( FinalRot );
	DesiredRotation = FinalRot;
	RotationRate = rot(0,0,0);
	Velocity = vect(0,0,0);
	SetPhysics( PHYS_None );

	if( Speed > MinBounceSoundSpeed ) 
	{
		Volume = class'util'.static.PerturbFloatPercent( BaseBounceVolume, VolumePerturbPercent );
		Pitch = class'util'.static.PerturbFloatPercent( BaseBouncePitch, PitchPerturbPercent );

		PlaySound( LandSound1, SLOT_Misc, Volume, , , Pitch );
	}
	else if( bPushSoundPlaying )
	{
		PlaySound( EndPushSound, SLOT_Misc, 0.1 );
	}
	bPushSoundPlaying = false;
}


singular event Touch( Actor Other )
{
	if( HitDamage > 0 && VSize( Velocity ) > MinBounceSpeed )
	{
		Other.TakeDamage( HitDamage, None, Location, Normal( Other.Location - Location ) * HitMomentum, HitDamageType );
	}
}


event Timer()
{
	if( VSize( Velocity ) < MinBounceSoundSpeed )
	{
		if( bPushSoundPlaying )
		{
			PlaySound( EndPushSound, SLOT_Misc, 0.1 );
			bPushSoundPlaying = false;
		}
	}
	else
	{
		SetTimer( 1.0, false );
	}
}


event Bump( Actor Other )
{
	local vector HitNormal;
	local float Mass1, Mass2, Speed;
	local float OldZ;

	if( bPushable )
	{
		OldZ = Velocity.Z;
		HitNormal = Normal( Location - Other.Location );
		if( Pawn(Other) != None )
		{
			HitNormal.Z = 0.0;
		}
		Speed = VSize( Other.Velocity );
		Velocity += HitNormal * FMin( 120.0, 20 + Speed ); //ARL convert to "real" physics and implement PHYS_Sliding/Rolling
		if( Physics == PHYS_None )
		{
			Velocity.Z = 25; // make object moveable
			if( !bPushSoundPlaying )
			{
				PlaySound( PushSound, SLOT_Misc, 0.25 );
				bPushSoundPlaying = true;
			}
		}
		else
		{
			Velocity.Z = OldZ; // avoid floating decorations caused by pushing
		}
		SetPhysics( PHYS_Falling ); //ARL replace w/ PHYS_Sliding/Rolling
		SetTimer( 0.3,False );
		Instigator = Pawn(Other);
	}
}


event HitWall( vector HitNormal, Actor Wall )
{
	local float Speed;
	local float Volume, Pitch;

//DM( Self$".HitWall()" );
	// breakable handling
	if( HitPoints > 0 )
	{
		if( Velocity.Z < -200 )
		{
			TakeDamage( 100, Pawn(Owner), HitNormal, HitNormal * 10000, class'Crushed' );
		}
		bBounce = false;
		Velocity = vect( 0, 0, 0 );
		return;
	}

	// record speed before changing velocity
	Speed = VSize(Velocity);
	
	if( bBounce && Speed > MinBounceSoundSpeed ) 
	{
		Volume = class'util'.static.PerturbFloatPercent( BaseBounceVolume, VolumePerturbPercent );
		Pitch = class'util'.static.PerturbFloatPercent( BaseBouncePitch, PitchPerturbPercent );

		PlaySound( LandSound1, SLOT_Misc, Volume, , , Pitch );
	}

	if( bFirstHit && Speed < MinFirstHitSpeed )
	{
		bFirstHit = false;
		bRotatetoDesired = true;
		bFixedRotationDir = false;
		DesiredRotation.Pitch = 0;	
		DesiredRotation.Yaw = FRand() * 65536;
		DesiredRotation.Roll = 0;		
	}

	RotationRate.Yaw = RotationRate.Yaw * RotationDamping;
	RotationRate.Roll = RotationRate.Roll * RotationDamping;
	RotationRate.Pitch = RotationRate.Pitch * RotationDamping;	
	
	if( Speed * BounceDamping >= MinBounceSpeed ) 
	{
		// elastic reflection off surface, with damping
		Velocity = BounceDamping * ( Velocity - 2.0 * HitNormal * ( Velocity dot HitNormal ) );
	}
	else
	{
		// stop bouncing
		bBounce = false;
		if( bCanStickIntoWalls )
			Landed( HitNormal );
	}
}	


function TakeDamage( int Damage, Pawn InstigatedBy, vector HitLocation, vector Momentum, class<DamageType> DamageType )
{
	if( bStatic )
	{
		return;
	}

	DamageFilterClass.static.ApplyFilter( Damage, Momentum, DamageType );

	// mdf-tbd: no reaction if all damage/momentum filtered out
	if( Damage > 0.0 || VSize(Momentum) > 0.0 )
	{
		Instigator = InstigatedBy;
		if( Instigator != None )
		{
			MakeNoise( 1.0 );
		}
	
		// bounceable handling
		if( bBounceable )
		{
			Velocity += Momentum / 100.0;
			Velocity.Z += 25;
			SetupBounce();
			SetTimer( 1.0, false );
		}
	
		// breakable handling
		if( HitPoints > 0 )
		{
			HitPoints -= Damage;
			if( HitPoints <= 0 )
			{
				/*ARL
				if( FragmentClass != None )
				{
					if( FragmentSkin != None )
					{
						skinnedFrag( FragmentClass, FragmentSkin, Momentum, FragmentSize, FragmentCount );
					}
					else
					{
						Frag( FragmentClass, Momentum / 100.0, FragmentSize, FragmentCount ); //ARL 100.0 factor due to Decoration.uc asymmetry
					}
				}
				else
				{
					Destroy();
				}
				*/
				Destroy();
			}		
		}
		else if( !bIgnoreSingularityDamage && DamageType == class'DamageTypeSingularityCannon' && Damage > 500 )
		{
			Destroy();
		}
	}
}

defaultproperties
{
	DamageFilterClass=Class'U2.DamageFilterDecoration'
	MinAnimRate=1.000000
	MaxAnimRate=1.000000
	FragmentCount=12
	MinDamageVelocityZ=500
	HitDamageType=Class'U2.DamageTypePhysical'
	MinBounceSoundSpeed=200.000000
	MinFirstHitSpeed=400.000000
	MinBounceSpeed=200.000000
	BounceDamping=0.300000
	RotationDamping=0.300000
	VolumePerturbPercent=30.000000
	PitchPerturbPercent=10.000000
	BaseBounceVolume=1.000000
	BaseBouncePitch=1.000000
	LandedYaw=-1.000000
	LandedRoll=-1.000000
	LandedPitch=-1.000000
	bCanTeleport=true
	bIgnoreSingularityDamage=false
	bIgnoreSingularityForces=false
	bCollideActors=true
	bBlockActors=true
	bBlockPlayers=true
	Mass=50.000000
	Buoyancy=60.000000
     UseReticleOnEvents(0)="UseReticleText"
     UseReticleOnEvents(1)="UseReticleCorners"
     UseReticleOnEvents(2)="UseReticleTopBars"
     ProximityReticleOnEvents(0)="ProximityReticleCorners"
     ProximityReticleOnEvents(1)="ProximityReticleTopBars"
}