UPawn - Remaking Pawn in UnrealScript

[Gustavo6046]

Do you know the Pawn class? Chances are you do. You know, that ugly, native, unflexible, boring class which is hard to extend and harsh to subclass.

Well, not for long!

Presenting, UPawn. Well, it's not done yet, but this pre-alpha code compiles. Whenever it does something I'll test it.
In fact, this is a remade version of Pawn, which uses the projectile physics to be able to walk on surfaces in a flexible way, but that's not it! It also supports Fun, and in the future, it'll have many more features!

Code: Select all

//=============================================================================
// UPawn.
//=============================================================================
class UPawn expands Actor;

enum PawnType
{
	PT_None,
	PT_Native,
	PT_New,
	PT_Both
};

enum PawnPhysics
{
	PP_Walking,
	PP_Falling,
	PP_Swimming,
	PP_Flying
};

enum NavigationClass
{
	NC_Breadcrumb,
	Nc_Native
};

struct WeaponUse
{
	var()	float		MinRange, MaxRange;
	var()	float		AverageDmg;
	var()	float		SplashRange;
	var()	float		ProjSpeed;
	var()	float		ShootRate;
};

struct AnyPawn
{
	var()	PawnType	ThisType;
	var()	Pawn		Native;
	var()	UPawn		New;
};

// UPhysics.
var(UPhysics)	float				MaxFloorPitch;
var(UPhysics)	Vector				MovementBob;
var(UPhysics)	float				JumpSpeed;
var(UPhysics)	float				WalkSpeed;
var(UPhysics)	AnyPawn				Mount;

// Artificial Intelligence of UPawn.
var(AI)			float				EyeHeight;
var(AI)			float				Cowardness;
var(AI)			float				Smartness;
var(AI)			float				Boredness;
var(AI)			float				Eagerness; // how fast the fun of playing only a single Toy is lost
var(AI)			class<Weapon>		FavoriteGun;
var(AI)			WeaponUse			GunStats;
var(AI)			Pawn				Enemies[32];
var(AI)			Pawn				PriorityEnemy;
var(AI)			NavigationClass		NavType;
var				Actor				Toy;
var				float				ToyStrenght;
var				int					PlayTimes;

// Inventory stuff.
var(PawnInv)	Inventory			StartingInv[64];
var(PawnInv)	Weapon				CurrentWeapon;

var(Anim)		float				IdleSpeed;
var(Anim)		float				BoredModifier; // multiplies idle anim speed when bored

var				Rotator				FloorNormal;
var				Vector				WalkOffset;
var				Vector				OldVel;
var				Actor				NvCurrent;
var				Actor				NvNext;
var				int					PathSize;
var				Inventory			Inv;
var				float				CurrentSpeed;
var				name				InterruptingWalk;
var				name				OldState;
var				bool				bMoving;


simulated function PreBeginPlay()
{
	local Vector v, n;

	v = Location;
	v.Z -= 16384;

	Trace(v, n, v);

	FloorNormal = Rotator(n);
}

simulated function bool ActorCloser(Actor Other, Actor aFrom)
{
	return aFrom == None || VSize(Other.Location - Location) < VSize(aFrom.Location - Location);
}

simulated function WalkToward(Actor Target, float Speed, bool bStrafe)
{
	WalkNormal(Rotator(Target.Location - Location).Yaw, VSize(Location - Target.Location), Speed, bStrafe);
}

simulated function WalkTo(Vector Target, float Speed, bool bStrafe)
{
	WalkNormal(Rotator(Target - Location).Yaw, VSize(Location - Target), Speed, bStrafe);
}

simulated function WalkNormal(float Angle, float Distance, float Speed, bool bStrafe)
{
	local Rotator Dir;

	Dir = FloorNormal;
	Dir.Yaw = Angle;

	if ( !bStrafe )
		SetRotation(Dir);

	WalkOffset += Vector(Dir) * Distance;
	CurrentSpeed = WalkSpeed * Speed;
	OldState = GetStateName();

	GoToState('Walking');
}

simulated function Actor NextTo(Actor Target)
{
	local Breadcrumb Closest, B;
	local NavigationHelper H;

	if ( Breadcrumb(NvCurrent) != None )
	{
		foreach AllActors(class'Breadcrumb', B)
			if ( ActorCloser(B, Closest) )
				Closest = B;

		NvNext = Breadcrumb(NvCurrent).FindPathToBreadcrumb(Closest).Next;
	}

	else if ( NavigationPoint(NvCurrent) != None )
	{
		H = Spawn(class'NavigationHelper', self);
		H.LoadPathToward(Target);

		NvNext = H.Helped(true);
	}

	return NvNext;
}

simulated function bool Walkable(vector Normal)
{
	return Rotator(Normal).Pitch / 65535 < MaxFloorPitch;
}

simulated function StopWalking(name NewState)
{
	if ( IsInState('Walking') )
		InterruptingWalk = NewState;
}

simulated function Tick(float TimeDelta)
{
	if ( bMoving )
	{
		Velocity = OldVel;

		bMoving = false;
	}
}

simulated function GotFun(Actor Source, float Strenght)
{
	Boredness -= Strenght;

	if ( Source == Toy )
	{
		ToyStrenght -= PlayTimes * Eagerness - Strenght;
		PlayTimes++;

		return;
	}

	if ( Strenght > ToyStrenght )
	{
		Toy = Source;
		ToyStrenght = Strenght;
		PlayTimes = 0;
	}
}

simulated function TickMove(Vector NewLocation)
{
	Velocity = NewLocation - Location;
	OldVel = Velocity;

	bMoving = true;
}

simulated function HitWall(vector HitNormal, Actor Wall)
{
	Landed(HitNormal);
}

simulated function Landed(vector Normal)
{
	if ( !Walkable(Normal) )
		return;

	FloorNormal = Rotator(Normal);
}

auto state Idle
{
	function Timer()
	{
		Boredness += 1;
	}

Begin:
	SetTimer(0.5, true);

	if ( Boredness > 16 )
		GoToState('Bored');

	LoopAnim('Idle', IdleSpeed);
}

function Roam()
{
	local Vector v, Norm, f;

	v = Location + VRand() * 60;

	while ( !FastTrace(v) )
		v = Location + VRand() * 60;

	f = v;
	f.Z -= CollisionHeight * 1.6;

	Trace(v, Norm, f, v);

	WalkTo(v, 0.9, false);
}

state Bored
{
	function Timer()
	{
		Boredness += 1;

		if ( FRand() < Eagerness )
			Roam();
	}

Begin:
	LoopAnim('Idle', IdleSpeed + BoredModifier);

	if ( Boredness > 36 )
		Roam();
}

state Walking
{
	function EndWalk()
	{
		GoToState(OldState);
	}

	function Tick(float TimeDelta)
	{
		while ( VSize(WalkOffset) > (CurrentSpeed * 2.0) )
		{
			if ( InterruptingWalk != 'None' )
			{
				EndWalk();

				GoToState(InterruptingWalk);
			}

			else
			{
				TickMove(Location + Normal(WalkOffset) * CurrentSpeed);

				WalkOffset -= Normal(WalkOffset);
			}
		}

		EndWalk();
	}
}

I know this project is going to be VERY hard to code. That's why I'm a programmer!

[ShaiHulud]

Interesting concept. There aren't a lot of obvious entry points for modifying the stock bot behaviour, which makes it a bit tricky to bend them to your will (and another reason I've been planning to investigate FerBotz for building off of instead in future).

[sektor2111]

Interesting concept.

and probably useless done by a "programmer".
First of all

Code: Select all

//=============================================================================
// Pawn, the base class of all actors that can be controlled by players or AI.
// This is a built-in Unreal class and it shouldn't be modified.
//=============================================================================
class Pawn extends Actor 
	abstract
	native
	nativereplication;
.....
var		vector		LastSeenPos; 		// enemy position when I last saw enemy (auto updated if EnemyNotVisible() enabled)
var		vector		LastSeeingPos;		// position where I last saw enemy (auto updated if EnemyNotVisible enabled)
var		float		LastSeenTime;
var	 	Pawn    	Enemy; //LOL I'm gonna see who will fight with an actor and not a Pawn

Then all creatures having an ENEMY are taking in account a Pawn and NOT an Actor to not forget all "Pawn(Owner)" and all chained things with Pawn. It is when everything will get broken in a full mess... but no worries I did not see more things finished and fully operational yet in forum by our sweet friend. Good luck, Gustavo, with your project ! When it will be ready I'll be the one using it...

PS: If this would be operational it would be created years ago...

[Gustavo6046]

Code: Select all

var	 	Pawn    	Enemy; //LOL I'm gonna see who will fight with an actor and not a Pawn

First, I'm intending to replace Pawn (unless of course I come up with some fucked up Pawn subclass which manages to work with those UPawn thingies around). Second, I'm intending to have UPawn support Pawn, and both GusPackII Breadcrumbs (when available) and NavigationPoints.

(where are the preprocessor statements )

Finally, I'm not going to code a ton of stuff at the same time -- got to fix GusBot3's command wrapper.

But don't worry ~ I've got physics planned. I'm going to extend every feature I see wrong or limited in Pawn ~ everything else will be consequences.

As for replication, I'll analyze variables that need to be replicated, and for now set most functions as "simulated" ~ I'll unsimulate some functions after the code.

[PrinceOfFunky]

At this point you should put a "brain" variable to use neural networks and genetic algorithms .o.

[Gustavo6046]

At this point you should put a "brain" variable to use neural networks and genetic algorithms .o.

holy shit I already tried that ages ago why can't I do neural networks g r r r r r
(although I do know that, nowadays, this is not exactly the way one does a neural network. help me plzzzz)

NeuralNetwork

Code: Select all

//=============================================================================
// NeuralNetwork.
//=============================================================================
class NeuralNetwork expands Info;

var	byte		NumLayers;
var	NeuralLayer	Layers[32];

function SetUp(int InputSize, int Sizes[32])
{
	local	int	i;

	for ( i = 0; i < NumLayers; i++ )
	{
		Layers[i] = Spawn(class'NeuralLayer', self);
		Layers[i].OutputSize = Sizes[i];

		if ( i == 0 )
			Layers[i].SetUp(InputSize);

		else
			Layers[i].SetUp(Sizes[i - 1]);
	}
}

function Activate(out float Inputs[63], float Fitness)
{
	local	float	Results[63];
	local	int		i;

	Log(Layers[0].Nodes[0].InputSize);
	for ( i = 0; i < Layers[0].Nodes[0].InputSize; i++ )
		Results[i] = Inputs[i];

	for ( i = 0; i < NumLayers; i++ )
		Layers[i].Activate(Results, Fitness);

	Log(Layers[NumLayers - 1].OutputSize);
	for ( i = 0; i < Layers[NumLayers - 1].OutputSize; i++ )
		Inputs[i] = Results[i];
}

static function NeuralNetwork QuickBuild(Actor NNUser, byte InputSize, int Sizes[32], optional byte NumLayers)
{
	local	int				i;
	local	NeuralNetwork	FinalNN;

	if ( NumLayers < 1 )
	{
		NumLayers = 0;

		for ( i = 0; i < 32; i++ )
		{
			if ( Sizes[i] < 1 )
				break;

			NumLayers++;
		}

		if ( NumLayers == 0 )
			return None;
	}

	FinalNN = NNUser.Spawn(class'NeuralNetwork', NNUser);
	FinalNN.NumLayers = NumLayers;
	FinalNN.SetUp(InputSize, Sizes);

	return FinalNN;
}

NeuralLayer

Code: Select all

//=============================================================================
// NeuralLayer.
//=============================================================================
class NeuralLayer expands Info;

var	LinearNode	Nodes[63];
var	byte		OutputSize;

function SetUp(byte InputSize)
{
	local int i;

	for ( i = 0; i < OutputSize; i++ )
	{
		Nodes[i] = Spawn(class'LinearNode', self);
		Nodes[i].InputSize = InputSize;
		Nodes[i].SetUp();
	}
}

function Activate(out float Inputs[63], float Fitness)
{
	local float Result[64];
	local int i;

	for ( i = 0; i < OutputSize; i++ )
	{
		Result[i] = Nodes[i].ActivateNode(Inputs, Spawn(class'MinFitness'));
	}
		
	for ( i = 0; i < OutputSize; i++ )
		Inputs[i] = Result[i];
}

LinearNode

Code: Select all

//=============================================================================
// LinearNode.
//=============================================================================
class LinearNode expands Info;

var		float		Weights[63];
var		byte		InputSize;

var()	float		Eta;

function SetUp()
{
	local int i;

	for ( i = 0; i < InputSize; i++ )
		Weights[i] = FRand() * 2.0 - 1.0;
}

function float ProcessOutput(float Output)
{
	return Output;
}

function float Dot63(float A[63], float B[63])
{
	local float Result;
	local int 	i;

	for ( i = 0; i < InputSize; i++ )
		Result += A[i] * B[i];

	return Result;
}

function float ActivateNode(float Inputs[63], MinFitness FitnessEvaluator)
{
	local float Result; 
	local int 	i;

	Result = Dot63(Inputs, Weights);
	
	for ( i = 0; i < InputSize; i++ )
		Weights[i] += Eta * ProcessOutput(Result) * (1 - FitnessEvaluator.Evaluator(i, Eta, Weights[i], Result, Inputs[i])) * Inputs[i];

	return Result;
}

SigmoidNode

Code: Select all

//=============================================================================
// SigmoidNode.
//=============================================================================
class SigmoidNode expands LinearNode;

function float ProcessOutput(float Output)
{
	return 1.0 / (1.0 + 2.718281828459045235360287 ** -Output);
}

UnitStepNode

Code: Select all

//=============================================================================
// UnitStepNode.
//=============================================================================
class UnitStepNode expands LinearNode;

function float ProcessOutput(float Output)
{
	if ( Output < 0 )
		return 0;

	return 1;
}

Sorry for my autism excitation, I'm just excited duh for the coincidence of you talking about a neural network when I already tried doing one in UnrealScript.

[PrinceOfFunky]

Spoiler

At this point you should put a "brain" variable to use neural networks and genetic algorithms .o.

holy shit I already tried that ages ago why can't I do neural networks g r r r r r
(although I do know that, nowadays, this is not exactly the way one does a neural network. help me plzzzz)

NeuralNetwork

Code: Select all

//=============================================================================
// NeuralNetwork.
//=============================================================================
class NeuralNetwork expands Info;

var	byte		NumLayers;
var	NeuralLayer	Layers[32];

function SetUp(int InputSize, int Sizes[32])
{
	local	int	i;

	for ( i = 0; i < NumLayers; i++ )
	{
		Layers[i] = Spawn(class'NeuralLayer', self);
		Layers[i].OutputSize = Sizes[i];

		if ( i == 0 )
			Layers[i].SetUp(InputSize);

		else
			Layers[i].SetUp(Sizes[i - 1]);
	}
}

function Activate(out float Inputs[63], float Fitness)
{
	local	float	Results[63];
	local	int		i;

	Log(Layers[0].Nodes[0].InputSize);
	for ( i = 0; i < Layers[0].Nodes[0].InputSize; i++ )
		Results[i] = Inputs[i];

	for ( i = 0; i < NumLayers; i++ )
		Layers[i].Activate(Results, Fitness);

	Log(Layers[NumLayers - 1].OutputSize);
	for ( i = 0; i < Layers[NumLayers - 1].OutputSize; i++ )
		Inputs[i] = Results[i];
}

static function NeuralNetwork QuickBuild(Actor NNUser, byte InputSize, int Sizes[32], optional byte NumLayers)
{
	local	int				i;
	local	NeuralNetwork	FinalNN;

	if ( NumLayers < 1 )
	{
		NumLayers = 0;

		for ( i = 0; i < 32; i++ )
		{
			if ( Sizes[i] < 1 )
				break;

			NumLayers++;
		}

		if ( NumLayers == 0 )
			return None;
	}

	FinalNN = NNUser.Spawn(class'NeuralNetwork', NNUser);
	FinalNN.NumLayers = NumLayers;
	FinalNN.SetUp(InputSize, Sizes);

	return FinalNN;
}

NeuralLayer

Code: Select all

//=============================================================================
// NeuralLayer.
//=============================================================================
class NeuralLayer expands Info;

var	LinearNode	Nodes[63];
var	byte		OutputSize;

function SetUp(byte InputSize)
{
	local int i;

	for ( i = 0; i < OutputSize; i++ )
	{
		Nodes[i] = Spawn(class'LinearNode', self);
		Nodes[i].InputSize = InputSize;
		Nodes[i].SetUp();
	}
}

function Activate(out float Inputs[63], float Fitness)
{
	local float Result[64];
	local int i;

	for ( i = 0; i < OutputSize; i++ )
	{
		Result[i] = Nodes[i].ActivateNode(Inputs, Spawn(class'MinFitness'));
	}
		
	for ( i = 0; i < OutputSize; i++ )
		Inputs[i] = Result[i];
}

LinearNode

Code: Select all

//=============================================================================
// LinearNode.
//=============================================================================
class LinearNode expands Info;

var		float		Weights[63];
var		byte		InputSize;

var()	float		Eta;

function SetUp()
{
	local int i;

	for ( i = 0; i < InputSize; i++ )
		Weights[i] = FRand() * 2.0 - 1.0;
}

function float ProcessOutput(float Output)
{
	return Output;
}

function float Dot63(float A[63], float B[63])
{
	local float Result;
	local int 	i;

	for ( i = 0; i < InputSize; i++ )
		Result += A[i] * B[i];

	return Result;
}

function float ActivateNode(float Inputs[63], MinFitness FitnessEvaluator)
{
	local float Result; 
	local int 	i;

	Result = Dot63(Inputs, Weights);
	
	for ( i = 0; i < InputSize; i++ )
		Weights[i] += Eta * ProcessOutput(Result) * (1 - FitnessEvaluator.Evaluator(i, Eta, Weights[i], Result, Inputs[i])) * Inputs[i];

	return Result;
}

SigmoidNode

Code: Select all

//=============================================================================
// SigmoidNode.
//=============================================================================
class SigmoidNode expands LinearNode;

function float ProcessOutput(float Output)
{
	return 1.0 / (1.0 + 2.718281828459045235360287 ** -Output);
}

UnitStepNode

Code: Select all

//=============================================================================
// UnitStepNode.
//=============================================================================
class UnitStepNode expands LinearNode;

function float ProcessOutput(float Output)
{
	if ( Output < 0 )
		return 0;

	return 1;
}

Sorry for my autism excitation, I'm just excited duh for the coincidence of you talking about a neural network when I already tried doing one in UnrealScript.

I'm studying it on my own too and it is surely more difficult then a genetic algorithm, but after some studies I found this Java library source code, I studied the code and I understood some things I didn't get before while studying ANN's.
Does you code even compile tho? I didn't know you could use arrays as function's parameters.
If you can't manage to get a first person view of what the UPawn sees, you still could give actors that are next to it and sounds around it as input data to the ANN, you wouldn't even need a convolutional NN since you wouldn't need to apply any segmentation of the data.

[JackGriffin]

Why is all this even a discussion? At what point are you just making a new game?

PS: If this would be operational it would be created years ago...

/thread

[PrinceOfFunky]

PS: If this would be operational it would be created years ago...

There must be a reason if EpicGames made the possibility for all calsses to be extendible within UnrealScript.
The fact that we have a UnrealScript compilator is to have a "full" control of the game mechanisms, it works like with UnrealEditor, the fact that a map already exists doesn't mean that it would be useless to create a new one or modify that map itself. I think in a community we should let people believe in themselves, instead than telling them that doing it is useless.

[JackGriffin]

Please. How does saying "this is a bad idea" in any way equate with "letting people believe in themselves"? It's a bad idea in every sense. The fact that no one has even approached the idea without creating a new game tells you it's likely confirmed to be bad. Don't try piling an unwarranted emotional facet to the discussion, it just doesn't belong in the marketplace of ideas.

[sektor2111]

Funky let's get into problem "Remaking Pawn" What Remake ? What compatibility will you have with the rest of UT things ? EPIC did not wrote "shouldn't be modified" because of some nightmare - it's because Pawn is boosted by Engine natively which another class won't get in account that soon, unless you will rewrite some C++ stuff for this task .
While so called Pawn expands actor with nothing native from engine dedicated to Pawn, this is only a self-defaming. Look at weapon code, at entire Botpack. Sample, function "killed" it will never get called properly because it is demanding PAWN and not other expanded actor. Aside, Pawn is main root supported natively, it can be expanded in a lot of forms without reinventing any broken wheels - BOTZ is the most relevant example in expanding Pawn rather that blabbering a similar nearby class so you probably don't even understand why this will be a broken thing, and YES, mainly looks useless without creating a completely new game type as long as such stuff has 0 zero compatibility with UT. Bot will never fight with a let's say KeyPoint and this actor is nothing similar with "Pawn" except name-fragment U-Pawn - "amazingly" engine doesn't use grammar so this blabbering spree is nothing without an entire package which will summarize a few tens of MB - see current stock.

Given previous activity I can predict how long will take this thing, But I prefer to spectate because it's a funny show after all...
You can look 100 times at this

Code: Select all

class UPawn expands Actor;

and maybe you'll get what I mean.
In UnrealScript if you don't like an actor you can subclass it, overriding bad functions, and writing others without RE-creating it. We have already Pawn expanding Actor another class expanding actor will never be a true natively supported Pawn because OF HEADERS - keep dreaming green horses on the roof if that's cool, but this is programming LOGIC in Unreal Engine.

[SilverSound]

To sum up what Sektor is saying:

You need UT source code and some new native stuff to be able to do this properly.

Things like "UnPawn.cpp" <(Has movement and AI related things) "UnActor.cpp"<(Has a whole entire everything)

These are some guesses of what you would need to change. But who knows what Pawn is linked to in native code. Could be a bunch of stuff. And I don't feel like going through shit..

You want to change movement? Well you need to change things in UnPawn.cpp and UnPhysics.cpp.

Unless you learn C++ and get your self the src and a licence you won't have luck in your endeavors. But I'm not going to say "Don't do it"

Experiment and see what you guys can do with it. I'm sure you will hit a lot of walls with out the keys though.

[papercoffee]

I'm sure you will hit a lot of walls with out the keys though.

I like this metaphor

[Gustavo6046]

i'm... I'm speechless. I could have subclassed Pawn, but that would mean bugs, and loads of redirecting functions. sektor is right. I should focus on my model converter in Python... epic, fuck you, I just want to make my models

[PrinceOfFunky]

I should focus on my model converter in Python

Oh well, goodbye UPawn. lol