1 / 37

Unreal Script Syntax

Unreal Script Syntax. CIS 488/588 Bruce R. Maxim UM-Dearborn. Based on Tim Sweeney’s UnrealScript Language Reference. Variable Declarations. var int a; // integer var byte Table[64]; // array of 64 bytes // max 32-character string. var string[32] PlayerName;

derek-alexander
Download Presentation

Unreal Script Syntax

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Unreal Script Syntax CIS 488/588 Bruce R. Maxim UM-Dearborn

  2. Based on Tim Sweeney’sUnrealScript Language Reference

  3. Variable Declarations var int a; // integer var byte Table[64]; // array of 64 bytes // max 32-character string. var string[32] PlayerName; var actor Other; // an actor.

  4. Data Types - 1 • byte (0 to 255). • int (32-bit). • bool (either "true" or "false“) • float (32-bit) • string (string of characters) • name (item in Unreal - function, state, class, etc). Names are stored as a 16-bit index into the global name table. Names correspond to simple strings of 1-31 characters. • enum (similar to C++ enum)

  5. Data Types - 2 • struct (similar to C++, passed by value) • For example, two commonly-used structs are "vector", which consists of an X, Y, and Z component; and "rotator", which consists of a pitch, yaw, and roll component. • object and actor references (use . operator like C++) • Object references may also contain a special value called "None", which is the equivalent of the C "NULL" pointer: it says "this variable doesn't refer to any object".

  6. Variable Modifiers - 1 • const (treats the contents of the variable as a constant - used for variables which the engine is responsible for updating), • editconst (variable can be seen in UnrealEd but not edited) • input (variable accessible to Unreal's input system, so that input (such as button presses and joystick movements) can be directly mapped onto it. Only relevant with variables of type "byte" and "float“). • Transient (transient variables are not saved to disk and are initialized to zero when an actor is loaded)

  7. Variable Modifiers - 2 • native (variable is loaded and saved by C++ code, rather than by UnrealScript). • private (variable may only be accessed by the class's script; no other classes or subclasses) • travel (only supported for PlayerPawn,this is the mechanism that keeps your health and ammo counts intact when switching levels) • skip (only used for logical operators like && and ||) • export (only meaningful for the Brush variable in Actor classes)

  8. Arrays • UnrealScript supports only single-dimensional arrays, though you can simulate multidimensional arrays by carrying out the row/column math yourself • Dynamic arrays are possible (discussed later) // Declares an array of 20 integers var int MyArray[20];

  9. Editability - 1 • You can make an instance variable "editable", so that users can edit the variable's value in UnrealEd via Actor Properties // Declare an editable integer in the default category var ( ) int MyInteger; // Declare an editable bool in "MyCategory". var (MyCategory) bool MyBool;

  10. Editability - 2 • You can also declare a variable as "editconst", which means that the variable should be visible but not editable UnrealEd (can be changed using a script). // MyBool is visible but not editable in UnrealEd var(MyCategory) editconst bool MyBool;  // MyBool is visible but not editable in UnrealEd // and not changeable in script var(MyCategory) const editconst bool MyBool;

  11. Actor References // Declare two variables that refer to a pawns. var pawn P, Q;  // Here is a function that makes use of P. MyFunction( ) { // Set P's enemy to Q. P.Enemy = Q;  // Tell P to play his running animation. P.PlayRunning( ); }

  12. Class Reference Variables - 1 • Classes are objects just like actors, textures, and sounds are objects. • Class objects belong to class named "class" • You can store a reference to a class object, so that you can spawn an actor belonging to that class (without knowing what the class is at compile-time).

  13. Class Reference Variables - 2 var ( ) class C; var actor A; // Spawn an actor belonging to some arbitrary // class C. A = Spawn( C ); • You can optionally use the special class<classlimiter> syntax to limit the variable to only containing references to classes which extend a given superclass

  14. Enumerations // EColor enumeration, with three values. enum Ecolor { CO_Red, CO_Green, CO_Blue }; // Now, declare two variables of type EColor. var EColor ShirtColor, HatColor;

  15. Structs // A point or direction vector in 3D space.  struct Vector { var float X; var float Y; var float Z }; // Declare a bunch of variables of type Vector. var Vector Position; var Vector Destination;

  16. Pre-defined Structs • Vector (3D point in space, with an X, Y, Z) • Plane (3D plane is defined by its X, Y, Z components, which are assumed to be normalized plus its W component - distance of the plane from the origin) • Rotator (Pitch, Yaw, Roll components) • Coords (coordinate system in 3D space) • Color (RGB color value) • Region (unique convex region within level)

  17. Expressions • UnrealScript expressions and operators are similar to those found in C++ • Named constants can be defined const LargeNumber=123456; const PI=3.14159; const MyName="Tim"; const Northeast=Vect(1.0,1.0,0.0); • UnrealScript does automatic type conversions among most numeric types

  18. Non-Automatic Type Conversions - 1 • String to Byte, Int, Float • Byte, Int, Float, Vector, Rotation to String • String to Vector, Rotation • String to Bool • Bool to String • Byte, Int, Float, Vector, Rotation to Bool • Bool to Byte, Int, Float • Name to String

  19. Non-Automatic Type Conversions - 2 • Rotator to Vector • Vector to Rotator • Object (or Actor) to Int • Object (or Actor) to Bool • Object (or Actor) to String

  20. Typecasting - 1 • All actors have a variable named "Target", which is a reference to another actor • If you need to check and see if your Target belongs to the "Pawn" actor class, and you need to do something special with your target that only makes sense when it’s a pawn • For example, you may need to call one of the Pawn functions.

  21. Typecasting - 2 var actor Target; function TestActorConversions ( ) { local Pawn P;  // See if my target is a Pawn. P = Pawn(Target); // Attempt typecast if ( P != None ) // P set to None if typecast fails { // Target is a pawn, so set its Enemy to Self. P.Enemy = Self; } }

  22. Functions - 1 • Similar to function definition in C++ • Functions can have return types and make recursive calls • Arguments are passed by value (the default) • Arguments can be passed by reference (if the key word out precedes the formal argument declaration) • Functions can have their own local variable declarations if local precedes the declarations

  23. Functions - 2 // Compute minimum and component of a vector. function VectorRange( vector V, out float Min) { if ( V.X<V.Y && V.X<V.Z ) Min = V.X; else if ( V.Y<V.Z ) Min = V.Y; else Min = V.Z;  }

  24. Overriding Functions - 1 • You can override function definitions (for example every actor has a Touch function and a Message function) // Called when something touches this actor. function Touch( actor Other ) { Log( "I was touched!") Other.Message( "You touched me!" ); }

  25. Overriding Functions - 2 • UnrealScript can be declared as "final". • The "final" keyword (which appears immediately before the word "function") says "this function cannot be overridden by child classes". • This should be used in functions which you know nobody would want to override, because it results in faster script code.

  26. Fuction Calling Specifiers class MyClass extends Pawn;  function MyExample( actor Other ) { // calls Touch residing in class Pawn or higher Super(Pawn).Touch( Other ); // call most derived (non-state) version of Touch Global.Touch( Other ); // call Touch defined in parent class Super.Touch( Other ); }

  27. Control Structures – for Loops function ForExample( ) { local int i; log( "Demonstrating the for loop" ); for ( i = 0; i < 4; i++ ) { log( "The value of i is " $ i ); } log( "Completed with i=" $ i); }

  28. Control Structures – do..until function DoExample( ) { local int i; log( "Demonstrating the do loop" ); do { log( "The value of i is " $ i ); i = i + 1; } until( i == 4 ); log( "Completed with i=" $ i); }

  29. Control Structures - while function WhileExample( ) { local int i; log( "Demonstrating the while loop" ); while( i < 4 ) { log( "The value of i is " $ i ); i = i + 1; } log( "Completed with i=" $ i); }

  30. Break function WhileExample( ) { local int i; log( "Demonstrating break" ); for( I = 0; I < 10; i++ ) { if( i == 3 ) break; } }

  31. goto function GotoExample( ) { log( "Starting GotoExample" ); goto Hither; Yon: log( "At Yon" ); goto Elsewhere; Hither: log( "At Hither" ); goto Yon; Elsewhere: log( "At Elsewhere" ); }

  32. Control Structures – if..else - 1 // Example of simple "if". if ( LightBrightness < 20 ) log( "My light is dim" );  // Example of "if-else". if ( LightBrightness < 20 ) log( "My light is dim" ); else log( "My light is bright" );

  33. Control Structures – if..else - 2 // Example of "if-else if-else". if ( LightBrightness < 20 ) log( "My light is dim" ); else if ( LightBrightness < 40 ) log( "My light is medium" ); else if ( LightBrightness < 60 ) log( "My light is kinda bright" ); else log( "My light is very bright" );

  34. Control Structures - switch switch( LightType ) { case LT_None: log( "There is no lighting" ); break; case LT_Steady: log( "There is steady lighting" ); break; case LT_Backdrop: log( "There is backdrop lighting" ); break; default: log( "There is dynamic" ); break; }

  35. foreach and Iterators - 1 • UnrealScript's "foreach" command makes it easy to deal with large groups of actors • For example all of the actors in a level, or all of the actors within a certain distance of another actor. • "foreach" works in conjunction with a special kind of function called an "iterator" function whose purpose is to iterate through a list of actors.

  36. foreach and Iterators - 2 function Something( ) { local Actor A; log( "Lights:" ); // Display a list of all lights in the level. foreach AllActors( class 'Actor', A ) // all level actors { if( A.LightType != LT_None ) log( A ); } }

  37. Iterator Functions • AllActors ( class BaseClass, out actor Actor, optional name MatchTag ) • ChildActors( class BaseClass, out actor Actor ) • BasedActors( class BaseClass, out actor Actor ) • TouchingActors( class BaseClass, out actor Actor ) • TraceActors( class BaseClass, out actor Actor, out vector HitLoc, out vector HitNorm, vector End, optional vector Start, optional vector Extent ) • RadiusActors( class BaseClass, out actor Actor, float Radius, optional vector Loc ) • VisibleActors( class BaseClass, out actor Actor, optional float Radius, optional vector Loc )

More Related