Ինչպես կատարել Multiplayer խաղ Arduino վերահսկիչներով ՝ 6 քայլ

2024 Հեղինակ: John Day | [email protected]. Վերջին փոփոխված: 2024-01-30 09:45

Երբևէ մտածե՞լ եք, թե ինչպես են խաղերի մշակողները ստեղծում զարմանալի խաղեր, որոնք ամբողջ աշխարհում հաճույքով են խաղում: Դե, այսօր ես ձեզ ընդամենը մի փոքր ակնարկ կտամ դրա մասին ՝ պատրաստելով փոքրիկ բազմաֆունկցիոնալ խաղ, որը կառավարվելու է Arduino վերահսկիչով, որը դուք նույնպես պատրաստելու եք: Այսպիսով, եկեք սկսենք:

Պարագաներ

Ձեզ հարկավոր կլինի.

• Նոութբուք
• Միասնության շարժիչ
• C# IDE, որն աշխատում է Unity- ի հետ, ինչպիսիք են վիզուալ ստուդիան կամ Atom- ը: (Ես կօգտագործեմ Visual Studio կոդ)
• 2X Arduino Nano
• 2X մեծ հացի տախտակ
• 2X փոքր հացի տախտակ
• 4X Tack Switch (սեղմիչ կոճակ)
• 4X 200Ω դիմադրություն
• 12X Արականից տղամարդու Jumper լարերը
• Arduino IDE

Դա օգտակար կլինի, եթե ունեք Unity- ի օգտագործման հիմնական պատկերացում, սակայն դա չի ազդի ձեր առաջընթացի վրա, քանի որ դուք կծանոթանաք դրան ՝ խաղը պատրաստելու ընթացքում:

Unity Engine- ը ներբեռնելու հղում.

store.unity.com/download-nuo

Visual Studio Code IDE ներբեռնման հղում.

code.visualstudio.com/download

Arduino IDE- ն ներբեռնելու հղում.

www.arduino.cc/hy/Main/Software

Քայլ 1: Կարգավորեք խաղի սահմանները

Առաջին հերթին, դուք պետք է ներբեռնեք միասնություն

Երբ դա արվի, կարող եք սկսել կարգավորել ձեր խաղի տեսքը:

Բացեք նոր Unity նախագիծ, անվանեք այն և ընտրեք 2D խաղ:

Երբ նախագիծը բացվի, նկատեք, որ կան 3 հիմնական բաժիններ, որոնք կոչվում են

• Հիերարխիա (այստեղ է, որ կավելացվեն ձեր խաղի բոլոր օբյեկտներն ու մանրամասները):
• Տեսարան (որտեղ դուք կարգավորում եք խաղի տեսքը):
• Խաղ (որտեղ կարող եք ստուգել, թե իրական խաղը ինչպիսին կլինի):

Ուշադրություն դարձրեք, որ հիերարխիայի ներքո ձեր տեսարանն է, իսկ տեսարանի տակ `« Հիմնական տեսախցիկը »: Երբ դուք ընտրում եք տեսախցիկը հիերարխիայից, այն կընտրվի դեպքի վայրում

(Այս տեսախցիկի սահմաններում ամեն ինչ կցուցադրվի իրական խաղում):

Նայեք նկար 1 -ին

Մեր խաղը բաղկացած է երկու տախտակից, գնդակ, որը շարժվում է շուրջը և եզրեր, որոնք սահմանափակում են տախտակների և գնդակի շարժումները:

Սկսենք սահմաններ ստեղծելով:

1. Խաղի նոր օբյեկտ ստեղծելու համար ընտրեք Ակտիվներ> Ստեղծել> Sprites> քառակուսի (անվանեք այն «աջ և ձախ եզրեր») Նայեք նկար 2 -ին
2. Քաշեք և գցեք աջ և ձախ եզրերը դեպի հիերարխիա, և հրապարակում կհայտնվի տեսարան:
3. Կարգավորեք նրա x առանցքի դիրքը (5) «աջ և ձախ եզրեր»> տեսուչ> փոխակերպում> դիրք> X: Նայեք նկար 3 -ին
4. Այնուհետև հարմարեցրեք դրա մասշտաբը այնքան մեծ, որ կարողանա ծածկել տեսախցիկի սահմանները (քաշեք քառակուսու վերին և ստորին կողմերը ՝ այն ձգելու համար):
5. Կարգավորեք դրա գույնը «աջ և ձախ եզրերից»> տեսուչ> sprite render> գույն: Նայեք նկար 3 -ին
6. Ոլորեք ներքև տեսուչի մեջ և ընտրեք ավելացնել բաղադրիչ, այնուհետև մուտքագրեք Rigidbody2D և սեղմեք enter, սա հիմնականում ֆիզիկա կավելացնի ձեր խաղային օբյեկտին, քանի որ այն տալիս է զանգված, ինքնահոս և բախումների հայտնաբերում: Այնուամենայնիվ, մեր խաղում մենք ծանրության կարիք չունենք, այնպես որ դրա փոխարեն գրավիտացիան դարձրեք 0: Դուք նաև պետք է սառեցնեք դիրքն ու պտույտը, որպեսզի եզրը չշարժվի բախվելիս: Նայեք նկար 4 -ին
7. ընտրեք ավելացնել բաղադրիչ, այնուհետև մուտքագրեք Box Collider 2D և սեղմեք enter, սա կավելացնի խաղային օբյեկտի շուրջը մի տարածք, որտեղ կարող են հայտնաբերվել բախումներ: Նայեք նկար 4 -ին
8. Այժմ ընտրեք աջ և ձախ եզրեր և սեղմեք (ctrl+d) այն կրկնօրինակելու համար:
9. Վերանվանել այն «ձախ եզր» և վերանվանել առաջինը («աջ սահման»):
10. Ընտրեք ձախ եզրագիծը և կարգավորեք դրա x առանցքի դիրքը (-5) նույն քայլով 3-րդ քայլում: Այժմ դուք ունեք աջ և ձախ եզրեր:

Կրկնեք նախորդ 10 քայլերը վեր և վար եզրերով և x դիրքի փոխարեն փոխեք քառակուսի y դիրքը: Վերջնական նախադիտումը պետք է նման լինի նկարում պատկերվածին:

Նայեք նկար 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 Switch (սեղմիչ կոճակ)
• 4X դիմադրություն
• 12X Արականից տղամարդու Jumper լարերը

Այժմ նայեք հացի տախտակի լուսանկարներին և քարտեզագրմանը `ջիստիկները հավաքելու համար:

1. Փոքր հացի տախտակով ամրացրեք մեկ Arduino Nano չիպ:
2. կցեք 2 հենակետային անջատիչ մեծ հացի տախտակի վրա, ինչպես ցույց է տրված նկարում: Փորձեք հացի տախտակի աջ կողմը սիմետրիկ պահել ձախին, քանի որ դա ավելի լավ տեսք կտա ջոյստիկին (որպես սիմետրիա կարող եք օգտագործել 30 -րդ սյունակը տող)
3. Փոքր հացի տախտակի վրա Arduino- ի 5V կապի հետ միացրեք ձախ կոճակի վերևի ձախ քորոցը (հացահատիկի նույն սյունակի հետ կապված իրերը միացված են միմյանց):
4. Միացրեք աջ կոճակի վերևի աջ քորոցը Arduino- ի 5V կապի հետ:
5. Ձախ կոճակի ներքևի աջ քորոցը 31-րդ սյունակի կետով միացրեք դիմադրության միջոցով:
6. Միացրեք աջ կոճակի ներքևի ձախ քորոցը 29-րդ սյունակի կետով `օգտագործելով դիմադրություն:
7. Միացրեք դիմադրողները Arduino- ի GND կապով:
8. Ձախ կոճակի վերին աջ կապը միացրեք Arduino- ի D3 կապին:
9. Միացրեք աջ կոճակի վերին ձախ քորոցը Arduino- ի D9 կապով:
10. Այժմ կրկնում ենք այս քայլերը և պատրաստում երկրորդ վերահսկիչը:

Քայլ 3. Arduino- ի միացում սերիալային նավահանգստին

Նախ պետք է տեղադրել Arduino IDE- ն:

Տեղադրվելուց հետո կարող եք սկսել ՝ ստեղծելով Arduino ծրագիր, որը մուտքեր է ստանում կոճակներից և պահում դրանք Սերիական նավահանգստում (COM նավահանգիստ): Երբ Arduino տախտակը միացված է ձեր նոութբուքին, օպերացիոն համակարգը ինքնաբերաբար ճանաչում է տախտակը որպես սերիական նավահանգիստ, որի ծրագրերը կարող են վերբեռնվել: Սերիական նավահանգստում պահվող արժեքները կարող են օգտագործվել հաջորդ քայլին, երբ Unity Engine- ը միացնում ենք սերիալային պորտին:

Այժմ եկեք միացնենք Arduino- ն Սերիալ նավահանգստին:

Նայեք նկարներին

1. Միացրեք Arduino- ն ձեր նոութբուքի հետ
2. Գործիքներ> Տախտակ> Arduino Nano
3. Եթե ձեր Arduino չիպը վերջերս է (2018-2020) Գործիքներ> Պրոցեսոր> ATmega328P (Հին բեռնիչ):
4. Եթե ձեր Arduino չիպը նոր չէ (մինչև 2018 թ.) Գործիքներ> Պրոցեսոր> ATmega328P
5. Գործիքներ> Պորտ> COM (ինչ թիվ էլ հայտնվի, իմ դեպքում դա 10 է): * Սա սերիական նավահանգիստ է, որտեղ արժեքները կպահվեն:
6. Պատճենեք կոդը և տեղադրեք այն Arduino IDE- ում և սեղմեք ctrl+u ծրագիրը վերբեռնելու համար:
7. Կրկնեք երկրորդ Arduino- ով: (5 -րդ քայլն անելիս համոզվեք, որ ընտրեք մեկ այլ COM նավահանգիստ, որպեսզի երկու վերահսկիչներն էլ միացված չլինեն նույն սերիական նավահանգստին):

Կոդ:

void setup () {

Serial.begin (9600); pinMode (3, Մուտք); // Arduino- ին ասելու, որ մուտքագրում ստանա D3 pinMode pin (9, INPUT); // Arduino- ին ասելու համար, որ PIN- ից մուտք ունենա} void loop () {if (digitalRead (3) == 1) { /* Եթե Arduino- ն ստանում է 1 Serial.write (1) մուտք; կապիչ 3 -ից 1 -ի արժեքը թողարկեք դեպի սերիական պորտ Serial.flush (); */ ուշացում (2); } if (digitalRead (9) == 1) { /* Եթե Arduino- ն ստանում է 1 Serial.write (2) մուտքագրում; pin 9 -ից Ելք 2 արժեք դեպի սերիալային պորտ Serial.flush (); */ ուշացում (2); }}

'Sրագրի բացատրությունը.

Այս կոդը պարզապես մուտքագրում է D3 կապից և Arduino- ի D9 կապից, որոնք միացված են կոճակներին: Կոճակները կամ սեղմված են, կամ չսեղմված, ինչը նշանակում է, որ դրանցից վերցված ընթերցումները կամ 1 են (սեղմված), կամ 0 (չճնշված): Եթե աջ կոճակի մուտքը (D9- ից) 1 է (սեղմված), 1 -ի արժեքը պահեք Սերիայի նավահանգստում: Եթե ձախ կոճակի մուտքը (D3- ից) 1 է (սեղմված), 2 -ի արժեքը պահեք Սերիական նավահանգստում:

Քայլ 4. Միասնությունը միացնելով սերիական նավահանգստին

Այս քայլի համար մենք պատրաստվում ենք նույնականացնել սերիական պորտը Unity- ում, որպեսզի այն ստանա մուտքեր Arduino- ից, երբ կոճակները սեղմվում են: Տեղադրեք Visual Studio Code- ը ձեր նոութբուքի վրա: Այնուհետև գնացեք Միասնություն, ընտրեք նվագարկիչ 1 -ը հիերարխիայից, ոլորեք ներքև և ընտրեք ավելացնել բաղադրիչ և մուտքագրեք player1_motion, այնուհետև սեղմեք Enter: Նայեք նկար 1 -ին

Տեսուչում կստեղծվի C# սցենար, աջ կտտացրեք դրա վրա և ընտրեք խմբագրել սկրիպտը, վիզուալ ստուդիայի ծածկագիրը պետք է բացվի և ցույց կտա լռելյայն ծածկագիր, որը նման է նկարի 2 -ին:

Պատճենեք հետևյալ կոդը, այնուհետև փոխեք "SerialPort sp = new SerialPort (" COM10 ", 9600);" SerialPort sp = նոր SerialPort- ով («COM պորտ, որին միացված է ձեր Arduino», 9600); դուք կարող եք գտնել նրան ՝ վերադառնալով ձեր Arduino կոդին և օգտվելով Գործիքներ> Պորտ> COM (ինչ թիվ էլ հայտնվի):

Կոդ:

օգտագործելով System. Collections;

օգտագործելով System. Collections. Generic; օգտագործելով UnityEngine; օգտագործելով System. IO. Ports; public class player1_motion: MonoBehaviour {բոց արագություն = 8; մասնավոր բոց գումարի շարժում; SerialPort sp = նոր SerialPort ("COM10", 9600); // Start- ը կանչվում է առաջին շրջանակի թարմացումից առաջ void Start () {sp. Open (); sp. ReadTimeout = 1; } // Թարմացումը կոչվում է մեկ անգամ մեկ շրջանակի համար անվավեր Update () {amounttomove = speed*0.01f; if (sp. IsOpen) {try {moveObject (sp. ReadByte ()); տպել (sp. ReadByte ()); } catch (System. Exception) {}}} void moveObject (int Direction) {if (Direction == 1) {transform. Translate (Vector3.left*amounttomove, Space. World); } if (Direction == 2) {transform. Translate (Vector3.right*amounttomove, Space. World); }}}

Կոդի բացատրություն.

Այս ծածկագիրը հուշում է միասնությանը `մուտքեր ստանալու սերիական պորտից (COM 10): Երբ ձախ կոճակը սեղմվում է, Arduino- ն սերիական նավահանգիստ է ուղարկում 1 արժեքը, եթե սերիական նավահանգստից 1 -ը ստանում է, ձախ ուղղությամբ «խաղացող 1» խաղային օբյեկտին ավելանում է արագություն: Երբ աջ կոճակը սեղմվում է, Arduino- ն սերիական նավահանգիստ է ուղարկում 2 արժեք, եթե սերիական պորտից միասնությունը ստանում է 2, արագություն է ավելացվում խաղային օբյեկտին ՝ «նվագարկիչ 1» ճիշտ ուղղությամբ: եթե սերիալային պորտը արժեք չի ստանում սերիական նավահանգստից, ոչ մի ուղղություն արագություն չի ավելանում, ուստի տախտակը մնում է անշարժ:

Կոդը պատճենելուց հետո սեղմեք F5 ՝ ծածկագիրը կառուցելու և գործարկելու համար: Վերադարձեք միասնություն և սեղմեք նվագարկման կոճակը: Խաղացող 1 -ը պետք է շարժվի աջ, երբ սեղմում եք աջ և ձախ, երբ սեղմում եք ձախ:

Այժմ, նորից կատարեք նույն քայլերը, բայց 2 -րդ նվագարկիչով և համոզվեք, որ player1_motion- ի փոխարեն գրեք «Ավելացնել բաղադրիչ» player2_motion- ում և նույնականացրեք երկրորդ COM պորտը, որին միացված է երկրորդ վերահսկիչը, այլ ոչ թե նույն սերիական պորտը:

Նաև անհրաժեշտ կլինի փոխել «public class player1_motion: MonoBehaviour» - ը «public class player2_motion: MonoBehaviour» կոդի մեջ:

Քայլ 5: Գնդակի ավելացում

1. Ավելացրեք խաղի նոր օբյեկտ, բայց այս անգամ քառակուսի փոխարեն ընտրեք շրջան:
2. Վերանվանել այն «գնդակ»:
3. Քաշեք և թողեք հիերարխիայում:
4. Կարգավորեք սանդղակը (X: 0.2 - Y: 0.2 - Z: 0.2):
5. Ավելացրեք Rigidbody 2D և սառեցրեք միայն Z առանցքը:
6. Փոխեք զանգվածը մինչև 0,0001
7. Փոխեք Ձգողականության սանդղակը 0 -ի:
8. Ավելացրեք արկղի բախիչ 2D:
9. Գնալ դեպի Ակտիվներ> Ստեղծել> Ֆիզիկայի նյութ 2D Նայեք նկար 1 -ին
10. փոխել անունը ՝ դարձնելով «վերադարձ»
11. Տեսուչից շփումը հասցրեք զրոյի
12. Փոխեք ցատկումը տեսուչից 1 -ի
13. Քաշեք և թողեք «վերադարձը» Rigidbody 2D> Material Նայեք նկար 2 -ին
14. Հիերարխիայից նորից ընտրեք «գնդակը» և գնացեք բաղադրիչ ավելացնելու և մուտքագրեք Ball_movement, այնուհետև սեղմեք enter:
15. Աջ սեղմեք սցենարի վրա և ընտրեք խմբագրել սցենարը:
16. Պատճենեք ներքևի ծածկագիրը և սեղմեք F5 ՝ այն կառուցելու և գործարկելու համար:

Կոդ:

օգտագործելով System. Collections;

օգտագործելով System. Collections. Generic; օգտագործելով UnityEngine; public class Ball_movement: MonoBehaviour {// Սկիզբը կոչվում է առաջին շրջանակի թարմացումից առաջ մասնավոր բոց ուժ = 2; void Start () {StartCoroutine (move ()); } IEnumerator move () {yield return new WaitForSeconds (2); GetComponent (). AddForce (նոր վեկտոր 2 (1f, 0.5f)*0.02f*ուժ); }}

Կոդի բացատրություն

Այս ծածկագիրը երկու ուղղություններով արագություն է տալիս երկու ուղղությամբ ՝ X և Y ուղղություն ՝ նույն մեծությամբ, ինչը ստիպում է գնդակին շարժվել 45 ° անկյան տակ: 8 -րդ քայլում մենք ֆիզիկային նյութ ավելացրինք գնդակին և փոխեցինք դրա արագությունը: Սա պահպանում է գնդակի շարժումը խաղի ընթացքում:

Քայլ 6: Խաղի ավարտում

Այժմ մենք պետք է հնարավոր դարձնենք պարտվելը, եթե խաղը վարեք, կնկատեք, որ երբ գնդակը փոխանցում է խաղացող 1 -ին կամ 2 -րդ խաղացողին, այն պարզապես ցատկում է եզրից, և դա այն չէ, ինչ մեզ պետք է մեր խաղում: Փոխարենը մենք ցանկանում ենք հաշիվների հաշվիչ կազմել, որը կհաշվի հաշիվը ամեն անգամ, երբ գնդակը բախվում է կամ վեր կամ վար եզրագծերի հետ և վերականգնել գնդակի դիրքը:

1. Քաշեք և գցեք գնդակը Հիերարխիայից դեպի Նախագիծ: Դուք պատրաստել եք գնդակի նախածանցը, որպեսզի կարողանաք այն հետագայում օգտագործել:
2. Աջ սեղմեք հիերարխիայի վրա և ընտրեք Ստեղծել դատարկ: կհայտնվի դատարկ օբյեկտ, որը կվերանվանվի գնդակի վերածննդի և կփոխի իր դիրքը ՝ նույնը, ինչ գնդակի դիրքը:
3. Աջ սեղմեք հիերարխիայի վրա և ընտրեք UI >> Text: Ուշադրություն դարձրեք, որ տեքստը կտավին ուղեկցում է, խաղի տեքստի դիրքը կախված է կտավի տեքստի դիրքից, այլ ոչ թե մեր խաղի սահմաններում: (Նայեք նկար 1 -ին):
4. Փոխեք տեքստի դիրքը այնտեղ, որտեղ ցանկանում եք, որ այն լինի:
5. Կրկնեք 3 -րդ և 4 -րդ քայլերը երկրորդ խաղացողի հաշվի համար:
6. Առաջին տեքստում մուտքագրեք «Խաղացող 1 միավոր ՝ 0» և երկրորդ տեքստում ՝ «Խաղացող 2 միավոր ՝ 0»: (Նայեք նկար 2 -ին):
7. Ստեղծեք մի սցենար p1wins անունով և պատճենեք հետևյալ ծածկագիրը:

Կոդ:

օգտագործելով System. Collections;

օգտագործելով System. Collections. Generic; օգտագործելով UnityEngine; օգտագործելով UnityEngine. SceneManagement; օգտագործելով UnityEngine. UI; p1 հանրային դաս. հաղթում է. MonoBehaviour {public Text score; public Transform ball_respawn; հանրային GameObject գնդակ; մասնավոր int p1 = 0; // Start- ը կանչվում է առաջին շրջանակի թարմացումից առաջ void Start () {} // Update- ը կանչվում է մեկ անգամ մեկ frame void Update () {score.text = "Player 1 Score:" + p1; } void OnCollisionEnter2D (Collision2D այլ) {if (other.gameObject.tag == «Գնդակ») {Ոչնչացնել (other.gameObject); p1 ++; Instantiate (գնդակ, ball_respawn.position, ball_respawn.rotation); }}}

8. Քաշեք և գցեք գնդակի հավաքածուն նախագծից 1 -ին քայլում Ball պարամետրի մեջ: (Նայեք 3 -րդ նկարին)

9. Քաշեք և գցեք գնդակը, որը վերածնվում է հիերարխիայից դեպի Ball-rerspawn պարամետր: (Նայեք 3 -րդ նկարին)

10. քաշել և թողնել խաղացողի 1 հաշիվը հիերարխությունից դեպի Score պարամետր: (Նայեք 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 {public Text score; public Transform ball_respawn; հանրային GameObject գնդակ; մասնավոր int p2 = 0; // Start- ը կանչվում է շրջանակի առաջին թարմացումից առաջ void Start () {} // Update- ը կանչվում է մեկ անգամ մեկ frame void Update () {score.text = "Player 2 Score:" + p2; } void OnCollisionEnter2D (Collision2D այլ) {if (other.gameObject.tag == «Գնդակ») {Ոչնչացնել (other.gameObject); p2 ++; Instantiate (գնդակ, ball_respawn.position, ball_respawn.rotation); }}}