ติดตั้งเกม Unity ของคุณด้วย Firebase Remote Config

1. บทนำ

คุณสามารถใช้การกำหนดค่าระยะไกลของ Firebase เพื่อ กำหนดคู่คีย์-ค่า หรือที่เรียกว่าพารามิเตอร์ ในแอปของคุณ และอัปเดตค่าในระบบคลาวด์ ซึ่งช่วยให้คุณ แก้ไขรูปลักษณ์และลักษณะการทำงานของแอปได้ โดยไม่ต้องเผยแพร่การอัปเดตแอป

คุณจะเพิ่มฟังก์ชันใหม่นี้ให้กับเกมตัวอย่าง MechaHamster: Level Up with Firebase Edition เกมตัวอย่างนี้เป็นเวอร์ชันใหม่ของเกม Firebase สุดคลาสสิก MechaHamster ที่นำฟังก์ชัน Firebase ในตัวส่วนใหญ่ออก ทำให้คุณมีโอกาสนำการใช้งาน Firebase ใหม่ๆ มาใช้แทนได้

เพื่อให้แน่ใจว่าแอปของคุณทำงานตามที่ตั้งใจไว้ คุณจะต้องตั้งค่าการกำหนดค่าเริ่มต้นสำหรับค่าในโค้ดเกมตัวอย่าง และค่าเหล่านี้สามารถแทนที่ได้ด้วยค่า ที่คุณตั้งไว้ในการกำหนดค่าระยะไกลในคอนโซล Firebase

สิ่งที่คุณจะได้เรียนรู้

  • วิธีการตั้งค่า Remote Config ในระบบคลาวด์และดึงข้อมูล
  • วิธีวัดโค้ด Unity C# ของคุณเพื่อใช้ค่าที่ดึงมาโดยอัตโนมัติ
  • วิธีจัดเก็บ เครื่องมือ และแทนที่ค่าผสม/อ็อบเจ็กต์เป็นค่า JSON
  • วิธีใช้เงื่อนไขการกำหนดค่าระยะไกลเพื่อให้บริการตัวแปรค่าที่แตกต่างกันให้กับกลุ่มผู้ใช้ที่แตกต่างกัน

สิ่งที่คุณต้องการ

  • Unity 2019.1.0f1 หรือสูงกว่าพร้อมรองรับ iOS และ/หรือ Android build
  • อุปกรณ์ Android/iOS จริงหรือเครื่องจำลอง/เครื่องจำลองเพื่อสร้างและรันเกม

2. ตั้งค่าสภาพแวดล้อมการพัฒนาของคุณ

ส่วนต่อไปนี้อธิบายวิธีดาวน์โหลดโค้ด Level Up ด้วย Firebase เปิดใน Unity และเพิ่มโปรเจ็กต์ Firebase เกมตัวอย่างการอัพเลเวลด้วย Firebase นี้ใช้งานโดย Codelab อื่นๆ ของ Firebase + Unity ดังนั้นคุณอาจทำงานในส่วนนี้เสร็จสิ้นแล้ว หากเป็นเช่นนั้น คุณสามารถข้ามขั้นตอนเหล่านี้และดำเนินการเพิ่ม Firebase SDK สำหรับ Unity เพื่อเพิ่มการกำหนดค่าระยะไกลลงในโค้ดเกมตัวอย่าง

ดาวน์โหลดรหัส

โคลน ที่เก็บ GitHub ของ Codelab นี้จากบรรทัดคำสั่ง:

git clone https://github.com/firebase/level-up-with-firebase

หรือหากคุณไม่ได้ติดตั้ง git คุณสามารถ ดาวน์โหลดที่เก็บเป็นไฟล์ ZIP ได้

เปิด Level Up ด้วย Firebase ในตัวแก้ไข Unity

  1. เปิด Unity Hub และจากแท็บ Projects ให้คลิก ลูกศรแบบเลื่อนลง ถัดจาก Open
  2. คลิก เพิ่มโครงการจากดิสก์
  3. นำทางไปยังไดเร็กทอรีที่มีรหัส จากนั้นคลิก ตกลง
  4. หากได้รับแจ้ง ให้เลือกเวอร์ชันตัวแก้ไข Unity ที่จะใช้และแพลตฟอร์มเป้าหมายของคุณ (Android หรือ iOS)
  5. คลิกที่ชื่อโปรเจ็กต์ Level-up-with-firebase และโปรเจ็กต์จะเปิดขึ้นในตัวแก้ไข Unity
  6. หากโปรแกรมแก้ไขของคุณไม่เปิดโดยอัตโนมัติ ให้เปิด MainGameScene ใน Assets > Hamster ในแท็บ Project ของ Unity Editor

สำหรับข้อมูลเพิ่มเติมเกี่ยวกับการติดตั้งและใช้งาน Unity โปรดดู การทำงานใน Unity

3. เพิ่ม Firebase ให้กับโปรเจ็กต์ Unity ของคุณ

สร้างโปรเจ็กต์ Firebase

  1. ใน คอนโซล Firebase คลิก เพิ่มโครงการ
  2. หากต้องการสร้างโปรเจ็กต์ใหม่ ให้ป้อนชื่อโปรเจ็กต์ที่ต้องการ
    นอกจากนี้ยังจะตั้งค่ารหัสโปรเจ็กต์ (แสดงใต้ชื่อโปรเจ็กต์) ให้เป็นค่าบางอย่างตามชื่อโปรเจ็กต์ คุณสามารถเลือกคลิกไอคอน แก้ไข บนรหัสโปรเจ็กต์เพื่อปรับแต่งเพิ่มเติมได้
  3. หากได้รับแจ้ง ให้อ่านและยอมรับ ข้อกำหนดของ Firebase
  4. คลิก ดำเนินการต่อ
  5. เลือกตัวเลือก เปิดใช้งาน Google Analytics สำหรับโปรเจ็กต์นี้ จากนั้นคลิก ดำเนินการต่อ
  6. เลือกบัญชี Google Analytics ที่มีอยู่เพื่อใช้หรือเลือก สร้างบัญชีใหม่ เพื่อสร้างบัญชีใหม่
  7. คลิก สร้างโครงการ
  8. เมื่อสร้างโครงการแล้ว คลิก ดำเนินการต่อ

ลงทะเบียนแอปของคุณกับ Firebase

  1. เปิด คอนโซล Firebase และจากตรงกลางหน้าภาพรวมโปรเจ็กต์ ให้คลิกไอคอน Unity เพื่อเปิดเวิร์กโฟลว์การตั้งค่า หรือหากคุณได้เพิ่มแอปลงในโปรเจ็กต์ Firebase แล้ว ให้คลิก เพิ่มแอป เพื่อแสดงตัวเลือกแพลตฟอร์ม
  2. เลือกเพื่อลงทะเบียนทั้งเป้าหมายบิลด์ Apple (iOS) และ Android
  3. ป้อนรหัสเฉพาะแพลตฟอร์มของโปรเจ็กต์ Unity สำหรับ Codelab นี้ ให้ป้อนข้อมูลต่อไปนี้:
  4. หรือป้อนชื่อเล่นเฉพาะแพลตฟอร์มของโปรเจ็กต์ Unity ของคุณ
  5. คลิกลง ทะเบียนแอป แล้วไปที่ส่วน ดาวน์โหลดไฟล์กำหนดค่า
  6. ทำซ้ำขั้นตอนสำหรับเป้าหมายบิลด์ใดก็ตามที่คุณไม่ได้ทำในครั้งแรก

เพิ่มไฟล์การกำหนดค่า Firebase

หลังจากคลิก ลงทะเบียนแอป คุณจะได้รับแจ้งให้ดาวน์โหลดไฟล์การกำหนดค่าสองไฟล์ (ไฟล์การกำหนดค่าหนึ่งไฟล์สำหรับแต่ละเป้าหมายบิลด์) โปรเจ็กต์ Unity ของคุณต้องมีข้อมูลเมตา Firebase ในไฟล์เหล่านี้เพื่อเชื่อมต่อกับ Firebase

  1. ดาวน์โหลดทั้งสองไฟล์กำหนดค่าที่มีอยู่:
    • สำหรับ Apple (iOS) : ดาวน์โหลด GoogleService-Info.plist
    • สำหรับ Android : ดาวน์โหลด google-services.json
  2. เปิดหน้าต่าง โปรเจ็กต์ ของโปรเจ็กต์ Unity ของคุณ จากนั้นย้ายไฟล์กำหนดค่าทั้งสองไฟล์ไปยังโฟลเดอร์ สินทรัพย์
  3. กลับไปที่คอนโซล Firebase ในเวิร์กโฟลว์การตั้งค่า คลิก ถัดไป และดำเนินการเพิ่ม Firebase SDK สำหรับ Unity

หมายเหตุ: คุณสามารถดาวน์โหลดไฟล์เหล่านี้ซ้ำได้ในภายหลังโดยเปิด การตั้งค่าทั่วไป ของโปรเจ็กต์ เลื่อนลงไปที่ส่วน แอปของคุณ จากนั้นคลิกปุ่มดาวน์โหลดสำหรับไฟล์การกำหนดค่าที่ต้องการ

เพิ่ม Firebase SDK สำหรับ Unity

  1. คลิก ดาวน์โหลด Firebase Unity SDK ในคอนโซล Firebase
  2. แตกไฟล์ SDK ที่ไหนสักแห่งที่สะดวก
  3. ใน Unity Project ที่เปิดอยู่ ให้ไปที่ Assets > Import Package > Custom Package
  4. ใน กล่องโต้ตอบนำเข้าแพ็คเกจ ให้นำทางไปยังไดเร็กทอรีที่มี SDK ที่คลายซิปแล้ว เลือก FirebaseAnalytics.unitypackage จากนั้นคลิก เปิด
  5. จากกล่องโต้ตอบ นำเข้าแพ็คเกจ Unity ที่ปรากฏขึ้น ให้คลิก นำเข้า
  6. ทำซ้ำขั้นตอนก่อนหน้าเพื่อนำเข้าสองแพ็คเกจต่อไปนี้:
    • FirebaseRemoteConfig.unitypackage
    • FirebaseCrashlytics.unitypackage
      Crashlytics คือโปรแกรมรายงานข้อขัดข้องแบบเรียลไทม์น้ำหนักเบาที่ช่วยคุณติดตาม จัดลำดับความสำคัญ และแก้ไขปัญหาความเสถียรที่กัดกร่อนคุณภาพของแอป หากคุณไม่เคยใช้มาก่อน ลองพิจารณา Crashlytics Learning Pathway for Unity ให้เสร็จสิ้น
  7. กลับไปที่คอนโซล Firebase และในขั้นตอนการตั้งค่า ให้คลิก ถัดไป

สำหรับข้อมูลเพิ่มเติมเกี่ยวกับการเพิ่ม Firebase SDK ไปยังโปรเจ็กต์ Unity โปรดดู ตัวเลือกการติดตั้ง Unity เพิ่มเติม

4. ตั้งค่าเริ่มต้นของการกำหนดค่าระยะไกลและดึงค่าใหม่

ใน Codelab นี้ คุณจะอัปเดตออบเจ็กต์ที่ใช้ค่าที่กำหนดไว้ในโค้ดหรือทำให้เป็นอนุกรมในตัวแก้ไข Unity เพื่อใช้ค่าที่มาพร้อมกับการกำหนดค่าระยะไกล คุณจะกำหนดค่าเริ่มต้นสำหรับแต่ละพารามิเตอร์โดยใช้ SetDefaultsAsync เพื่อให้แอปของคุณทำงานตามที่ตั้งใจก่อนที่จะเชื่อมต่อกับแบ็กเอนด์การกำหนดค่าระยะไกล แอปของคุณจะอัปเดตอยู่เสมอโดยการดึงค่าใหม่จากการกำหนดค่าระยะไกลและเปิดใช้งานเพื่อให้สามารถใช้งานได้ในโค้ด

หากต้องการดึงค่าใหม่จากการกำหนดค่าระยะไกล มีวิธีการจำนวนหนึ่งที่ยังไม่ได้ใช้งานซึ่งมีอยู่ในไฟล์ Assets/Hamster/Scripts/MainGame.cs ที่ต้องดำเนินการให้เสร็จสิ้น

  1. เพิ่มคำสั่งต่อไปนี้ using คำสั่งใน MainGame.cs :
    using Firebase.Crashlytics;
using Firebase.Extensions;
using Firebase.RemoteConfig;
    โมดูล Firebase.Extensions มีส่วนขยายบางส่วนใน C# Tasks API ซึ่งจะช่วยทำให้การจัดการกระบวนการเริ่มต้นด้วยการเรียกกลับง่ายขึ้น
  2. เพิ่มการเริ่มต้น Firebase ให้กับเมธอด MainGame.cs Start() ของคุณโดยแทนที่เมธอด InitializeCommonDataAndStartGame() ที่มีอยู่ด้วยเมธอดที่ยังไม่ได้ใช้งานในปัจจุบัน InitializeFirebaseAndStartGame() :
    void Start()
{
   Screen.SetResolution(Screen.width / 2, Screen.height / 2, true);
   InitializeFirebaseAndStartGame();
}
  3. ใน MainGame.cs ให้ค้นหา InitializeFirebaseAndStartGame() ประกาศตัวแปรแอปและเขียนทับการใช้งานวิธีการดังต่อไปนี้:
    public Firebase.FirebaseApp app = null;

// Begins the firebase initialization process and afterwards, opens the main menu.
private void InitializeFirebaseAndStartGame()
{
   Firebase.FirebaseApp.CheckAndFixDependenciesAsync()
   .ContinueWithOnMainThread(
      previousTask =>
      {
         var dependencyStatus = previousTask.Result;
         if (dependencyStatus == Firebase.DependencyStatus.Available) {
         // Create and hold a reference to your FirebaseApp,
         app = Firebase.FirebaseApp.DefaultInstance;
         // Set the recommended Crashlytics uncaught exception behavior.
         Crashlytics.ReportUncaughtExceptionsAsFatal = true;
         SetRemoteConfigDefaults();
         } else {
         UnityEngine.Debug.LogError(
            $"Could not resolve all Firebase dependencies: {dependencyStatus}\n" +
            "Firebase Unity SDK is not safe to use here");
         }
      });
}
  4. การเริ่มต้น Firebase เรียก SetRemoteConfigDefaults เมื่อสำเร็จเพื่อตั้งค่าเริ่มต้นในแอป แทนที่เมธอด SetRemoteConfigDefaults ที่ยังไม่ได้ใช้งานด้วยสิ่งต่อไปนี้:
    private void SetRemoteConfigDefaults()
{
   var defaults = new System.Collections.Generic.Dictionary < string, object > ();
   defaults.Add(
      Hamster.MapObjects.AccelerationTile.AccelerationTileForceKey,
      Hamster.MapObjects.AccelerationTile.AccelerationTileForceDefault);
   defaults.Add(
      Hamster.States.MainMenu.SubtitleOverrideKey,
      Hamster.States.MainMenu.SubtitleOverrideDefault);
   var remoteConfig = FirebaseRemoteConfig.DefaultInstance;
   remoteConfig.SetDefaultsAsync(defaults).ContinueWithOnMainThread(
      previousTask =>
      {
         FetchRemoteConfig(InitializeCommonDataAndStartGame);
      }
   );
}

5. ดึงข้อมูลและเปิดใช้งานค่าใหม่ (ตามความจำเป็น)

ตอนนี้เราจำเป็นต้องดำเนินการวิธี FetchRemoteConfig ที่มีอยู่ให้เสร็จสิ้น การดำเนินการนี้จะเชื่อมโยงการเรียกไปยังเมธอดของการกำหนดค่าระยะไกล FetchAsync (ซึ่งดึงค่าใหม่จากการกำหนดค่าระยะไกล) และ ActivateAsync (ซึ่งจะเปิดใช้งานค่าที่ได้รับเหล่านั้นเพื่อให้สามารถใช้ได้ในโค้ด) โดยใช้พารามิเตอร์การเรียกกลับที่ชื่อ onFetchAndActivateSuccessful

รหัสเริ่มต้นที่เราเพิ่มในขั้นตอนก่อนหน้านี้เรียก FetchRemoteConfig โดยมี InitializeCommonDataAndStartGame เป็นตัวเรียกกลับเพื่อเริ่มเกมเมื่อสิ้นสุดซีเควนซ์ คุณสามารถส่งการเรียกกลับทางเลือกไปยัง FetchRemoteConfig เพื่อเรียกใช้การดึงข้อมูลด้วยผลลัพธ์ที่แตกต่างกัน ตัวอย่าง (ที่คุณจะนำไปใช้ในภายหลัง) กำลังส่งผ่านวิธีการที่เปิดเมนู UI ใหม่ ซึ่งขึ้นอยู่กับค่าการกำหนดค่าระยะไกล ซึ่งจะทำให้เมนูเปิดขึ้นหลังจากที่ดึงข้อมูลและเปิดใช้งานค่าเหล่านั้นแล้วเท่านั้น

  1. วางโค้ดด้านล่างลงใน FetchRemoteConfig :
    public void FetchRemoteConfig(System.Action onFetchAndActivateSuccessful)
{
   if(app==null)
   {
      Debug.LogError($"Do not use Firebase until it is properly initialized by calling {nameof(InitializeFirebaseAndStartGame)}.");
      return;
   }

   Debug.Log("Fetching data...");
   var remoteConfig = FirebaseRemoteConfig.DefaultInstance;
   remoteConfig.FetchAsync(System.TimeSpan.Zero).ContinueWithOnMainThread(
      previousTask=>
      {
         if (!previousTask.IsCompleted)
         {
         Debug.LogError($"{nameof(remoteConfig.FetchAsync)} incomplete: Status '{previousTask.Status}'");
         return;
         }
         ActivateRetrievedRemoteConfigValues(onFetchAndActivateSuccessful);
      });
}
  2. ถัดไป ดำเนินการเมธอด ActivateRetrievedRemoteConfigValues ​​ให้สมบูรณ์ ซึ่งรับการเรียกกลับที่ส่ง onFetchAndActivateSuccessful เมื่อการเปิดใช้งานเสร็จสิ้น การโทรกลับที่ระบุจะถูกเรียกใช้:
    private void ActivateRetrievedRemoteConfigValues(System.Action onFetchAndActivateSuccessful)
{
   var remoteConfig = FirebaseRemoteConfig.DefaultInstance;
   var info = remoteConfig.Info;
   if(info.LastFetchStatus == LastFetchStatus.Success)
   {
      remoteConfig.ActivateAsync().ContinueWithOnMainThread(
         previousTask =>
         {
         Debug.Log($"Remote data loaded and ready (last fetch time {info.FetchTime}).");
         onFetchAndActivateSuccessful();
         });
   }
}

เมื่อเรียกดาวน์สตรีมโดย SetRemoteConfigDefaults จากบริบทการเริ่มต้น ActivateRetrievedRemoteConfigValues ​​จะเรียกจุดเริ่มต้นก่อนหน้า InitializeCommonDataAndStartGame เพื่อเริ่มเกมโดยการเปิดเมนูหลัก

6. ตั้งค่ากลยุทธ์การโหลด Remote Config

หากต้องการดึงข้อมูลและเปิดใช้งานค่าในเวลาอื่นระหว่างการใช้งานแอพ คุณจะต้องเรียกใช้ฟังก์ชันเหล่านี้อีกครั้ง และหากมีออบเจ็กต์ใด ๆ แคชค่าไว้ จะต้องได้รับแจ้งเพื่อทำการอัปเดต เพื่อพัฒนากลยุทธ์ในการดึงค่าการกำหนดค่าระยะไกลอีกครั้ง ให้พิจารณาว่าเมื่อใดจำเป็นต้องใช้ค่าใหม่ และเมื่อใดที่จะเริ่มดึงข้อมูลและเปิดใช้งานค่าใหม่เพื่อหลีกเลี่ยงการเปลี่ยนแปลงขณะใช้งาน

ตามที่นำมาใช้ในปัจจุบัน ค่าการกำหนดค่าระยะไกลจะถูกดึงและเปิดใช้งานเมื่อแอปเริ่มทำงาน การดึงข้อมูลสามารถซ่อนได้ระหว่างการเปลี่ยนแปลงเมนู ในขณะเดียวกันก็บล็อกการโต้ตอบระหว่างการเปลี่ยนแปลงด้วย นอกจากนี้ เวลานี้มักจะเป็นเวลาที่เกี่ยวข้องมากที่สุดในการรับค่าใหม่ เนื่องจากการเปลี่ยนแปลงสถานะเมนูมักจะสามารถใช้เพื่อรู้ว่า "ที่" ผู้เล่นกำลังจะไป และคาดการณ์ว่าค่าจะถูกใช้

เมื่อพิจารณาระบบเมนูของ Mechahamster วิธีที่ง่ายที่สุดในการเพิ่มการรีเฟรชเมนูการบล็อก UI คือการเรียกมัน ก่อนที่ เมนูหลักจะดำเนินการต่อ (โดยเฉพาะเมื่อเข้าถึงได้โดยการออกจากเมนูอื่น) และส่งวิธีแสดง UI เป็นการเรียกกลับ onFetchAndActivateSuccessful สามารถทำได้เช่นเดียวกันกับเมนู เลือกระดับ

เมื่อโหลดครั้งแรกเป็นส่วนหนึ่งของการเริ่มต้นแอป การนำทางเมนูใดๆ ที่ผ่านเมนูหลักจะถูกจัดการโดยเมนูแรก ในขณะที่การกลับเข้าสู่เมนู เลือกระดับ จะทำให้เกิดการรีเฟรชด้วย การเข้าสู่เมนูเลือกระดับครั้งแรกนั้นไม่สำคัญ เนื่องจากสามารถเข้าถึงได้จากเมนูหลักเท่านั้น ดังนั้นจึงครอบคลุมอยู่แล้ว

หากต้องการเปิดใช้งานสิ่งนี้ในแอป ให้ทำตามวิธีการที่เกี่ยวข้องในเมนูหลักและไฟล์เลือกระดับ ซึ่งจะบล็อกการแสดง UI จนกว่า FetchAsync และ ActivateAsync จะเสร็จสมบูรณ์:

  1. เปิด Assets/Hamster/Scripts/States/MainMenu.cs และแทนที่วิธี Resume ที่มีอยู่ด้วยวิธีต่อไปนี้:
    public override void Resume(StateExitValue results) {
   CommonData.mainGame.SelectAndPlayMusic(CommonData.prefabs.menuMusic, true);
   CommonData.mainGame.FetchRemoteConfig(InitializeUI);
}
  2. บันทึกไฟล์.
  3. เปิด Assets/Hamster/Scripts/States/BaseLevelSelect.cs แทนที่วิธี Resume ที่มีอยู่ด้วยวิธีต่อไปนี้:
    public override void Resume(StateExitValue results) {
   CommonData.mainGame.FetchRemoteConfig(ShowUI);
}
  4. บันทึกไฟล์.

7. ดีบัก/ตรวจสอบพฤติกรรมการดึงข้อมูล

ณ จุดนี้ การตรวจวินิจฉัย/ตรวจสอบความถูกต้องจะเป็นประโยชน์ ขั้นตอนต่อไปนี้จะช่วยให้คุณสามารถทดสอบแอปของคุณด้วยตนเอง ตลอดจนวิธี/หากแอปดึงข้อมูลและเปิดใช้งานค่าการกำหนดค่าระยะไกล

ข้อมูลจะถูกพิมพ์เป็นส่วนหนึ่งของบันทึกการจำลอง อุปกรณ์ หรือตัวแก้ไขของคุณ สำหรับ iOS คุณสามารถดูบันทึกอุปกรณ์และเครื่องจำลองได้ใน Xcode สำหรับ Android ดูบันทึกโดยเรียกใช้ adb logcat หากคุณรันโค้ดใน Unity โดยการกด Play ในตัวแก้ไข บันทึกจะปรากฏในแท็บคอนโซล

  1. สร้างและเรียกใช้แอปใหม่ (ใน Editor โดยใช้อุปกรณ์หรือเครื่องจำลอง)
  2. หลังจากที่ เมนูหลัก ของเกมปรากฏขึ้น ให้ตรวจสอบเอาต์พุตบันทึกของเกมของคุณ ซึ่งควรมีบันทึกที่สร้างโดย Debug.Log ใน FetchRemoteConfig และ ActivateRetrievedRemoteConfigValues ข้อความเหล่านี้ควรแสดงข้อความ "กำลังดึงข้อมูล..." และ "ข้อมูลระยะไกลที่โหลดและพร้อมแล้ว" สังเกตการประทับเวลาที่จุดเริ่มต้นของข้อความเหล่านี้
  3. ในเกมกด License .
  4. กด ตกลง
  5. รอให้ เมนูหลัก ของเกมปรากฏขึ้น
  6. ตรวจสอบผลลัพธ์บันทึกของเกมของคุณ ซึ่งควรจะคล้ายกับในขั้นตอนก่อนหน้า ด้วยการประทับเวลาใหม่ (ตรงกับเวลาที่ตั้งไว้ในนาฬิการะบบที่คุณเล่นเกม)
  7. ในเกมให้กด Play
  8. กด Let's Roll
  9. นำทางลูกบอลไปยังเป้าหมายโดยใช้ลูกศรบนแป้นพิมพ์ ซึ่งจะเปิดเมนูระดับเสร็จสมบูรณ์
  10. กด ระดับ
  11. รอให้เมนู เลือกระดับ โหลด
  12. ตรวจสอบผลลัพธ์บันทึกของเกมของคุณอีกครั้ง ควรจับคู่ข้อความบันทึกจากขั้นตอนก่อนหน้านี้ กับการประทับเวลาที่ใหม่กว่า (ตรงกับเวลาที่ตั้งไว้ในนาฬิการะบบที่คุณกำลังเล่นเกม)

หากสิ่งใดไม่ปรากฏในแอปของคุณ แสดงว่าขั้นตอนการดึงข้อมูลและเปิดใช้งานบางส่วน (หรืออุปกรณ์ของคุณ) อาจมีการกำหนดค่าไม่ถูกต้อง หากบันทึกแรกไม่ปรากฏขึ้น มีโอกาสที่เกมของคุณจะไม่เริ่มต้นขึ้น ตรวจสอบคอนโซลตัวแก้ไขหรือบันทึกอุปกรณ์/โปรแกรมจำลองเพื่อดูคำเตือนและข้อผิดพลาดเกี่ยวกับโปรเจ็กต์/สภาพแวดล้อมของคุณ และตรวจสอบปัญหาเหล่านั้น ปัญหาอาจทำได้ง่ายเพียงแค่เชื่อมต่ออินเทอร์เน็ต

หากบันทึกเริ่มต้นจากการโหลดเมนูปรากฏขึ้น แต่รายการใดรายการหนึ่งต่อมาไม่ปรากฏ ให้ตรวจสอบ/ปรับใช้วิธี Resume ใน Assets/Hamster/Scripts/States/MainMenu.cs และ Assets/Hamster/Scripts/States/BaseLevelSelect.cs

8. ติดตั้งโค้ดของคุณ

ตอนนี้คุณได้กำหนดค่าพารามิเตอร์ในแอปใน SetDefaultsAsync() และทำให้เวอร์ชันล่าสุดพร้อมใช้งานกับ FetchAsync() และ ActivateAsync() แล้ว คุณจะอ้างอิงและใช้ค่าเหล่านั้นในโค้ด

หลังจากที่คุณตั้งค่าในแบ็กเอนด์การกำหนดค่าระยะไกลแล้ว ให้ดึงข้อมูลและเปิดใช้งาน ( หรือทำทั้งสองอย่างพร้อมกัน ) ค่าเหล่านั้นจะพร้อมใช้งานสำหรับแอปของคุณ หากต้องการใช้ค่าเหล่านี้ ให้เรียก GetValue(string key ) และเลือกคีย์พารามิเตอร์เป็นอาร์กิวเมนต์ ซึ่งส่งคืน ConfigValue ซึ่งมีคุณสมบัติในการเข้าถึงค่าเป็นประเภทที่รองรับต่างๆ: string , bool , long , double ในโปรเจ็กต์นี้และกรณีการใช้งานเกมส่วนใหญ่ คุณต้องส่งสองประเภทสุดท้ายไปยัง int และ float ที่มีสำนวนมากกว่า เพื่อให้แน่ใจว่า Conversion เหล่านี้จะไม่ก่อให้เกิดปัญหา ตรวจสอบให้แน่ใจว่าค่าเริ่มต้นที่ตั้งไว้ในการกำหนดค่าระยะไกลอยู่ภายในช่วงที่ถูกต้องของประเภทที่คุณจะใช้ในโค้ดของแอป

  1. นำเข้าการกำหนดค่าระยะไกลโดยการเพิ่ม using Firebase.RemoteConfig; ไปที่ด้านบนของไฟล์ต่อไปนี้:
    • Assets/Hamster/Scripts/States/MainMenu.cs
    • Assets/Hamster/Scripts/MapObjects/AccelerationTile.cs
  2. แทนที่วิธี Start ของ AccelerationTile.cs :
    private void Start() {
   var remoteConfig = FirebaseRemoteConfig.DefaultInstance;
   Acceleration = (float)remoteConfig.GetValue(AccelerationTileForceKey).DoubleValue;
}
    ด้วยการเปลี่ยนแปลงนี้ จำนวนแรงที่ส่งมาจากไทล์การเร่งความเร็วจะเปลี่ยนเป็นแรงที่ได้รับจากการกำหนดค่าระยะไกล
  3. แก้ไขเนื้อความของเมธอด InitializeUI ของ MainMenu.cs :
    private void InitializeUI() {
   if (menuComponent == null) {
      menuComponent = SpawnUI<Menus.MainMenuGUI>(StringConstants.PrefabMainMenu);
   }

   var remoteConfig = FirebaseRemoteConfig.DefaultInstance;
   var subtitleOverride = JsonUtility.FromJson<Menus.MainMenuGUI.SubtitleOverride>(
      remoteConfig.GetValue(SubtitleOverrideKey).StringValue);
   // Only sets values if all fields of the override are non-default.
   if(subtitleOverride != null && subtitleOverride.IsValidOverride())
   {
      menuComponent.MenuSubtitleText.text = subtitleOverride.text;
      menuComponent.MenuSubtitleText.fontSize = subtitleOverride.fontSize;
      menuComponent.MenuSubtitleText.color = subtitleOverride.textColor;
   }
   ShowUI();
}
    ที่นี่ subtitleOverride จะถูกตั้งค่าให้เปลี่ยนคำบรรยายบนหน้าจอเมนูหลัก หากฟิลด์ทั้งหมดในคลาวด์ถูกตั้งค่าเป็นค่าอื่นที่ไม่ใช่ ค่าเริ่มต้นของประเภท

9. ตั้งค่าพารามิเตอร์จากระยะไกล

เมื่อแอปของคุณมีอุปกรณ์ครบถ้วนแล้ว คุณก็พร้อมที่จะกำหนดค่าพารามิเตอร์และค่าบนเซิร์ฟเวอร์การกำหนดค่าระยะไกลแล้ว ใน Codelab นี้ เราจะตั้งค่านี้โดยใช้คอนโซล Firebase

  1. ใน คอนโซล Firebase ให้เปิดโปรเจ็กต์ของคุณ
  2. เลือกการกำหนดค่าระยะไกลจากเมนูเพื่อดูแดชบอร์ดการกำหนดค่าระยะไกล
  3. สำหรับแต่ละพารามิเตอร์ที่คุณกำหนดไว้ในแอปของคุณและแสดงอยู่ในตารางต่อไปนี้ ให้คลิก เพิ่มพารามิเตอร์ วางชื่อพารามิเตอร์ (คีย์) เลือก ประเภทข้อมูล ที่แสดงในตาราง ปิดใช้งาน ใช้ค่าเริ่มต้นในแอป และวางใน ค่าเริ่มต้นใหม่:

    ชื่อพารามิเตอร์ (คีย์)

    ประเภทข้อมูล

    ค่าเริ่มต้น

    การเร่งความเร็ว_tile_force

    ตัวเลข

    100

    subtitle_override

    เจสัน

    {"text":"We overwrote the subtitle","fontSize":8,"textColor":{"r":0.0,"g":255.0,"b":0.0,"a":255.0}}

    Remote Config Parameter editor with\nacceleration_tile_force populated
  4. คลิก บันทึก เพื่อบันทึกการเปลี่ยนแปลงของคุณ
  5. คลิก เผยแพร่ เพื่อเผยแพร่การกำหนดค่าใหม่และทำให้ค่าใหม่พร้อมใช้งานกับเกมของคุณ
  6. เรียกใช้แอปของคุณอีกครั้งหลังจากตั้งค่าพารามิเตอร์ระยะไกลเหล่านี้ และสังเกตดูว่าพารามิเตอร์เหล่านั้นแทนที่ค่าเริ่มต้นดั้งเดิมอย่างไร Mechahamster main screen with Debug\nMenu enabled

10. ใช้เงื่อนไขการกำหนดค่าระยะไกลเพื่อรองรับตัวแปรต่างๆ

คุณอาจต้องการมอบประสบการณ์การใช้งานแอปให้กับผู้ใช้ตามภาษาที่พวกเขาพูด สถานที่ที่พวกเขาอยู่ ช่วงเวลาของวัน หรือแพลตฟอร์มที่พวกเขาใช้ เงื่อนไขการกำหนดค่าระยะไกล ทำให้คุณสามารถใช้แอตทริบิวต์เหล่านี้และแอตทริบิวต์อื่นๆ ทีละรายการหรือรวมกันเพื่อแสดงค่าที่แตกต่างกัน (เรียกว่าตัวแปร) ให้กับผู้ใช้ได้

การใช้เงื่อนไขทั่วไปประการหนึ่งคือการเปลี่ยนเนื้อหาระหว่างแพลตฟอร์ม iOS และ Android ทำตามขั้นตอนด้านล่างเพื่อใช้เงื่อนไขที่ให้บริการค่าที่แตกต่างกันสำหรับ subtitle_override ขึ้นอยู่กับแพลตฟอร์มที่ใช้งานอยู่

  1. เปิดแท็บ Remote Config ของโปรเจ็กต์ของคุณใน คอนโซล Firebase
  2. คลิกปุ่มแก้ไขสำหรับ subtitle_override.
  3. ที่มุมซ้ายล่าง ให้คลิก เพิ่มใหม่
  4. ในรายการแบบเลื่อนลงที่ปรากฏขึ้น ให้วางเมาส์เหนือ ค่าเงื่อนไข แล้วคลิก สร้างเงื่อนไขใหม่ Remote Config parameter editor:\nConditional value option
  5. เมื่อได้รับแจ้ง ให้ตั้งชื่อเงื่อนไขว่า "เป็น iOS" หากคุณกำหนดเป้าหมายเป็น iOS หรือ "เป็น Android" หากคุณกำหนดเป้าหมายเป็น Android หากคุณกำหนดเป้าหมายทั้งสองอย่าง เพียงเลือกหนึ่งรายการที่นี่แล้วใช้กับส่วนที่เหลือของ Codelab Using the Define a new condition\ndialog to define an iOS-specific condition
  6. ใต้ ใช้ถ้า... คลิก เมนูแบบเลื่อนลงเลือก... และเลือก แพลตฟอร์ม จากนั้นเลือกแพลตฟอร์มที่เหมาะสม Using the Define a new condition\neditor to select the iOS platform
  7. คลิก สร้างเงื่อนไข เพื่อสร้างเงื่อนไข กล่องโต้ตอบแก้ไขพารามิเตอร์จะปรากฏขึ้นอีกครั้ง และคุณสามารถตั้งค่าได้แล้ว:
    • หากคุณกำหนดเป้าหมายเป็น Android ให้ตั้ง ค่า เป็น: 
      {"text":"Level Up Android Version","fontSize":8,"textColor":{"r":0.0,"g":255.0,"b":0.0,"a":255.0}}
    • หากคุณกำหนดเป้าหมายเป็น iOS ให้ตั้ง ค่า เป็น: 
      {"text":"Level Up iOS Version","fontSize":8,"textColor":{"r":0.0,"g":255.0,"b":0.0,"a":255.0}}
  8. คลิก บันทึก เพื่อบันทึกการเปลี่ยนแปลงของคุณ
  9. คลิก เผยแพร่ เพื่อเผยแพร่การกำหนดค่าใหม่และทำให้ค่าใหม่พร้อมใช้งานกับเกมของคุณ

หากคุณสร้างและรันเกมอีกครั้ง คุณจะเห็นคำบรรยายของเกมแทนที่ด้วยรูปแบบเฉพาะแพลตฟอร์ม

11. กำหนดค่า Remote Config เพื่อรับการอัพเดตแบบเรียลไทม์

ขณะนี้ Remote Config สามารถรับฟังและจัดการการอัปเดต เทมเพลต Remote Config ได้แบบเรียลไทม์ แอพสามารถสมัครรับ Remote Config API แบบเรียลไทม์ใหม่เพื่อฟังการเปลี่ยนแปลงการกำหนดค่าและค่าที่อัปเดต

มันทำงานอย่างไร

หากต้องการฟังการอัปเดต แอปของคุณต้องใช้วิธีการที่สมัครรับเหตุการณ์ OnConfigUpdateListener ในขณะที่สมัครฟังการอัปเดตการกำหนดค่าตั้งแต่หนึ่งรายการขึ้นไป เทมเพลตการกำหนดค่าระยะไกลใหม่จะถูกดึงออกมาโดยอัตโนมัติ ตัวจัดการที่สมัครเป็นสมาชิกจะถูกเรียกและสามารถใช้เพื่อดำเนินการตรรกะในการตอบสนอง เช่น การเปิดใช้งานค่าใหม่ และทำให้พร้อมใช้งานกับส่วนที่เหลือของแอปพลิเคชัน

ใช้การกำหนดค่าระยะไกลแบบเรียลไทม์

เพื่อแสดงให้เห็นวิธีการทำงานในเกม ให้ทำการเปลี่ยนแปลงโค้ดของคุณต่อไปนี้

สร้างตัวจัดการการอัปเดตการกำหนดค่า

ขั้นตอนแรกในการใช้เหตุการณ์ Config Update คือการสร้างวิธีการที่สามารถรับฟังได้ วางวิธีการต่อไปนี้ใน Assets/Hamster/Scripts/MainGame.cs :

   void ActivateValuesOnConfigUpdate( object sender, ConfigUpdateEventArgs args)
   {
      if (args.Error != RemoteConfigError.None) {
         Debug.Log($"Error occurred while listening: {args.Error}");
         return;
      }

      Debug.Log("Updated keys: " + string.Join(", ", args.UpdatedKeys));
      // Activate all fetched values and then logs.
      var remoteConfig = FirebaseRemoteConfig.DefaultInstance;
      remoteConfig.ActivateAsync().ContinueWithOnMainThread(
         task => {
            Debug.Log($"Keys from {nameof(ActivateValuesOnConfigUpdate)} activated.");
         });
   }

วิธีนี้จะพิมพ์รายการคีย์ที่อัปเดตและข้อความแสดงความสำเร็จไปยังบันทึกเมื่อเปิดใช้งานค่าใหม่

สมัครสมาชิกกิจกรรมอัปเดต

หากต้องการเปิดใช้งาน ActivateValuesOnConfigUpdate เมื่อมีการเรียกเหตุการณ์ ให้สมัครรับเหตุการณ์ แทนที่เมธอด InitializeCommonDataAndStartGame() ใน Assets/Hamster/Scripts/MainGame.cs ด้วยค่าต่อไปนี้:

   void InitializeCommonDataAndStartGame()
   {
      CommonData.prefabs = FindObjectOfType<PrefabList>();
      CommonData.mainCamera = FindObjectOfType<CameraController>();
      CommonData.mainGame = this;

      Screen.orientation = ScreenOrientation.LandscapeLeft;

      musicPlayer = CommonData.mainCamera.GetComponentInChildren<AudioSource>();

      CommonData.gameWorld = FindObjectOfType<GameWorld>();

      // Set up volume settings.
      MusicVolume = PlayerPrefs.GetInt(StringConstants.MusicVolume, MaxVolumeValue);
      // Set the music to ignore the listeners volume, which is used for sound effects.
      CommonData.mainCamera.GetComponentInChildren<AudioSource>().ignoreListenerVolume = true;
      SoundFxVolume = PlayerPrefs.GetInt(StringConstants.SoundFxVolume, MaxVolumeValue);

      // Subscribes to on config update after first initial fetch and activate
      FirebaseRemoteConfig.DefaultInstance.OnConfigUpdateListener += ActivateValuesOnConfigUpdate;

      stateManager.PushState(new States.MainMenu());
   }

บรรทัดใหม่ (ลงท้ายด้วย += ActivateValuesOnConfigUpdate; ) สมัครสมาชิกตัวจัดการเหตุการณ์กับเหตุการณ์

ยกเลิกการสมัครเมื่อวัตถุที่เป็นเจ้าของของผู้จัดการถูกทำลาย

เพื่อป้องกันข้อผิดพลาดในการอ้างอิงที่เป็นโมฆะ อ็อบเจ็กต์ที่มีเมธอดที่สมัครรับเหตุการณ์จะต้องยกเลิกการสมัครเมธอดนั้นเมื่อถูกทำลาย เพิ่มวิธีการต่อไปนี้ใน Assets/Hamster/Scripts/MainGame.cs :

   private void OnDestroy() 
   {
      FirebaseRemoteConfig.DefaultInstance.OnConfigUpdateListener -= ActivateValuesOnConfigUpdate;
   }

ทดสอบฟังก์ชันการทำงานใหม่

หากต้องการตรวจสอบฟังก์ชันการทำงานใหม่ ให้ลองใช้แอปที่คุณสร้างขึ้น ขั้นตอนต่อไปนี้กำหนดให้คุณสามารถ อ่านบันทึกและแก้ไขจุดบกพร่องได้โดยใช้อุปกรณ์จริง

เปลี่ยน acceleration_tile_force และสังเกต

หลังจากเริ่มแอปของคุณแล้ว ใน ส่วนการกำหนดค่าระยะไกล ของคอนโซล Firebase ให้ทำดังนี้

  1. กดปุ่มแก้ไขข้าง acceleration_tile_force

dc602d4db54e50a4.png

  1. เปลี่ยนค่าเป็น '120' แล้วกด บันทึก

fcbc1df848f88009.png

  1. คลิกปุ่ม เผยแพร่การเปลี่ยนแปลง

3785c1e00e7a6359.png

  1. ตรวจสอบบันทึก
  2. หากคุณเห็นข้อความบันทึกที่ขึ้นต้นด้วย "เกิดข้อผิดพลาดขณะฟัง" ให้อ่านข้อความที่เหลือและลองแก้ไขข้อบกพร่องด้วยข้อความแสดงข้อผิดพลาดที่พิมพ์ออกมา
  3. หากคุณเห็นบันทึกที่ขึ้นต้นด้วย "คีย์ที่อัปเดต" แสดงว่าแอปของคุณได้รับค่าที่เปลี่ยนแปลงแล้ว
  4. หากคุณไม่เห็นสิ่งใดเลย ให้ดูบันทึกที่เหลือของคุณ จากนั้นตรวจสอบคำแนะนำจาก Create a Config Update handler อีกครั้ง ทดสอบใหม่ และตรวจสอบบันทึกอีกครั้งเพื่อดูว่ามีอะไรผิดปกติหรือไม่

12. ขอแสดงความยินดี!

คุณได้ใช้การกำหนดค่าระยะไกลเพื่อควบคุมค่าในเกมจากระยะไกลโดยการดึงค่าเหล่านั้นในแอปของคุณ และใช้เงื่อนไขเพื่อรองรับตัวแปรที่แตกต่างกัน!

สิ่งที่เราได้กล่าวถึง

  • วิธีการตั้งค่าและรับค่า Remote Config
  • วิธีใช้เครื่องมือโค้ด Unity C# ของคุณเพื่อใช้ค่าที่ดึงมา
  • วิธีจัดเก็บ เครื่องมือ และแทนที่ค่าผสม/อ็อบเจ็กต์เป็นค่า JSON
  • วิธีใช้เงื่อนไขการกำหนดค่าระยะไกลเพื่อรองรับตัวแปรค่าต่างๆ

ขั้นตอนถัดไป

อ่านเกี่ยวกับ ลำดับความสำคัญของค่าพารามิเตอร์ เพื่อทำความเข้าใจตรรกะของค่าที่อินสแตนซ์แอปได้รับได้ดีขึ้น เมื่อใช้พารามิเตอร์ที่มีหลายค่า (เนื่องจากเงื่อนไขหรือตำแหน่ง)