תחילת העבודה עם 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. פותחים את מנהל החבילות ומחפשים את 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 יכולות ליצור גרסאות build של Android שתואמות ל-x86 ול-x86-64 (מסומנות כ-ChromeOS), ו-Unity מגרסה 2018 ומגרסאות קודמות יכולות ליצור גרסאות build של x86. כדי לבטל את הנעילה של הארכיטקטורות האלה, צריך קודם לעבור אל קצה העורף של סקריפטים 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 plugin, בוחרים באפשרות Tools -> Open Terminal (כלים -> פתיחת Terminal) כדי לפתוח Terminal לספרייה שבה Unity משתמש.adb.exe

האפשרות 'פתיחת 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,וכדאי לשקול לתמוך בפלטפורמה הזו בנוסף למחשב.