Canvas Scaler 組件(Component)是控制 UI 縮放的組件。主要負責控制在不同解析度下 UI 元件大小縮放比例，讓 UI 可以自動適應不同的螢幕，但它不負責位置，位置由 (RectTransform)[/2024/07/05/2024-07-05-ugui-recttransform] 組件負責。

Canvas Size 為 Cavas 中 RectTransform 的寬高。

• 下圖中，
  • 左側的 Screen 為目前裝置的螢幕大小，下圖為 1012 x 515
  • Cavas 中 RectTransform 的 寬高＊縮放係數 = 螢幕解析度， (width * X scale) x (height * Y scale)， (1012 * 1) x (515 * 1)
    

Reference Resolution(參考解析度)：在 Scale With Screen Size 模式中，它會參與解析度自適應的計算

主要提供三種模式

• Constant Pixel Size(恆定像素模式)：不論螢幕大小如何，UI始終保持相同像素大小。
  • 一般在遊戲中不常用。
  • 它不會讓 UI 元件自動適應解析度大小，除非使用程式碼去修改
• Scale With Screen Size(縮放模式)：根據螢幕大小進行縮放
  • 在遊戲中最常用
• Constant Physical Size(恆定物理模式)：不論螢幕大小如何，UI元素始終保持相同物理大小
• World (世界模式)：當 Canvas 的 Render Mode 選擇為 World Space 時，會將 Canvas Scaler 變為 World。
  • 一般不常更改，主要像素密度，一般值越大越清晰。因此當文字模糊時，可以考慮加大這個值。

Constant Pixel Size(恆定像素模式)

Scale Factor

Scale Factor 縮放 Canvas 中所有 UI 元素。

當 Scale Factor 為 1 且 Screen Size=1024x768 則 Canvas Size 會為 1024x768，圖片大小為原樣

當 Scale Factor 為 2 且 Screen Size=1024x768 則 Canvas Size 會為 512x384，在其中的圖片大小看起來會放大 2 倍。

Reference Pixel Per Unit

Reference Pixel Per Unit 設定多少像素對應 Unity 中的一個單位，預設一個單位為 100 像素。

在計算時，圖片設定中的 Pixels Per Unit 設定會與此參數一起計算。(圖片設定中的 Texture Type 要設為 Sprite(2D and UI))，

當 Pixels Per Unit=100，表示每單位由 100 像素組成，而圖片解析度是512x512，那麼圖片在世界座標中大小就會變成 512/100 = 5.12x5.12 Unit
Sprite 在世界座標的大小 = 原圖片大小(像素) / Pixels Per Unit

UI的大小 = 原圖片大小(像素) / (Pixels Per Unit / Reference Pixels Per Unit)

Scale With Screen Size

Reference Resolution

Reference Resolution：參考解析度，美術人員出圖的標準解析度。一邊選擇市面上最常見的解析度作為標準。

• 使用在電腦上的話，可以用 1920x1080
• 假設你要用於 Android 或是 iOS 的手機遊戲的話，可以用 1080x1440

Screen Match Mode

Screen Match Mode：螢幕匹配模式，當目前螢幕解析度寬高不符合解析度時，用於解析度大小自適應的匹配模式。

Expand(擴大)

Expand：水平或垂直擴大 Canvas Size，讓它高於Reference Resolution，不會裁剪 UI 元素，可能會有黑邊。
計算公式：

• scaleFactor(縮放係數) = Mathf.Min(screenSize.x(螢幕寬) / m_ReferenceResolution.x(Reference Resolution寬), screenSize.y(螢幕高) / m_ReferenceResolution.y(Reference Resolution高))
• Canvas Size = 螢幕寬高 / scaleFactor(縮放係數)

例子： Reference Resolution 為 1920x1080 ， 螢幕(screen)解析度為 800x600。
scaleFactor = Mathf.Min(800/1920, 600/1080) = Mathf.Min(0.41667, 0.5555) = 0.41667
Canvas Size = (800,600) / 0.41667 = (1920, 1440)

效果：最大程度的顯示所有 UI 元素，保留 UI 所有的細節，可能會有黑邊。

Shirk(收縮)

Shirk：水平或垂直收縮 Canvas Size，讓它低於Reference Resolution，可能會被裁減。
計算公式：

• scaleFactor(縮放係數) = Mathf.Max(screenSize.x(螢幕寬) / m_ReferenceResolution.x(Reference Resolution寬), screenSize.y(螢幕高) / m_ReferenceResolution.y(Reference Resolution高))
• Canvas Size = 螢幕寬高 / scaleFactor(縮放係數)

例子： Reference Resolution 為 1920x1080 ， 螢幕(screen)解析度為 800x600。
scaleFactor = Mathf.Max(800/1920, 600/1080) = Mathf.Max(0.41667, 0.5555) = 0.5555
Canvas Size = (800,600) / 0.5555 = (1440, 1080)

效果：最大程度的放大 UI 元素，可能會被裁減。

Match Width Or Height

Match Width Or Height：以寬和高進行混合縮放。

• Match：用於計算寬高匹配值。
  • 當值為 0 時，適合直立螢幕模式的遊戲。將 Canvas Size 寬度設為 Reference Resolution 的寬度，並保持比例不變，螢幕越高時可能會出現黑邊。
  • 當值為 1 時，用在橫向螢幕模式的遊戲。將 Canvas Size 高度設為 Reference Resolution 的高度，並保持比例不變，螢幕越長時可能會出現黑邊。
    計算公式：

    1 2 3 4

    float logWidth = Mathf.Log(screenSize.x / m_ReferenceResolution.x, kLogBase); float logHeight = Mathf.Log(screenSize.y / m_ReferenceResolution.y, kLogBase); float logWeightedAverage = Mathf.Lerp(logWidth, logHeight, m_MatchWidthOrHeight); scaleFactor = Mathf.Pow(kLogBase, logWeightedAverage);

使用建議

• 存在直立螢幕模式和橫向螢幕模式的遊戲選擇使用 Expand 或 Shirnk
• 不存在螢幕模式切換的遊戲（即定死為直立螢幕模式或是橫向螢幕模式）選擇使用 Match Width Or Height
• 直式螢幕稱為 Portrait ，橫式螢幕 Landscape

Constant Physical Size(恆定物理模式)

DPI (Dots Per Inch，每英吋點數)

DPI：圖像每英吋長度內的像素點數

Physical Unit

Physical Unit：物理單位，使用的物理單位種類

• Centimeters(cm 公分)：1 英吋 = 2.54 公分
• Millimeters(mm 公釐)：1 英吋 = 25.4 公釐
• Inches(英吋)： 1 英吋 = 1 英吋
• Points (點)： 1 英吋 = 72 點
• Picas (派卡)： 1 英吋 = 6 派卡

Fallback Screen DPI：備用 DPI ，當找不到裝置 DPI 時，使用此值

Default Sprite DPI：預設圖片 DPI

計算公式：根據 DPI 算出新的 Reference Pixels Per Unit
新 Reference Pixels Per Unit = Reference Pixels Per Unit ＊ Physical Unit / Default Sprite DPI

UI的大小 = 原圖片大小(像素) / (Pixels Per Unit / 新 Reference Pixels Per Unit)

根據裝置的 DPI 進行計算，在不同裝置上的顯示大小更加準確

World 模式

當 Canvas 的 Render Mode 選擇為 World Space 時，會將 Canvas Scaler 變為 World ， 3D 世界模式。

Dynamic Pixels Per Unit

UI 中動態建立的點陣圖(例如文字)，中的單位像素(類似密度)。一般值越大越清晰。因此當文字模糊時，可以考慮加大這個值。

Reference Pixels Per Unit

單位參考像素，多少像素對應 Unity 中的一個單位，預設一個單位為 100 像素。

Reference:

• https://www.arkaistudio.com/blog/2016/03/28/unity-ugui-%e5%8e%9f%e7%90%86%e7%af%87%e4%ba%8c%ef%bc%9acanvas-scaler-%e7%b8%ae%e6%94%be%e6%a0%b8%e5%bf%83/
• https://forum.unity.com/threads/what-reference-resolution-and-game-view-settings-should-i-use.1088650/

Canvas 組件(Component)為 UGUI 中的根本，主要用來渲染自己的所有 UI 組件。UI 組件必須要為 Canvas 組件的子組件才可正常顯示。

Render Mode

UI 渲染方式有以下三種

• Screen Space - Overlay(預設)：螢幕空間，覆蓋模式，
  • UI 始終顯示在場景(Scene)內容前方。
  • Pixel Perfect：是否開啟無鋸齒精確渲染，性能換效果，當勾選時會有較好的 UI 顯示，但是較耗費性能
  • SortOrder：排序層編號，用於控制多個 Canvas 時的渲染先後順序。該值越高顯示越前面
  • Target Display：目標裝置，在哪個裝置上顯示。
  • Additional Shader Channels：其他著色器通道，決定著色器可以讀取哪些資料。
• Screen Space - Camera：螢幕空間，攝影機模式，
  • 3D 物體可以顯示在 UI 之前。
  • Render Camera：用於渲染UI的攝影機，如果不設定，則會類似於覆蓋模式
    • 一般不建議直接使用主攝影機去渲染 UI
  • Plane Distance：UI 平面在攝影機前方的距離，類似整體 Z 軸的感覺。值越小該 Canvas UI 越靠近攝影機。
  • Sorting Layer：Canvas屬於的排序層，可在 Edit -> Project Setting -> Tags and Layers -> Sorting Layers 進行新增與編輯，越下方的層顯示越前面
  • Order in Layer：Canvas在所屬排序層下的順序，該值越高顯示越前面
  • 例如角色狀態，一般會選這種模式，因為玩家角色物件要顯示在 UI 前面。
• World Space： 世界空間，3D模式。
  • Event Camera：用於處理 UI 事件(Click、Drag)的攝影機。如果不設定，不能正常註冊UI事件，有就是說如果沒設定則像是 Click 事件就無法正常使用。
    • 一般使用主攝影機
  • 把 UI 當作 3D 物件，可以圍著人物或其他物件旋轉，移動。

Reference:

• https://www.bilibili.com/video/BV14N411Z7Fz?p=3&vd_source=f103d4eb21cc24456defbcf356882852

錄製遊戲影片是時間管理中的一個特例。保存螢幕圖片的操作需要耗費相當多的時間，這會導致遊戲的正常幀率降低，錄製出的影片無法反映遊戲的實際表現。為了解決這個問題，可以使用 captureFramerate 屬性。該屬性的預設值為 0，表示未錄製遊戲。如果要進行錄製，則需要將該屬性的值設為非零值，此時遊戲時間會變慢，幀更新會在精確的間隔內發生。
幀之間的間隔等於 1/Time.captureFramerate，所以如果將值設置為5.0，則更新每五分之一秒發生一次。由於幀率需求有效降低，在 Update 方法中有時間保存螢幕截圖或執行其他操作。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

public class ExampleScript : MonoBehaviour {
    string folder = "ScreenshotFolder";
    int frameRate = 25;
        
    void Start () {
        Time.captureFramerate = frameRate;
        System.IO.Directory.CreateDirectory(folder);
    }
    
    void Update () {
        string name = string.Format("{0}/{1:D04} shot.png", folder, Time.frameCount );
        
        // 抓取螢幕截圖，並存放到指定位置
        Application.CaptureScreenshot(name);
    }
}

返回 時間與幀 大綱

以下將說明各種 Time 類中的屬性是如何回報與響應幀率的巨大變化；下面的表格展示了 Unity 執行了 16 幀的情況，其中第 8 幀出現一個大延遲。

在第 1 到第 7 幀中，

• 從 time 和 unscaledTime 可以發現這些值穩定的增加，約為 60 幀， timeScale 設為 1 。

在第 8 幀中，出現了超過一秒的大延遲，

• 當幀延遲超過 maximumDeltaTime 的值時，Unity 會限制 deltaTime 回報的值以及增加到目前時間的量。這個限制的目的是避免如果時間步長超過這個數值可能會發生的不良副作用。
  • 所謂的不良副作用：像這樣的延遲會導致 deltaTime 的值變得非常大。例如，如果延遲超過一秒，deltaTime 可能會超過 1.0 秒。如果一個物體的移動量是透過 deltaTime 縮放的，這樣大的 deltaTime 值會導致物體在一幀內移動非常大的距離，可能直接穿過遊戲中的牆壁或其他障礙物，導致遊戲中不希望看到的「穿牆」現象。

下圖表中可以看到在第 8 幀時， unscaledDeltaTime 超過一秒(1.016)，但是 deltaTime 回報的是 0.333 ，這是因為 deltaTime 被 maximumDeltaTime 限制。

在第 8 幀時， unscaledTime 增加將近一秒(1.123)的時間，但是 time 只增加較小的時間(0.440)，這是因為 time 加上的是被限制的 deltaTime (即 maximumDeltaTime 的值)。簡單的說：

• unscaledTime 代表從遊戲開始到目前幀的真實經過時間，不受限制。
• time 代表遊戲開始到目前幀的經過時間，但是受 maximumDeltaTime 限制。

Time.smoothDeltaTime 提供了最近一段時間內 deltaTime 的平滑近似值，這種平滑處理可以避免在計算中突然出現的波動，這種平滑的演算法無法預測未來的變化，但是可以讓回報的時間較平滑，因此可以比較符合實際預期的時間。

maximumDeltaTime 也會影響物理系統，物理系統使用 fixedTimestep 值來決定每個固定步長中模擬的時間量。Unity 嘗試保持物理模擬與實際經過的時間同步，有時會在一幀內執行多次物理更新。然而，如果由於某些重計算或延遲導致物理模擬落後太多，系統可能需要多次步驟來追趕當前時間。這種大量的步驟可能進一步導致性能下降。

• 為了避免由於試圖追趕而導致的逐步減慢，maximumDeltaTime 值還作為物理系統在任何給定兩幀之間模擬時間的上限。
• 如果一次幀更新的處理時間超過了 maximumDeltaTime，物理引擎將不會試圖模擬超過 maximumDeltaTime 的時間，而是讓幀處理趕上。一旦幀更新完成，物理模擬將恢復，就像它停止後沒有時間流逝一樣。這樣做的結果是，物理物體將不會像通常那樣以完全實時移動，而是會略微減速。然而，物理的「時鐘」仍然會跟踪它們，就好像它們在正常移動一樣。物理時間的減速通常不容易察覺，並且通常是在遊戲性能與實時物理模擬之間的可接受折衷。

返回 時間與幀 大綱

flowchart TD
    A["`deltaTime`"] --> B{"`deltaTime 
                             是否比
                             maximumDeltaTime 大？`"}
    B -- 是 --> C[deltaTime 的值設為
maximumDeltaTime]
    C --> D
    B -- 否 --> D[ deltaTime 
被加到 time 中 ]
    D --> E{"`fixedTime 
              是否落後 Time.time 
              一個固定時間步長？`"}
    E -- 是 --> F[ fixedDeltaTime 
加到 fixedTime中 ]
    F --> G[ 執行 FixedUpdate ]
    G --> E
    E -- 否 --> H[ 執行 Update ]

Time.time ：為遊戲開始後經過的時間，以秒為單位，一般會持續穩定的增加，只可讀。

• 受 timeScale 影響，如果 Time.timeScale 設為 0 ，那麼 Time.time 會停止計時，可以達到遊戲暫停的功能。
• 受 maximumDeltaTime 限制。
• 當在 FixedUpdate 中呼叫時，回傳的是 Time.fixedTime 的值。
• 通常用於關於整場遊戲計時的計算。

Time.deltaTime ：從上一個幀到目前幀之間的時間間隔，以秒為單位。

• 可以在遊戲中用來製作倒數裝置，例如施放技能的時間變化。

Time.timeScale ：時間流逝的縮放程度，可以用在實現慢動作效果，預設為 1.0 。

• 當為 1.0 時，表示遊戲時間和真實時間同步，
• 如果設為 0.5 則遊戲時間以半速運行。
• 設為 0.1 可以實現慢動作效果，這表示播放速度為正常速度的 10%。經過十秒之後 Time.time 的值會增加 1。
• 當為 0 時，則時間停止，但是遊戲邏輯(像是 Update 方法仍然會被呼叫)與渲染事件仍然會被觸發。但 Time.time 不會增加，Time.deltaTime 也為 0。

Time.maximumDeltaTime ：上面的屬性會被 Time.maximumDeltaTime 限制，這表示這些屬性任何幀率變化的長度永遠不會超過 Time.maximumDeltaTime，例如，如果發生一秒的延遲，且 maximumDeltaTime 為 0.333，那麼 Time.time 只會增加 0.333，而 Time.deltaTime 也會等於 0.333，儘管實際上已經過了更多時間。

• unscale版本的屬性(如Time.unscaledTime和Time.unscaledDeltaTime)會忽略這些變化和限制，並回報實際經過的時間。對於需要在遊戲慢動作播放時仍以固定速度響應的任何事物都很有用。例如，用於 UI 交互動畫。

返回 時間與幀 大綱

Reference:

• https://docs.unity3d.com/uploads/Main/time-flowchart.png

在 Unity 中，它的物理系統使用固定時間步長(Fixed Timestep)，Unity 提供 FixedUpdate 作為我們程式碼的入口(entry point)，你可以在這邊執行與物理相關的程式碼，例如向 Rigidbody 施加力。

fixedDeltaTime 是 Unity 中控制固定時間步長循環間隔的屬性，以秒為單位。

• 例如，當 fixedDeltaTime為 0.01 時意味著每個固定時間步長持續 1/100 秒，因此每秒會執行 100 次固定更新。

當你的APP執行的幀率高於每秒固定時間步長(Fixed Timestep)時，這表示每個幀的持續時間會比單個固定時間步長的持續時間還要短。

• 例如，如果 fixedDeltaTime 設為 0.02，那麼通常每秒會有 50 次固定更新。
  • 如果你的 APP 以每秒 60 幀的速度執行，這會超過每秒 50 次的固定更新，這表示大約每十幀中會有一幀不會觸發固定更新。

如果你的 APP 的幀率低於固定時間步長值，這意味著每個幀的持續時間比單個固定時間步長還要長。為了解決這個問題，Unity 每幀會執行一個或多個固定更新，以便物理模擬能夠趕上自上一幀以來流逝的時間。

• 例如，如果你的固定時間步長值為 0.01，每秒會執行 100 次固定更新。如果你的應用以每秒 25 幀的速度運行，每幀的持續時間（0.04 秒）是固定時間步長值（0.01 秒）的四倍， Unity 將每幀執行四次固定更新。在幀率較低時，Unity 通過增加固定更新次數來保持物理模擬的準確性。

fixedDeltaTime 設定的越低，表示越頻繁的執行物理更新，模擬的越精確，但是會加大 CPU 的負擔。

返回 時間與幀 大綱

在 Unity 中， APP 的每一幀所執行的時間會因為程式碼複雜度或是顯示畫面的複雜度而有所不同，此外也會受到裝置設備的效能影響。

• 例如：當有一百個角色在螢幕上活動時，每一幀的執行速度會比只有一個角色來的慢，這種可變的速率通常被稱為 每秒幀數 FPS 。
• 一般來說 Unity 會嘗試以最快的幀率執行你的 APP。

Update 方法

在 Unity 中，提供了 Update 方法作為每一幀執行我們程式碼的入口(entry point)，例如在 Update 中取得使用者的輸入讓遊戲角色向前移動。但是要記住遊戲的幀率是可變的，因此Update調用之間的時間間隔也會變化。

幀率變動對遊戲物件移動速度的影響

下面的程式碼想做的事是把這個遊戲物件平移一段距離，但是幀率(frame rate)是會變動的，因此這個遊戲物件在移動時，它的速度也會變化。
例如：

• 假設遊戲為每秒 100 幀的速度在執行，那麼 Update 這個方法會執行 100 次，因此這個物件每秒會移動 distancePerFrame 一百次
• 但是如果因為 CPU 負載變高導致速度下降到 每秒 60 幀的速度在執行的話，那麼這個物件會變為每秒移動 distancePerFrame 六十次

1
2
3
4
5
6
7

public class ExampleScript : MonoBehaviour {
    public float distancePerFrame;
    
    void Update() {
        transform.Translate(0, 0, distancePerFrame); // 錯誤
    }
}

大部分的情況下，這是不好的，因為通常在遊戲中會希望物體是以穩定且可預測的速度移動而不受到幀率影響。

使用 Time.deltaTime 確保一致性

Time.deltaTime 為從上一幀到目前幀之間的時間間隔，以秒為單位。這個屬性通常用於在 Update 方法中進行時間相關的計算
例如，你想要從現開始，經過一秒後做某些動作，可以這樣操作：

1
2
3
4
5
6
7
8
9
10
11

public class ExampleScript : MonoBehaviour {
    private float timer = 0f;

    void Update() {
        timer += Time.deltaTime;
        if (timer >= 1f) {
            Debug.Log("一秒過去了，某些動作");
            timer = 0f;
        }
    }
}

因此解決上面位移問題的方式是根據每一幀經過的時間來縮放每一幀的移動量，這樣無論幀率如何變化，物體每秒移動的總距離都會保持一致。程式碼如下：

1
2
3
4
5
6
7
8

public class ExampleScript : MonoBehaviour {
    // 變數的名稱變為 per second ，這是因為此時不再是依靠幀而是秒了
    public float distancePerSecond;
    
    void Update() {
        transform.Translate(0, 0, distancePerSecond * Time.deltaTime);
    }
}

返回 時間與幀 大綱

以下將建立一個簡單的技能冷卻計時器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

public class SkillTimer : MonoBehaviour
{
    private float timer = 0;
    private float skillCooldown = 3;

    void Update()
    {

        // 讓計時器隨時間增加
        timer += Time.deltaTime;
        
        if (timer > skillCooldown)
        {
            // 重置計時器
            timer = 0;

            // 釋放技能...
            Debug.Log("施放技能");
        }
        
    }
}

timer 變數用於累計經過的時間。

skillCooldown 用於設定技能冷卻時間為 3 秒。

每次 Update 被呼叫時，timer 會不斷的加上 Time.deltaTime

當 timer 超過 skillCooldown 時，就會重置計時器，並施放技能

返回 時間與幀 大綱

Mathf.Lerp 是 Unity 中的一個數學函數，用於在兩個值之間進行線性插值(Linear Interpolation)。
這個函數可以幫助你製作平滑的效果，像是顏色轉換，動畫轉換等。

語法為 float Mathf.Lerp(float a, float b, float t)

• a ：起始值
• b ：結束值
• t ：代表 a 與 b 之間的插值比例，範圍在 0 到 1 之間。如果 t 為 0，則返回 a；如果 t 為 1，則返回 b；如果 t 為 0.5，則返回 a 和 b 之間的中間值(0.5)。
• 例如： Mathf.Lerp (3f, 5f, 0.5f) 會得到 4 。

我們來看一個例子，假設 a=0 ， b=20 ， t=0.5 。 每一秒執行一次，並將結果儲存回 a

• 開始： a=0 ，
• 第一秒： a = Mathf.Lerp (0f, 20f, 0.5f) = 10
• 第二秒： a = Mathf.Lerp (10f, 20f, 0.5f) = 15
• 第三秒： a = Mathf.Lerp (15f, 20f, 0.5f) = 17.5
  …

將結果畫為一個座標圖，其中 X 軸代表時間(每一秒)， Y 軸代表每一秒執行之後的 a

可得出以下簡單的結論

• 隨著時間增加 a 會從開始快速增加，但是當越接近 b 時，成長的速度就會越慢。

下面是一個使用 Mathf.Lerp 調整光強度的例子。

• 假設光的強度從 0 開始
• 在第一次更新幀後： Mathf.Lerp(0f, 8f, 0.5f) 得到的值為 4
• 第二次更新幀後： Mathf.Lerp(4f, 8f, 0.5f) 得到的值為 6
• 第三次更新幀後： Mathf.Lerp(6f, 8f, 0.5f) 得到的值為 7
• 第四次更新幀後： Mathf.Lerp(7f, 8f, 0.5f) 得到的值為 7.5
• …依此類推，最後將趨近於 8 ，但是隨著 a 的值接近 b ，其變化的速率將減慢。

  1 2 3 4 5 6 7 8

  void Start() { light.intensity = 0; } void Update () { light.intensity = Mathf.Lerp(light.intensity, 8f, 0.5f); }

下面的程式碼將展示如何使用 Mathf.Lerp 來在兩個值之間做插值，讓一個遊戲物件來回移動。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

public class Example : MonoBehaviour
{
    // 定義遊戲物件在X軸上的移動範圍
    public float minimum = -1.0F;  // 最小值 -1.0
    public float maximum =  1.0F;  // 最大值  1.0


    // Lerp 的初始值
    static float t = 0.0f;

    void Update()
    {
        // 使用 Lerp 函數在 minimum 和 maximum 之間插值，這個遊戲物件一開始將從 minimum 移動到 maximim
        transform.position = new Vector3(Mathf.Lerp(minimum, maximum, t), 0, 0);

        // 增加 t 的值，0.5f * Time.deltaTime 來控制插值的速度
        t += 0.5f * Time.deltaTime;

        // 當 t 超過 1.0 時，將 t 重置為 0 並交換 minimum 和 maximum
        // 這樣物件將開始從 maximum 移動回 minimum
        if (t > 1.0f)
        {
            float temp = maximum;
            maximum = minimum;
            minimum = temp;
            t = 0.0f;
        }
    }
}

使用 0.5f * Time.deltaTime 的原因是：確保增量操作（例如移動或旋轉）在不同的幀率下保持一致。這樣，無論遊戲以每秒 30 幀還是每秒 60 幀運行，物件的移動速度都會保持一致。
舉個例子：假設你的遊戲每秒運行 60 幀，則 Update 每一秒會執行 60 次， 那麼每幀的 Time.deltaTime 約為 1/60 秒 ≈ 0.0167 秒

• 如果想要讓每秒 t 增長的量為 0.5f ， 以每一幀來看， t 增長的量要為 0.5f * 0.0167 ≈ 0.0083 ， 這樣在執行 60 次 Update 後約為一秒 => 0.5f * 0.0167 * 60 ≈ 0.5f

另外還有 Color.Lerp 和 Vector3.Lerp 這些方法的工作方式與 Mathf.Lerp 完全相同，差別在於輸入 a 和 b 的類型

Reference:

• https://learn.unity.com/tutorial/xian-xing-cha-zhi?language=zh&projectId=5e3afd88edbc2a2998252c77#5e3afd8bedbc2a2998252cb0
• https://docs.unity3d.com/ScriptReference/Mathf.Lerp.html

ScriptableObject 除了作為資料的容器外，還可在其內部定義方法，讓 MonoBehaviour 可以將自己傳入 ScriptableObject 的方法中，根據不同的 ScriptableObject 實體去執行不同的動作。

例如：要做增益效果，定義一個抽象的 PowerupEffect 類，它繼承 ScriptableObject ，並且只有一個 ApplyTo 方法，這個方法將增益效果應用到傳入的 GameObject 中。

1
2
3
4

public abstract class PowerupEffect : ScriptableObject 
{
    public abstract void ApplyTo(GameObject object);
}

建立一個子類 HpBooster ，並 override 了 ApplyTo ，將增加遊戲物件的生命值。

1
2
3
4
5
6
7
8

public class HpBooster : PowerupEffect
{
    public int Amount;
    public override void ApplyTo(GameObject object) 
    {
        object.GetComponent<HP>().currentValue += Amount;
    }
}

在建立一個 增益物件 的腳本，這個增益物件將持有 PowerupEffect 的參考，當在觸發器中觸發時，就會呼叫它持有的 PowerupEffect 來將增益效果應用到碰到的遊戲物件。

1
2
3
4
5
6
7
8
9

public class Powerup : MonoBehaviour 
{
    public PowerupEffect effect;

    public void OnTriggerEnter(Collider other)
    {
        effect.ApplyTo(other.gameObject);
    }
}

例子，使用音效

1
2
3
4
5
6
7

// 這個 struct 為最大最小值的結構
[Serializable]
public struct RangedFloat
{
    public float minValue;
    public float maxValue;
}

定義一個抽象的 AudioDelegateSO 並繼承 ScriptableObject。在其中含有一個 Play 抽象方法，讓傳入的 AudioSource 播放音效。

1
2
3
4

public abstract class AudioDelegateSO: ScriptableObject
{
    public abstract void Play(AudioSource source);
}

定義一個 SimpleAudioDelegateSO 類，它繼承 AudioDelegateSO ，
這個 SimpleAudioDelegateSO 可以管理一個音效列表clips，在 Play 方法中，將隨機播放 clips 列表中的聲音。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

[CreateAssetMenu(fileName ="AudioDelegate")]
public class SimpleAudioDelegateSO : AudioDelegateSO
{
    public AudioClip[] clips;
    public RangedFloat volume;
    public RangedFloat pitch;
    public override void Play(AudioSource source)
    {
        if (clips.Length == 0 || source == null) 
        {
            return;
        }
        source.clip = clips[Random.Range(0, clips.Length)]; 
        source.volume = Random.Range(volume.minValue, volume.maxValue);
        source.pitch = Random.Range(pitch.minValue, pitch.maxValue);
        source.Play();
    }
}

我們可以使用這個 SimpleAudioDelegateSO 讓同一個遊戲物件隨機播放不同的聲音，例如可以儲存狗的叫聲，每當觸碰狗遊戲物件時，就隨機播放一種叫聲。

例子： 在遊戲中，會分為玩家控制，或是電腦控制的遊戲物件，如坦克遊戲中的坦克，可以由不同 AI 控制，也可以為玩家控制。這種不同的行為，我們也可以用 Delegate Object 來做。

定義一個抽象的 TankBrain 繼承 ScriptableObject。其中

• 含有 Initialize 虛方法，不一定會實作這個方法，但是當需要做初始化的動作時可以 override 它。
• 含有一個 Think 抽象方法，決定傳入的 TankThinker 要有什麼行為。

  1 2 3 4

  public abstract class TankBrain : ScrptableObject { public abstract void Think(TankThinker tank); }

定義一個 PlayerControlledTank 類，它繼承 TankBrain

• 它為玩家操控的坦克。
• override Think 方法，在裡面取得坦克的位置，並判斷輸入來移動坦克或是發射砲彈。

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

  [CreateAssetMenu(menuName="Brains/Player Controlled")] public class PlayerControlledTank : TankBrain { public int PlayerNumber; private string m_MovementAxisName; private string m_TurnAxisName; private string m_FireButton; public void OnEnable() { m_MovementAxisName = "Vertical" + PlayerNumber; m_TurnAxisName = "Horizontal" + PlayerNumber; m_FireButton = "Fire" + PlayerNumber; } public override void Think(TankThinker tank) { // 取得坦克移動 component var movement = tank.GetComponent<TankMovement>(); // 透過 Steer 與 Input 輸入來移動坦克 movement.Steer(Input.GetAxis(m_MovementAxisName), Input.GetAxis(m_TurnAxisName)); // 取得坦克發射砲彈 component var shooting = tank.GetComponent<TankShooting>(); // 判斷 Input 輸入是否為開火按鈕 if (Input.GetButton(m_FireButton)) shooting.BeginChargingShot(); else shooting.FireChargedShot(); } }

定義一個 SimpleSniper 類，它也繼承 TankBrain ，它為電腦操控的坦克。

• override Think 方法，在裡面判斷是否移動與開火
  • 如取得坦克的位置，並根據它的記憶(Remeber)中判斷是否看過玩家坦克
    • 如果記憶(Remeber)中沒有玩家坦克，則找最近的物件，並判斷是否為玩家坦克
    • 如果還是沒找到，則移動自己

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

[CreateAssetMenu(menuName="Brains/Simple sniper")]
public class SimpleSniper : TankBrain
{
 
    public float aimAngleThreshold = 2f;
    [MinMaxRange(0, 0.05f)]
    public RangedFloat chargeTimePerDistance;
    [MinMaxRange(0, 10)]
    public RangedFloat timeBetweenShots;
 
    public override void Think(TankThinker tank)
    {
        GameObject target = tank.Remember<GameObject>("target");
        var movement = tank.GetComponent<TankMovement>();
 
        if (!target)
        {
            // 如果記憶(`Remeber`)中沒有玩家坦克，則找最近的物件，並判斷是否為玩家坦克
            target =
                GameObject
                    .FindGameObjectsWithTag("Player")
                    .OrderBy(go => Vector3.Distance(go.transform.position, tank.transform.position))
                    .FirstOrDefault(go => go != tank.gameObject);
            // 記住找到的目標
            tank.Remember<GameObject>("target", target);
        }
 
        if (!target)
        {
            // 如果還是沒找到，則移動自己
            movement.Steer(0.5f, 1f);
            return;
        }

        // 瞄準目標
        Vector3 desiredForward = (target.transform.position - tank.transform.position).normalized;
        if (Vector3.Angle(desiredForward, tank.transform.forward) > aimAngleThreshold)
        {
            // 判斷轉動方向
            bool clockwise = Vector3.Cross(desiredForward, tank.transform.forward).y > 0;
            movement.Steer(0f, clockwise ? -1 : 1);
        }
        else
        {
            // 停止轉向
            movement.Steer(0f, 0f);
        }

        // 獲取坦克的射擊 component
        var shooting = tank.GetComponent<TankShooting>();
        // 檢查是否可以開始充能射擊
        if (!shooting.IsCharging)
        {
            if (Time.time > tank.Remember<float>("nextShotAllowedAfter"))
            {
                float distanceToTarget = Vector3.Distance(target.transform.position, tank.transform.position);
                float timeToCharge = distanceToTarget*Random.Range(chargeTimePerDistance.minValue, chargeTimePerDistance.maxValue);
                tank.Remember("fireAt", Time.time + timeToCharge);
                shooting.BeginChargingShot();
            }
        }
        else
        {
            float fireAt = tank.Remember<float>("fireAt");
            if (Time.time > fireAt)
            {
                shooting.FireChargedShot();
                tank.Remember("nextShotAllowedAfter", Time.time + Random.Range(timeBetweenShots.minValue, timeBetweenShots.maxValue));
            }
        }
    }
}

返回 ScriptableObject 系列

Reference:

• https://unity.com/cn/how-to/scriptableobjects-delegate-objects
• https://unity.com/cn/resources/create-modular-game-architecture-with-scriptable-objects-ebook