Prerequisites:
Skills:
You will need a solid understanding of Unrealscript basics.
If you do not understand the fundamentals, you will not understand the logic behind the code and will experience difficulty adapting it to your own needs.
Beyond the basics, this tutorial assumes no prior experience with AI inside or outside of UDK.
Existing Code:
- A custom Pawn
- A custom weapon
- A custom GameInfo with your custom weapon defined in the default inventory
The goal:
Create basic AI that will:
- React to seeing player
- Fire at player with distance-dependent accuracy
- Only react when player is within range
The concept:
AI Controllers and Pawns:
In UDK, a Pawn is a physical representation of anything that can be controlled (Vehicles, people, turrets etcetera).
A pawn, generally speaking, will never have to be specifically made for a player or an AI controller, since a pawn can be possessed and controlled by either.
A controller, will translate physical input or programmed logic into actions called on the pawn, depending on whether or not it’s a player controller or AI controlled.
A player controller is generally easier to create since it takes most of it’s logic from the player, while an AI controller will do nothing until it is pre-programmed.
AI, or at least the way we have to deal with it right now, is not “intelligent”. It can not “create” any logic of it’s own, it is merely a pre-programmed object that will call functions based on different circumstances to create the illusion that it is intelligent enough to think.
Initial Setup
Class definition:
[MyCustomAIController.uc]
class MyCustomAIController extends UDKBot;
//Extending from UDKBot will make our lives a lot easier
//Now, we must override GetPlayerViewPoint as the default implementation puts the AI's "eyes" in the ground!
simulated event GetPlayerViewPoint(out vector out_Location, out Rotator out_Rotation)
{
local vector AI_Location; //Vector variable to apply offset from our location
AI_Location=Pawn.Location;
AI_Location.z=Pawn.Location.z+Pawn.EyeHeight; //To re-iterate: Make sure your eyeheight is set up in your custom pawn!
out_Location = AI_Location;
out_Rotation = Rotation;
}
[MyCustomBot.uc]
class MyCustomBot extends MyCustomPawn
placeable;
//We can place this bot in the level without using kismet or console commands to spawn
simulated event PostBeginPlay()
{
Super.PostBeginPlay();
AddDefaultInventory(); //We don't be able to shoot at player without a weapon!
}
defaultproperties
{
ControllerClass=class'MyCustomGameInfo.MyCustomAIController' //This will automatically create an AI controller for the bot
}
The Framework: 1.1
http://entrod.sp-website.net/images/UDK/Tutorials/UDKBOT_Accuracy/1.1.png
Fig 1.1
When Player is within range of bot and within field of view, bot will set player as enemy.
Variables:
[MyCustomAIController.uc]
var Actor Target; //Using Actor instead of Pawn adds flexibility to have AI respond to non players EG. Investigating noise from an object thrown by player. Casting is used when checks are done on actual enemies
var float MaxVisibleDistance; //This will determine whether or not we should react to the player
Functions:
[Controller.uc]
event SeePlayer( Pawn Seen );
//We will use this event to run logic based on seeing the player
[Object.uc]
native(225) static final function float VSize( vector A ); //We will use this to determine if the player is close enough to be detected
The Framework: 2.1
http://entrod.sp-website.net/images/UDK/Tutorials/UDKBOT_Accuracy/2.1.png
Fig 2.1
Bot will track player as he moves around.
Variables:
[Controller.uc]
var Actor Focus; //Setting this variable will automatically make our AI (pawn) aim at the player
The Framework: 3.1
http://entrod.sp-website.net/images/UDK/Tutorials/UDKBOT_Accuracy/3.1.png
Fig 3.1
When firing, a random offset to the aim direction is applied based on distance (exaggerated).
Variables:
[MyCustomAIController.uc]
var () float accuracy; //We will use this to determine the distance at which our bot becomes inaccurate.
[Controller.uc]
var editinline repnotify Pawn Pawn; //A reference to the pawn currently controlled by us, used for firing logic
var BasedPosition FocalPosition; //The point we will be modifying for our random offset
Functions:
[Controller.uc]
native final function Vector GetFocalPoint(); //In order to add an offset from where we are aiming, we must get the point we are aiming at
function Rotator GetAdjustedAimFor( Weapon InWeapon, vector ProjStart ) //This event is called when the weapon is fired, we will override this to add our offset aim
Implementation
1.1:
auto state Idle
{
event SeePlayer (Pawn Seen)
{
if (vsize(Pawn.Location-Seen.Location)<MaxVisibleDistance)
{
SetTarget(Seen); //If player is close enough, set him as our current target
}
Super.SeePlayer(Seen);
}
}
2.1:
simulated function SetTarget(Actor E)
{
//If we already have a target, don't reset it
if (Target==none)
{
Target=E; //Handle for the target
Focus=E; //Look at the target
GotoState('Combat'); //Handle shooting at the target now
}
}
3.1:
state Combat
{
begin:
if (Pawn.Weapon.HasAmmo(0) && !Pawn.IsFiring())
{
Pawn.StartFire(0); //Start firing! If we aren't firing already. If you understand weapons well enough you should replace 0 with a custom variable in your class
}
sleep(0);
Goto('Begin'); //Pseudo tick event
}
function Rotator GetAdjustedAimFor( Weapon InWeapon, vector ProjStart )
{
local vector AimAdj;
local float TargetDist;
AimAdj = GetFocalPoint(); //We must first get the location of our aim before we can offset it
if ( target != None )
{
TargetDist=vsize(Pawn.Location-GetFocalPoint()); //This will determine the distance to the target
AimAdj.x=RandRange(AimAdj.x-TargetDist/accuracy,AimAdj.x+TargetDist/accuracy); //We will add a random offset based on the distance and our accuracy
AimAdj.y=RandRange(AimAdj.y-TargetDist/accuracy,AimAdj.y+TargetDist/accuracy);
AimAdj.z=RandRange(AimAdj.z-TargetDist/accuracy,AimAdj.z+TargetDist/accuracy);
}
SetRotation(Rotator(AimAdj - ProjStart)); //Now it will point the gun (or projectile to be accurate) at our new aiming spot
return Rotation;
}
Closing thoughts
Learning:
I hope you learned something from this (even if rudimentary) tutorial and have a better concept of how ai works in UDK and how to apply behaviour based on circumstantial variables.
While basic, it should give you a solid foundation to expand on with your own logic.
For the future:
To the more adept UnrScript programmers, this tutorial doesn’t really offer much right now, but I do intend to expand on it greatly when I get free time.
So if there’s anybody who already has their core AI in place but wishes to expand, please check in once in a while for updated modules.
