כיצד להכין משחק מרובה משתתפים עם בקרי ארדואינו: 6 שלבים

2024 מְחַבֵּר: John Day | [email protected]. שונה לאחרונה: 2024-01-30 09:12

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

אספקה

אתה תצטרך:

• מחשב נייד
• מנוע אחדות
• C# IDE שעובד עם Unity כגון studio studio או Atom. (אני אשתמש בקוד Visual Studio)
• 2X Arduino Nano
• 2X לוח לחם גדול
• 2X לוח לחם קטן
• מתג 4X Tack (לחצן לחיצה)
• הנגד 4X 200Ω
• 12X חוטי מגשר זכר לזכר
• Arduino IDE

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

קישור להורדת Unity Engine:

store.unity.com/download-nuo

קישור להורדת קוד Visual Studio IDE:

code.visualstudio.com/download

קישור להורדת Arduino IDE:

www.arduino.cc/en/Main/Software

שלב 1: הגדר את גבולות המשחק

קודם כל, עליך להוריד אחדות

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

פתח פרויקט Unity חדש, שם אותו ובחר משחק דו ממדי.

כאשר הפרויקט נפתח, שים לב שיש 3 חלקים עיקריים הנקראים

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

שימו לב שמתחת ההיררכיה יש את הסצנה שלכם ותחת הסצנה יש את "המצלמה הראשית". כאשר תבחר את המצלמה מההיררכיה היא תיבחר בסצנה

(כל דבר בגבולות המצלמה הזו יראה במשחק האמיתי).

תסתכל על תמונה 1

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

נתחיל ביצירת הגבולות.

1. ליצירת אובייקט משחק חדש, בחר נכסים> יצירה> ספריטים> ריבוע (קראו לו "גבולות ימין ושמאל") התבוננו בתמונה 2
2. גרור ושחרר גבולות ימינה ושמאלה להיררכיה ויופיע ריבוע בסצנה.
3. התאם את מיקום ציר ה- x שלו ל (5) "גבולות ימין ושמאל"> מפקח> טרנספורמציה> מיקום> X. תסתכל על תמונה 3
4. לאחר מכן התאם את קנה המידה שלה כך שיהיה גדול מספיק כדי לכסות את גבולות המצלמה (גרור את הצד העליון והתחתון של הריבוע כדי למתוח אותו).
5. התאם את צבעו "מהגבולות הימניים והשמאליים"> מפקח> עיבוד ספרייט> צבע. תסתכל על תמונה 3
6. גלול מטה במפקח ובחר הוסף רכיב ואז הקלד Rigidbody2D ולחץ על enter, זה בעצם יוסיף פיזיקה לאובייקט המשחק שלך מכיוון שהוא נותן לו מסה, כוח משיכה וזיהוי התנגשות. עם זאת אנחנו לא צריכים את כוח הכבידה במשחק שלנו אז הפוך את כוח הכבידה 0 במקום 1. תצטרך גם להקפיא את המיקום והסיבוב כדי שהגבול לא יזוז כשהוא יתנגש. תסתכל על תמונה 4
7. בחר הוסף רכיב ואז הקלד Box Collider 2D ולחץ על Enter זה יוסיף אזור סביב אובייקט המשחק שבו ניתן לזהות התנגשויות. תסתכל על תמונה 4
8. כעת בחר גבולות ימין ושמאל ולחץ על (ctrl+d) כדי לשכפל אותו.
9. שנה את שמו "הגבול השמאלי" ושנה את השם הראשון ("הגבול הימני").
10. בחר את הגבול השמאלי והתאם את מיקום ציר ה- x שלו ל- (-5) באותה הדרך בשלב 3. כעת יש לך גבולות ימין ושמאל.

חזור על 10 השלבים הקודמים עם הגבולות למעלה ולמטה ושנה את מיקום y של הריבוע במקום מיקום x. התצוגה המקדימה האחרונה צריכה להיות משהו דומה לזה שבתמונה.

תסתכל על תמונה 5

שלב 2: הוספת לוחות ויצירת בקרים

הוספת לוחות

צור אובייקט משחק חדש וקרא לו שחקן 1.

לְהַתְאִים:

• קנה מידה: X (1.2), Y (0.15), Z (1)
• מיקום: X (0), Y (-3.6), z (0)
• הוסף BoxCollider2D
• הוסף את Rigidbody 2D והקפיא את צירי y ו- z.

שכפל (ctrl+d) ושנה את שם נגן ההעתקים 2.

לְהַתְאִים:

• קנה מידה: X (1.2), Y (0.15), Z (1)
• מיקום: X (0), Y (3.6), z (0)
• BoxCollider כבר יהיה שם.
• Rigidbody 2D כבר יהיה שם וצירי y ו- z כבר יוקפאו.

תסתכל על תמונה 1

יצירת בקרים

אתה תצטרך:

• 2X Arduino Nano
• 2X לוח לחם גדול
• 2X לוח לחם קטן
• מתג 4X Tack (לחצן לחיצה)
• הנגד 4X
• 12X חוטי מגשר זכר לזכר

עכשיו תסתכל על תמונות לוח הלחם והמיפוי להרכבת הג'ויסטיקים.

1. צרף שבב אחד של Arduino Nano עם לוח לחם קטן.
2. צרף 2 מתגי Tack על לוח הלחם הגדול כפי שמוצג בתמונה. נסה לשמור על הצד הימני של לוח הלחם סימטרי לידו השמאלית מכיוון שזה יגרום לג'ויסטיק להיראות טוב יותר (תוכל להשתמש בעמודה ה -30 כסימטריה. קַו)
3. חבר את הסיכה השמאלית העליונה של הכפתור השמאלי עם סיכת 5V בארדואינו בלוח הלחם הקטן (דברים המחוברים לאותה העמודה בלוח הלחם מחוברים זה לזה).
4. חבר את הסיכה הימנית העליונה של הכפתור הימני עם סיכת 5V בארדואינו.
5. חבר את הסיכה הימנית התחתונה של הכפתור השמאלי עם נקודה בעמודה ה -31 באמצעות נגד.
6. חבר את הסיכה השמאלית התחתונה של הכפתור הימני עם נקודה בעמודה ה -29 באמצעות נגד.
7. חבר את הנגדים בעזרת סיכת ה- GND בארדואינו.
8. חבר את הסיכה הימנית העליונה של הכפתור השמאלי עם סיכת D3 בארדואינו.
9. חבר את הסיכה השמאלית העליונה של הכפתור הימני עם סיכת D9 בארדואינו.
10. כעת חזור על שלבים אלה והפוך את הבקר השני.

שלב 3: חיבור Arduino ליציאה הטורית

ראשית יהיה עליך להתקין את Arduino IDE.

לאחר ההתקנה, תוכל להתחיל ביצירת תוכנית Arduino המקבלת כניסות מהכפתורים ולאחסן אותם ביציאה טורית (יציאת COM). כאשר לוח Arduino מחובר למחשב הנייד שלך, מערכת ההפעלה מזהה את הלוח באופן אוטומטי כיציאה טורית שאליה ניתן להעלות תוכניות. ניתן להשתמש בערכים המאוחסנים ביציאה הטורית בשלב הבא כאשר אנו מחברים את Unity Engine ליציאה הטורית.

עכשיו בואו נחבר את הארדואינו ליציאה הטורית.

תסתכל על התמונות

1. חבר Arduino למחשב הנייד שלך
2. כלים> לוח> Arduino Nano
3. אם שבב ה- Arduino שלך הוא (2018-2020) כלים חדשים> מעבד> ATmega328P (מטען אתחול ישן).
4. אם שבב ה- Arduino שלך אינו עדכני (לפני 2018) כלים> מעבד> ATmega328P
5. כלים> יציאה> COM (כל מספר שמופיע, במקרה שלי הוא 10). * זוהי היציאה הטורית שבה יישמרו ערכים.
6. העתק את הקוד והדבק אותו ב- Arduino IDE והקש על ctrl+u כדי להעלות את התוכנית.
7. חזור על הפעולה עם הארדואינו השני. (בעת ביצוע שלב 5 הקפד לבחור יציאת COM אחרת כך ששני הבקרים לא יהיו מחוברים לאותה יציאה טורית).

קוד:

הגדרת בטל () {

Serial.begin (9600); pinMode (3, INPUT); // לספר ל- Arduino לקבל קלט מהפין D3 pinMode (9, INPUT); // לספר ל- Arduino לקבל קלט מהפין D9} לולאת void () {if (digitalRead (3) == 1) { /* אם ה- Arduino מקבל קלט של Serial.write 1 (1); מפין 3 פלט ערך 1 ליציאה הטורית Serial.flush (); */ עיכוב (2); } if (digitalRead (9) == 1) { /* אם הארדואינו מקבל קלט של Serial.write 1 (2); מהפין 9 פלט ערך 2 ליציאה הטורית Serial.flush (); */ עיכוב (2); }}

הסבר התוכנית:

קוד זה פשוט לוקח קלט מהפין D3 וסיכת D9 בארדואינו, המחוברים לכפתורים. הכפתורים נלחצים או לא נלחצים, כלומר הקריאות שנלקחות מהן הן 1 (נלחץ) או 0 (לא נלחץ). אם הקלט מהכפתור הימני (מ- D9) הוא 1 (לחוץ) אחסן ערך 1 ביציאה הטורית. אם הקלט מהכפתור השמאלי (מ- D3) הוא 1 (לחוץ) אחסן ערך 2 ביציאה הטורית.

שלב 4: חיבור אחדות עם הנמל הסידורי

עבור שלב זה אנו הולכים לזהות את היציאה הסדרתית ב- Unity כך שתוכל לקבל את הכניסות מארדואינו בעת לחיצה על הכפתורים. התקן קוד Visual Studio במחשב הנייד שלך. לאחר מכן עבור אל אחדות, בחר שחקן 1 מההיררכיה, גלול מטה ובחר הוסף רכיב והקלד player1_motion ואז הקש enter. תסתכל על תמונה 1

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

העתק את הקוד הבא ולאחר מכן שנה "SerialPort sp = SerialPort חדש (" COM10 ", 9600);" עם SerialPort sp = SerialPort חדש ("יציאת COM שאליה מחובר הארדואינו", 9600); אתה יכול למצוא את שלו על ידי חזרה לקוד הארדואינו שלך ולחפש כלים> יציאה> COM (כל מספר שמופיע).

קוד:

שימוש ב- System. Collections;

באמצעות System. Collections. Generic; שימוש ב- UnityEngine; שימוש ב- System. IO. Ports; מעמד ציבורי player1_motion: MonoBehaviour {speed float = 8; צף פרטי amounttomove; SerialPort sp = SerialPort חדש ("COM10", 9600); // התחלה נקראת לפני עדכון המסגרת הראשון חלל התחל () {sp. Open (); sp. ReadTimeout = 1; } // עדכון נקרא פעם אחת למסגרת חלל עדכון () {amounttomove = מהירות*0.01f; if (sp. IsOpen) {try {moveObject (sp. ReadByte ()); print (sp. ReadByte ()); } catch (System. Exception) {}}} void moveObject (int Direction) {if (Direction == 1) {transform. Translate (Vector3.left*amounttomove, Space. World); } אם (כיוון == 2) {transform. Translate (Vector3.right*amounttomove, Space. World); }}}

הסבר הקוד:

קוד זה אומר לאחדות לקבל כניסות מהיציאה הטורית (COM 10). כאשר לוחצים על הכפתור השמאלי, הארדואינו שולח ערך 1 ליציאה הסדרתית, אם אחדות מקבלת 1 מהיציאה הטורית, נוספה מהירות לאובייקט המשחק "שחקן 1" בכיוון השמאלי. כאשר לוחצים על הכפתור הימני, הארדואינו שולח ערך 2 ליציאה הסדרתית, אם אחדות מקבלת 2 מהיציאה הטורית, נוספה מהירות לאובייקט המשחק "שחקן 1" בכיוון הנכון. אם היציאה הסדרתית אינה מקבלת ערך מהיציאה הטורית, לא מתווספת מהירות לשני הכיוונים ולכן הלוח נשאר נייח.

לאחר העתקת הקוד לחץ על F5 כדי לבנות ולהפעיל את הקוד. חזור לאחדות ולחץ על כפתור ההפעלה, שחקן 1 צריך לזוז ימינה כאשר אתה לוחץ ימינה ושמאלה כאשר אתה לוחץ שמאלה.

כעת, בצע שוב את אותם השלבים אך עם שחקן 2 והקפד לכתוב ב- 'הוסף רכיב' player2_motion במקום player1_motion ולזהות את יציאת ה- COM השנייה שהבקר השני מחובר אליה, לא אותה יציאה טורית.

כמו כן, יהיה עליך לשנות את "player class_ player1_motion: MonoBehaviour" ל- "class2 player2_motion: MonoBehaviour" בקוד עצמו.

שלב 5: הוספת הכדור

1. הוסף אובייקט משחק חדש, אך הפעם בחר עיגול במקום ריבוע.
2. שנה את שמו "כדור".
3. גרור ושחרר בהיררכיה.
4. התאם את הסולם (X: 0.2 - Y: 0.2 - Z: 0.2).
5. הוסף 2D Rigidbody והקפיא את ציר ה- Z בלבד.
6. שנה את המסה ל 0,0001
7. שנה את סולם הכבידה ל -0.
8. הוסף Box Collider 2D.
9. עבור אל נכסים> צור> חומר פיזיקלי דו ממדי תסתכל על תמונה 1
10. שנה את שמו ל"הקפצה"
11. שנה את החיכוך לאפס מהמפקח
12. שנה את הקפיצות ל -1 מהמפקח
13. גרור ושחרר "הקפצה" לתוך Rigidbody 2D> חומר תסתכל על תמונה 2
14. בחר שוב "כדור" מההיררכיה ועבור להוסיף רכיב והקלד Ball_movement ואז הקש enter.
15. לחץ לחיצה ימנית על התסריט ובחר עריכת סקריפט.
16. העתק את הקוד למטה והקש F5 כדי לבנות ולהפעיל אותו.

קוד:

שימוש ב- System. Collections;

באמצעות System. Collections. Generic; שימוש ב- UnityEngine; מעמד ציבורי Ball_movement: MonoBehaviour {// Start נקרא לפני עדכון הפריים הראשון force float force = 2; void Start () {StartCoroutine (move ()); } מהלך IEnumerator () {תשואה תשואה WaitForSeconds חדש (2); GetComponent (). AddForce (ווקטור 2 (1f, 0.5f)*0.02f*כוח); }}

הסבר הקוד

קוד זה נותן לכדור מהירות לשני הכיוונים בכיוון X וכיוון Y באותה גודל, מה שגורם לכדור לנוע בזווית של 45 °. בשלב 8 הוספנו חומר פיזיקלי לכדור ושינינו את הקפיצות שלו, זה שומר על תנועת הכדור לאורך כל המשחק.

שלב 6: סיום המשחק

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

1. גרור ושחרר את הכדור מההיררכיה לפרויקט, עשית הכנה מוקדמת של הכדור כדי שתוכל להשתמש בו מאוחר יותר.
2. לחץ לחיצה ימנית על ההיררכיה ובחר צור ריק. אובייקט ריק יופיע, ישנה את שמו לריפוד הכדור וישנה את מיקומו להיות זהה למיקום הכדור.
3. קליק ימני על ההיררכיה ובחר ממשק משתמש >> טקסט. שימו לב שהטקסט מלווה בד, מיקומו של הטקסט במשחק תלוי במיקום הטקסט בקנבס, לא בגבולות המשחק שלנו. (תסתכל על תמונה 1).
4. שנה את מיקום הטקסט לכל מקום שתרצה שהוא יהיה.
5. חזור על שלבים 3 ו -4 שוב לציון השחקן השני.
6. הקלד את הטקסט הראשון "שחקן 1 ציון: 0" והקלד את הטקסט השני "ציון שחקן 2: 0". (תראו את התמונה 2).
7. צור סקריפט בגבול למעלה שנקרא p1wins והעתק את הקוד הבא.

קוד:

שימוש ב- System. Collections;

באמצעות System. Collections. Generic; שימוש ב- UnityEngine; שימוש ב- UnityEngine. SceneManagement; באמצעות UnityEngine. UI; מעמד ציבורי p1wins: MonoBehaviour {ציון טקסט ציבורי; טרנספורמציה ציבורית ball_respawn; כדור GameObject ציבורי; int int p1 = 0; // התחלה נקראת לפני עדכון המסגרת הראשון חלל התחל () {} // עדכון נקרא פעם אחת לכל מסגרת חלל עדכון () {score.text = "ציון שחקן 1:" + p1; } בטל OnCollisionEnter2D (Collision2D אחר) {if (other.gameObject.tag == "Ball") {Destroy (other.gameObject); p1 ++; Instantiate (ball, ball_respawn.position, ball_respawn.rotation); }}}

8. גרור ושחרר את הכדור הטרמי מהפרויקט בשלב 1 לפרמטר הכדור. (תראו את התמונה 3)

9. גרור ושחרר את הכדור המוחזר מההיררכיה לפרמטר הכדור- rerspawn. (תראו את התמונה 3)

10. גרור ושחרר ציון שחקן 1 מהיררכיה לפרמטר הציון. (תראו את התמונה 3)

הסבר הקוד:

כאשר הכדור מתנגש עם הגבול העליון הוא הורס ושוב מגיב בעמדת הכדור_רצף שהקצבנו בשלב 2. המטרה להפוך את הכדור למכנה טרומית היא להיות מסוגל להניף אותו מחדש על כל התכונות שלו, אחרת, אם השתמשנו בכדור מההיררכיה הוא יעלה מחדש אבל הוא לא יזוז. כמו כן כאשר הכדור מתנגש עם הגבול העליון ערך שהוא במקור שווה ל- 0 הנקרא p1 עולה ב -1. ערך זה מוצג כטקסט ולכן כאשר הכדור מתנגש עם הגבול העליון הציון של שחקן 1 עולה ב -1.

כעת בצע את שלבים 7, 8, 9 ו -10 לגבול למטה

עבור שלב 7, צור סקריפט בשם p2wins והעתיק במקום זאת את הקוד הבא.

בשלב 10, גרור ושחרר את ציון השחקן 2 מההיררכיה לפרמטר הציון.

קוד:

שימוש ב- System. Collections;

באמצעות System. Collections. Generic; שימוש ב- UnityEngine; שימוש ב- UnityEngine. SceneManagement; שימוש ב- UnityEngine. UI; מעמד ציבורי p2wins: MonoBehaviour {ציון טקסט ציבורי; טרנספורמציה ציבורית ball_respawn; כדור GameObject ציבורי; int int p2 = 0; // התחלה נקראת לפני עדכון המסגרת הראשון חלל התחלה () {} // עדכון נקרא פעם אחת לכל מסגרת חלל עדכון () {score.text = "ציון שחקן 2:" + p2; } בטל OnCollisionEnter2D (Collision2D אחר) {if (other.gameObject.tag == "Ball") {Destroy (other.gameObject); p2 ++; Instantiate (ball, ball_respawn.position, ball_respawn.rotation); }}}