U2.SpawnPoint

//=============================================================================
// SpawnPoint.uc
// $Author: Mfox $
// $Date: 12/16/02 10:29p $
// $Revision: 27 $
//=============================================================================
class SpawnPoint extends NavigationPoint
	placeable;

#exec Texture Import File=Icons\I_SpawnPoint.pcx Mips=Off Masked=1

enum EPropertyType
{
	PT_Default,
	PT_Physics,
	PT_Collision,
	PT_bCollideActors,
	PT_DrawType,
};

struct DefaultT
{
	var() string		Property;
	var() string		Value;
	var() EPropertyType PropertyType;
	var() EPhysics		PhysicsValue;
	var() float			CollisionRadiusValue;
	var() float			CollisionHeightValue;
	var() EDrawType		DrawType;
};

// These override the properties of the factory
var() name			ItemEvent;				// if set spawned Actors' events set to this, otherwise factory's Tag used
var() name			ItemTag;				// if set spawned Actors' tags set to this, otherwise factory's ItemTag used
var() int			ItemTeam;				// obsolete? team number (overrides default for class)
var() name			ItemOrders;				// orders to give spawnees
var() class<Actor>	ItemPrototype;			// actor class for spawned items
var() string		ItemCommandFileName;	// script file to use
var() string		ItemCommandLabel;		// label to start in the script file
var() vector		SpawnOffset;			// offset from SpawnPoint location where items are spawned

var() Sound			CreateSound;			// if set, sound played "from" spawned actor when spawned
var() ESoundSlot	CreateSoundSlot;		// parameter for CreateSound
var() float			CreateSoundVolume;		// parameter for CreateSound
var() bool			CreateSoundbNoOverride;	// parameter for CreateSound
var() float			CreateSoundRadius;		// parameter for CreateSound
var() float			CreateSoundPitch;		// parameter for CreateSound

var() DefaultT		DefaultProps[8];		// property values to be assigned to spawned objects via property flipping

// stuff stolen from WoT SpewTrigger class:
var() bool bSpewActors;						// actors will be given velocity etc.
var() bool bTumble;							// if true spawned actors tumble (random rotation while falling)
var() bool bInheritVelocity;				// if true initial velocity is along direction SpewTrigger is aimed in
var() rotator SpewRotationSpread;			// if bInheritVelocity is true, Roation is randomized by this about SpewTrigger's Rotation
var() bool bCollision;						// set to true if spawned actors should have collision on
var() float MinSpeed;						// min initial speed
var() float MaxSpeed;						// max initial speed
var() bool bSilentDecorationBounce;			// if set, decorations shouldn't make bounce noise

// set by associated ActorFactory
var ActorFactory Factory;

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

function bool Create()
{
	local actor NewActor;
	local class<actor> SpawnClass;
	// make sure no player can see this SpawnPoint
	if( factory.bCovert && PlayerCanSeeMe() ) 
	{
		return false;
	}


	if( ItemPrototype != None )
		SpawnClass = ItemPrototype;
	else
		SpawnClass = factory.prototype;

	// create the creature
	NewActor = Spawn( SpawnClass, , , Location + SpawnOffset, , , Self );
	if( NewActor != None )
	{
		SetActorProps( NewActor );

		if( bSpewActors )
			SetSpewProps( NewActor );
				
		if( Pawn(NewActor) != None )
		{
			SetPawnProps( Pawn(NewActor), PawnFactory(factory) );
			if( PawnFactory( factory ) == None )
				DM( "Warning: a PawnFactory should be used to spawn pawns" );
		}

		// fire off the spawnpoints event
		class'TriggerHelper'.static.TriggerActors( Self, class'Actor', Self, Instigator, Event, true );

		if( CreateSound != None )
		{
			NewActor.PlaySound( CreateSound, 
								CreateSoundSlot, 
								CreateSoundVolume, 
								CreateSoundbNoOverride, 
								CreateSoundRadius, 
								CreateSoundPitch );
		}

		return true;
	}

	return false;
}

//-----------------------------------------------------------------------------
// set up the default properties before PreBeginPlay

event ModifyDefaultProperties( Actor SpawningActor )
{
	SetDefaultProps( SpawningActor );
}

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

function DestroyAllSpawnees()
{
	local actor Spawnee;
	local class<actor> ActorClass;
	local name ActorTag;

	if( ItemPrototype != None )
		ActorClass = ItemPrototype;
	else
		ActorClass = factory.prototype;

	if( ItemTag != '' )
		ActorTag = ItemTag;
	else
		ActorTag = factory.ItemTag;

	foreach AllActors( ActorClass, Spawnee, ActorTag )
		Spawnee.Destroy();
}

//-----------------------------------------------------------------------------
// NOTE: pretty similar to PropertyFlipper code -- these should be collapsed at 
// some point.

function SetProperty( Actor TargetActor, DefaultT PropertyInfo )
{
	if( PropertyInfo.Property ~= "CollisionHeight" || PropertyInfo.Property ~= "CollisionRadius" )
	{
		DMT( "WARNING: SpawnPoint DefaultProps need to use PT_Collision for " $ Self );
		return;
	}
	else if( PropertyInfo.Property ~= "DrawType" )
	{
		DMT( "WARNING: SpawnPoint DefaultProps need to use PT_DrawType for " $ Self );
		return;
	}
	else if( PropertyInfo.PropertyType == PT_Default && !TargetActor.CanSetProperty( PropertyInfo.Property ) )
	{
		DMT( "WARNING: can't set property '" $ PropertyInfo.Property $ "' (Type=" $ EnumStr( enum'EPropertyType', PropertyInfo.PropertyType ) $ ") for actor " $ TargetActor $ " using " $ Self );
		return;
	}
	
	switch( PropertyInfo.PropertyType )
	{
	case PT_Default:
		TargetActor.SetPropertyText( PropertyInfo.Property, PropertyInfo.Value );
		break;

	case PT_Physics:
		TargetActor.SetPhysics( PropertyInfo.PhysicsValue );
		break;

	case PT_Collision:
		TargetActor.SetCollisionSize( PropertyInfo.CollisionRadiusValue, PropertyInfo.CollisionHeightValue );
		break;

	case PT_bCollideActors:
		TargetActor.SetCollision( bool(PropertyInfo.Value) );
		break;

	case PT_DrawType:
		TargetActor.SetDrawType( PropertyInfo.DrawType );
		break;
		
	default:
		DMT( "Warning -- unhandled PropertyType" );
		break;
	}
}

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

function SetDefaultProps( Actor NewActor )
{
	local int i;
	
	for( i=0; i<ArrayCount(DefaultProps); i++ )
	{
		if( DefaultProps[i].Property != "" )
		{
			SetProperty( NewActor, DefaultProps[ i ] );
		}
	}
}

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

function SetActorProps( Actor NewActor )
{
	local rotator newRot;

	// orient new actor to that of the spawn point
	newRot = rot(0,0,0);
	newRot.yaw = rotation.yaw;
	NewActor.SetRotation(newRot);

	if( ItemEvent != '' )
	{
		NewActor.event = ItemEvent;

		/*mdf-tbd: assume LD's know what they are doing?
		if( factory.capacity > 1 )
			Log( "Warning: Setting spawned item's event will disrupt factory notification of spawned actor deaths" );
		*/
	}
	else
	{
		NewActor.event = factory.tag;
	}

	if( ItemTag != '' )
	{
		NewActor.tag = ItemTag;
	}
	else
	{
		NewActor.tag = factory.ItemTag;
	}
}

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

function SetSpewProps( Actor A )
{
	local Rotator SpewRotation;
	
	if( bTumble )
	{
		A.SetRotation( RotRand() );
		
		A.RotationRate.Yaw = 250000 * FRand() - 125000;
		A.RotationRate.Pitch = 250000 * FRand() - 125000;
		A.RotationRate.Roll = 250000 * FRand() - 125000;	
		A.DesiredRotation = RotRand();
		A.bRotateToDesired = false;
		A.bFixedRotationDir = true;
	}

	if( bInheritVelocity )
	{		
		// direction comes from SpewTrigger's current rotation
		SpewRotation = Rotation;

		SpewRotation.Yaw = class'Util'.static.PerturbInt( SpewRotation.Yaw, SpewRotationSpread.Yaw ) & 0xFFFF;
		SpewRotation.Roll = class'Util'.static.PerturbInt( SpewRotation.Roll, SpewRotationSpread.Roll ) & 0xFFFF;
		SpewRotation.Pitch = class'Util'.static.PerturbInt( SpewRotation.Pitch, SpewRotationSpread.Pitch ) & 0xFFFF;
	}
	else
	{
		// direction is random
		SpewRotation = RotRand();
	}

	A.Velocity = vector(SpewRotation) * RandRange( MinSpeed, MaxSpeed );

	// This is so the spawned actors will bounce around when they're spawned.
	A.bBounce = true;

	if( !bCollision )
	{
		// If this is not done, the actors will spawn in, hit each other, and end
		// up in a stupid stack.  This allows them to bounce/fall naturally.
		A.SetCollision( false );
	}
	
	// Sometimes the bouncing sounds are annoying.
	if( bSilentDecorationBounce )
	{
		if( U2Decoration(A) != None && U2Decoration(A).bBounceable )
		{
			U2Decoration(A).LandSound1 = None;
		}
	}

	// Other.
	A.SetPhysics( PHYS_Falling );
}

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

function SetPawnProps( Pawn P, PawnFactory PawnFactory )
{
	local Controller C;
	local Pawn CurrentEnemy;
	local U2NPCController U2NPCC;

	C = P.Controller;
	CurrentEnemy = C.ControllerEnemy;
	
	if( CurrentEnemy != None )
		C.EnemyDetected( CurrentEnemy.Location );

	if( PawnFactory.Team != PawnFactory.default.Team )
	{
		if( PawnFactory.Team >= Pawn.Team_MinValid && PawnFactory.Team <= Pawn.Team_MaxValid )
			P.TeamNumber = PawnFactory.Team;
		else
			DM( "Warning: invalid team index specified for PawnFactory " $ PawnFactory $ ": " $ PawnFactory.Team );
	}

	U2NPCC = U2NPCController(C);
	if( U2NPCC != None )
	{
		if( ItemOrders != '' )
		{
			U2NPCC.SetOrders( ItemOrders, None );
		}
		else
		{
			U2NPCC.SetOrders( PawnFactory.Orders, None );
		}

		if( ItemCommandFileName != "" )
		{
			U2NPCC.SetScript( ItemCommandFileName, ItemCommandLabel );
		}
		else
		{
			U2NPCC.SetScript( PawnFactory.CommandFileName, PawnFactory.CommandLabel );
		}
	}

}

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

function DumpInfo( Pawn P )
{
	P.log( "    name: "       $ name );
	P.log( "    event: "      $ event );
	P.log( "    tag: "        $ tag );
	P.log( "    eventtag: "   $ itemevent );
	P.log( "    itemtag: "    $ itemtag );
}

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

defaultproperties
{
	SpawnOffset=(Z=16.000000)
	bTumble=true
	bInheritVelocity=true
	MinSpeed=512.000000
	MaxSpeed=512.000000
	ConnectFlags=CFL_Source
	bFindBase=false
	Texture=Texture'U2.I_SpawnPoint'
	SoundVolume=128
	bDirectional=true
     UseReticleOnEvents(0)="UseReticleText"
     UseReticleOnEvents(1)="UseReticleCorners"
     UseReticleOnEvents(2)="UseReticleTopBars"
     ProximityReticleOnEvents(0)="ProximityReticleCorners"
     ProximityReticleOnEvents(1)="ProximityReticleTopBars"
}