Arduino Touch Tic Tac Toe თამაში: 6 ნაბიჯი (სურათებით)

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

ძვირფასო მეგობრებო, კეთილი იყოს თქვენი მობრძანება არდუინოს სხვა გაკვეთილზე! ამ დეტალურ გაკვეთილში ჩვენ ვაპირებთ ავაშენოთ Arduino Tic Tac Toe თამაში. როგორც ხედავთ, ჩვენ ვიყენებთ სენსორულ ეკრანს და ვთამაშობთ კომპიუტერთან. მარტივი თამაში, როგორიცაა Tic Tac Toe არის შესანიშნავი შესავალი თამაშის პროგრამირებისა და ხელოვნური ინტელექტისთვის. მიუხედავად იმისა, რომ ჩვენ არ გამოვიყენებთ ხელოვნურ ინტელექტის ალგორითმებს ამ თამაშში, ჩვენ გვესმის, თუ რატომ არის საჭირო ხელოვნური ინტელექტის ალგორითმები უფრო რთულ თამაშებში.

Arduino– სთვის თამაშების შემუშავება ადვილი არ არის და დიდ დროს მოითხოვს. მაგრამ ჩვენ შეგვიძლია ავაშენოთ რამდენიმე მარტივი თამაში Arduino– სთვის, რადგან ის სახალისოა და ის საშუალებას მოგვცემს შეისწავლოთ პროგრამირების უფრო მოწინავე თემები, როგორიცაა ხელოვნური ინტელექტი. ეს არის დიდი სწავლის გამოცდილება და ბოლოს გექნებათ სასიამოვნო თამაში ბავშვებისთვის!

ახლა ავაშენოთ ეს პროექტი.

ნაბიჯი 1: მიიღეთ ყველა ნაწილი

ამ პროექტის შესაქმნელად საჭიროა შემდეგი ნაწილები:

Arduino Uno ▶

2.8”სენსორული ეკრანი ▶

პროექტის ღირებულება ძალიან დაბალია. ეს მხოლოდ 15 დოლარია

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

ნაბიჯი 2: 2.8 დიუმიანი სენსორული ფერის ჩვენება არდუინოსთვის

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

მიიღეთ აქ ▶

ეკრანი გთავაზობთ 320x240 პიქსელის გარჩევადობას და ის არის ფარი, რაც არდუინოსთან კავშირს უადვილებს. როგორც ხედავთ, ეკრანი იყენებს Arduino Uno– ს თითქმის ყველა ციფრულ და ანალოგიურ პინს. ამ ფარის გამოყენებისას ჩვენ დაგვრჩა მხოლოდ 2 ციფრული ქინძისთავი და 1 ანალოგური პინი ჩვენი პროექტებისთვის. საბედნიეროდ, ეკრანი მშვენივრად მუშაობს არდუინო მეგაზეც, ასე რომ, როდესაც ჩვენ გვჭირდება მეტი ქინძისთავები, შეგვიძლია გამოვიყენოთ არდუინო მეგა არდუინო უნოს ნაცვლად. სამწუხაროდ ეს ჩვენება არ მუშაობს Arduino Due– სთან ან Wemos D1 ESP8266 დაფაზე. ფარის კიდევ ერთი უპირატესობა ის არის, რომ ის გთავაზობთ მიკრო SD სლოტს, რომლის გამოყენებაც ძალიან მარტივია.

ნაბიჯი 3: პროექტის შედგენა და მისი გამოცდა

ეკრანის Arduino Uno– სთან დაკავშირების შემდეგ, ჩვენ შეგვიძლია ჩავტვირთოთ კოდი და ჩვენ მზად ვართ ვითამაშოთ.

თავდაპირველად, ჩვენ ვაჭერთ ღილაკს "თამაშის დაწყება" და თამაში იწყება. არდუინო ჯერ უკრავს. შემდეგ ჩვენ შეგვიძლია ვითამაშოთ ჩვენი ნაბიჯი უბრალოდ ეკრანზე შეხებით. Arduino შემდეგ უკრავს თავის ნაბიჯს და ასე შემდეგ. მოთამაშე, რომელიც მოახერხებს სამი ნიშნის განთავსებას ჰორიზონტალურ, ვერტიკალურ ან დიაგონალურ რიგში, იგებს თამაშს. თამაშის დასრულების შემდეგ გამოჩნდება თამაშის დასრულების ეკრანი. ამის შემდეგ ჩვენ შეგვიძლია დავაჭიროთ ღილაკს play again, რათა თავიდან დავიწყოთ თამაში.

Arduino არის ძალიან კარგი ამ თამაშში. ის მოიგებს თამაშების უმეტესობას, ან თუ ძალიან კარგი მოთამაშე ხართ, თამაში ფრედ დასრულდება. მე განზრახ შევიმუშავე ეს ალგორითმი გარკვეული შეცდომების დასატოვებლად, რათა ადამიანურ მოთამაშეს მივცე გამარჯვების შანსი. თამაშის კოდს კიდევ ორი სტრიქონის დამატებით, ჩვენ შეგვიძლია Arduino- ს თამაშის წაგება შეუძლებელი გავხადოთ. მაგრამ როგორ შეუძლია 2 $ ჩიპს, არდუინოს პროცესორს, დაამარცხოს ადამიანის ტვინი? არის თუ არა ჩვენ მიერ შემუშავებული პროგრამა ადამიანის ტვინზე უფრო ჭკვიანი?

ნაბიჯი 4: თამაშის ალგორითმი

ამ კითხვაზე პასუხის გასაცემად, მოდით შევხედოთ ჩემს მიერ განხორციელებულ ალგორითმს.

კომპიუტერი ყოველთვის თამაშობს პირველ რიგში. მხოლოდ ეს გადაწყვეტილება არდუინოს თამაშს ბევრად უადვილებს თამაშს. პირველი ნაბიჯი ყოველთვის კუთხეშია. მეორე ნაბიჯი არდუინოსთვის ასევე არის შემთხვევითი კუთხე დანარჩენიდან მოთამაშის მოძრაობაზე ზრუნვის გარეშე. ამ მომენტიდან არდუინო ჯერ ამოწმებს შეძლებს თუ არა მოთამაშეს მომდევნო სვლის მოგება და ბლოკავს ამ მოძრაობას. თუ მოთამაშეს არ შეუძლია გაიმარჯვოს ერთ სვლაში, ის თამაშობს კუთხეში, თუ ის ხელმისაწვდომია ან დარჩენილიდან შემთხვევითი. ესე იგი, ამ უბრალო ალგორითმს შეუძლია დაამარცხოს ადამიანი მოთამაშე ყოველ ჯერზე ან უარეს შემთხვევაში სცენარი თამაში გამოიწვევს ფრედ. ეს არ არის საუკეთესო tic tac toe თამაშის ალგორითმი, მაგრამ ერთ -ერთი ყველაზე მარტივი.

ეს ალგორითმი შეიძლება მარტივად განხორციელდეს არდუინოში, რადგან Tic Tac Toe თამაში ძალიან მარტივია და ჩვენ შეგვიძლია მარტივად გავაანალიზოთ იგი და გადავწყვიტოთ. თუ ჩვენ ვამუშავებთ თამაშის ხეს, ჩვენ შეგვიძლია აღმოვაჩინოთ რამდენიმე გამარჯვებული სტრატეგია და მარტივად განვახორციელოთ ისინი კოდში, ან შეგვიძლია დავუშვათ, რომ პროცესორმა გამოთვალოს თამაშის ხე რეალურ დროში და აირჩიოს საუკეთესო ნაბიჯი თავისთავად. რა თქმა უნდა, ალგორითმი, რომელსაც ჩვენ ვიყენებთ ამ თამაშში, ძალიან მარტივია, რადგან თამაში ძალიან მარტივია. თუ ჩვენ ვცდილობთ შევქმნათ ჭადრაკის გამარჯვებული ალგორითმი, მაშინაც კი, თუ ჩვენ ვიყენებთ ყველაზე სწრაფ კომპიუტერს, ჩვენ არ შეგვიძლია გამოვთვალოთ თამაშის ხე ათასი წლის განმავლობაში! მსგავსი თამაშებისთვის ჩვენ გვჭირდება სხვა მიდგომა, ჩვენ გვჭირდება ხელოვნური ინტელექტის ალგორითმები და რა თქმა უნდა უზარმაზარი დამუშავების ძალა. დაწვრილებით ამის შესახებ მომავალ ვიდეოში.

ნაბიჯი 5: პროექტის კოდი

მოდით სწრაფად გადავხედოთ პროექტის კოდს. ჩვენ გვჭირდება სამი ბიბლიოთეკა, რათა კოდი შევადგინოთ.

1. Adafruit TFTLCD:
2. Adafruit GFX:
3. სენსორული ეკრანი:

როგორც ხედავთ, თუნდაც ასეთი მარტივი თამაში მოითხოვს 600 -ზე მეტ ხაზს. კოდი არის რთული, ამიტომ არ შევეცდები მისი ახსნა მოკლე სახელმძღვანელოში. მე გაჩვენებთ ალგორითმის განხორციელებას არდუინოს მოძრაობებისთვის.

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

<int firstMoves = {0, 2, 6, 8}; // გამოიყენებს ამ პოზიციებს ჯერ (counter = 0; counter <4; counter ++) // პირველი პირველი ნაბიჯების დათვლა {if (დაფა [firstMoves [counter]! = 0) // პირველ სვლას ასრულებს ვინმე {movesPlayed ++; }} გააკეთე {თუ (მოძრაობს <= 2) {int randomMove = შემთხვევითი (4); int c = firstMoves [randomMove]; if (დაფა [c] == 0) {დაგვიანებით (1000); დაფა [c] = 2; Serial.print (firstMoves [randomMove]); Serial.println (); drawCpuMove (firstMoves [randomMove]); b = 1; }}

შემდეგი, თითოეულ რაუნდში ჩვენ ვამოწმებთ, შეუძლია თუ არა მოთამაშეს მომდევნო სვლაში გამარჯვება.

int checkOponent ()

{if (დაფა [0] == 1 && დაფა [1] == 1 && დაფა [2] == 0) დაბრუნება 2; else if (დაფა [0] == 1 && დაფა [1] == 0 && დაფა [2] == 1) დაბრუნება 1; else if (დაფა [1] == 1 && დაფა [2] == 1 && დაფა [0] == 0) დაბრუნება 0; წინააღმდეგ შემთხვევაში, თუ (დაფა [3] == 1 && დაფა [4] == 1 && დაფა [5] == 0) დაბრუნდება 5; else if (დაფა [4] == 1 && დაფა [5] == 1 && დაფა [3] == 0) დაბრუნება 3; წინააღმდეგ შემთხვევაში, თუ (დაფა [3] == 1 && დაფა [4] == 0 && დაფა [5] == 1) დაბრუნდება 4; else if (დაფა [1] == 0 && დაფა [4] == 1 && დაფა [7] == 1) დაბრუნება 1; სხვაგვარად დააბრუნე 100; }

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

შენიშვნა: მას შემდეგ, რაც Banggood გთავაზობთ ერთსა და იმავე ეკრანს ორი განსხვავებული ეკრანის დრაივერთან ერთად, თუ ზემოთ მოყვანილი კოდი არ მუშაობს, შეცვალეთ initDisplay ფუნქცია შემდეგზე:

void initDisplay ()

{tft.reset (); tft.begin (0x9341); tft.setRotation (3); }

ნაბიჯი 6: საბოლოო აზრები და გაუმჯობესებები

როგორც ხედავთ, თუნდაც Arduino Uno– ით, ჩვენ შეგვიძლია ავაშენოთ დაუმარცხებელი ალგორითმი მარტივი თამაშებისთვის. ეს პროექტი შესანიშნავია, რადგან მისი აშენება ადვილია და ამავდროულად შესანიშნავი შესავალია ხელოვნური ინტელექტისა და თამაშის პროგრამირების სფეროში. მე შევეცდები მომავალში ხელოვნური ინტელექტის მქონე უფრო მოწინავე პროექტების აშენება უფრო მძლავრი Raspberry Pi- ს გამოყენებით, ასე რომ იყავით თვალყური! სიამოვნებით მოვისმენდი თქვენს აზრს ამ პროექტის შესახებ.

გთხოვთ გამოაქვეყნოთ თქვენი კომენტარები ქვემოთ და არ დაგავიწყდეთ მოწონდეს ინსტრუქცია, თუ თქვენთვის საინტერესოა. მადლობა!