Food Feud

class FFSquadAI extends UTSquadAI;

var FFBaseObjective homeBase, enemyBase;

var FFFlag ownedFlags[ 3 ];
var FFFlag enemyFlags[ 3 ];
var FFFlag neutralFlags[ 3 ];
var int nOwnedFlags;
var int nEnemyFlags;
var int nNeutralFlags;

var float AIDropFlagDistTolerance;
var float AIIgnoreFlagDistance;

/* FindPathToObjective()
Returns path a bot should use moving toward a base
*/
function bool FindPathToObjective( UTBot B, Actor O )
{
	// don't ever use gather points when have flag
	if ( UTPlayerReplicationInfo(B.PlayerReplicationInfo).bHasFlag )
	{
		B.bFinalStretch = true;
	}

	return Super.FindPathToObjective(B, O);
}

// Find out who owns which flags
function RecheckFlagStatus()
{
	local FFFlag curFlag;

	nOwnedFlags = 0;
	nEnemyFlags = 0;
	nNeutralFlags = 0;

	foreach AllActors(class'FoodFeud.FFFlag', curFlag )
	{
		if ( curFlag.Team == Team )
		{
			ownedFlags[ nOwnedFlags ] = curFlag;
			++nOwnedFlags;
		} 
		else if ( curFlag.Team == none )
		{
			neutralFlags[ nNeutralFlags ] = curFlag;
			++nNeutralFlags;
		}
		else
		{
			enemyFlags[ nEnemyFlags ] = curFlag;
			++nEnemyFlags;
		}
	}
}

/* OrdersForFlagCarrier()
Tell bot what to do if he's carrying the flag
*/
function bool OrdersForFlagCarrier( UTBot B )
{
	//local UTCTFBase FlagBase;

	B.GoalString = "Return to Base with enemy flag!";
	if ( !FindPathToObjective( B, homeBase ) )
	{
		B.GoalString = "No path to home base for flag carrier";
		// FIXME - suicide after a while
		`log( "Bot could not find path to home base" );
		return false;
	}

	if ( B.MoveTarget == homeBase )
	{
		B.GoalString = "Near my Base with enemy flag!";
		
		if ( VSize( B.Pawn.Location - homeBase.Location ) < AIDropFlagDistTolerance )
			FFPawn( B.Pawn ).DropFlag();
	}
	return true;
}


function bool CheckSquadObjectives( UTBot B )
{
	local FFFlag closestFlag;
	local float closestFlagDist;
	local FFCTF game;
	local UTGameObjective testObjective;

	if ( UTPlayerReplicationInfo(B.PlayerReplicationInfo).bHasFlag )
		return OrdersForFlagCarrier(B);

	AddTransientCosts(B,1);
	
	// Always grab a free flag when it's visible and close enough
	game = FFCTF( WorldInfo.Game );
	closestFlag = game.ClosestVisibleFreeFlag( B );
	
	if ( closestFlag != none )
	{
		// I see a free flag
		closestFlagDist = VSize( closestFlag.Location - B.Pawn.Location );
		
		if ( closestFlagDist < AIIgnoreFlagDistance )
		{
			// Flag is close enough to matter
			if ( closestFlagDist < game.FlagGrabDistance )
			{
				// Flag is close enough to grab
				FFPawn( B.Pawn ).GrabFlag( closestFlag );
				return OrdersForFlagCarrier( B );
			}
			
			// Move to the flag
			if ( FindPathToObjective( B, closestFlag ) )
				return true;
		}
	}

	// Don't see a free flag, or no path to it.
	// If I'm not grabbing a free flag, then...

	// If we have a delivery guy who is boosting, go grab a granny.
	if ( FFBot( B ).bBoosting )
	{
		if ( FFFlagSpawnPoint( SquadObjective ) == none )
		{
			testObjective = FFCTF( WorldInfo.Game ).FindReadyFlagBaseObjective();
			if ( testObjective != none )
			{
				if ( FFFlagSpawnPoint( testObjective ).bFlagIsHere )
					SquadObjective = testObjective;
			}
		}
		
		if ( FFFlagSpawnPoint( SquadObjective ) == none && B.Enemy != none )
			return false;
	}
	// I should go to the squad's objective only if I'm not actively fighting
	else if ( B.Enemy != none )
	{
		return false;
	}
	
	// If I've reached my squad's objective, send my squad somewhere else
	if ( SquadObjective == none || VSize( B.Pawn.Location - SquadObjective.Location ) < AIDropFlagDistTolerance )
	{
		UTTeamInfo( Team ).AI.FindNewObjectiveFor( self, true );
		// Or TellBotHowToDisable() could set a new squad objective.
		return true;
	}

	return Super.CheckSquadObjectives(B);
}

DefaultProperties
{
	AIDropFlagDistTolerance = 100;
	AIIgnoreFlagDistance = 1000;
}

class GreaseTrapProjectile extends Actor;

var float BounceRatio;

var float maxLifespan;
var float curAge;
var float greaseDuration;
var float greaseGrowTime;
var float greaseShrinkTime;
var float greaseMaxRadius;
var float greaseRadius;

var byte nBounces;
var byte maxBounces;

var GreaseBlob myBlob;

var Controller damageInstigator;

//=========================================================================
//=========================================================================
auto simulated state Flying
{
	simulated function Tick( float DeltaTime )
	{
		curAge += DeltaTime;
		if ( curAge > maxLifespan ) Landed( Velocity, none );
	}

	//=========================================================================
	//=========================================================================
	simulated function Landed( Vector HitNormal, Actor FloorActor )
	{
		SetPhysics( PHYS_NONE );

		GotoState('Resting');
	}

	//=========================================================================
	//=========================================================================
	simulated function HitWall (vector norm, actor wall, primitivecomponent something )
	{
		if ( wall.bWorldGeometry )
		{
			if ( norm.Z > 0.7 )
			{
				++nBounces;

				if ( nBounces > maxBounces )
				{
					Landed( norm, wall );
				
					return;
				}
			}
			
			Velocity = BounceRatio * (( Velocity dot norm ) * norm * (-2.0) + Velocity);
		}
	}
	
	//=========================================================================
	//=========================================================================
	simulated function BeginState( Name PreviousStateName )
	{
		curAge = 0;
	}
}

//=========================================================================
//=========================================================================
simulated state Resting
{
	simulated function Tick( float DeltaTime )
	{
		curAge += DeltaTime;
		
		if ( curAge > greaseDuration )
		{
			myBlob.Destroy();
			Destroy();
			return;
		}
		else if ( curAge > greaseDuration - greaseShrinkTime )
		{
			greaseRadius = ( greaseDuration - curAge ) / greaseShrinkTime * greaseMaxRadius;
			myBlob.setSize( greaseRadius );
		}
		else if ( curAge > greaseGrowTime )
		{
			if ( greaseRadius < greaseMaxRadius )
			{
				greaseRadius = greaseMaxRadius;
				myBlob.setSize( greaseRadius );
			}
		}
		else
		{
			greaseRadius = curAge / greaseGrowTime * greaseMaxRadius;
			myBlob.setSize( greaseRadius );
		}
	}
	
	simulated function BeginState( Name PreviousStateName )
	{
		if ( Role == ROLE_Authority )
		{
			myBlob = Spawn( class'FoodFeud.GreaseBlob' );

			myBlob.DamageInstigator = damageInstigator;
		}

		curAge = 0;
	}
}

//=========================================================================
//=========================================================================
replication
{
	if ( Role==ROLE_Authority )
		BounceRatio, maxLifespan, curAge,
		greaseDuration, greaseGrowTime,
		greaseShrinkTime, greaseMaxRadius,
		nBounces, maxBounces, myBlob;
}

//=========================================================================
//=========================================================================
DefaultProperties
{
	Begin Object Class=DynamicLightEnvironmentComponent Name=MyLightEnvironment
	End Object
	Components(0)=MyLightEnvironment

	Begin Object Class=StaticMeshComponent Name=MyStaticMesh
		LightEnvironment=MyLightEnvironment
		StaticMesh=StaticMesh'FoodFued.Models.fry_basket_mesh_01'
	End Object
	Components(1)=MyStaticMesh
	CollisionComponent=MyStaticMesh;

	RemoteRole=ROLE_SimulatedProxy;

	bCollideWorld=true
	Physics=PHYS_Falling
	bStatic=False
	bMovable=True
	bAlwaysRelevant=true;

	bBounce = true
	curAge = 0
	nBounces = 0;
	greaseRadius = 0; 
	
	// How bouncy is it ( 0 - no bounce, 1 - crazy bouncy )
	BounceRatio = 0.3
	
	// How many times does the grease trap bounce on the ground before landing
	maxBounces = 1;

	// How long will it bounce around before exploding due to timeout
	maxLifespan = 5
	
	// How long is the grease ball active
	greaseDuration = 13;
	
	// How much of that time is spent growing to full size?
	greaseGrowTime = 2;

	greaseShrinkTime = 1;

	greaseMaxRadius = 500;

	
}