Engine.PhysicsVolume

//=============================================================================
// PhysicsVolume:  a bounding volume which affects actor physics
// Each Actor is affected at any time by one PhysicsVolume
// This is a built-in Unreal class and it shouldn't be modified.
//=============================================================================
class PhysicsVolume extends Volume
	native
	nativereplication;

var()		bool		bPainCausing;	 // Zone causes pain.
var()		vector		ZoneVelocity;
var()		vector		Gravity;
var()		float		GroundFriction;
var()		float		TerminalVelocity;
var()		float		DamagePerSec;
var() class<DamageType>	DamageType;
var()		int			Priority;	// determines which PhysicsVolume takes precedence if they overlap
var() sound EntrySound;	// only if waterzone
var() sound ExitSound;	// only if waterzone
var() string UnderwaterSoundStr;	// ambient sound to play when player is underwater
var() class<actor> EntryActor;	// e.g. a splash (only if water zone)
var() class<actor> ExitActor;	// e.g. a splash (only if water zone)
var() float  FluidFriction;
var() vector ViewFlash, ViewFog;

var()		bool	bDestructive; // Destroys most actors which enter it.
var()		bool	bNoInventory;
var()		bool	bMoveProjectiles;// this velocity zone should impart velocity to projectiles and effects
var()		bool	bBounceVelocity;	// this velocity zone should bounce actors that land in it
var()		bool	bNeutralZone; // Players can't take damage in this zone.
var()		bool	bWaterVolume;	//NEW (mwp) allow bWaterVolume to be edited on the DefaultPhysicsVolume
var	Info PainTimer;

// Distance Fog
var(VolumeFog) bool   bDistanceFog;	// There is distance fog in this physicsvolume.
var(VolumeFog) color DistanceFogColor;
var(VolumeFog) float DistanceFogStart;
var(VolumeFog) float DistanceFogEnd;
// NEW (mw): Support for different fog settings depending on detaillevel.
var(ZoneLight) float DetailDistanceFogStart[5];
var(ZoneLight) float DetailDistanceFogEnd[5];
 
var PhysicsVolume NextPhysicsVolume;


event Replication()
{
	Super.Replication();
	if( bSkipActorPropertyReplication && !bNetInitial )
	{
		DOREP('Location');
		DOREP('Rotation');
		DOREP('Base');
		if( Base != None && !Base.bWorldGeometry )
		{
			DOREP('RelativeLocation');
			DOREP('RelativeRotation');
			DOREP('AttachmentBone');
		}
	}
}

simulated event PostBeginPlay()
{
	local int i, j;

	Super.PostBeginPlay();

	if ( Role < ROLE_Authority )
		return;

	if ( bPainCausing )
		PainTimer = Spawn(class'VolumeTimer', self);

	//NEW (mw): Check the DetailDistanceFogStart/End arrays and update DistanceFogStart/End according to DetailLevel.
	if( Level.NetMode == NM_DedicatedServer )
		return;
	
	for( i=GetMaxDetailLevel(); i<5; i++ )
	{
		if( DetailDistanceFogStart[i] != 0 )
		{
			DistanceFogStart = DetailDistanceFogStart[i];
			break;
		}
	}

	for( j=GetMaxDetailLevel(); j<5; j++ )
	{
		if( DetailDistanceFogEnd[j] != 0 )
		{
			DistanceFogEnd = DetailDistanceFogEnd[j];
			break;
		}
	}
}

/* Called when an actor in this PhysicsVolume changes its physics mode
*/
event PhysicsChangedFor(Actor Other);

event ActorEnteredVolume(Actor Other);
event ActorLeavingVolume(Actor Other);

event PawnEnteredVolume(Pawn Other)
{
	if ( Other.IsPlayerPawn() )
		TriggerEvent(Event,Other, Other);
}

event PawnLeavingVolume(Pawn Other)
{
	if ( Other.IsPlayerPawn() )
		UntriggerEvent(Event,Other, Other);
}

/*
TimerPop
damage touched actors if pain causing.
since PhysicsVolume is static, this function is actually called by a volumetimer
*/
function TimerPop(VolumeTimer T)
{
	local actor A;

	if ( T == PainTimer )
	{
		if ( !bPainCausing )
			return;

		ForEach TouchingActors(class'Actor', A)
			CausePainTo(A);
	}
}

//NEW (mdf)
function Trigger( Actor Other, Pawn EventInstigator, optional name EventName )
/*OLD
function Trigger( Actor Other, Pawn EventInstigator )
*/
{
	// turn zone damage on and off
	if (DamagePerSec != 0)
	{
		bPainCausing = !bPainCausing;
		if ( bPainCausing && (PainTimer == None) )
			PainTimer = spawn(class'VolumeTimer', self);
	}
}

event touch(Actor Other)
{
	Super.Touch(Other);
	if ( bNoInventory && Other.IsA('Inventory') && (Other.Owner == None) )
	{
		Other.LifeSpan = 1.5;
		return;
	}
	if ( bMoveProjectiles && (ZoneVelocity != vect(0,0,0)) )
	{
		if ( Other.Physics == PHYS_Projectile )
			Other.Velocity += ZoneVelocity;
		else if ( Other.IsA('Effects') && (Other.Physics == PHYS_None) )
		{
			Other.SetPhysics(PHYS_Projectile);
			Other.Velocity += ZoneVelocity;
		}
	}
	if ( bPainCausing )
	{
		if ( Other.bDestroyInPainVolume )
		{
			Other.Destroy();
			return;
		}
		CausePainTo(Other);
	}
	if ( bWaterVolume && Other.CanSplash() )
		PlayEntrySplash(Other);
}

function PlayEntrySplash(Actor Other)
{
	local float SplashSize;
	local actor splash;

	splashSize = FClamp(0.00003 * Other.Mass * (250 - 0.5 * FMax(-600,Other.Velocity.Z)), 0.1, 1.0 );
	if( EntrySound != None )
	{
//NEW (mdf) fix
		Other.PlaySound(EntrySound, SLOT_Interact, splashSize);
		if ( Other.Instigator != None )
			Other.MakeNoise(SplashSize);
/*OLD
		PlaySound(EntrySound, SLOT_Interact, splashSize);
		if ( Other.Instigator != None )
			MakeNoise(SplashSize);
*/			
	}
	if( EntryActor != None )
	{
//NEW (mdf) fix
		splash = Spawn( EntryActor, , , Other.Location - vect(0,0,1)*Other.CollisionHeight );
/*OLD		
		splash = Spawn(EntryActor); 
*/		
		if ( splash != None )
			splash.SetDrawScale(splashSize);
	}
}

event untouch(Actor Other)
{
	if ( bWaterVolume && Other.CanSplash() )
		PlayExitSplash(Other);
}

function PlayExitSplash(Actor Other)
{
	local float SplashSize;
	local actor splash;

	splashSize = FClamp(0.003 * Other.Mass, 0.1, 1.0 );
	if( ExitSound != None )
//NEW (mdf) fix
		Other.PlaySound(ExitSound, SLOT_Interact, splashSize);
/*OLD
		PlaySound(ExitSound, SLOT_Interact, splashSize);
*/		
	if( ExitActor != None )
	{
//NEW (mdf) fix	
		splash = Spawn( ExitActor, , , Other.Location - vect(0,0,1)*Other.CollisionHeight );
/*OLD		
		splash = Spawn(ExitActor); 
*/
		if ( splash != None )
			splash.SetDrawScale(splashSize);
	}
}

function CausePainTo(Actor Other)
{
	local float depth;
	local Pawn P;

	// FIXMEZONE figure out depth of actor, and base pain on that!!!
	depth = 1;
	P = Pawn(Other);

	if ( DamagePerSec > 0 )
	{
		Other.TakeDamage(int(DamagePerSec * depth), None, Location, vect(0,0,0), DamageType); 
		if ( (P != None) && (P.Controller != None) )
			P.Controller.PawnIsInPain(self);
	}	
	else
	{
		if ( (P != None) && (P.Health < P.Default.Health) )
		P.Health = Min(P.Default.Health, P.Health - depth * DamagePerSec);
	}
}

defaultproperties
{
	Gravity=(Z=-1250.000000)
	GroundFriction=8.000000
	TerminalVelocity=4096.000000
	UnderwaterSoundStr="U2AmbientA.Underwater_08"
	FluidFriction=0.300000
	bAlwaysRelevant=true
     UseReticleOnEvents(0)="UseReticleText"
     UseReticleOnEvents(1)="UseReticleCorners"
     UseReticleOnEvents(2)="UseReticleTopBars"
     ProximityReticleOnEvents(0)="ProximityReticleCorners"
     ProximityReticleOnEvents(1)="ProximityReticleTopBars"
}