【Unity C#】Mathfとは？Mathとの違い・よく使う関数・使い方を初心者向けに解説

はじめに

UnityでC#を書いていると、Mathfという名前をよく見かけます。たとえば、プレイヤーの移動速度を制限したり、HPを0〜100の範囲に収めたり、オブジェクトをなめらかに移動させたりするときに使います。

C#には標準でMathという数学計算用のクラスもありますが、UnityではMathfを使う場面が非常に多いです。

この記事では、Unity初心者向けに「Mathfとは何か」「Mathとの違い」「よく使う関数」「実際の使い方」をわかりやすく解説します。

1. Unity C#のMathfとは？

1-1. MathfはUnityで使える数学計算用のクラス

Mathfとは、Unityで数学的な計算を行うために用意されている機能です。

絶対値、最小値、最大値、平方根、丸め処理、補間、角度計算など、ゲーム開発でよく使う計算を簡単に書けます。

たとえば、次のように使います。

C#
float value = Mathf.Abs(-10f);
Debug.Log(value); // 10

Mathf.Absは、数値の絶対値を取得する関数です。-10を渡すと、符号を取り除いた10が返されます。

Unityのスクリプトでは、float型の数値を扱うことが多いため、floatに対応したMathfはとても便利です。

1-2. Mathfでできること

Mathfを使うと、主に次のような処理ができます。

数値の絶対値を取得する、値を一定範囲に制限する、2つの値の間をなめらかに変化させる、小数を四捨五入・切り上げ・切り捨てする、最小値や最大値を取得する、平方根や累乗を計算する、角度や三角関数を扱う、といった処理です。

ゲーム開発では、単純な足し算や引き算だけでなく、「値が大きくなりすぎないようにする」「時間に応じて少しずつ変化させる」「距離や角度を計算する」といった場面が多くあります。

そのようなときにMathfを使うと、コードを短く読みやすく書けます。

1-3. Mathfを使う場面の具体例

Mathfは、Unity開発のさまざまな場面で使われます。

たとえば、プレイヤーの移動速度を最大値以下に制限したい場合はMathf.Clampが使えます。HPが0未満にならないようにしたい場合にもMathf.Clampが便利です。

また、カメラをプレイヤーにゆっくり追従させたい場合はMathf.LerpやVector3.Lerpを使います。UIのゲージをなめらかに増減させたいときにも補間処理が役立ちます。

そのほか、ジャンプ力の計算、ダメージ計算、経験値ゲージ、角度調整、ランダムな揺れの演出などにもMathfはよく使われます。

1-4. Mathfを使うために必要な準備

MathfはUnityのUnityEngine名前空間に含まれています。

通常、Unityで新しくC#スクリプトを作成すると、先頭に次のような記述があります。

C#
using UnityEngine;

このusing UnityEngine;が書かれていれば、Mathfをそのまま使えます。

C#
using UnityEngine;

public class Sample : MonoBehaviour
{
    void Start()
    {
        float value = Mathf.Sqrt(25f);
        Debug.Log(value); // 5
    }
}

もしusing UnityEngine;を書いていない場合は、UnityEngine.Mathfのように書く必要があります。

C#
float value = UnityEngine.Mathf.Abs(-5f);

Unityのスクリプトでは基本的にusing UnityEngine;を書くことが多いため、初心者のうちはMathfとそのまま書けると覚えておけば問題ありません。

2. MathfとMathの違い

2-1. MathfはUnity向け、MathはC#標準の数学クラス

Mathfと似たものに、C#標準のMathがあります。

MathfはUnityが用意している数学計算用の機能です。一方、MathはC#標準ライブラリに含まれる数学計算用のクラスです。

たとえば、絶対値を取得する場合、どちらでも似たような処理ができます。

C#
float a = Mathf.Abs(-10f);
double b = Math.Abs(-10.0);

ただし、Unity開発ではMathfのほうがよく使われます。理由は、Unityの多くの機能がfloat型を中心に作られているためです。

2-2. floatを扱うMathfとdoubleを扱うMath

MathfとMathの大きな違いは、主に扱う数値型です。

Mathfはfloat型を扱うことが多く、Mathはdouble型を扱うことが多いです。

C#
float result1 = Mathf.Sqrt(9f);
double result2 = Math.Sqrt(9.0);

floatは単精度浮動小数点数、doubleは倍精度浮動小数点数です。簡単に言うと、doubleのほうがより細かい数値を扱えますが、ゲーム開発ではfloatで十分な場面が多いです。

UnityのVector3、Transform.position、Time.deltaTimeなどは基本的にfloatを使います。そのため、UnityのコードではMathfを使うほうが型の変換が少なく、扱いやすくなります。

2-3. Unity開発ではMathfを使うことが多い理由

Unity開発でMathfを使うことが多い理由は、Unityの主要な機能がfloat型を基本にしているからです。

たとえば、オブジェクトの位置を表すVector3は、x、y、zの各値がfloatです。

C#
Vector3 position = new Vector3(1f, 2f, 3f);

また、フレーム間の時間を表すTime.deltaTimeもfloatです。

C#
float move = speed * Time.deltaTime;

このように、Unityではfloat型の値を扱う場面が多いため、Mathfを使うと自然にコードを書けます。

Mathを使うとdoubleが返ってくることがあり、floatに代入するときにキャストが必要になる場合があります。

C#
float value = (float)Math.Sqrt(25.0);

一方、Mathfならそのままfloatとして扱えます。

C#
float value = Mathf.Sqrt(25f);

初心者のうちは、Unityのゲーム処理では基本的にMathfを使うと覚えておくとよいでしょう。

2-4. MathfとMathの使い分け方

Unity開発では、基本的にMathfを使えば問題ありません。

プレイヤーの移動、ジャンプ、HP、UIゲージ、カメラ制御、アニメーション、角度計算など、Unity上で動くゲーム処理ではMathfが向いています。

一方、Unityに依存しない純粋なC#の処理や、より高い精度が必要な計算ではMathを使うことがあります。

たとえば、金融計算、統計計算、科学技術計算など、doubleの精度が重要になる場面ではMathのほうが適している場合があります。

使い分けの目安は次のとおりです。

Unityのオブジェクト操作やゲーム処理ではMathf、Unityに依存しないC#の計算や高精度な数値計算ではMathを使う、という考え方で問題ありません。

3. Mathfの基本的な使い方

3-1. Mathf関数の基本構文

Mathfの基本的な使い方は、次のような形です。

C#
Mathf.関数名(引数);

たとえば、絶対値を取得する場合は次のように書きます。

C#
float result = Mathf.Abs(-5f);

Mathf.Absのように、Mathfのあとにドットを付けて関数名を書きます。そして、丸かっこの中に計算したい値を入れます。

複数の値を渡す関数もあります。

C#
float result = Mathf.Clamp(120f, 0f, 100f);

この場合、120fを0fから100fの範囲に収めるという意味になります。結果は100fです。

3-2. Mathfを使った簡単なサンプルコード

次のコードは、Mathfを使って値を0〜100の範囲に制限するサンプルです。

C#
using UnityEngine;

public class MathfSample : MonoBehaviour
{
    void Start()
    {
        float hp = 120f;

        hp = Mathf.Clamp(hp, 0f, 100f);

        Debug.Log(hp); // 100
    }
}

この例では、hpに120fが入っています。しかし、Mathf.Clampを使って0fから100fの範囲に制限しているため、最終的な値は100fになります。

HPやMP、スタミナ、スコア倍率など、上限や下限がある値にはMathf.Clampがよく使われます。

3-3. 変数と組み合わせた使い方

Mathfは固定の数値だけでなく、変数と組み合わせて使うことができます。

C#
using UnityEngine;

public class SpeedSample : MonoBehaviour
{
    public float speed = 15f;
    public float maxSpeed = 10f;

    void Start()
    {
        speed = Mathf.Clamp(speed, 0f, maxSpeed);

        Debug.Log(speed); // 10
    }
}

このコードでは、speedがmaxSpeedを超えないようにしています。

ゲーム中に速度が変化する場合でも、Mathf.Clampを使えば最大速度を超えないように制御できます。

C#
speed += 5f;
speed = Mathf.Clamp(speed, 0f, maxSpeed);

このように、値を増減させたあとにMathf.Clampで範囲を制限する書き方は、Unity C#でよく使われます。

3-4. よくあるエラーと対処法

Mathfを使うときによくあるエラーのひとつが、Mathfが見つからないというエラーです。

C#
The name 'Mathf' does not exist in the current context

このエラーが出た場合は、スクリプトの先頭にusing UnityEngine;があるか確認しましょう。

C#
using UnityEngine;

また、floatの数値にfを付け忘れることもあります。

C#
float value = Mathf.Clamp(10.5, 0, 100);

このように書くと、数値がdoubleとして扱われてエラーになることがあります。Mathfではfloatを使うことが多いため、小数にはfを付けましょう。

C#
float value = Mathf.Clamp(10.5f, 0f, 100f);

また、Mathf.Clampの引数の順番を間違えることもあります。

C#
Mathf.Clamp(値, 最小値, 最大値);

正しい順番は、制限したい値、最小値、最大値です。

4. Mathfでよく使う関数一覧

4-1. Mathf.Abs：絶対値を取得する

Mathf.Absは、数値の絶対値を取得する関数です。

絶対値とは、数値の符号を取り除いた値のことです。-10なら10、5なら5になります。

C#
float value1 = Mathf.Abs(-10f);
float value2 = Mathf.Abs(5f);

Debug.Log(value1); // 10
Debug.Log(value2); // 5

Mathf.Absは、差分の大きさを知りたいときによく使います。

たとえば、プレイヤーと敵のX座標の差を調べたい場合、符号ではなく距離の大きさだけを知りたいことがあります。

C#
float distanceX = Mathf.Abs(player.position.x - enemy.position.x);

このように書くと、プレイヤーが敵の右にいても左にいても、X方向の距離を正の値として取得できます。

4-2. Mathf.Clamp：値を指定範囲内に制限する

Mathf.Clampは、値を指定した最小値と最大値の範囲内に制限する関数です。

C#
float result = Mathf.Clamp(120f, 0f, 100f);
Debug.Log(result); // 100

値が最大値を超えている場合は最大値に、最小値を下回っている場合は最小値になります。範囲内であれば、そのままの値が返されます。

C#
Debug.Log(Mathf.Clamp(50f, 0f, 100f));   // 50
Debug.Log(Mathf.Clamp(-10f, 0f, 100f));  // 0
Debug.Log(Mathf.Clamp(120f, 0f, 100f));  // 100

HP、MP、スタミナ、音量、明るさ、経験値ゲージなど、下限と上限がある値にはMathf.Clampがとても便利です。

C#
hp -= damage;
hp = Mathf.Clamp(hp, 0f, maxHp);

このコードでは、ダメージを受けたあとにHPが0未満にならないようにしています。

4-3. Mathf.Lerp：2つの値をなめらかに補間する

Mathf.Lerpは、2つの値の間を補間する関数です。

C#
float result = Mathf.Lerp(0f, 10f, 0.5f);
Debug.Log(result); // 5

基本構文は次のとおりです。

C#
Mathf.Lerp(開始値, 終了値, 割合);

3つ目の引数には、0〜1の値を指定します。0なら開始値、1なら終了値、0.5ならちょうど中間の値になります。

C#
Debug.Log(Mathf.Lerp(0f, 10f, 0f));   // 0
Debug.Log(Mathf.Lerp(0f, 10f, 0.5f)); // 5
Debug.Log(Mathf.Lerp(0f, 10f, 1f));   // 10

Mathf.Lerpは、UIゲージをなめらかに変化させたり、カメラのズーム値を少しずつ変えたりするときに使われます。

C#
currentValue = Mathf.Lerp(currentValue, targetValue, Time.deltaTime);

このように書くと、currentValueがtargetValueに向かってなめらかに近づいていきます。

4-4. Mathf.Round・Floor・Ceil：小数を丸める

Mathfには、小数を丸めるための関数があります。

Mathf.Roundは四捨五入、Mathf.Floorは切り捨て、Mathf.Ceilは切り上げです。

C#
float a = Mathf.Round(3.6f);
float b = Mathf.Floor(3.6f);
float c = Mathf.Ceil(3.2f);

Debug.Log(a); // 4
Debug.Log(b); // 3
Debug.Log(c); // 4

整数として取得したい場合は、RoundToInt、FloorToInt、CeilToIntも使えます。

C#
int a = Mathf.RoundToInt(3.6f);
int b = Mathf.FloorToInt(3.6f);
int c = Mathf.CeilToInt(3.2f);

Debug.Log(a); // 4
Debug.Log(b); // 3
Debug.Log(c); // 4

スコア表示、アイテム個数、レベル計算、グリッド座標への変換などでは、整数に丸める処理がよく使われます。

4-5. Mathf.Min・Max：最小値・最大値を取得する

Mathf.Minは複数の値の中から最小値を取得する関数です。Mathf.Maxは最大値を取得する関数です。

C#
float min = Mathf.Min(10f, 5f);
float max = Mathf.Max(10f, 5f);

Debug.Log(min); // 5
Debug.Log(max); // 10

たとえば、2つの値のうち小さいほうを使いたい場合はMathf.Min、大きいほうを使いたい場合はMathf.Maxを使います。

C#
float damage = Mathf.Max(baseDamage - defense, 0f);

このコードでは、防御力によってダメージが減っても、ダメージが0未満にならないようにしています。

Mathf.Clampと似た使い方もできますが、最小値だけ、または最大値だけを制限したい場合にはMinやMaxが便利です。

4-6. Mathf.Sqrt・Pow：平方根や累乗を計算する

Mathf.Sqrtは平方根を計算する関数です。

C#
float result = Mathf.Sqrt(25f);
Debug.Log(result); // 5

平方根は、距離計算や物理的な計算で使われることがあります。

Mathf.Powは累乗を計算する関数です。

C#
float result = Mathf.Pow(2f, 3f);
Debug.Log(result); // 8

この例では、2の3乗を計算しています。

C#
float power = Mathf.Pow(level, 2f);

レベルに応じて必要経験値を増やしたい場合など、累乗を使うとカーブのある成長式を作れます。

ただし、単純な2乗であれば、x * xと書いたほうがわかりやすく、処理も軽い場合があります。

C#
float square = value * value;

複雑な累乗が必要なときはMathf.Pow、単純な2乗なら掛け算、と使い分けるとよいでしょう。

5. Unity開発で便利なMathfの活用例

5-1. プレイヤーの移動速度を制限する

プレイヤーの移動速度が大きくなりすぎると、操作感が悪くなったり、ゲームバランスが崩れたりします。

そのため、速度を一定範囲に制限したい場合があります。

C#
using UnityEngine;

public class PlayerSpeed : MonoBehaviour
{
    public float speed = 0f;
    public float maxSpeed = 10f;

    void Update()
    {
        speed += 5f * Time.deltaTime;
        speed = Mathf.Clamp(speed, 0f, maxSpeed);

        transform.Translate(Vector3.forward * speed * Time.deltaTime);
    }
}

このコードでは、時間経過でspeedが増えていきますが、Mathf.ClampによってmaxSpeedを超えないようにしています。

移動速度、加速度、ジャンプ力、回転速度など、上限を決めたい値にはMathf.Clampが役立ちます。

5-2. HPやゲージの値を0〜最大値に収める

HPやスタミナなどの値は、0未満になったり最大値を超えたりしないように管理する必要があります。

C#
using UnityEngine;

public class PlayerHp : MonoBehaviour
{
    public float hp = 100f;
    public float maxHp = 100f;

    public void TakeDamage(float damage)
    {
        hp -= damage;
        hp = Mathf.Clamp(hp, 0f, maxHp);

        Debug.Log("現在のHP: " + hp);
    }

    public void Heal(float amount)
    {
        hp += amount;
        hp = Mathf.Clamp(hp, 0f, maxHp);

        Debug.Log("現在のHP: " + hp);
    }
}

このように、ダメージを受けたときも回復したときも、最後にMathf.Clampを使うことで安全に値を管理できます。

UIゲージに反映する場合も、値が範囲外になるのを防げるため、表示崩れを避けやすくなります。

5-3. オブジェクトをなめらかに移動させる

Mathf.Lerpを使うと、値をなめらかに変化させることができます。

たとえば、オブジェクトの高さを少しずつ目標値に近づける場合は、次のように書けます。

C#
using UnityEngine;

public class SmoothHeight : MonoBehaviour
{
    public float targetY = 5f;
    public float speed = 2f;

    void Update()
    {
        Vector3 pos = transform.position;

        pos.y = Mathf.Lerp(pos.y, targetY, speed * Time.deltaTime);

        transform.position = pos;
    }
}

このコードでは、現在のY座標がtargetYに向かってなめらかに近づきます。

位置全体をなめらかに移動させたい場合は、Mathf.LerpではなくVector3.Lerpを使うことも多いです。

C#
transform.position = Vector3.Lerp(transform.position, targetPosition, speed * Time.deltaTime);

単体の数値を補間するならMathf.Lerp、位置や方向などのベクトルを補間するならVector3.Lerpと覚えるとわかりやすいです。

5-4. ランダム値や角度計算と組み合わせる

MathfはRandom.Rangeや角度計算と組み合わせても便利です。

たとえば、ランダムな角度でオブジェクトを回転させる場合は、次のように書けます。

C#
float randomAngle = Random.Range(0f, 360f);
transform.rotation = Quaternion.Euler(0f, randomAngle, 0f);

角度を一定範囲に制限したい場合は、Mathf.Clampを使えます。

C#
float angle = 120f;
angle = Mathf.Clamp(angle, -90f, 90f);

また、三角関数を使う場合は、Mathf.SinやMathf.Cosを使います。

C#
float y = Mathf.Sin(Time.time) * 2f;
transform.position = new Vector3(0f, y, 0f);

このコードでは、オブジェクトが上下にゆらゆら動くような動きを作れます。

ただし、Mathf.SinやMathf.Cosに渡す値はラジアンです。度数法の角度を使う場合は、Mathf.Deg2Radを使って変換します。

C#
float radian = 90f * Mathf.Deg2Rad;
float result = Mathf.Sin(radian);

5-5. UI・アニメーション・カメラ制御で使う

MathfはUIやアニメーション、カメラ制御でもよく使われます。

たとえば、音量を0〜1の範囲に制限する場合は、Mathf.Clamp01が便利です。

C#
volume = Mathf.Clamp01(volume);

Mathf.Clamp01は、値を0〜1の範囲に制限する関数です。UIのスライダー、透明度、ゲージの割合などでよく使います。

カメラのズームをなめらかに変化させる場合は、Mathf.Lerpを使えます。

C#
Camera.main.fieldOfView = Mathf.Lerp(Camera.main.fieldOfView, targetFov, Time.deltaTime * 5f);

また、UIゲージをなめらかに減らす場合にも使えます。

C#
currentGauge = Mathf.Lerp(currentGauge, targetGauge, Time.deltaTime * 10f);

瞬間的に値を変えるのではなく、少しずつ変化させたい場面ではMathf.Lerpが非常に便利です。

6. Mathfを使うときの注意点

6-1. Mathfはfloat型が基本

Mathfは基本的にfloat型を扱います。

そのため、小数を書くときはfを付ける習慣をつけましょう。

C#
float value = 1.5f;

1.5のようにfを付けないと、C#ではdoubleとして扱われます。

C#
float value = 1.5; // エラーになる

正しくは次のように書きます。

C#
float value = 1.5f;

Mathfを使う場合も同じです。

C#
float result = Mathf.Lerp(0f, 10f, 0.5f);

初心者のうちは、小数にはfを付けると覚えておくと、型に関するエラーを減らせます。

6-2. Lerpの使い方を間違えやすいポイント

Mathf.Lerpでよくある間違いは、3つ目の引数に大きすぎる値を入れてしまうことです。

C#
float value = Mathf.Lerp(0f, 10f, 5f);

Mathf.Lerpの3つ目の引数は、基本的に0〜1の割合として考えます。0なら開始値、1なら終了値です。

また、次のような書き方もよく見かけます。

C#
current = Mathf.Lerp(current, target, Time.deltaTime);

この書き方は、現在値を目標値に少しずつ近づける処理としてよく使われます。ただし、一定時間で必ず到着する動きではなく、「だんだん近づく」動きになります。

一定時間で開始値から終了値まで移動させたい場合は、経過時間を管理して、0〜1の割合を作る必要があります。

C#
timer += Time.deltaTime;
float t = timer / duration;

value = Mathf.Lerp(startValue, endValue, t);

さらに安全にするなら、tをMathf.Clamp01で0〜1に制限します。

C#
float t = Mathf.Clamp01(timer / duration);
value = Mathf.Lerp(startValue, endValue, t);

6-3. Clampで最小値と最大値を逆にしない

Mathf.Clampは便利ですが、引数の順番を間違えないように注意しましょう。

正しい順番は次のとおりです。

C#
Mathf.Clamp(値, 最小値, 最大値);

たとえば、HPを0〜100に制限する場合は次のように書きます。

C#
hp = Mathf.Clamp(hp, 0f, 100f);

最小値と最大値を逆に書くと、意図した結果になりません。

C#
hp = Mathf.Clamp(hp, 100f, 0f);

このような書き方は避けましょう。

変数を使う場合も、minとmaxの値が正しく設定されているか確認することが大切です。

C#
float minHp = 0f;
float maxHp = 100f;

hp = Mathf.Clamp(hp, minHp, maxHp);

6-4. 角度計算ではラジアンと度数法に注意する

Unityでは、角度を扱う場面が多くあります。ここで注意したいのが、度数法とラジアンの違いです。

Transform.RotateやQuaternion.Eulerでは、基本的に度数法の角度を使います。

C#
transform.rotation = Quaternion.Euler(0f, 90f, 0f);

一方、Mathf.SinやMathf.Cosなどの三角関数では、ラジアンを使います。

C#
float result = Mathf.Sin(90f); // 90度の意味にはならない

90度のサインを計算したい場合は、Mathf.Deg2Radを使ってラジアンに変換します。

C#
float radian = 90f * Mathf.Deg2Rad;
float result = Mathf.Sin(radian);

逆に、ラジアンを度数に変換したい場合はMathf.Rad2Degを使います。

C#
float degree = radian * Mathf.Rad2Deg;

角度計算で思った通りの結果にならない場合は、度数法とラジアンを混同していないか確認しましょう。

7. Mathfと関連して覚えておきたいUnityの機能

7-1. Vector3との組み合わせ

Vector3は、Unityで3D空間の位置や方向を表すためによく使われます。

Mathfは単体の数値を扱いますが、Vector3の各成分と組み合わせて使うことができます。

C#
Vector3 pos = transform.position;

pos.x = Mathf.Clamp(pos.x, -5f, 5f);
pos.y = Mathf.Clamp(pos.y, 0f, 10f);

transform.position = pos;

このコードでは、オブジェクトのX座標とY座標を指定範囲内に制限しています。

また、Vector3.Distanceで距離を取得し、その値をMathf.Clampで制限するような使い方もできます。

C#
float distance = Vector3.Distance(player.position, enemy.position);
distance = Mathf.Clamp(distance, 0f, 20f);

MathfとVector3を組み合わせることで、位置、距離、方向に関する処理を柔軟に書けます。

7-2. Time.deltaTimeとの組み合わせ

Time.deltaTimeは、前のフレームから現在のフレームまでにかかった時間を表す値です。

Unityでは、フレームレートによってUpdateが呼ばれる回数が変わります。そのため、移動や回転をフレームレートに依存させないためにTime.deltaTimeを使います。

C#
transform.Translate(Vector3.forward * speed * Time.deltaTime);

Mathf.Lerpと組み合わせることもよくあります。

C#
currentValue = Mathf.Lerp(currentValue, targetValue, Time.deltaTime * 5f);

このように書くと、フレームごとに少しずつ目標値へ近づく処理になります。

また、時間経過で値を増やしながら、上限を超えないようにする場合にも使えます。

C#
stamina += recoverSpeed * Time.deltaTime;
stamina = Mathf.Clamp(stamina, 0f, maxStamina);

MathfとTime.deltaTimeは、Unity C#で自然な動きを作るためによくセットで使われます。

7-3. Transform操作との組み合わせ

Transformは、Unityでオブジェクトの位置、回転、拡大縮小を扱うための機能です。

Mathfを使うと、Transformの値を制限したり、なめらかに変化させたりできます。

たとえば、オブジェクトの高さを制限する場合は次のように書けます。

C#
Vector3 pos = transform.position;
pos.y = Mathf.Clamp(pos.y, 0f, 10f);
transform.position = pos;

回転角度を制限したい場合にもMathf.Clampが使えます。

C#
float angle = transform.eulerAngles.x;
angle = Mathf.Clamp(angle, 0f, 60f);

transform.rotation = Quaternion.Euler(angle, 0f, 0f);

ただし、eulerAnglesは0〜360度で表現されるため、マイナス角度を扱う場合は注意が必要です。

オブジェクトをなめらかに動かしたい場合は、Mathf.LerpやVector3.Lerpを使います。

C#
Vector3 target = new Vector3(0f, 5f, 0f);
transform.position = Vector3.Lerp(transform.position, target, Time.deltaTime * 3f);

7-4. Random.Rangeとの組み合わせ

Random.Rangeは、ランダムな値を取得するためのUnityの機能です。

Mathfと組み合わせることで、ランダム値を制限したり、加工したりできます。

C#
float randomValue = Random.Range(-10f, 10f);
float absValue = Mathf.Abs(randomValue);

このコードでは、-10〜10のランダムな値を取得し、その絶対値を求めています。

ランダムなダメージを作りつつ、最小ダメージを保証する場合は次のように書けます。

C#
float damage = Random.Range(5f, 20f);
damage = Mathf.Max(damage, 10f);

また、ランダムに増減した値を範囲内に収めたい場合はMathf.Clampが使えます。

C#
hp += Random.Range(-30f, 30f);
hp = Mathf.Clamp(hp, 0f, maxHp);

ランダム要素を使うと値が予想外の範囲になることがあるため、Mathf.Clampで安全に制限すると扱いやすくなります。

8. Mathfに関するよくある質問

8-1. Mathfはusingを書かないと使えない？

通常は、スクリプトの先頭にusing UnityEngine;が必要です。

C#
using UnityEngine;

Unityで新しくC#スクリプトを作成すると、多くの場合は最初からusing UnityEngine;が書かれています。

これがあれば、次のようにMathfをそのまま使えます。

C#
float value = Mathf.Abs(-10f);

using UnityEngine;を書かない場合は、次のように完全な名前で書く必要があります。

C#
float value = UnityEngine.Mathf.Abs(-10f);

基本的には、Unityのスクリプトではusing UnityEngine;を書いておくのが一般的です。

8-2. MathfとSystem.Mathはどちらを使うべき？

Unity開発では、基本的にMathfを使うことが多いです。

理由は、UnityのVector3、Time.deltaTime、Transformなどがfloatを中心に扱うためです。

C#
float value = Mathf.Sqrt(25f);

一方、C#標準のSystem.Mathはdoubleを扱うことが多いため、Unityのfloat型と組み合わせるとキャストが必要になる場合があります。

C#
float value = (float)System.Math.Sqrt(25.0);

ゲーム内の移動、UI、カメラ、アニメーションなどではMathfを使い、Unityに依存しない高精度な計算ではSystem.Mathを検討するとよいでしょう。

8-3. Mathf.LerpとVector3.Lerpの違いは？

Mathf.Lerpは、floatの値を補間する関数です。

C#
float value = Mathf.Lerp(0f, 10f, 0.5f);

一方、Vector3.Lerpは、Vector3の値を補間する関数です。

C#
Vector3 position = Vector3.Lerp(startPosition, endPosition, 0.5f);

つまり、単体の数値をなめらかに変化させたい場合はMathf.Lerp、位置や方向のような3Dベクトルをなめらかに変化させたい場合はVector3.Lerpを使います。

たとえば、UIの透明度やゲージの値にはMathf.Lerp、オブジェクトの位置移動にはVector3.Lerpが向いています。

8-4. Mathf.Clamp01とは何が違う？

Mathf.Clampは、最小値と最大値を自分で指定して値を制限する関数です。

C#
float value = Mathf.Clamp(120f, 0f, 100f);

一方、Mathf.Clamp01は、値を0〜1の範囲に制限する関数です。

C#
float value = Mathf.Clamp01(1.5f);
Debug.Log(value); // 1

Clamp01の「01」は、0から1までという意味です。

HPの割合、ゲージの割合、透明度、音量、進行度など、0〜1で表現する値にはMathf.Clamp01が便利です。

C#
float hpRate = currentHp / maxHp;
hpRate = Mathf.Clamp01(hpRate);

0〜1以外の範囲に制限したい場合はMathf.Clamp、0〜1に制限したい場合はMathf.Clamp01を使いましょう。

8-5. MathfはUnity以外のC#でも使える？

MathfはUnityの機能なので、通常のC#プロジェクトではそのまま使えません。

Unity以外のC#で数学計算を行う場合は、基本的にSystem.Mathを使います。

C#
double value = System.Math.Sqrt(25.0);

一方、Unityのプロジェクト内であれば、using UnityEngine;を書くことでMathfを使えます。

C#
using UnityEngine;

float value = Mathf.Sqrt(25f);

つまり、Unity C#ではMathf、通常のC#ではSystem.Mathを使うと考えるとわかりやすいです。

まとめ

Mathfは、Unity C#で数学計算を行うためによく使われる機能です。

絶対値を取得するMathf.Abs、値を範囲内に制限するMathf.Clamp、値をなめらかに変化させるMathf.Lerp、小数を丸めるMathf.Round、最小値や最大値を取得するMathf.Min・Mathf.Max、平方根や累乗を計算するMathf.Sqrt・Mathf.Powなど、ゲーム開発で役立つ関数が多数用意されています。

C#標準のMathとの違いは、主にfloatを扱うかdoubleを扱うかです。UnityではVector3やTime.deltaTimeなどfloatを使う機能が多いため、ゲーム開発ではMathfを使う場面が多くなります。

初心者のうちは、HPやスタミナを範囲内に収めるならMathf.Clamp、UIやカメラをなめらかに動かすならMathf.Lerp、距離や差分の大きさを扱うならMathf.Absというように、よく使う関数から覚えていくのがおすすめです。

Mathfを理解して使えるようになると、Unity C#での移動処理、UI制御、アニメーション、カメラ操作、ゲームバランス調整などが書きやすくなります。まずは小さなサンプルコードで試しながら、実際のゲーム制作に少しずつ取り入れていきましょう。