UDN
Search public documentation:

UnrealScriptFunctionsJP
English Translation
中国翻译
한국어

Interested in the Unreal Engine?
Visit the Unreal Technology site.

Looking for jobs and company info?
Check out the Epic games site.

Questions about support via UDN?
Contact the UDN Staff

UE3 ホーム > UnrealScript > UnrealScript 言語のリファレンス > UnrealScript の関数

UnrealScript の関数


概要


関数とは、関連するコマンドの集まりに名前を付けたものです。実行すると、全体で固有の動作を実行します。関数の動作には、特定の変数に値をセットするような単純なものから、NPC が進むパスを計算するような複雑なものまであります。クラスは基本的に 2 つの要素から成り立っています。それは、変数と関数です。変数はデータを持ちます。一方、関数は、そのデータの値を使用または改変する動作を実行します。これらの動作は、ゲーム内で目にするゲームプレイを構成します。

関数は、所属するオブジェクトのデータを使用して動作を実行するだけではありません。パラメータを使って、データを取り込み、データを返すことも行います。

関数の宣言


UnrealScript では、新たな関数を宣言することが可能であるとともに、既存の関数の新たなバージョンを書くことも可能です (関数のオーバーライド)。関数は、1 個以上のパラメータ (UnrealScript がサポートするあらゆる変数型のパラメータ) を使用することができます。また、オプションとして値を返すことができます。たいていの関数は UnrealScript で直接書かれていますが、次のような関数を宣言することもできます。すなわち、UnrealScript から呼び出すことができ、かつ、C++ で実装して DLL に置く関数を宣言することができるのです。「Unreal」テクノロジーは、関数呼び出しのあらゆる可能な組み合わせをサポートしています。そのため、C++ エンジンがスクリプト関数を呼び出すことができます。また、スクリプトが C++ の関数を呼び出すことができます。さらに、スクリプトがスクリプトを呼び出すことができます。

以下は、かなり単純な関数の宣言例です。

// Function to get the team a player is on
function byte GetTeam(Pawn PlayerPawn)
{
   return PlayerPawn.Controller.Team;
}

関数の宣言は 2 つの部分からなります。すなわち、シグネチャと本体です。

関数のシグネチャ

関数宣言の最初の行は、どのように関数が識別され、呼び出されるかということに関して定義しています。この行は、関数の シグネチャ と呼ばれます。シグネチャによって、次のものが指定されます。すなわち、関数名、 関数パラメータ を媒介にして取り込むことができる値、(あるとすれば) 関数が出力する 戻り値関数指定子 を使用する関数についてのその他情報。

ごく基本的な関数シグネチャは、 function キーワードから始まります。(ただし、特別な event 関数の場合は、それに代わって event キーワードから始まります)。このキーワードの次には、オプションで関数の 戻り値の型 が置かれます。さらに、関数名が続き、その次に、 関数のパラメータ リストがカッコ内に置かれます。

上記宣言例から、シグネチャの部分を抜き出すと次のようになります。

function byte GetTeam(Pawn PlayerPawn)

このシグネチャは、 GetTeam という名前の関数のためのものです。この関数は、 Pawn への参照が渡され、 byte 型の値を返すものです。(名前から想像がつくように、引き渡された Pawn のチーム名を得る関数です)。

また、関数は、宣言の中で 関数指定子 を使用することによって決定される、ある属性をもつことができます。そのような指定子は、通常、シグネチャの中で function (あるいは event ) キーワードに先行しますが、他の位置に置かなければならないものもあります。

関数の本体

シグネチャに続いて、波括弧に囲まれた部分が続き、関数に属するコマンドがすべてこの中に含まれることになります。これは、関数の 本体 と言われる部分です。関数が呼び出されると、本体に含まれているコードが上から下まで順番に実行されていきます。関数本体の内部では、ローカル変数を宣言することができます ( local キーワードを使用します)。また、有効な UnrealScript のコードを実行することができます。関数本体の実行が終了するのは、 return 文 または閉じ波括弧に達した時です。

上記の宣言例では、本体部分が次のようになります。

{
   return PlayerPawn.Controller.Team;
}

デフォルトでは、関数内で宣言したローカルの変数が、その変数の型に応じて、ゼロまたはゼロに相当する値に初期化されます。( Bool 型では FALSE 、Object 参照型では None など)。

戻り型と戻り値


関数は、 戻り型 をともなって宣言することができます。戻り型とは、関数によって返される値の型、あるいは、関数によって換算される値の型のことを言います。( 戻り値 としても知られています)。関数の本質的な意義は、関数をコード文の中で実行し、その結果を直接その文の中で値として使用することができるというところにあります。そのおかげで、関数の値を変数に代入したり、他の計算を実行したりするのに使用できるのです。

関数が値を返すためには、シグネチャ内で返す値の型をともなって宣言される必要があります。

function int GetHealth(Pawn PlayerPawn)

上記例では int 値を返す関数が宣言されています。UnrealScript の型はすべて、戻り値の型として使用することができます。

関数から値を返すには、 return キーワードに続けて戻り値を置きます。これは return 文 と呼ばれます。これによって、関数は、ただちに実行を終了し、指定された値を戻すことになります。関数が戻り値を宣言している場合は、return 文を使用して値を戻さなければなりません。

function int GetHealth(Pawn PlayerPawn)
{
   return PlayerPawn.Health;
}

例にあるリターン文は、この関数に渡された Pawn がもっている Health 変数の現在の値を返すに過ぎません。

関数には、複数の return 文を置くことができます。ただし、1 回の関数の実行につき、1 つの return 文しか実行されません。関数本体に、コードが取りうる複数の分岐が含まれている場合 (たとえば、 制御構造 が使用されている場合) は、分岐それぞれに return 文が含まれていなければなりません。あるいは、あらゆる場合に対応できる return 文が関数本体の最後に置かれていなければなりません。

function bool IsAlive(Pawn PlayerPawn)
{
   if(PlayerPawn.Health > 0)
   {
      return true;
   }
   else
   {
      return false;
   }
}

上記関数には、関数が返す可能性がある各 Bool 値に対応する return 文が 1 個ずつあります。ただし、当然のことながら、 Pawn が生きているか否かに基づいて、それら return 文のうちの 1 つだけが毎回実行されることになります。

関数のパラメータ


関数は、値を返すだけではなく、関数本体の内部で使用する値を受け取ることもできます。値を受け取るためには、最低 1 個以上の パラメータ を使って関数を宣言しなければなりません。パラメータは、本質的にローカル変数であり、関数内部でのみ使用できるものですが、その値は関数の外部から満たされます。そのため、関数が実行される際に関数に値が渡されることになります。

関数のパラメータは、シグネチャにおいて、関数名のすぐあとに続くカッコの中で指定されます。各パラメータは、型として宣言されます。この型の後には、関数内部でパラメータにアクセスするのに使用される名前が続きます。複数のパラメータを、コンマで分けて指定することが可能です。

function int GetHealth(Pawn PlayerPawn)

上記例では、 Pawn への参照である PlayerPawn という名の値を受け取る関数が宣言されています。関数のパラメータは、どの UnrealScript の型であっても構いません。

パラメータは、他の変数がアクセスされるのと同じ方法で、関数本体内部でアクセスされます。すなわち、パラメータの名前を使用するということです。

関数のパラメータ指定子

Out
関数が呼び出されると、通常、UnrealScript では、関数に渡されるパラメータのローカルコピーが作られます。関数がパラメータのいくつかを変更しても、その値の元となった変数には何の影響もありません。たとえば、次のプログラムをご覧ください。
   function int DoSomething( int x )
   {
      x = x * 2;
      return x;
   }

   function int DoSomethingElse()
   {
      local int a, b;

      a = 2;
      log( "The value of a is " $ a );

      b = DoSomething( a );
      log( "The value of a is " $ a );
      log( "The value of b is " $ b );
   }
   
上記のプログラムは、 DoSomethingElse が呼び出されると、次のような出力を行います。
   The value of a is 2
   The value of a is 2
   The value of b is 4
   
言い換えると、関数 DoSomething は、この関数に渡された変数 a のローカルのコピーを扱うため、変数 a 本体には影響を及ばさないのです。

out 指定子を付けることによって、ローカルのコピーが作られることはなくなり、関数に渡された変数を実際に変更することになります。これが便利なのは、たとえば、複数の値を呼び出し元に返さなければならない関数がある場合です。そのような場合には、呼び出し元が関数に対して、 out の値をもつ変数を渡すようにするだけで済みます。例 :
   // Compute the minimum and maximum components of a vector.
   function VectorRange( vector V, out float Min, out float Max )
   {
   	   // Compute the minimum value
   	   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;

   	   // Compute the maximum value.
   	   if ( V.X>V.Y && V.X>V.Z ) Max = V.X;
   	   else if( V.Y>V.Z ) Max = V.Y;
	   else Max = V.Z;
   }
   
out キーワードを使わずに、2 個以上の値を返さなければならない関数を書くことは大変なことです。out パラメータは、参照渡しです。したがって、パラメータの値を関数内で変更すると、直接元の変数が変更されることになります。このことは、大規模な値を最適化する場合にも使用することができます。(C++ 同様に、const out を指定します)。
Optional
optional キーワードを使用することによって、特定の関数パラメータをオプションにすることができます。これは、呼び出す側にとって便利です。UnrealScript の関数では、呼び出し側がオプションのパラメータを指定していない場合、関数宣言で指定されているデフォルトの値がパラメータにセットされます。関数シグネチャでデフォルト値が指定されていない場合は、ゼロ (例 : 0、false、””、none) がセットされます。ネイティブ関数については、関数によってオプション パラメータのデフォルト値が異なります。たとえば、Spawn 関数は、オプションの位置と回転を取りますが、スポーンするアクタの位置と回転がデフォルト値となります。オプションの引数のデフォルト値を指定するには、 = 値 を追加します。たとえば、次のようにします。 function myFunc(optional int x = -1)
Coerce
coerce キーワードは、呼び出し元のパラメータを強制的に指定された型に変換します。(UnrealScript が通常自動的な変換を行わないにもかかわらず)。このキーワードは、文字列を扱う関数で役立ちます。パラメータが自動的に文字列に変換してくれるからです。( Unreal の文字列 のページを参照してください。)

関数の指定子


Static
static (静的) 関数は、C のグローバル関数のように振る舞います。すなわち、クラスのオブジェクトへの参照を使わずに呼び出すことができます。static 関数は、他の static 関数を呼び出すことができ、変数のデフォルト値にアクセスすることができます。static 関数は、非 static 関数を呼び出すことができません。また、インスタンス変数にアクセスすることができません。(オブジェクトのインスタンスについて実行されないためです)。C++ などの言語とは異なり、UnrealScript の static 関数は仮想的なものであり、子クラスでオーバーライドすることができます。これが役立つのは、変数クラス (コンパイル時には認識されず、変数または式によって参照されるクラス) の static 関数を呼び出す場合です。
Singular
singular キーワード は、関数宣言の直前に表示されることによって、関数が再帰的に関数自身を呼び出さないようにすることができます。そのルールは、次のとおりです。すなわち、あるアクタが singular 関数の中にすでに存在している場合は、以降の singular 関数への呼び出しをすべてスキップします。これによって、無限再帰のバグを防ぐことができる場合があります。たとえば、 Bump 関数内にあるアクタを移動させようとすると、そのアクタが移動中に別のアクタにぶつかる可能性がかなりあります。その結果、もう一度 Bump 関数が呼び出され、さらにそれが繰り返さることが考えられます。そのような動作を避けるために細心の注意を払うべきですが、コードを書く際に再帰的な状況を完全に避ける自信が持てない場合は、この singular キーワードを使用すべきです。なお、このことは、singlar となっている特定の関数に限定されません。つまり、現在実行中の singular 関数に位置している場合、単一のオブジェクト内にあるすべての singular 関数が実行されなくなるのです。
Native
UnrealScript 関数を native として宣言することができます。native が付けられた関数は、UnrealScript から呼び出すことができますが、実際は (ほかの場所で) C++ で実装されていることになります。Actor クラスには、次のような、多数の native 関数の定義が含まれています。
   native(266) final function bool Move( vector Delta );
   
native キーワードの後に続く ( ) 内の数字は、( AUTOREGISTER_NATIVE マクロを使用することによって) C++ で関数が宣言されたときの数字に対応するものであり、演算子関数のためだけに必要となるものです。native 関数は、UnrealScript の定義を含んでいるクラスのパッケージと同一の名前がついた DLL に入っているものと見なされます。
NoExport
native 関数にのみ使用されます。当該の native 関数のための C++ による関数宣言がエクスポートされてはならないことを宣言します。関数のグルー バージョンのための宣言だけがエクスポートされることになります。
Exec
関数名をコンソールにタイプすることによって、当該の関数が実行されることを示します。特定のクラスでのみ有効です。
Latent
native 関数が潜在的 (latent) であることを宣言します。潜在的とは、ステートコードからのみ呼び出し可能であり、一定のゲーム時間が経過した後に値が返されることを意味しています。
Iterator
native 関数がイテレータであることを宣言します。( foreach コマンドに使って、アクタのリストを繰り返し処理するために使用することができます)。
Simulated
アクタが、シミュレートされたプロキシか自動プロキシのいずれかである場合に、関数がクライアント側で実行できることを宣言します。native 関数もすべて自動的にシミュレートされます。(注意 : 仮想的な native 関数を非 native 関数でオーバーライドする場合は、simulated キーワードが指定されなければ、非 native のオーバーライドがシミュレートされません。)
Server
関数が実行されるためには、ローカルのクライアント上で実行されるのではなく、サーバーに送られる必要があることを宣言します。
Client
関数が実行されるためには、サーバー上で実行されるのではなく、所有者であるクライアントに送信されなければならないことを宣言します。このフラグは、非明示的に、 simulated フラグを当該関数のためにセットします。
Reliable
レプリケートされた関数 ( server または client という印がついている) が、確実に (reliable) 送信されなければならないことを宣言します。すなわち、その Actor 上にある他のレプリケーションとは異なり、最終的には必ず順番どおりにもう一方の側に送信されることになります。
Unreliable
レプリケートされた関数 ( server または client という印がついている) が、不確実に (unreliable) 送信されなければならないことを宣言します。すなわち、十分な帯域幅がない場合は、いかなる順番であろうとも、もう一方の側に送信されることが保証されず、場合によっては完全に省略されることになります。
Private, Protected
これらのキーワードは、それぞれ、変数のキーワードと同じ意味をもちます。
Operator, PreOperator, PostOperator
これらのキーワードは、演算子と呼ばれる特別な種類の関数を宣言するためのものです。(C++ の演算子に相当します)。これによって、+ 、- 、== 、|| といったビルトインされている演算子すべてを UnrealScript が認識します。本ドキュメントでは、演算子の仕組みについて詳しく説明しませんが、演算子の考え方は C++ に類似しています。また、新たな演算子関数とキーワードを、UnrealScript 関数または native 関数として宣言することができます。
Event
native の C++ エンジンコードから実行可能な関数を宣言する場合に、 function キーワードに代わって使用されます。 詳細については、 イベント の項を参照してください。
Const
native と宣言されている関数でのみ使用することができます。この指定子は、関数宣言の 後に 付けます。この指定子によって、生成されたヘッダにおいて const として当該関数がエクスポートされるか否かが決まります。以下は、その使用例です。
   native function int doSomething(string myData) const;
   

関数のオーバーライド


関数のオーバーライド とは、サブクラスに新たな関数バージョンを書くことです。たとえば、 Demon という新たなモンスターのためのスクリプトを書いているとします。この Demon クラスは、作成したばかりで、 Pawn クラスを拡張したものです。ポーンが初めてプレーヤを見ると、ポーンの SeePlayer 関数が呼び出され、ポーンがプレーヤを攻撃開始できるようになります。このコンセプトはいいのですが、今作成している Demon クラスでは、 SeePlayer 関数に異なる動作をさせたいとします。どのようにしたら良いでしょうか? 正解は、関数のオーバーライドです。

関数をオーバーライドするには、今作成しているクラスに親クラスから関数の定義をカット & ペーストして、さらに、本体を改変します。 新たなクラスにおける関数のシグネチャは、指定子および戻り値の型、パラメータに関して、親クラスのシグネチャと一致していなければなりません。(パラメータ名は変更できますが、パラメータの数と型は同一のままでなければなりません)。たとえば、 SeePlayer 関数であれば、作成中の Demon クラスにこれを追加することができます。

// New Demon class version of the Touch function.
function SeePlayer( actor SeenPlayer )
{
	log( "The demon saw a player" );
   	// Add new custom functionality here...
}

関数のオーバーライドは、新たな UnrealScript クラスを効率的に作成するための鍵となります。まず、既存のクラスを拡張して、新たなクラスを作成します。次に、異なる動作をさせたい関数をオーバーライドするだけで済むのです。こうすることによって、膨大な量のコードを書かずに、新しいオブジェクトを作成することができます。

UnrealScript の関数のうちいくつかは、 final として宣言されています。 final キーワード (これは function という語の直前に付きます) の意味は、「この関数は子クラスによってオーバーライドすることができない」ということです。このキーワードは、だれにもオーバーライドされない関数について使用しなければなりません。これによって、より高速なスクリプトコードができます。たとえば、 VectorSize という関数があり、ベクターのサイズを計算するとします。だれかがこの関数をオーバーライドしようする理由が全く見当たらないため、 final として宣言します。一方、 Touch のような関数は、状況に依存する度合いが高いため、final にすべきではありません。

関数の実行


関数を実行するには、 関数コール として知られていることを行います。関数の呼び出しは、次のように構成されています。すなわち、関数の名前をまず置き、その後に丸括弧を付け加え、その中にこの関数に渡すデータ (パラメータとして) をコンマで区切って配置します。

以下がその例です。

function SetCollision( optional bool bNewColActors, optional bool bNewBlockActors, optional bool bNewIgnoreEncroachers );

アクタのためのコリジョンをすべて有効にするには、次のようにして関数を呼び出します。

SetCollision(true, true, true);

呼び出そうとしている関数にオプションのパラメータが含まれている場合は、呼び出し時にその全部または一部を省くことができます。あるパラメータを省いた後に、他のパラメータを加える場合は、省かれたパラメータそれぞれのためにコンマを置く必要があります。

たとえば、 Trace() 関数には、次のように複数のパラメータがあります。

/**
 * Trace a line and see what it collides with first.
 * Takes this actor's collision properties into account.
 * Returns first hit actor, Level if hit level, or None if hit nothing.
 */
function Actor Trace
(
	out vector					HitLocation,
	out vector					HitNormal,
	vector						TraceEnd,
	optional vector				TraceStart,
	optional bool				bTraceActors,
	optional vector				Extent,
	optional out TraceHitInfo	HitInfo,
	optional int				ExtraTraceFlags
);

TraceStarte および bTraceActors パラメータを省略するが、 Extent パラメータを含めてこの関数を呼び出すと、次のようになります。(なお、 HitLocationHitNormalEnd はすべて、これより前に宣言されているローカルの Vector 変数であると想定されています)。

Trace(HitLocation, HitNormal, End,,,vect(4,4,4));

関数の呼び出し指定子


複雑なプログラミングを行う際は、しばしば、関数の特別なバージョン (現在のスコープに入っている関数ではないバージョン) を呼び出す必要があります。これらの場合に対処するために、UnrealScript では次のキーワードが用意されています。

Global
最派生グローバル (非ステート) 関数バージョンを呼び出します。
Super
親クラス内において対応する関数バージョンを呼び出します。呼び出される関数はその状況によって、ステート関数か非ステート関数のいずれかになります。
Super(classname)
指定したクラスにおいて (またはその上位クラスにおいて) 対応する関数バージョンを呼び出します。呼び出される関数はその状況によって、ステート関数か非ステート関数のいずれかになります。

複数の指定子を同時に使用することはできません。(例 : Super(Actor).Global.Touch は無効です)。

以下は、呼び出し指定子の例です。

class MyClass extends Pawn;

function MyExample( actor Other )
{
   Super(Pawn).Touch( Other );
      Global.Touch( Other );
      Super.Touch( Other );
}

さらに例として、アクタがゲームプレイに入ろうとする時に呼び出される BeginPlay() 関数について考えてみます。 BeginPlay() 関数は、 Actor クラスで実装され、実行すべき重要な機能を含んでいるとします。ここで、新たなクラスである MyClass の中で BeginPlay() 関数をオーバーライドして、新たな機能を追加することにします。安全に行うには、まず親クラスにある BeginPlay() のバージョンを呼び出す必要があります。

class MyClass extends Pawn;

function BeginPlay()
{
	// Call the version of BeginPlay in the parent class (important).
   	Super.BeginPlay();

   	// Now do custom BeginPlay stuff.
   	//...
}

イベント


一定のイベントが発生した際に常にエンジンによって呼び出される UnrealScript 関数が存在します。これらの関数 (すなわちイベント) は、通常の function キーワードではなく event キーワードによって宣言されるため、簡単に見分けることができます。

たとえば、アクタが他のアクタによって触れられた場合は、エンジンがアクタの Touch イベントを呼び出すことによって、誰がアクタに触れたかをアクタに知らせます。

event Touch( Actor Other, PrimitiveComponent OtherComp, vector HitLocation, vector HitNormal );

カスタムの Touch 関数を書くことによって、タッチが発生した結果として特別な動作を取るようにすることができます。

// Called when something touches this actor.
function Touch( actor Other )
{
	`log( "I was touched!")
   	Other.Message( "You touched me!" );
}

上記の関数から分かることがいくつかあります。まず、この関数は、 `log コマンドを使用してメッセージをログファイルに書き出しています。(このコマンドは、Basic では print 、C では printf に相当します。ただし構文の形式は異なります)。第二に、この関数は、Other アクタにある Message 関数を呼び出しています。UnrealScript や Java などのようなオブジェクト指向言語では、他のアクタ内にある関数を呼び出すことが普通に行われています。これによって、アクタが他のアクタと互いに簡単にコミュニケーションすることができるのです。

関数の再帰


関数の呼び出しは再帰的に行うことができます。つまり、関数が関数自身を実際に呼び出すことができるということです。望ましい動作を実行するために必要となるコードをなるべく複雑化させないためには、この再帰的な呼び出しが、必須または有効となるケースが多々あります。

例として、ある数の階乗を計算する関数を次にあげます。

// Function to compute the factorial of a number.
function int Factorial( int Number )
{
	if( Number <= 0 )
      	return 1;
   	else
      	return Number * Factorial( Number - 1 );
}

静的な関数


変数クラス (variable class) に置かれた静的な (static) 関数は、次の構文を使って呼び出すことができます。

var class C;
var class PC;

class'SkaarjTrooper'.static.SomeFunction();	// Call a static function
                                        	// in a specific class.

PC.static.SomeFunction();	// Call a static function in a variable class.

class(C).static.SomeFunction();		// Call a static function in a
                                      	//casted class expression.

タイマー


タイマーは、時間経過にしたがってイベントを発生 (あるいは再発生) させるようにスケジュール管理するための仕組みとして使用されます。すなわち、Actor は、タイマーがゲームエンジンに登楼されるようにセットすることによって、予め定められた時間が経過した後に Timer() 関数が一度ないしは再度呼び出されるようにすることができます。

UnrealScript のタイマーは、各 Actor 内部で構造体配列として実装されています。(Actor は複数のタイマーをペンディングさせておくことが可能です)。構造体には、タイマーが満了するまでの残り時間と、タイマーが満了した時に呼び出す関数などが含まれています。

通常、ゲームループはフレームごとに 1 度、各 Actor を ティック します。各 Actor の Tick() 関数には、 UpdateTimers() への呼び出しが含まれているため、満了したタイマーをチェックし、適切な UnrealScript 関数を呼び出すことができます。

粒度は、フレームのデルタタイムに限定されますが、ハードウェアおよび OS リソースを必要としません。これらはみな C++ で実装されているため、安心して何百という UnrealScript のタイマーを安全に更新することが可能です。当然のことながら、これらタイマーを一斉に満了にしたり、毎フレーム満了にしたりすることは避けるべきです。これらがアクティベートされると、(遅い) スクリプトコードが実行されるからです。

タイマー関数は、 Actor のサブクラスでのみ使用することができます。

それぞれ異なる設定時間をもつ複数のタイマーを作成することが可能です。各タイマーは、独自のターゲットとなる関数をもちます。(デフォルトでは Timer() )。

function SetTimer(float inRate, optional bool inbLoop, optional Name inTimerFunc)
inRate 秒後にトリガーされるタイマーを開始します。 inbLoop が true である場合は、タイマーがループします。 inTimerFunc は、呼び出すべき関数を定義ます (デフォルトでは Timer() に設定されています)。この値は、複数のタイマーを識別するためにも使用されます。
ClearTimer(optional Name inTimerFunc)
作動中のタイマーを停止します。
bool IsTimerActive(optional Name inTimerFunc)
指定されたタイマーがアクティブな場合、true を返します。
float GetTimerCount(optional Name inTimerFunc)
タイマーのカウンタ値を返します。(前回タイマーが実行されてから経過した秒数)。タイマーがアクティブではない場合は、 -1 を返します。
float GetTimerRate(optional name TimerFuncName = 'Timer')
タイマーの設定時間を返します。したがって、 GetTimerRate(あるタイマー) - GetTimerCount(あるタイマー) によって、「あるタイマー」の残り時間が返されます。

組み込み関数


「Unreal」のオブジェクト階層におけるごく基本的なクラス ( ObjectActor など) には、多数の関数があります。これらの関数は、非常に便利であり、UnrealScript を使用してゲームの新たなクラスを作成する場合、覚えておくとたいへん役に立ちます。

オブジェクトの作成

新たなオブジェクトインスタンスを UnrealScript で作成するには、オブジェクトが Actor であるか否かに基づいて、2 つの関数のうち 1 つを使用します。Actor である場合は、Spawn 関数を使用します。(これは、 Actor.uc で宣言されています)。クラスが Actor から派生していない場合は、 new 演算子を使用しなければなりません。new 演算子のシンタックスは、他の関数のシンタックスとは異なります。オプションのパラメータの他に、新たなオブジェクトのクラスとオプションのテンプレートオブジェクトを指定する必要があります。new 演算子のための UnrealScript の宣言はありませんが、以下に、関数シグネチャがどのようなものであるかを示します。

native final operator function coerce Object new
(
   object   InOuter,
   name     InName,
   int      InFlags,
   class    InClass,
   object   InTemplate
);

InOuter
(オプション) 新たに作成されるオブジェクトのために Outer として割り当てられるオブジェクトです。これが指定されていない場合は、このオブジェクトの Outer が、ゲーム稼動中にのみ存在する特別なパッケージ (transient package)) に設定されます。
InName
(オプション) 新たなオブジェクトに付けられる名前です。これが指定されていない場合は、 ClassName_## という形式の一意な名前がオブジェクトに付けられます。( ## の部分は、このクラスのインスタンスが作成されるたびに、インクリメントされます)。
InFlags
(オプション。現在オブジェクトのフラグが 64 ビットになったため、機能しません) オブジェクトを作成する際に使用するオブジェクトのフラグです。有効な値は次のとおりです。
  • 0x0000000100000000 - エディタの undo (元に戻す) / redo (やり直す) をサポートします。(RF_Transactional)
  • 0x0000000400000000 - 外部のファイルによって参照することが可能です。(RF_Public)
  • 0x0000400000000000 - ディスクに保存することができません。(RF_Transient)
  • 0x0010000000000000 - ゲームクライアント上にオブジェクトをロードしません。(RF_NotForClient)
  • 0x0020000000000000 - ゲームサーバーにオブジェクトをロードしません。(RF_NotForServer)
  • 0x0040000000000000 - エディタにオブジェクトをロードしません。(RF_NotForEdit)
  • 0x0008000000000000 - オブジェクトが、参照されていない状態であっても、編集のために保持します。(RF_Standalone)
InClass
インスタンスを作成するクラスです。
InTemplate
新たなオブジェクトのプロパティ値を初期化するために使用するオブジェクトです。

new 演算子の実際の構文は、次のとおりです。

ObjectVar = new[(InOuter, InName, InFlags)] <class'InClass'>[(InTemplate)];

LightFunction クラスのオブジェクトを作成します。

function CreateALight()
{
   local LightFunction NewObj;

   NewObj = new class'Engine.LightFunction';
}

NewLight という名前の新たな LightFunction オブジェクトを作成します。このオブジェクトを Outer として割り当てています。

function CreateALight()
{
   local LightFunction NewObj;

   NewObj = new(Self,'NewLight') class'Engine.LightFunction';
}

一時パッケージにNewLight という名前の新たな LightFunction オブジェクトを作成します。新たなオブジェクトのプロパティを初期化するための LightFunctionTemplate 変数の値として割り当てられたオブジェクトを使用しています。

var LightFunction LightFunctionTemplate;

function CreateALight()
{
   local LightFunction NewObj;

   NewObj = new(None,'NewLight') class'Engine.LightFunction' (LightFunctionTemplate);
}

defaultproperties
{
   Begin Object Class=LightFunction Name=MyLightFunctionArchetype
   End Object
   LightFunctionTemplate=MyLightFunctionArchetype
}

整数関数

int Rand( int Max )
0 から Max-1 までの乱数を返します。
int Min( int A, int B )
2 つの整数のうち小さい方を返します。
int Max( int A, int B )
2 つの整数のうち大きい方を返します。
int Clamp( int V, int A, int B )
A から B までの範囲にクランプされた最初の整数を返します。

注意 : C または C++ とは異なり、UnrealScript のMin および Max は、整数に有効です。float 型にこれら関数を使用しても警告が出されません。そのまま端数を切り捨ててしまいます! float 型については、FMin と FMax を使用しなければなりません。

浮動小数点関数

float Abs( float A )
その数の絶対値を返します。
float Sin( float A )
半径で表された数のサインを返します。
float Cos( float A )
ラジアンで表された数のコサインを返します。
float Tan( float A )
ラジアンで表された数のタンジェントを返します。
float ASin( float A )
半径で表された数の逆サインを返します。
float ACos( float A )
半径で表された数の逆コサインを返します。
float ATan( float A )
ラジアンで表された数の逆タンジェントを返します。
float Exp( float A )
定数 e を A 乗して返します。
float Loge( float A )
A の対数 (e を底とする) を返します。
float Sqrt( float A )
A の平方根を返します。
float Square( float A )
A の平方 (A*A) を返します。
float FRand()
0.0 から 1.0 までの乱数を返します。
float FMin( float A, float B )
2 つの数のうち小さい方を返します。
float FMax( float A, float B )
2 つの数のうち大きい方を返します。
float FClamp( float V, float A, float B )
A から B までの範囲にクランプされた最初の数を返します。
float Lerp( float A, float B, float Alpha )
A と B の間の線形補間を返します。
float Smerp( float Alpha, float A, float B )
A と B の間のアルファ平滑化非線形補間を返します。
float Ceil ( float A )
切り上げます。
float Round ( float A )
通常通り四捨五入します。

文字列関数

int Len( coerce string S )
文字列の長さを返します。
int InStr( coerce string S, coerce string t)
1 番目の文字列から 2 番目の文字列を探し、存在する場合はオフセット値を返し、存在しない場合は -1 を返します。
string Mid ( coerce string S, int i, optional int j )
文字列 S の中に含まれる文字 i から文字 j までの部分を返します。( j が指定されていない場合は、すべての文字を返します)。
string Left ( coerce string S, int i )
文字列 S の左端から i 文字分を返します。
string Right ( coerce string) S, int i )
文字列 S の右端から i 文字分を返します。
string Caps ( coerce string S )
S を大文字に変換して返します。
string Locs ( coerce string S)
S を小文字にして返します。(v3323 以降)。
string Chr ( int i )
ASCII 表から文字を返します。
int Asc ( string S )
文字の ASCII 値を返します。(文字列の最初の文字だけが使用されます)。
string Repl ( coerce string Src, coerce string Match, coerce string With, optional bool bCaseSensitive )
文字列 Src において、 MatchWith で置き換えます。 (v3323 以降)。
string Split(coerce string Text, coerce string SplitStr, optional bool bOmitSplitStr)
SplitStr が最初に現れたところで文字列 Text を分割し、 Text の残りの部分を返します。 bOmitSplitStr が true の場合は、 SplitStr が除外されて、文字列が返されます。
array SplitString( string Source, optional string Delimiter=",", optional bool bCullEmpty )
単一の式を使用して、文字列を分割して文字列の配列にするためのラッパーです。
JoinArray(array StringArray, out string out_Result, optional string delim = ",", optional bool bIgnoreBlanks = true)
指定された区切り文字を使用して、文字列の配列から単一の文字列を作成します。オプションで空の配列メンバーを無視できます。
ParseStringIntoArray(string BaseString, out array Pieces, string Delim, bool bCullEmpty)
区切り文字で分けられた文字列を、文字列の配列要素に分解します。
A == B
両方の文字列が同一の場合に true を返す比較です。(大文字と小文字を区別します)。
A ~= B
両方の文字列が同一の場合に true を返す比較です。(大文字と小文字を区別しません)。
A = B
両方の文字列が異なる場合に true を返す比較です。(大文字と小文字を区別します)。

詳細については、 「Unreal」の文字列 のページを参照してください。

ベクター関数

vector vect( float X, float Y, float Z )
指定された成分で新たなベクターを作成します。
float VSize( vector A )
ベクターのユークリッド値 (平方の二乗和の平方根) を返します。
vector Normal( vector A )
指定されたベクターの方向を向いているサイズ 1.0 のベクターを返します。
Invert ( out vector X, out vector Y, out vector Z )
3 つの軸ベクターによって指定されている座標系を反転させます。
vector VRand ( )
一様に分布するランダムなベクターを返します。
vector MirrorVectorByNormal( vector Vect, vector Normal )
指定された法線ベクターについてベクターをミラーリングします。

デバッグ関数

以下の関数は、コードをデバッグする際に役立ちます。

LogEx( ELoggingSeverity Severity, name Category, coerce string Msg )
指定された重大度とカテゴリを用いてメッセージのログを取ります。この関数は、 log() 関数よりも自由に設定することができます。重大度とカテゴリに基づいて、実行時にログメッセージをフィルタリングすることが可能です。
LogFatal( name Category, coerce string Msg )
LogEx(LOG_FATAL, Category, Msg) の呼び出しを短縮したものです。
LogError( name Category, coerce string Msg )
TODO
function LogWarn( name Category, coerce string Msg )
TODO
LogInfo( name Category, coerce string Msg )
TODO
LogDebug( name Category, coerce string Msg )
TODO
LogTrace( name Category, coerce string Msg )
TODO

なお、チェンジリスト 134102 の時点で、上記ログ関数は使えなくなりました。これらは、ロギングマクロに換えられました。( UnrealScript プリプロセッサ のページで扱われています)。

ScriptTrace()
現在のスクリプトのコールスタックをログファイルにダンプします。
Name GetFuncName()
現在呼び出している関数名を返します。
DumpStateStack()
現在のステートスタックのログを取ります。