תחילת העבודה עם Unity ו-Google Play Games במחשב

1. מבוא

העדכון האחרון: 18 באוקטובר 2022

איך מכינים את המשחק ל-Google Play Games במחשב?

עם Google Play Games, קל להעביר את המשחק לנייד למחשבי Windows. כך תוכלו להגדיל את מעורבות השחקנים ואת קהל היעד בלי שתצטרכו לשנות את הארכיטקטורה של המשחק או לעצב מחדש את המודל העסקי. עדיין יש כמה שינויים שצריך לבצע כדי לספק לשחקנים החדשים במחשב האישי את החוויה הכי טובה שאפשר.

מה תלמדו

בשיעור Codelab הזה נסביר על החלקים הבסיסיים של רשימת הדרישות כדי להתחיל לפתח את המשחק שלכם, ונעזור לכם להכין משחק Unity משלכם ל-Google Play Games במחשב. המדריך לא כולל שילובים מורכבים יותר, כמו כניסה ל-Play Games ו-Play Integrity API.

• איך ליצור גרסה לארכיטקטורת x86 מ-Unity.
• איך בודקים ומבצעים פריסה לאמולטור של Google Play Games.
• איך משנים את ממשק המשתמש כדי שייראה מצוין במחשב.
• איך לזהות אם המשחק פועל באמולטור של Google Play Games, ולשנות את המשחק בהתאם.

מה תצטרכו

• התקנה של Unity 2020 LTS (ה-Codelab הזה נוצר באמצעות 2020.3.30f1).
• אמולטור Google Play Games.

2. להגדרה

פתיחה או יצירה של פרויקט חדש

1. יוצרים פרויקט חדש באמצעות משחק הפלטפורמה הדו-ממדי או פותחים פרויקט קיים.

2. בפרויקט, בוחרים באפשרות File -> Build Settings (קובץ -> הגדרות build) ומוודאים שההגדרה היא build ל-Android.

3. הכנת אמולטור Google Play Games

קודם מורידים את האמולטור.

אחרי ההתקנה, אמור להופיע שולחן עבודה של Android בחלון:

הערה: האמולטור מופיע ברשימת האפליקציות בשם Google Play Games Developer Emulator.

זו סביבת Android מלאה עם ביצועים גבוהים שמתאימה לפיתוח משחקים. הוא אמור להופיע ב-Android Debug Bridge‏ (adb) כמכשיר ב-localhost:

❯ adb devices
List of devices attached
localhost:6520  device

כדי לזהות את האמולטור, צריך גרסה עדכנית של adb. הגרסה שמצורפת ל-Android Studio פועלת, אבל יכול להיות ש-adb שמופץ עם Unity לא תפעל. גרסה תואמת מצורפת לאמולטור, ואפשר למצוא אותה בכתובת C:\Program Files\Google\Play Games Developer Emulator\current\emulator. כדי ליהנות מחוויית הפיתוח הטובה ביותר, מומלץ להתקין את Android Studio ולהשתמש בו לניהול Android SDK.

אם האמולטור מתנתק מ-adb, צריך לחבר אותו מחדש משורת הפקודה באופן הבא:

adb connect localhost:6520

4. הגדרה של Unity כדי לבצע build ופריסה ישירות לאמולטור (אופציונלי)

יכול להיות שהגרסה של adb שמגיעה עם Unity לא תואמת לאמולטור. כדי לוודא, בוחרים באפשרות File -> Build Settings (קובץ -> הגדרות בנייה) ובודקים אם המכשיר מופיע בתיבת הדו-שיח Run Device (הפעלת המכשיר).

זהירות: אם הפעלתם את adb לפני הבדיקה, הקפידו להשתמש ב-adb connect localhost:6520 עם הגרסה של adb שמגיעה עם Unity. אף אחת מגרסאות Unity שנבדקו בזמן כתיבת המאמר הזה לא כוללת adb תואם.

בהתאם לפרויקט, לתהליך build ולרמת הנוחות שלכם, אתם יכולים להגדיר את Unity כך שיפרוס ישירות לאמולטור של Google Play Games, או לבנות APK ולפרוס אותו באופן ידני באמצעות adb install. הפריסה הידנית דורשת הכי פחות שינויים, אבל היא עלולה להאט את מחזור האיטרציה.

כדי לפרוס ישירות לאמולטור, מבצעים את שני השלבים הבאים:

1. מגדירים את Unity כך שישתמש ב-Unity SDK אחר, רצוי ב-SDK שהותקן על ידי Android Studio.
2. כדי לעקוף באג ב-Unity, צריך לעדכן את הגרסה של Build Tools.

יכול להיות שגרסת Android SDK שסופקה עם Unity לא תזהה את האמולטור, ולכן צריך להשתמש ב-Android Studio כדי להתקין גרסה עדכנית יותר של SDK.

1. פותחים את Android Studio ובוחרים באפשרות Edit -> Preferences -> External Tools (עריכה -> העדפות -> כלים חיצוניים).
2. מבטלים את הסימון של Android SDK Tools Installed with Unity ומזינים את הנתיב להתקנה של Android Studio (בדרך כלל AppData/Local/Android/sdk). לא משנים את האפשרות Android NDK.

כשמרעננים את המכשירים המחוברים, Google HPE device (localhost:6520) אמור להופיע בחלון הבנייה:

הערה: אם האמולטור לא מופיע, יכול להיות שתצטרכו להריץ את הפקודה adb connect localhost:6520. הסיבה לכך היא ש-adb המובנה של Unity מקבל עדיפות עד שמשנים אותו ומתחברים מחדש באופן ידני למופע החדש של adb.

בהתאם למצב של הבאג הזה ולגרסת Unity שלכם, יכול להיות שתצטרכו גם לשנות את גרסת כלי הבנייה. כדי לעשות את זה, צריך לוודא שאתם יוצרים mainTemplate.gradle וlauncherTemplate.gradle.

3. פותחים את החלון Project Settings (הגדרות הפרויקט) אל Player Settings (הגדרות הנגן) ומאתרים את הקטע Publishing Settings.
4. גוללים למטה אל האפשרויות Build (גרסה) ומסמנים את התיבות Custom Main Gradle Template (תבנית Gradle ראשית מותאמת אישית) ו-Custom Launcher Gradle Template (תבנית Gradle של מרכז האפליקציות מותאמת אישית). כך ייווצרו שני קובצי Gradle בתיקייה Assets\Plugins\Android\.

הערה: בפרויקטים שנעשה בהם שימוש בספריות EDM4U ו-androidx, כמו Firebase, צריך גם ליצור Custom Gradle Properties Template כדי לבצע כראוי את ההגדרה של התלות. אם לא השתמשתם בעבר בתבנית Gradle בהתאמה אישית, כדאי לבדוק גם את ההגדרה הזו.

1. החלפת כל מופע של המחרוזת **BUILDTOOLS** ב-30.0.0. בשני הקבצים, קטע הקוד צריך להיראות עכשיו כך:

android {
    compileSdkVersion **APIVERSION**
    buildToolsVersion '30.0.0'

5. פריסה ב-Chromebook (אופציונלי)

אתם יכולים להתחיל לפתח משחקים ל-Google Play Games בלי גישה לאמולטור של Google Play Games באמצעות מכשיר ChromeOS. בדומה ל-Google Play Games במחשב, למכשירי Chromebook יש מקלדות ועכברים, מסכים גדולים והם זמינים בתצורות x86. נשתמש בתוסף Unity‏ Android Logcat עם Chromebook.

1. פותחים את Package Manager (מנהל החבילות) ומחפשים את Android Logcat בקטע Unity Registry.

צריך גם להגדיר את Chromebook לפיתוח ל-Android. קודם מפעילים את Linux.

2. בוחרים באפשרות 'הגדרות' -> 'מפתחים' -> 'Linux'.

לאחר מכן מפעילים ניפוי באגים באמצעות ADB.

3. בוחרים באפשרות הגדרות -> מפתחים -> סביבת הפיתוח של Linux -> פיתוח אפליקציות ל-Android -> הפעלת ניפוי באגים ב-ADB.

כדאי גם לברר מהי כתובת ה-IP של ה-Chromebook. הדרך הכי קלה לעשות את זה היא

4. לוחצים על סמל פרטי הרשת כדי לראות את כתובת ה-IP של ה-Chromebook.

5. בוחרים באפשרות Window -> Analysis -> Android Logcat (חלון > ניתוח > Android Logcat) כדי לפתוח את החלון Android Logcat.

6. פותחים את רשימת המכשירים. אם לא מחובר כרגע אף מכשיר, יכול להיות שיופיע הכיתוב No Device.

7. לוחצים על אפשרויות חיבור אחרות ומזינים את כתובת ה-IP של ה-Chromebook.

8. לוחצים על חיבור. אמור להופיע חלון Success:

ה-Chromebook שלכם יופיע עכשיו ברשימת המכשירים להרצה של Unity (יכול להיות שתצטרכו לרענן את המסך קודם):

עכשיו אפשר לפרוס משחקים ב-Chromebook ולהתחיל בבדיקות ובפיתוח על חומרה שדומה למחשב.

6. פריסת גרסת build לבדיקה

כדי להשתמש ב-Google Play Games, צריך לפרוס גרסת x86 של המשחק. זה חלק מהתהליך שמאפשר למשחק להגיע לביצועים ברמה גבוהה במחשבים. כל הגרסאות של Unity LTS יכולות ליצור גרסאות Android build שתואמות ל-x86 ול-x86-64 (מסומנות כ-ChromeOS), וגרסה 2018 של Unity וגרסאות קודמות יכולות ליצור גרסאות x86 build. כדי לבטל את הנעילה של הארכיטקטורות האלה, צריך קודם לעבור אל קצה העורף של סקריפטים מסוג IL2CPP, שכנראה כבר עושים זאת בייצור לתמיכה ב-arm64.

1. בוחרים באפשרות קובץ -> הגדרות ה-Build כדי לפתוח את חלון הגדרות ה-Build, ואז לוחצים על הגדרות המשחק.

2. עוברים לקטע הגדרות אחרות ומעבירים את המתג Scripting Backend למצב IL2CPP.

כדאי גם להפעיל תמיכה ב-x86 או ב-x86-64. כדי להשיק משחק בפלטפורמת Google Play Games, צריך לתמוך רק ב-x86, אבל אנחנו ממליצים על x86-64.

הערה: כל ארכיטקטורה נוספת שמוסיפים מאריכה את משך זמן של תהליך build. אמנם אפשר לאגד את כל יעדי ה-ARM וה-x86 בחבילה אחת, אבל יכול להיות שתרצו לבחור רק x86 או x86-64 במהלך פיתוח התכונה.

הגרסה של ספריית Frame Pacing ש-Unity כוללת גם היא לא תואמת ל-Google Play Games, וגורמת לקריסת המשחק בהפעלה.

3. כדי להשבית את קצב הפריימים מהחלון Player Settings (הגדרות הנגן), פותחים את הקטע Resolution and Presentation (רזולוציה והצגה) ומבטלים את הסימון של Optimized Frame Pacing (קצב פריימים אופטימלי).

עכשיו אפשר להתחיל לבנות!

1. פותחים שוב את החלון Build Settings (הגדרות בנייה) ולוחצים על Build And Run (בנייה והפעלה). המשחק יופיע בחלון האמולטור.

אם אתם לא מצליחים לפרוס את המשחק, בדקו אם האפשרות Google HPE device (localhost:6520) מופיעה ברשימה Run Device (הפעלת מכשיר). אם הוא חסר, מוודאים ש-HPE_Dev פועל ורואים את מסך הבית של Android. אם הוא עדיין לא מופיע ברשימת המכשירים, מריצים את הפקודה adb connect localhost:6520 עם adb.exe המדויק שבו אתם משתמשים. אם אתם משתמשים בתוסף Android Logcat Unity, בוחרים באפשרות Tools -> Open Terminal (כלים -> פתיחת חלון Terminal) כדי לפתוח חלון Terminal לספרייה שבה adb.exe Unity משתמש.

האפשרות 'פתיחת Terminal' מסומנת בסגנון 'width: 624.00px' src="img/9101ce3c95fb1aa2.png" srcset="img/9101ce3c95fb1aa2_36.png 36w, img/9101ce3c95fb1aa2_48.png 48w, img/9101ce3c95fb1aa2_72.png 72w, img/9101ce3c95fb1aa2_96.png 96w, img/9101ce3c95fb1aa2_480.png 480w, img/9101ce3c95fb1aa2_720.png 720w, img/9101ce3c95fb1aa2_856.png 856w, img/9101ce3c95fb1aa2_960.png 960w, img/9101ce3c95fb1aa2_1440.png 1440w, img/9101ce3c95fb1aa2_1920.png 1920w, img/9101ce3c95fb1aa2_2880.png 2880w" sizes="(max-width: 840px) 100vw, 856px">

7. התאמת המשחק למחשב

אם אפשר, כדאי לבצע שינויים במשחק על סמך מדדים שלא תלויים בפלטפורמה או על סמך נוכחות של תכונות מסוימות. לדוגמה, שחקן ב-Android יכול לחבר עכבר ומקלדת או לחבר מסך. לכן, שינוי של תוכנית הבקרה או של רכיבי ה-HUD בתגובה להגדרת המכשיר מאפשר לכם להשתמש ב-Google Play Games במחשב בכל הפלטפורמות הנתמכות.

אם יש היגיון בשינוי הלוגיקה בהתאם לשאלה אם השחקן נמצא ב-Google Play Games או ב-ChromeOS, הסקריפט הזה עוזר לכם לזהות את זה על ידי בדיקה של תכונת המערכת HPE_EXPERIENCE:

using UnityEngine;

public class GoogleDeviceUtilities
{
#if UNITY_ANDROID && !UNITY_EDITOR
    private static AndroidJavaObject PackageManager
    {
        get
        {
            var unityPlayerClass = new AndroidJavaClass("com.unity3d.player.UnityPlayer");
            var currentActivity = unityPlayerClass.GetStatic<AndroidJavaObject>("currentActivity");
            return currentActivity.Call<AndroidJavaObject>("getPackageManager");
        }
    }

    public static bool IsChromeOS => PackageManager.Call<bool>("hasSystemFeature", "org.chromium.arc");

    public static bool IsGooglePlayGames =>
        PackageManager.Call<bool>("hasSystemFeature", "com.google.android.play.feature.HPE_EXPERIENCE");

    public static bool HasKeyboard
    {
        get
        {
            var unityPlayerClass = new AndroidJavaClass("com.unity3d.player.UnityPlayer");
            var currentActivity = unityPlayerClass.GetStatic<AndroidJavaObject>("currentActivity");
            var resources = currentActivity.Call<AndroidJavaObject>("getResources");
            var configuration = resources.Call<AndroidJavaObject>("getConfiguration");
            var keyboard = configuration.Get<int>("keyboard");
            return keyboard == 2; // Configuration.KEYBOARD_QWERTY
        }
    }
#else
    public static bool IsChromeOS => false;
    public static bool IsGooglePlayGames => false;
    public static bool HasKeyboard => true;
#endif
}

המסך של מחשב גדול יותר מהמסך של טלפון Android רגיל. אם אפשר, מומלץ שה-HUD יתפוס לא יותר מ-20% מהמסך. מכיוון שבהרבה משחקים לנייד נעשה שימוש באפשרות 'שינוי גודל בהתאם לגודל המסך', שינוי ההגדרה הזו ל'גודל פיזי קבוע' או ל'גודל פיקסל קבוע' יכול להיות צעד ראשון טוב להשגת המטרה הזו.

אפשר גם להגדיר באופן דינמי את הגדרות האיכות באמצעות הפקודה QualitySettings.SetQualityLevel בזמן הריצה, אם אתם מזהים שהאפליקציה פועלת ב-Google Play Games. האמולטור של Google Play Games משתמש ב-ANGLE כדי להנפיק פקודות מובנות של DirectX או Vulkan מ-OpenGL Unity, כך שסביר להניח שתשיגו איכות גרפית גבוהה יותר מזו שהייתה זמינה בגרסאות של משחקים לנייד.

8. טיפול בקלט

משחקים שמופצים ב-Google Play Games צריכים להיות מבוססים על קלט מהעכבר ומהמקלדת. תצטרכו לתכנן איך לשחק במשחק באמצעות עכבר ומקלדת, ולכן כדאי להוריד עכשיו את Input SDK unitypackage. אם ההורדה לא מופיעה בדף הזה, צריך לוודא שנכנסתם לחשבון בקבוצה play-mp-libs.

לצורך בדיקה, במשחקים רבים יש אמצעי בקרה בסיסיים של העכבר והמקלדת לפיתוח בעורך. אם אפשר, כדאי להפעיל את האפשרויות האלה כשמריצים את המשחק במכשיר ChromeOS או באמולטור של Google Play Games.

הערה: אם אתם משתמשים כרגע ב-#if UNITY_EDITOR כדי לזהות אם אתם מריצים בעורך, אתם צריכים לשנות את זה לבדיקת זמן הריצה if (Application.isEditor) כדי לבדוק גם את GoogleDeviceUtilities.IsGooglePlayGames או GoogleDeviceUtilities.HasKeyboard.

כברירת מחדל, Google Play Games ו-ChromeOS ממירים את קלט העכבר למגע מדומה. אם אתם משתמשים ב- Input.GetTouch וב- Input.touchCount, המשחק ימשיך לפעול כצפוי. אם אתם מסתמכים על קלט מולטי-טאץ', כמו פקדים עם שני אגודלים או צביטה להגדלת התצוגה, אתם צריכים למפות את הפעולה ללחיצות על מקשים. כדאי גם למפות פעולות במשחק ללחיצות על מקשים, כמו לחיצה על i כדי לפתוח את המלאי, על Escape כדי לסגור תיבות דו-שיח ועל Enter כדי לשלוח הודעות במשחק.

במשחק הפלטפורמה הדו-ממדי הקטן משתמשים במקשי החיצים כדי לזוז ובמקש הרווח כדי לקפוץ. אם אתם משתמשים במשחק שלכם, ודאו שיש לכם את מיפוי המקשים המועדף לשלב הבא.

9. שילוב של SDK לקלט

אחרי שמגדירים את אמצעי הבקרה של העכבר והמקלדת, צריך להוסיף תמיכה ב-Input SDK . כך השחקנים יכולים לגלות את הקלט במחשב באמצעות חלון קופץ שימושי:

1. אחרי שמייבאים את ה-SDK לפרויקט, יוצרים קובץ בשם InputMappingProviderBehaviour.cs ומוסיפים את התוכן הבא:

using System.Collections.Generic;
using Google.Play.InputMapping;
using UnityEngine;
using Input = Google.Play.InputMapping.Input;

public class InputMappingProviderBehaviour : MonoBehaviour
{
    private void Start()
    {
        Input.GetInputMappingClient().RegisterInputMappingProvider(new MyInputMappingProvider());
    }

    private class MyInputMappingProvider : InputMappingProvider
    {
        public InputMap OnProvideInputMap()
        {
            return new InputMap
            {
                InputGroups = new List<InputGroup> { },
                MouseSettings = new MouseSettings
                {
                    InvertMouseMovement = false,
                    AllowMouseSensitivityAdjustment = false
                }
            };
        }
    }

    private enum ActionIds
    {
    }
}

2. עכשיו ממלאים את ActionIds ברשימת הפעולות שבהן משתמשים במשחק. במשחק המיקרו מסוג פלטפורמה דו-ממדית, הפעולות הן שמאלה, ימינה וקפיצה:

private enum ActionIds
{
    Left,
    Right,
    Jump
}

3. בOnProvideInputMap, יוצרים InputAction לכל פעולה. לשם כך צריך את שם הפעולה, הקלט ואז את לחצני העכבר או קודי המקשים שיוגדרו עבורה. למשחק לדוגמה:

var leftAction = new InputAction
{
    ActionLabel = "Walk Left",
    UniqueId = (int)ActionIds.Left,
    InputControls = new InputControls
    {
        AndroidKeycodes = new[]
        {
            AndroidKeyCode.KEYCODE_DPAD_LEFT
        }
    }
};

var rightAction = new InputAction
{
    ActionLabel = "Walk Right",
    UniqueId = (int)ActionIds.Right,
    InputControls = new InputControls
    {
        AndroidKeycodes = new[]
        {
            AndroidKeyCode.KEYCODE_DPAD_RIGHT
        }
    }
};

var jumpAction = new InputAction
{
    ActionLabel = "Jump",
    UniqueId = (int)ActionIds.Jump,
    InputControls = new InputControls
    {
        AndroidKeycodes = new[]
        {
            AndroidKeyCode.KEYCODE_SPACE
        }
    }
};

4. לאחר מכן, מכניסים את פעולות הקלט האלה לקבוצות.

במשחק המיקרו יש רק קבוצה אחת, אבל אתם יכולים ליצור כמה קבוצות שאתם צריכים כדי לעזור לשחקנים למצוא את הפעולות שהם צריכים. מוסיפים את הפריט הבא לOnProvideInputMap:

var movementInputGroup = new InputGroup
{
    GroupLabel = "Movement",
    InputActions = new List<InputAction>
    {
        leftAction, rightAction, jumpAction
    }
};

5. מוסיפים למפת הקלט את כל קבוצות הקלט שיצרתם. משנים את הצהרת ההחזרה ב-OnProvideInputMap כך שתהיה:

return new InputMap
{
    InputGroups = new List<InputGroup> { movementInputGroup },
    MouseSettings = new MouseSettings
    {
        InvertMouseMovement = false,
        AllowMouseSensitivityAdjustment = false
    }
};

6. לבסוף, מוסיפים את הסקריפט שיצרתם למשחק:

7. כשמפעילים את המשחק שוב, לוחצים על Shift+Tab כדי לפתוח את שכבת העל במשחק.

8. לוחצים על אמצעי בקרה כדי לראות את אמצעי הבקרה שהגדרתם.

10. הסרה של תצוגות אינטרנט מוטמעות

כדי לספק לשחקנים חוויה טובה, מומלץ להסיר תצוגות אינטרנט מוטמעות. בדרך כלל משתמשים ברכיבי WebView מוטמעים כדי להציג פריטים כמו מדיניות הפרטיות או התנאים וההגבלות. למרות שהם פועלים ב-Google Play Games, הם מוצגים בדפדפן 'נייד' מוטמע, ולא בדפדפן המועדף של השחקן במחשב, ויכולים לגרום לבלבול מסוים בקרב שחקנים במחשב. לכן, ב-Unity, אם אתם משתמשים בתוספים כלשהם כדי להציג דפדפן מוטמע, צריך לחזור ל- Application.OpenURL(url).

11. הרשאות ותכונות

יש מספר תכונות והרשאות של Android שלא נתמכות ב-Google Play Games. כלל אצבע כללי הוא שבניית המחשב האישי שלכם לעולם לא צריכה להציג תיבת דו-שיח של הרשאות. עכשיו, כשהגרסה שלכם מוכנה, מומלץ לבצע התקנה חדשה טיפוסית ולרשום את כל תיבות הדו-שיח שמופיעות כדי להוסיף אותן לרשימת המשימות לפני שליחת המשחק.

חלק מהמשחקים ב-Unity מבקשים הרשאות באמצעות Android.Permission API. מומלץ להוסיף את הפקודות האלה בתוך בדיקות if (GoogleDeviceUtilities.IsGooglePlayGames) ולעבור ישירות ללוגיקה של הכשל, אם רלוונטי.

12. אופטימיזציות למחשב

יש כמה הבדלים בין Google Play Games לבין טלפון Android רגיל, ולכן כדאי להגדיר את המשחק בהתאם.

מעבר ל-DXT לדחיסת מרקם. פורמטים נפוצים של טקסטורות ב-Android, כמו ETC, מפוענחים בזיכרון בזמן הריצה אם אי אפשר להעביר אותם ישירות ל-GPU של נגן. ‫ASTC מספק את התאימות הטובה ביותר למחשבים, אבל צריך להשתמש בכלי ליצירת פרופילים של GPU במחשב כדי לאמת את ההתנהגות הצפויה של המשחק.

מכיוון שאתם מפעילים עכשיו GPU במחשב, יכול להיות שתרצו גם להגביר את איכות הגרפיקה. אפשר לשנות את ההגדרה ישירות בהגדרות הפרויקט בקטע איכות

13. מזל טוב

הכול מוכן ואפשר להתחיל לעבוד על המשחק ל-Google Play Games. אפשר להתחיל לבדוק את המשחק ולבצע בו שינויים. חשוב לזכור שאף על פי שאפשר להשתמש באותו בסיס קוד, כדאי להתאים את המשחק כך שירגיש כמו משחק מקורי למחשב.

מה השלב הבא?

יש עוד עבודה לעשות כדי להשיק משחק ב-Google Play Games:

• מידע עדכני זמין במדריך למתחילים.
• כדאי לשדרג ל-Play Games Services Sign In v2 כדי שהשחקן יתחבר אוטומטית כשהמשחק יופעל, וכך לעמוד בדרישות ההמשכיות.
• כדי לוודא שהחוויה במחשב תהיה מאובטחת כמו החוויה בנייד, כדאי להטמיע את Play Integrity API.

לבסוף, חלק גדול מהעבודה שביצעתם עד עכשיו כדי לתמוך ב-Google Play Games עוזר לכם גם להשיק משחקים ב-ChromeOS,וכדאי לשקול לתמוך בפלטפורמה הזו בנוסף למחשב.