როგორ გავაკეთოთ მულტიპლეიერის თამაში Arduino კონტროლერებთან: 6 ნაბიჯი

2024 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2024-01-30 10:15

ოდესმე გიფიქრიათ იმაზე, თუ როგორ ქმნიან თამაშების დეველოპერები გასაოცარ თამაშებს, რომლებითაც მთელს მსოფლიოში სიამოვნებით თამაშობენ? დღეს, მე ვაპირებ მოგაწოდოთ მცირეოდენი მინიშნება ამის შესახებ, მცირე მულტიპლეიერი თამაშის გაკეთებით, რომელსაც გააკონტროლებს ან არდუინოს კონტროლერი, რომელსაც თქვენც გააკეთებთ. მაშ, დავიწყოთ.

მარაგები

თქვენ დაგჭირდებათ:

• Ლეპტოპი
• ერთობის ძრავა
• C# IDE, რომელიც მუშაობს Unity– თან, როგორიცაა ვიზუალური სტუდია ან Atom. (ვიყენებ Visual Studio კოდს)
• 2X არდუინო ნანო
• 2X დიდი პურის დაფა
• 2X პატარა პურის დაფა
• 4X Tack Switch (Push Button)
• 4X 200Ω რეზისტორი
• 12X მამაკაცი მამაკაცი მხტუნავი მავთულები
• Arduino IDE

ეს იქნება სასარგებლო, თუ თქვენ გაქვთ ძირითადი გაგება Unity– ის გამოყენების შესახებ, თუმცა ეს არ იმოქმედებს თქვენს პროგრესზე, რადგან თქვენ გაეცნობით მას თამაშის შექმნისას.

Unity Engine- ის ჩამოტვირთვის ბმული:

store.unity.com/download-nuo

Visual Studio Code IDE ჩამოტვირთვის ბმული:

code.visualstudio.com/download

Arduino IDE ჩამოტვირთვის ბმული:

www.arduino.cc/en/Main/Software

ნაბიჯი 1: დააყენეთ თამაშის საზღვრები

უპირველეს ყოვლისა, თქვენ უნდა ჩამოტვირთოთ ერთიანობა

ამის დასრულების შემდეგ თქვენ შეგიძლიათ დაიწყოთ თქვენი თამაშის ხედის დაყენება.

გახსენით Unity– ის ახალი პროექტი, დაასახელეთ და შეარჩიეთ 2D თამაში.

როდესაც პროექტი იხსნება, შენიშნეთ, რომ არსებობს 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 არდუინო ნანო
• 2X დიდი პურის დაფა
• 2X პატარა პურის დაფა
• 4X Tack Switch (Push Button)
• 4X რეზისტორი
• 12X მამაკაცი მამაკაცი მხტუნავი მავთულები

ახლა შეხედეთ პურის დაფის ფოტოებს და რუკებს ჯოისტიკების ასაწყობად.

1. მიამაგრეთ ერთი არდუინო ნანო ჩიპი პატარა პურის დაფით.
2. მიამაგრეთ 2 პურის გადამრთველი დიდ პურის დაფაზე, როგორც ეს სურათზეა ნაჩვენები. სცადეთ პურის მარჯვენა მხარეს სიმეტრიულად შეინახოთ მარცხენა ხელი, რადგან ეს ჯოისტიკს უკეთესს გახდის (სიმეტრიის სახით შეგიძლიათ გამოიყენოთ მე -30 სვეტი ხაზი)
3. დააკავშირეთ მარცხენა ღილაკის მარცხენა ზედა მარცხენა პინდი არდუინოს 5V პინთან პატარა პურის დაფაზე (საგნები, რომლებიც დაკავშირებულია პურის დაფაზე იმავე სვეტთან, ერთმანეთთან არის დაკავშირებული).
4. შეაერთეთ მარჯვენა ღილაკის ზედა მარჯვენა პინი 5V პინთან Arduino– ში.
5. შეაერთეთ მარცხენა ღილაკის ქვედა მარჯვენა ქვედა პუნქტი წერტილით 31-ე სვეტზე რეზისტორის გამოყენებით.
6. შეაერთეთ მარჯვენა ღილაკის ქვედა მარცხენა პინი პუნქტით 29-ე სვეტზე რეზისტორის გამოყენებით.
7. შეაერთეთ რეზისტორები GND პინთან არდუინოში.
8. დააკავშირეთ მარცხენა ღილაკის ზედა მარჯვენა პინი D3 პინთან Arduino– ში.
9. შეაერთეთ მარჯვენა ღილაკის ზედა მარცხენა პინი Ddu პინთან Arduino– ში.
10. ახლა გაიმეორეთ ეს ნაბიჯები და შექმენით მეორე კონტროლერი.

ნაბიჯი 3: Arduino– ს დაკავშირება სერიულ პორტთან

პირველ რიგში თქვენ უნდა დააინსტალიროთ Arduino IDE.

როდესაც ისინი დაინსტალირდება, შეგიძლიათ დაიწყოთ Arduino პროგრამის შექმნით, რომელიც ღებულობს ღილაკებს და შეინახავს მათ სერიულ პორტში (COM პორტი). როდესაც Arduino დაფა უკავშირდება თქვენს ლეპტოპს, ოპერაციული სისტემა ავტომატურად აღიარებს დაფას, როგორც სერიული პორტი, რომლის პროგრამების ატვირთვაც შესაძლებელია. სერიულ პორტში შენახული მნიშვნელობები შეიძლება გამოყენებულ იქნას მომდევნო ეტაპზე, როდესაც ჩვენ Unity Engine- ს დავუკავშირებთ სერიულ პორტს.

ახლა მოდით დავუკავშიროთ არდუინო სერიულ პორტს.

ნახეთ სურათები

1. შეაერთეთ Arduino ლეპტოპთან
2. ინსტრუმენტები> დაფა> არდუინო ნანო
3. თუ თქვენი Arduino ჩიპი არის უახლესი (2018-2020) ინსტრუმენტები> პროცესორი> ATmega328P (ძველი ჩამტვირთავი).
4. თუ თქვენი Arduino ჩიპი არ არის უახლესი (2018 წლამდე) ინსტრუმენტები> პროცესორი> ATmega328P
5. ინსტრუმენტები> პორტი> COM (რა რიცხვიც გამოჩნდება, ჩემს შემთხვევაში ეს არის 10). * ეს არის სერიული პორტი, სადაც შეინახება ღირებულებები.
6. დააკოპირეთ კოდი და ჩასვით Arduino IDE- ში და დააჭირეთ პროგრამის ასატვირთად ctrl+u.
7. გაიმეორეთ მეორე არდუინოსთან ერთად. (მე –5 ნაბიჯის შესრულებისას დარწმუნდით, რომ აირჩიეთ სხვა COM პორტი, რათა ორივე კონტროლერი არ იყოს დაკავშირებული იმავე სერიულ პორტთან).

კოდი:

void setup () {

სერიული.დაწყება (9600); pinMode (3, INPUT); // Arduino- სთვის ნათქვამია, რომ მიიღოს pin D3 pinMode (9, INPUT); // Arduino- ს ეუბნება მიიღოს pin P9} 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); პინიდან 9 გამოუშვით მნიშვნელობა 2 სერიულ პორტში Serial.flush (); */ დაგვიანებით (2); }}

პროგრამის ახსნა:

ეს კოდი უბრალოდ იღებს შეყვანას D3 პინიდან და არდუინოს D9 პინიდან, რომლებიც დაკავშირებულია ღილაკებთან. ღილაკები ან დაჭერილია ან არაპრესირებული რაც ნიშნავს რომ მათგან აღებული მაჩვენებლები არის 1 (დაჭერილი) ან 0 (არაპრესირებული). თუ მარჯვენა ღილაკიდან (D9) არის 1 (დაჭერილი) შეინახეთ მნიშვნელობა 1 სერიულ პორტში. თუ მარცხენა ღილაკიდან (D3– დან) არის 1 (დაჭერილი) შეინახეთ მნიშვნელობა 2 სერიულ პორტში.

ნაბიჯი 4: ერთობის დაკავშირება სერიულ პორტთან

ამ ნაბიჯისათვის ჩვენ ვაპირებთ სერიული პორტის იდენტიფიცირებას Unity– ში, რათა მან მიიღოს ღილაკები დაჭერისას Arduino– დან. დააინსტალირეთ Visual Studio კოდი თქვენს ლეპტოპზე. შემდეგ გადადით Unity– ში, შეარჩიეთ მოთამაშე 1 იერარქიიდან, გადაახვიეთ ქვემოთ და შეარჩიეთ კომპონენტის დამატება და ჩაწერეთ player1_motion, შემდეგ დააჭირეთ Enter. შეხედე სურათს 1

ინსპექტორში შეიქმნება C# სკრიპტი, დააწკაპუნეთ მასზე მარჯვენა ღილაკით და აირჩიეთ სკრიპტის რედაქტირება, ვიზუალური სტუდიის კოდი უნდა გაიხსნას და გამოჩნდება ნაგულისხმევი კოდი, რომელიც სურათს 2 ჰგავს.

დააკოპირეთ შემდეგი კოდი და შემდეგ შეცვალეთ "SerialPort sp = new SerialPort (" COM10 ", 9600);" SerialPort sp = ახალი SerialPort ("COM პორტი, რომელსაც თქვენი Arduino უკავშირდება", 9600); მისი პოვნა შეგიძლიათ თქვენი Arduino კოდის დაბრუნებით და goning Tools> Port> COM (რა რიცხვიც გამოჩნდება).

კოდი:

System. Collection- ების გამოყენებით;

System. Collections. Generic- ის გამოყენებით; UnityEngine- ის გამოყენებით; System. IO. Ports- ის გამოყენებით; public class player1_motion: MonoBeviviour {float speed = 8; კერძო საცურაო თანხა გადაადგილება; SerialPort sp = ახალი SerialPort ("COM10", 9600); // დაწყება იძახება პირველი ჩარჩოს განახლებამდე void Start () {sp. Open (); sp. ReadTimeout = 1; } // განახლება ეწოდება ერთხელ კადრზე void განახლება () {amounttomove = სიჩქარე*0.01f; if (sp. IsOpen) {სცადეთ {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 -ით და დარწმუნდით, რომ ჩაწერეთ "დაამატე კომპონენტი" player2_motion ნაცვლად player1_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. დაამატეთ Box Collider 2D.
9. გადადით აქტივებზე> შექმნა> ფიზიკის მასალა 2D შეხედეთ სურათს 1
10. შეცვალე სახელი "bounce"
11. შეცვალეთ ხახუნის დონე ნულამდე ინსპექტორისგან
12. ინსპექტორისგან შეცვალეთ სიმკვეთრე 1 -ზე
13. გადაიტანეთ და ჩამოაგდეთ "bounce" Rigidbody 2D> Material შეხედეთ სურათს 2
14. კვლავ შეარჩიეთ "ბურთი" იერარქიიდან და გადადით კომპონენტის დასამატებლად და ჩაწერეთ Ball_movement შემდეგ დააჭირეთ Enter.
15. დააწკაპუნეთ მარჯვენა სკრიპტზე და აირჩიეთ სკრიპტის რედაქტირება.
16. დააკოპირეთ ქვემოთ მოცემული კოდი და დააჭირეთ F5 მის ასაშენებლად და გასაშვებად.

კოდი:

System. Collection- ების გამოყენებით;

System. Collections. Generic- ის გამოყენებით; UnityEngine- ის გამოყენებით; საჯარო კლასი Ball_movement: MonoBehaviour {// Start იძახება პირველი ჩარჩოს განახლებამდე private float force = 2; void დაწყება () {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. დააწკაპუნეთ მარჯვენა ღილაკით იერარქიაზე და აირჩიეთ ინტერფეისი >> ტექსტი. გაითვალისწინეთ, რომ ტექსტი ახლავს ტილოს, ტექსტის პოზიცია თამაშში დამოკიდებულია ტექსტის პოზიციაზე ტილოზე და არა ჩვენი თამაშის საზღვრებში. (შეხედეთ სურათს 1).
4. შეცვალეთ ტექსტის პოზიცია იქ, სადაც გსურთ.
5. გაიმეორეთ ნაბიჯები 3 და 4 ისევ მეორე მოთამაშის ქულისთვის.
6. ჩაწერეთ პირველი ტექსტი "მოთამაშე 1 ქულა: 0" და ჩაწერეთ მეორე ტექსტი "მოთამაშე 2 ქულა: 0". (შეხედეთ სურათს 2).
7. შექმენით სკრიპტი ზედა ზღვარში სახელწოდებით p1wins და დააკოპირეთ შემდეგი კოდი.

კოდი:

System. Collection- ების გამოყენებით;

System. Collections. Generic- ის გამოყენებით; UnityEngine- ის გამოყენებით; UnityEngine. SceneManagement- ის გამოყენებით; UnityEngine. UI გამოყენებით; საჯარო კლასი p1 გაიმარჯვებს: MonoBehaviour {საჯარო ტექსტის ქულა; საჯარო ტრანსფორმაცია ball_respawn; საჯარო GameObject ბურთი; პირადი int p1 = 0; // დაწყება იძახება პირველი ჩარჩოს განახლებამდე void დაწყება () {} // განახლება ეწოდება ერთხელ ჩარჩოს ბათილად განახლება () {score.text = "მოთამაშეს 1 ქულა:" + p1; } void OnCollisionEnter2D (Collision2D სხვა) {if (other.gameObject.tag == "ბურთი") {განადგურება (other.gameObject); p1 ++; მყისიერი (ბურთი, ბურთი_გადაღება.პოზიცია, ბურთი_წესვა.ბრუნვა); }}}

8. გადაიტანეთ და ჩააგდეთ ბურთის ასაწყობი პროექტიდან 1 საფეხურზე, Ball პარამეტრში. (შეხედეთ სურათს 3)

9. გადაათრიეთ და ჩამოაგდეთ ბურთი იერარქიიდან, Ball-rerspawn პარამეტრზე. (შეხედეთ სურათს 3)

10. გადაიტანეთ და ჩამოაგდეთ მოთამაშე 1 ქულა იერარქიიდან ქულის პარამეტრამდე. (შეხედეთ სურათს 3)

კოდის ახსნა:

როდესაც ბურთი ეჯახება ზედა საზღვარს, ის ანადგურებს და კვლავ იბადება ბურთის_განწყობის პოზიციაზე, რომელიც ჩვენ მივეცით მე –2 საფეხურში. მიზანია, რომ ბურთი მოვამზადოთ, შევძლოთ მისი გაცოცხლება მისი ყველა მახასიათებლით, წინააღმდეგ შემთხვევაში, თუ ჩვენ გამოვიყენეთ ბურთი იერარქიიდან ის გამოჩნდება, მაგრამ ის არ გადავა. ასევე, როდესაც ბურთი ეჯახება ზედა ზღვარს, მნიშვნელობა, რომელიც თავდაპირველად უდრის 0 ეწოდება p1, იზრდება 1 -ით. ეს მნიშვნელობა გამოჩნდება ტექსტის სახით, ასე რომ, როდესაც ბურთი ზედა ზღვარს შეეჯახება, მოთამაშეს ანგარიში 1 იზრდება 1 -ით.

ახლა გააკეთეთ ნაბიჯები 7, 8, 9 და 10 ქვედა საზღვრისთვის

მე –7 ნაბიჯისათვის შექმენით სკრიპტი სახელწოდებით p2wins და ნაცვლად დააკოპირეთ შემდეგი კოდი.

მე –10 ნაბიჯისათვის გადაიტანეთ და ჩამოაგდეთ მოთამაშე 2 ქულა იერარქიიდან ქულის პარამეტრამდე.

კოდი:

System. Collection- ების გამოყენებით;

System. Collections. Generic- ის გამოყენებით; UnityEngine- ის გამოყენებით; UnityEngine. SceneManagement- ის გამოყენებით; UnityEngine. UI გამოყენებით; საჯარო კლასი p2 გაიმარჯვებს: MonoBehaviour {საჯარო ტექსტის ქულა; საჯარო ტრანსფორმაცია ball_respawn; საჯარო GameObject ბურთი; პირადი int p2 = 0; // დაწყება იძახება პირველი ჩარჩოს განახლებამდე void დაწყება () {} // განახლება ეწოდება ერთხელ ჩარჩოს ბათილად განახლება () {score.text = "მოთამაშე 2 ქულა:" + p2; } void OnCollisionEnter2D (Collision2D სხვა) {if (other.gameObject.tag == "ბურთი") {განადგურება (other.gameObject); p2 ++; მყისიერი (ბურთი, ბურთი_გადაღება.პოზიცია, ბურთი_წესვა.ბრუნვა); }}}