יצירת קוד ושילוב מנוע: Unity (C#) ו-Unreal (Blueprint/C++)

רווחים:

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

המשחק הוא תוכנה; לא משנה כמה הוא מעוצב, הוא מיושם עם קוד. מנוע המשחק הוא התשתית שגורמת למשחק לרוץ: Unity (מנוע בשימוש נרחב ב-C#) ו-Unreal Engine (מנוע המשתמש ב-C++ ושפת הסקריפט החזותית Blueprint) הם השניים הנפוצים ביותר. בינה מלאכותית היא אחד העזרים הבוגרים ביותר ביצירת קוד: בקר נגן, מערכת מלאי, מכונות מצב, שמירה/טעינה, לוגיקה של ממשק, איתור באגים ו-refactoring (שחזור קוד מבלי לשבור את התנהגותו). אבל לקוד המשחק יש מלכודות משלו: ביצועים (קצב פריימים), מחזור חיי מנוע, אבטחה מרובה משתתפים. ביחידה זו תלמדו כיצד להשתמש ב-AI בצורה בטוחה ויעילה בקוד המשחק.

עקרון קריטי: הקשר מנוע וגרסה

אם ה-AI לא יודע לאיזה מנוע וגרסה הוא כותב, הוא ייצר API מבולבל, מיושן או לא קיים. אז תן הקשר למנוע, גרסה, שפה וארכיטקטורה בכל הנחית קוד. "כתוב תנועת שחקן למען אחדות" חלש; "Unity 2022.3, C#, מערכת קלט חדשה, תנועת פיזיקה מבוססת Rigidbody" היא רבת עוצמה. ציין אם אתה רוצה Blueprint או C++ ב-Unreal ובאיזה גרסה אתה משתמש.

זרימת קוד מאובטחת צעד אחר צעד:

1. תן הקשר (מנוע, גרסה, שפה, ארכיטקטורה נוכחית, אילוצים).
2. רוצה אותו קטן ומוגדר (רכיב בודד, לא כל המערכת).
3. קרא והבין את הקוד (תבין מה הוא עושה שורה אחר שורה; אל ​​תכניס קוד שאתה לא מבין).
4. בנייה ובדיקה (הפעלה על מנוע; פרופיל - למדוד ביצועים).
5. Refactor ושילוב (התאמה לתקן פרויקט).

טיפ: כשאתה מבקש מה-AI קוד, אמור "הסבר עם הערות". המטרה שלך היא להבין את הקוד; הכנסת קוד AI שאתה לא מבין בפרויקט יצבור חובות בלתי ניתנים לשימור. בקש גם קוד בנתחים קטנים וניתנים לבדיקה: במקום מערכת של 500 שורות, קל לאימות וגם לשלב רכיב של 30-50 שורות שעושה עבודה מוגדרת יחידה.

מלכודות ספציפיות לקוד המשחק

ביצועים. קוד המשחק פועל 30-60+ פעמים בשנייה. בינה מלאכותית יכולה להכניס פעולות יקרות (הקצאת זיכרון, חיפוש, מניפולציה של מחרוזות) לתוך לולאת העדכון שפועלת בכל מסגרת; זה מפחית את קצב הפריימים. פרופיל קודים קריטיים לביצועים ותן אילוצי AI כגון "הפעלה על כל פריים, ללא הקצאה".

מחזור חיי המנוע. AI לפעמים מבלבל כאשר קוראים לשיטות מיוחדות, כגון Awake/Start/Update in Unity, BeginPlay/Tick in Unreal. תפוס שגיאות במחזור החיים על ידי בדיקה.

אבטחה מרובה משתתפים. זהו הנושא הקריטי ביותר מבחינת IT/אבטחה. לעולם אל תסמוך על הלקוח במשחק מרובה משתתפים: ניתן לתמרן את הלקוח במחשב של השחקן לצורך רמאות. אמת מצב קריטי כגון נקודות, נזק, כסף בשרת (סמכותי לשרת). שליטה בקוד הרשת שנוצר על ידי ה-AI נגד עיקרון זה; אם ה-AI יצר פגיעות נותנת אמון בלקוח, תקן אותה. השתמש במידע זה רק כדי להגן ולאמת את המשחק שלך; גישה לא מורשית או רמאות בשרת של מישהו אחר היא לא חוקית ולא אתית.

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

חוב אדריכלות ואחזקה

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

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

שלושה מיני תיקים

מקרה 1 - הקשר שחרור מנע את הבאג. מתכנת אמר לראשונה, "כתוב מלאי למען אחדות"; הקוד השתמש ב-API ישן, הוא לא הידור. ואז זה נתן את ההקשר "Unity 2022.3, C#, מבוסס על ScriptableObject"; הקוד הידור בפעם הראשונה והתאים לפרויקט. ההקשר חסך שעה של איתור באגים.

מקרה 2 - מלכודת ביצועים. במשחק אחד קצב הפריימים היה נמוך. בעת יצירת פרופילים, ניתן היה לראות ששיטת עדכון שהופקה על ידי ה-AI הקצתה רשימה חדשה בכל פריים וחיפשה אויבים. תיקן את הקוד עם הפניה במטמון ועדכון לא ריבועי, והגדיל את קצב הפריימים מ-42 ל-60.

מקרה 3 - נתפסה פגיעות אבטחה. במשחק מרובה משתתפים, הקוד שנוצר בינה מלאכותית חישב את הנזק על הלקוח ודיווח עליו לשרת; זה היה פתוח לבגידה (לקוח יכול לגרום נזק אינסופי). הקוד הפך לשרת-סמכותי (השרת מחשב את הנזק). הביקורת מנעה שערוריית רמאות לאחר הפרסום.

ארבע תבניות הניתנות להעתקה

1) בקשת קוד עם הקשר:

מנוע: Unity 2022.3. שפה: C#. אדריכלות: [למשל. מבוסס רכיב]. אילוץ: הקצאה בעדכון; להיות קריא ולהגיב. משימה: [רכיב בודד, מוגדר, למשל. "בקר דמות קפיצה כפולה"]. ודא שכל API שבו אתה משתמש נמצא בגרסה זו; אם אתה לא בטוח, תודיע לי.

2) הסבר/סקירה של הקוד:

הסבר את הקוד הבא שורה אחר שורה וכתוב (1) מה הוא עושה, (2) בעיות ביצועים אפשריות (הקצאה לכל מסגרת, חיפוש יקר), (3) באגים אפשריים, (4) הצעות לשיפור. קוד: [הדבק]

3) ביקורת אבטחה מרובה משתתפים:

בדוק את הקוד מרובה משתתפים הבא לצורך אבטחה. ספציפית: מקומות שבהם ניתן לסמוך על הלקוח, מצב קריטי שצריך לאמת בשרת (נזק, נקודות, כסף), אימות קלט חסר. הצע תיקון כדי להפוך את השרת לסמכותי. זה רק כדי להגן על המשחק שלי. קוד: [הדבק]

4) רפקטור ממוקד פרופיל ביצועים:

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

הנחיה חלשה / הנחיה חזקה

הנחיה חלשה:

כתוב מערכת שמירה ב-Unity.

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

הנחיה עוצמתית:

מנוע: Unity 2022.3, C#. משימה: מערכת שמירה/טעינה מבוססת JSON. לשמירה: מיקום שחקן, מלאי, התקדמות. אילוץ: קבל ניהול שגיאות נגד השחתת קבצים; הוסף בדיקת תקינות (hash) לקובץ השמירה כדי למנוע רמאות על ידי שינוי בקלות על ידי השחקן. שים לב לקוד וודא שכל API נמצא בגרסה זו.

גירסאות, היקף, טיפול בשגיאות ובדיקת תקינות מקשיחים את הפלט.

טבלת הקשר של מנוע/שפה

מנוע

שפה

מה שאתה צריך לתת ל-AI

תשומת לב מיוחדת

אחדות

C#

גרסה, מערכת קלט/פיסיקה

הקצאת עדכון, מחזור חיים

לא אמיתי

שרטוט

גרסה, הקשר צומת

מגבלות לוגיקה חזותית

לא אמיתי

C++

גרסה, מבנה מודול

זיכרון, GC, פקודות מאקרו

מרובה משתתפים

שניהם

דגם רשת

מגיש-סמכותיות

טעויות נפוצות

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

לסיכום

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

משימת יישום

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

רשימת בדיקה

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