Een Arduino Tic-Tac-Toe Spel op een Touchscreen Bouwen: Stap-voor-Stap Handleiding

Onderdelen en Benodigdheden

Apps en Online Services

• Arduino IDE

Over Dit Project

Beste vrienden, welkom bij een nieuwe Arduino-tutorial! In deze gedetailleerde handleiding bouwen we een Tic-Tac-Toe-spel met Arduino. Zoals je ziet, gebruiken we een touchscreen en spelen we tegen de computer. Een eenvoudig spel als Tic-Tac-Toe is een uitstekende inleiding tot spelprogrammeren en kunstmatige intelligentie. Hoewel we in dit spel geen AI-algoritmen gebruiken, zullen we begrijpen waarom die essentieel zijn voor complexere spellen.

Spellen ontwikkelen voor Arduino is niet makkelijk en kost veel tijd. Toch kunnen we eenvoudige spellen bouwen omdat het leuk is en ons de mogelijkheid geeft geavanceerde programmeringsconcepten te verkennen, zoals kunstmatige intelligentie. Het is een geweldige leerervaring en aan het eind heb je een leuk spel voor de kinderen!

Laten we nu beginnen met het bouwen van dit project.

Stap 1: Alle Onderdelen Verzamelen

De benodigde onderdelen voor dit project zijn:

• Een Arduino Uno
• Een 2,8" Touchscreen

De kosten van het project zijn zeer laag: slechts $15.

Belangrijk: Voordat je begint, bekijk de video over het touchscreen-display (klik op de kaart in de oorspronkelijke tutorial). Dit helpt je de code te begrijpen en de touchscreen te kalibreren.

Stap 2: De 2,8" Touch Kleurdisplay voor Arduino

Ik ontdekte deze touchscreen op banggood.com en besloot hem te kopen voor mijn projecten. Het display is goedkoop, ongeveer $11.

Het display biedt een resolutie van 320x240 pixels en komt als een shield, wat de verbinding met de Arduino Uno extrememakkelijk maakt. Het display gebruikt bijna alle digitale en analoge pinnen van de Arduino Uno. Bij gebruik van deze shield blijven nog slechts 2 digitale pinnen en 1 analoge pin over. Gelukkig werkt het display ook prima met de Arduino Mega, zodat je meer pinnen beschikbaar hebt. Let op: deze display werkt niet met de Arduino Due of de Wemos D1 ESP8266. Een extra voordeel is de ingebouwde micro-SD-kaartslot.

Stap 3: Het Project Bouwen en Testen

Na het aansluiten van het scherm op de Arduino Uno, laad je de code en ben je klaar om te spelen.

Eerst druk je op de knop "Start Game" en het spel begint. De Arduino maakt de eerste zet. Jij speelt jouw zet door het scherm aan te raken. De Arduino speelt daarna zijn zet, en zo voort. Wie als eerste drie symbolen op een horizontale, verticale of diagonale rij krijgt, wint. Als het spel voorbij is, verschijnt het "Game Over"-scherm. Druk op "Play Again" om opnieuw te beginnen.

De Arduino is erg goed in dit spel. Hij wint de meeste partijen, of het eindigt in gelijkspel als je heel goed speelt. Ik heb het algoritme bewust zo ontworpen dat het soms fouten maakt, zodat de menselijke speler een kans heeft te winnen. Door twee regels code toe te voegen, kun je de Arduino onverslaanbaar maken. Maar hoe kan een $2 chip (de Arduino CPU) het menselijke brein verslaan? Is ons programma slimmer dan ons brein?

Stap 4: Het Spelalgoritme

Om die vraag te beantwoorden, kijken we naar het geïmplementeerde algoritme:

1. De computer speelt altijd eerst. Deze keuze alleen al maakt het spel voor de Arduino veel makkelijker te winnen.
2. De eerste zet is altijd een hoek.
3. De tweede zet is ook een willekeurige hoek uit de overgebleven, zonder rekening te houden met de zet van de speler.
4. Vanaf dat moment controleert de Arduino of de speler in de volgende zet kan winnen en blokkeert die zet.
5. Als de speler niet in één zet kan winnen, speelt de Arduino een hoekzet als die beschikbaar is, of een willekeurige overgebleven zet.

Dit simpele algoritme verslaat de menselijke speler telkens of leidt ten minste tot gelijkspel. Het is niet het optimale Tic-Tac-Toe-algoritme, maar een van de simpelste.

Dit algoritme is eenvoudig te implementeren op Arduino omdat Tic-Tac-Toe heel simpel is en we de spelboom makkelijk kunnen analyseren en oplossen. Als we de spelboom ontwerpen, ontdekken we winnende strategieën die we in code kunnen gieten of we laten de CPU de spelboom in realtime berekenen en de beste zet kiezen. Natuurlijk is ons algoritme simpel omdat het spel simpel is. Probeer je een winnend algoritme voor schaken te ontwerpen, dan kan zelfs de snelste computer de spelboom niet in duizend jaar berekenen! Voor zulke spellen heb je kunstmatige intelligentie-algoritmen en enorme rekencracht nodig. Meer hierover in een toekomstige video.

Stap 5: De Code van het Project

Laten we snel naar de code kijken. We hebben drie bibliotheken nodig om de code te compileren:

• Aangepaste Adafruit TFTLCD
• Adafruit GFX
• Touchscreen

Zelfs een simpel spel als dit vereist meer dan 600 regels code. De code is complex, dus ik zal het niet volledig uitleggen in deze korte tutorial. Ik toon wel de implementatie van het algoritme voor de Arduino-zetten.

Eerst spelen we twee willekeurige hoeken:

int firstMoves[]={0,2,6,8}; // deze posities gebruiken we eerst
for(counter=0; counter<4; counter++) {
  if(board[firstMoves[counter]]!=0) {
    movesPlayed++;
  }
}
do {
  if(moves<=2) {
    int randomMove = random(4);
    int c = firstMoves[randomMove];
    if (board[c]==0) {
      delay(1000);
      board[c]=2;
      Serial.print(firstMoves[randomMove]);
      Serial.println();
      drawCpuMove(firstMoves[randomMove]);
      b=1;
    }
  }
} while(...);

Vervolgens controleren we in elke ronde of de speler in de volgende zet kan winnen:

int checkOpponent() {
  if(board[0]==1 && board[1]==1 && board[2]==0) return 2;
  else if(board[0]==1 && board[1]==0 && board[2]==1) return 1;
  else if (board[1]==1 && board[2]==1 && board[0]==0) return 0;
  else if (board[3]==1 && board[4]==1 && board[5]==0) return 5;
  else if (board[4]==1 && board[5]==1 && board[3]==0) return 3;
  else if (board[3]==1 && board[4]==0 && board[5]==1) return 4;
  else if (board[1]==0 && board[4]==1 && board[7]==1) return 1;
  else return 100;
}

Als ja, blokkeren we die zet – meestal. We blokkeren niet alle zetten om de menselijke speler een kans te geven. Kun je ontdekken welke zetten niet geblokkeerd worden? Na het blokkeren speelt de Arduino een overgebleven hoek of een willekeurige zet. Je kunt de code bestuderen en je eigen onverslaanbare algoritme implementeren. De volledige code vind je bij deze tutorial.

LET OP: Omdat Banggood hetzelfde display met twee verschillende displaydrivers aanbiedt, als de bovenstaande code niet werkt, verander dan de initDisplay-functie naar:

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

Stap 6: Conclusie en Verbeteringen

Zoals je ziet, kunnen we zelfs met een Arduino Uno een onverslaanbaar algoritme bouwen voor simpele spellen. Dit project is geweldig omdat het makkelijk te bouwen is en tegelijkertijd een uitstekende inleiding biedt tot kunstmatige intelligentie en spelprogrammeren. Ik ga in de toekomst proberen meer geavanceerde AI-projecten te bouwen met de krachtigere Raspberry Pi, dus blijf op de hoogte! Ik hoor graag jullie mening over dit project.

Plaats je reacties hieronder en vergeet niet de tutorial te liken als je hem interessant vindt. Bedankt!