UT99.org | Unreal Tournament Community

Code: Select all

//=============================================================================
// RotationalSpriteActor.
//=============================================================================
class RotationalSpriteActor expands Actor;

var(Sprites)	Texture	FrontSprite, FrontRightSprite, RightSprite, RearRightSprite, RearSprite, RearLeftSprite, LeftSprite, FrontLeftSprite;
var				byte	ClientSpriteNum;

function PreBeginPlay()
{
	DrawType = DT_Sprite;
}

replication
{
	reliable if (role == ROLE_Authority)
		FrontSprite, FrontRightSprite, RightSprite, RearRightSprite, RearSprite, RearLeftSprite, LeftSprite, FrontLeftSprite;
	unreliable if (role == ROLE_Authority)
		ClientSpriteNum;
}

function Tick(float Delta)
{
	local Rotator ViewAngle;

	Super.Tick(Delta);
	//do the math

	//placeholder

	//end math estimation of life B-)

	ClientSpriteNum = (ViewAngle.Roll * 8) / 360

	switch ClientSpriteNum:
		case 1:
			Sprite = FrontSprite;
		case 2:
			Sprite = FrontRightSprite;
		case 3:
			Sprite = RightSprite;
		case 4:
			Sprite = RearRightSprite;
		case 5:
			Sprite = RearSprite;
		case 6:
			Sprite = HearLeftSprite;
		case 7:
			Sprite = LeftSprite;
		case 8:
			Sprite = FrontLeftSprite;
		default:
			log('Invalid ClientSpriteNum: ' + string(ClientSpriteNum) + ' Destroying actor...');
			Destroy();
}

Code: Select all

//=============================================================================
// Breadcrumb.
//=============================================================================
class Breadcrumb expands Actor;

var		BreadcrumbPath	Pathes;
var()	float			MaxBreadcrumbDistance;
var		bool			bFindingPath;

function BreadcrumbPath AppendPathes(BreadcrumbPath A, BreadcrumbPath B)
{
	A.AddPath(B);
	return A;
}

function UpdatePathes()
{	
	local Breadcrumb BC;
	local Breadcrumbpath NewPath;
	local Breadcrumbpath Current;

	foreach AllActors(class'Breadcrumb', BC)
		if ( BreadcrumbReachable(BC) )
			for ( Current = Pathes; Current != None; Current = Current.Next )
				if ( Current.Next == None )
				{
					NewPath = Spawn(class'BreadcrumbPath', self);

					NewPath.Destination = BC;
					Current.Next = NewPath;

					break;
				}
}

function bool BreadcrumbReachable(Breadcrumb Other)
{
	return FastTrace(Other.Location) && -1024 < Other.Location.Z - Location.Z && Other.Location.Z - Location.Z < 256 && VSize(Other.Location - Location) < MaxBreadcrumbDistance;
}

function BreadcrumbPath FindPathToBreadcrumb(Breadcrumb Destination, BreadcrumbPath Path)
{
	local BreadcrumbPath Current;
	local BreadcrumbPath NewPath;
	local BreadcrumbPath BP;

	for ( Current = Pathes; Current.Next != None; Current = Current.Next )
		if ( Current.Destination == Destination )
			return AppendPathes(Path, Current);
		
		else 
			if ( !BreadcrumbInPathes(Current.Destination, Path) )
				return Current.Destination.FindPathToBreadcrumb(Destination, AppendPathes(Path, Current));

	return None;
}

function PostBeginPlay()
{
	UpdatePathes();
}

function bool BreadcrumbInPathes(Breadcrumb Current, BreadcrumbPath Pathes)
{
	local BreadcrumbPath BP;

	for ( BP = Pathes; BP.Next != None; BP = BP.Next )
		if ( BP.Next == Current )
			return true;

	return false;
}

function BreadcrumbPath PathAt(BreadcrumbPath Root, int Index)
{
	local int i;
	local BreadcrumbPath BP;

	for ( BP = Root; BP.Next != None; BP = BP.Next )
	{
		if ( i == Index )
			return BP;

		i++;
	}

	return none;
}

function Leaving(Pawn Other, BreadcrumbPath Next, Breadcrumb Destination)
{
	Next.ControlEntrance(Other, Destination);

	Destination.Entering(Other, Next, Destination);
}

function Entering(Pawn Other, BreadcrumbPath Origin, Breadcrumb Destination);

auto	state()	Activated	{}
	state()	Deactivated	{}

Code: Select all

//=============================================================================
// AutoRocket.
//=============================================================================
class AutoRocket expands UT_SeekingRocket;

var()	float	SeekAcceleration, SeekSpeed, TargetAcquiringRadius, WallAvoidSpeed, WallPredictionFactor, WallAvoidSlowdown;
var		Pawn	User;
var		int		Slowdown;
var		bool	bFoundUser;

replication
{
	reliable if ( Role == ROLE_Authority )
		User,
		Slowdown,
		bFoundUser;
}

simulated event Vector EstimateLocation(Actor Other)
{
	return Other.Location + (Other.Velocity / VSize(Velocity)) * 0.5;
}

simulated event HomeAt(Actor Other)
{
	Velocity *= VSize(Velocity cross (EstimateLocation(Seeking) - Location)) * SeekAcceleration;
	Acceleration = (EstimateLocation(Seeking) - Location) * SeekSpeed;
}

simulated event Actor WillHitWall(optional out Vector Location, optional out Vector OutNormal)
{
	return Trace(Location, OutNormal, Self.Location + Velocity * WallPredictionFactor);
}

simulated event bool CheckSeekable(Pawn Other, Pawn FireAgent)
{
	if
	(
		Other != None
		&&
		(
			FireAgent == None
			||
			(
				FastTrace(Other.Location)
				&& Other != FireAgent
				&& !Other.IsInState('Dying')
				&&
				(
					(
						ScriptedPawn(FireAgent) != None
						&& ScriptedPawn(FireAgent).AttitudeTo(Other) != ATTITUDE_Friendly
					)
					||
					(
						ScriptedPawn(Other) != None
						&& ScriptedPawn(Other).AttitudeTo(FireAgent) != ATTITUDE_Friendly
					)
					||
					(
						PlayerPawn(FireAgent) != None
						&& Other.AttitudeToPlayer != ATTITUDE_Friendly
						&& Other.PlayerReplicationInfo.Team != FireAgent.PlayerReplicationInfo.Team
					)
					|| Other.PlayerReplicationInfo.Team != FireAgent.PlayerReplicationInfo.Team
				)
			)
		)
	)	
	{
		return True;
	}

	return False;
}

function BeginPlay()
{
	if ( Owner == None )
		return;

	if ( Pawn(Owner) != None )
		User = Pawn(Owner);

	else
		User = Pawn(Owner.Owner);

	if ( User == None )
		return;
}

simulated function SetTarget(Pawn Other)
{
	Seeking = Other;

	Log(self@"is now seeking after:"@Other);
}

simulated event Timer()
{
	local Pawn P;
	local Pawn Target;
	local Actor A;
	local Vector WallNorm, WallLoc;

	SetRotation(Rotator(Velocity));

	A = WillHitWall(WallLoc, WallNorm);

	if ( A != None && ( LevelInfo(A) != None || !CheckSeekable(Pawn(A), User) ) && WallNorm dot (Velocity + Acceleration) < 0.9 )
	{
		Velocity /= WallAvoidSlowdown;
		Slowdown *= WallAvoidSlowdown;
		Acceleration -= WallAvoidSpeed * 2 * (WallNorm dot Velocity) * WallNorm;
	}

	else if ( Slowdown > 1 )
	{
		Velocity *= Slowdown;
		Slowdown = 1;
	}

	else bFoundUser = True;

	if ( Seeking != None && ( Pawn(Seeking) == None || !Pawn(Seeking).IsInState('Dying') || ( ScriptedPawn(Seeking) == None && User != None && ScriptedPawn(Seeking).AttitudeTo(User) == ATTITUDE_Friendly ) ) )
	{
		HomeAt(Seeking);
	}

	else
	{
		foreach RadiusActors(class'Pawn', P, TargetAcquiringRadius)
		{
			if ( Target == None || VSize(P.Location - Location) < VSize(Target.Location - Location) )
			{
				Target = P;

				if ( CheckSeekable(Target, User) )
					SetTarget(Target);
			}
		}
	}
}