U2.U2Grapple

//=============================================================================
// $Author: Mfox $
// $Date: 4/30/02 12:34p $
// $Revision: 4 $
//=============================================================================

//------------------------------------------------------------------------------
// Name:	U2Grapple.uc
// Author:	Aaron R Leiby
// Date:	4 August 2000
//------------------------------------------------------------------------------
// Description:	
//------------------------------------------------------------------------------
// How to use this class:
//------------------------------------------------------------------------------

class U2Grapple extends Inventory;

// Fix ARL: Needs pickup.

struct T_Contact
{
	var() Actor					Actor;
	var   vector				Offset;
	var() vector				Point;
	var   PulseLineGenerator	Cable;
};

var() float      ContractSpeed;
var() float      MinContractLength;

var() float      ExtendSpeed;
var() float      MaxExtendLength;

var   T_Contact  Contacts[32];
var   int        cIndex;

var   float      TimeActivated;
var   float      LastDeltaTime;
var   float      Dampening;

var   bool       bGrappling;

replication
{
	unreliable if( Role<ROLE_Authority )
		Grapple, UnGrapple;
}

//------------------------------------------------------------------------------
function SetContactPoint( int Index, Actor A, vector P )
{
	Contacts[Index].Actor = A;
	Contacts[Index].Point = P;
	if( A != None )
	{
		Contacts[Index].Offset = (P - A.Location) << A.Rotation;
	}
}

//------------------------------------------------------------------------------
function vector GetContactPoint( int Index )
{
	if( Contacts[Index].Actor != None )
	{
		return Contacts[Index].Actor.Location + (Contacts[Index].Offset >> Contacts[Index].Actor.Rotation);
	}
	else
	{
		return Contacts[Index].Point;
	}
}

//------------------------------------------------------------------------------
function InitCable( int Index, vector Start, vector End )
{
	if( Contacts[Index].Cable == None )
	{
		Contacts[Index].Cable = Spawn( class'PulseLineGenerator' );
	}
	Contacts[Index].Cable.Connections[0].Start	= End;
	Contacts[Index].Cable.Connections[0].End	= Start;
	Contacts[Index].Cable.bHidden				= false;

	Owner.SwingPivot = Start;
	Owner.SwingLength = VSize(Start - End);
}

//------------------------------------------------------------------------------
function ResetContact( int Index )
{
	if( Contacts[Index].Cable != None )
	{
		Contacts[Index].Cable.bHidden = true;
	}
	Contacts[Index].Actor = None;
}

//------------------------------------------------------------------------------
function UpdateCables()
{
	local vector Start, Dir, P;
	local CheckResult Hit;

	P     = GetContactPoint( cIndex );
	Start = Owner.Location;
	Dir   = P - Owner.Location;

	if
	(	!class'Util'.static.RSLC( Hit, Owner, Start, Dir,,, TRACE_AllColliding | TRACE_ProjTargets )
//!!arl	&&	(GetSurfFlags(Hit) & PF_FakeBackdrop)==0
	)
	{
		if( Hit.Actor != None && Hit.Actor.IsA('LevelInfo') )
		{
			Hit.Actor = None;
		}

		SetContactPoint( cIndex, Hit.Actor, Hit.Location );
		InitCable( cIndex, GetContactPoint( cIndex ), Owner.Location );
	}
}

//------------------------------------------------------------------------------
event Tick( float DeltaTime )
{
	if( bGrappling )
	{
		TimeActivated += DeltaTime;
		LastDeltaTime = DeltaTime;

		UpdateCables();

		if( Owner.SwingLength > MinContractLength )
		{
			Owner.SwingLength -= FMin( Sqrt(Owner.SwingLength - MinContractLength) * 60.0, ContractSpeed ) * DeltaTime;
		}
		else if( Owner.SwingLength < MaxExtendLength )
		{
			Owner.SwingLength += (MaxExtendLength - Owner.SwingLength) / 10.0 * DeltaTime;
		}
	}
}

//------------------------------------------------------------------------------
exec function Grapple()
{
	local vector Start, Dir;
	local CheckResult Hit;

	TimeActivated = 0;

	Start = Owner.Location + vect(0,0,1) * Pawn(Owner).BaseEyeHeight;
	Dir   = vector(Pawn(Owner).GetViewRotation());

	if
	(	!class'Util'.static.RSLC( Hit, Owner, Start, Dir,,, TRACE_AllColliding | TRACE_ProjTargets )
//!!arl	&&	(GetSurfFlags(Hit) & PF_FakeBackdrop)==0
	)
	{
		Owner.Velocity = vect(0,0,0);
		Owner.SetPhysics( PHYS_Swinging );
		Owner.SwingFriction = Dampening;

		if( Hit.Actor != None && Hit.Actor.IsA('LevelInfo') )
		{
			Hit.Actor = None;
		}

		cIndex = 0;
		SetContactPoint( cIndex, Hit.Actor, Hit.Location );
		InitCable( cIndex, GetContactPoint( cIndex ), Owner.Location );

		bGrappling = true;
	}
}

//------------------------------------------------------------------------------
exec function UnGrapple()
{
	local int i;

	Owner.SetPhysics( PHYS_Falling );
	Owner.SwingLength = 0;

	if( TimeActivated > 0.2 )
	{
		Owner.Velocity = 0.7 * (Owner.Location - Owner.ColLocation) / LastDeltaTime;
	}

	for( i=0; i<ArrayCount(Contacts); i++ )
	{
		ResetContact(i);
	}

	bGrappling = false;
}



/*
//     bActivatable=True
//     PickupMessage="You picked up Aaron's test grapple"
//     RespawnTime=40.000000
//     PickupViewMesh=Mesh'UnrealShare.Flashl'
//     PickupSound=Sound'UnrealShare.Pickups.GenPickSnd'
//     Icon=Texture'UnrealShare.Icons.I_Flashlight'
//     Mesh=Mesh'UnrealShare.Flashl'
*/

defaultproperties
{
	ContractSpeed=900.000000
	MinContractLength=200.000000
	ExtendSpeed=30.000000
	MaxExtendLength=100.000000
	Dampening=0.300000
	bDisplayableInv=true
	RemoteRole=ROLE_DumbProxy
	AmbientGlow=96
	CollisionHeight=4.000000
     UseReticleOnEvents(0)="UseReticleText"
     UseReticleOnEvents(1)="UseReticleCorners"
     UseReticleOnEvents(2)="UseReticleTopBars"
     ProximityReticleOnEvents(0)="ProximityReticleCorners"
     ProximityReticleOnEvents(1)="ProximityReticleTopBars"
}