דף זה תורגם על ידי Cloud Translation API.

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

1. מבוא

הלוגו של Google Play Games

עדכון אחרון: 18.10.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, ולשנות את המשחק בהתאם.

מה צריך להכין

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

2. להגדרה

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

יוצרים פרויקט חדש באמצעות 2D Platformer Microgame או פותחים פרויקט משלכם.

האחדות

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

צילום מסך של Unity

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

בשלב הראשון, מורידים את האמולטור.

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

צילום מסך של החלון של האמולטור Google Play Games. מסך הבית של Android גלוי.

זוהי סביבת 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 לפיתוח ופריסה ישירות לאמולטור (אופציונלי)

יכול להיות שגרסת ה-adb שנשלחה עם Unity לא תואמת לאמולטור. כדי לוודא, בוחרים באפשרות קובץ -> יוצרים הגדרות ובודקים את תיבת הדו-שיח הפעלת מכשיר כדי לראות אם היא מופיעה.

הפעלת המכשיר ב

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

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

מגדירים את Unity להשתמש ב-Unity SDK אחר, עדיף בערכת Unity Studio שמותקנת על ידי Android Studio.
כדי לעקוף באג ב-Unity, מעדכנים את גרסת כלים ל-Build.

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

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

צילום מסך של

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

צילום מסך של

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

פותחים את החלון הגדרות הפרויקט בקטע הגדרות הנגן ומאתרים את הקטע Publishing Settings.
גוללים למטה אל אפשרויות Build ומסמנים את האפשרות 'Custom Gradle Template' ו-'Custom Launcher Gradle Template', שייצור את שני קובצי Gradle בקטע Assets\Plugins\Android\.

צילום מסך של

מחליפים כל מופע של המחרוזת **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. אנחנו נשתמש בפלאגין של Android Logcat ב-Unity עם Chromebook.

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

החלון של 'מנהל החבילות' עם

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

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

תמונה עם אנימציה שמראה איך להפעיל תמיכה ב-Linux. המפתח נבחר בחלון ההגדרות. Then

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

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

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

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

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

צילום מסך של חלון הרשת שפתוח ב-Chromebook.

בוצעה לחיצה על הלחצן של פרטי הרשת, שמציג את כתובת ה-IP.

בוחרים באפשרות חלון -> ניתוח -> Android Logcat כדי לפתוח את חלון Android Logcat.

חלון>הניתוח פתוח ב-Unity עם

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

מוצג החלון של Android Logcat, נבחר התפריט הנפתח של המכשיר.

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

החלון 'חיבורים אחרים' פתוח. הוזנה כתובת IP.

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

תיבת דו-שיח עם הכיתוב

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

האחדות

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

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

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

בוחרים באפשרות File -> (קובץ ->) Build Settings כדי לפתוח את החלון Build Settings (הגדרות Build) ולאחר מכן לחץ על Player Settings (הגדרות נגן).

צילום מסך של

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

צילום מסך של

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

צילום מסך של הקטע 'הגדרות' בהגדרות הנגן

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

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

צילום מסך

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

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

צילום מסך של האמולטור Google Play Games עם

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

צילום מסך של טרמינל פתוח מודגש" style="width: 624.00px" src="img/9101ce3c95fb1aa2.png" . גדלים="(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, כך שסביר להניח שרמת הגרפיקה תהיה גבוהה יותר מזו שהייתה זמינה בגרסאות ה-build של המשחק לנייד.

8. טיפול בקלט

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

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

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

ב-2D Platformer Microgame משתמשים בחיצים כדי לזוז ובמרחב כדי לקפוץ. אם השתמשת במשחק משלך, עליך לוודא שבחרת את קישורי המפתחות המועדפים בשלב הבא.

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

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

אחרי שמייבאים את ה-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
    {
    }
}

עכשיו צריך למלא את ActionIds ברשימת הפעולות שמשמשות אותך במשחק. במיקרו-משחק הפלטפורמה הדו-ממדית, הפעולות הן 'שמאל', 'ימין' ו'קפיצה':

private enum ActionIds
{
    Left,
    Right,
    Jump
}

ב-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
        }
    }
};

בשלב הבא, חלק את פעולות הקלט האלה בקבוצות.

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

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

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

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

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

צילום מסך של צומת בשם

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

צילום מסך של

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

צילום מסך של

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

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

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

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

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

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

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

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

האחדות

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

צילום מסך של

13. מזל טוב

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

מה השלב הבא?

יש עוד דברים שצריך לעשות כדי לשלוח משחק ב-Google Play Games:

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

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