Intelligent Arduino Uno & Mega Tic Tac Toe (luffarschack) (4 / 5 steg)

Steg 4: Koden

Den fullständiga koden är nedan. Var särskilt uppmärksam på konstanterna förklarade dock överst i koden. För den Arduino Mega versionen, kolla pin definitionerna för de röda och gröna lysdioderna, knapparna, den röda och gröna vinna lysdioder, reset-knappen. De flesta av dem har definierats som 3D matriser och jag lagt koden för att motsvara de lysdioder och knappar som visas i bilderna. Översta vänstra knappen på bilden motsvarar det första elementet i arrayen. Vi sedan arbeta över till höger, ner rad, över igen, ner en rad och över igen. Kom ihåg att Fritzing diagrammet vrids 90° medurs jämfört med bilderna - men jag har märkt "numrering" av LED-lampor och knappar i diagrammet.

För den Arduino Uno versionen, kolla Charlieplex stiften på toppen av koden, den analoga pin ("knappen") och reset knappen PIN-koden. Du bör inte ha några problem med LED numreringen och det kan vara kvar som-är. Om av någon konstig anledning, matrisen knappen inte fungerar, måste du göra din egen felsökning för att kontrollera spänningsvärden som är på väg in analoga PIN-koden på varje knapptryckning och justera arrayen "resButtons".

Glöm inte, för Arduino Uno-versionen, måste du Charlieplex biblioteket bifogad som en fil nedan koden. Packa upp och placera den i mappen Bibliotek i din Arduino IDE (du kan söka hur du på webben om du inte vet).

Intelligens biten är inget annat än Arduino kontroll varje kolumn, rad och diagonal att se om det finns redan två röda lysdioderna lyser och ett extra utrymme att placera en pjäs. Detta skulle innebära Arduino kunde vinna och detta tar prioritet. Om Arduino inte kan hitta sådan linje, gör så då samma sak igen men den här gången söker två gröna lysdioder och en extra utrymme. Detta innebär människan kunde vinna och Arduino kommer därför att placera en bit för att blockera mänskliga. Slutligen, om det inte kan vinna eller blockera, det kommer att plocka en plats på måfå genom att välja en av de fria utrymmena ombord.

Jag har kommenterat koden som möjligt att hjälpa dig förstå vad som händer. Jag vet koden skulle vara mycket effektivare. Jag tror det inte är dåligt för ett första försök ändå. Lycka till!

För Arduino Mega: (Arduino Uno version är nedan)

TIC TAC TOE för Arduino Mega
av Nick Harvey

Inkludera alla bibliotek som behövs för
#include < liquidcrystal.h > / / för LCD

Definiera pins
CONST int gröna [3] [3] = {/ / grön är spelaren
{30, 31, 32},
{33, 34, 35},
{36, 37, 38}
};
CONST int röd [3] [3] = {/ / röd är Arduino
{40, 41, 42},
{43, 44, 45},
{46, 47, 48}
};
CONST int knappen [3] [3] = {/ / knapparna för att välja läge
{2, 3, 4},
{5, 6, 7},
{8, 9, 10}
};

CONST int greenWin = 50; Lyser om spelaren vinner
CONST int redWin = 51. Lyser om Arduino vinner
CONST int resetButton = 11; Knappen för att starta ett nytt spel

CONST int win [8] [3] [3] = {/ / här 4D matrisen definierar alla möjliga vinnande kombinationer
{
{1, 1, 1},
{0, 0, 0},
{0, 0, 0}
},
{
{0, 0, 0},
{1, 1, 1},
{0, 0, 0}
},
{
{0, 0, 0},
{0, 0, 0},
{1, 1, 1}
},
{
{1, 0, 0},
{1, 0, 0},
{1, 0, 0}
},
{
{0, 1, 0},
{0, 1, 0},
{0, 1, 0}
},
{
{0, 0, 1},
{0, 0, 1},
{0, 0, 1}
},
{
{1, 0, 0},
{0, 1, 0},
{0, 0, 1}
},
{
{0, 0, 1},
{0, 1, 0},
{1, 0, 0}
}
};

LiquidCrystal lcd (A4, A5, A3, A2, A1, A0); Stift för LCD-skärmen (standard Arduino LCD-bibliotek)

Globala variabler
int gamePlay [3] [3] = {/ / innehar det aktuella spelet
{0, 0, 0},
{0, 0, 0},
{0, 0, 0}
};

int squaresLeft = 9; Antalet fria rutor kvar i styrelsen
int spelade = 0; Spelat Arduino eller inte

Globala konstanter
CONST int startupFlashSpeed = 100; Tid i millisekunder lamporna tända för vid start
CONST int arduinoDelay = 3000; Hur länge Arduino väntar innan du spelar (simulerar tanken)

void setup() {
sätta din installation kod här, om du vill köra en gång:
Starta seriell kommunikation
Serial.BEGIN(9600);

Initiera LCD
LCD.BEGIN (16, 2);
Definiera gröna och röda pins som utgångar
för (int jag = 0; jag < 3; i ++) {
för (int j = 0; j < 3; j ++) {
pinMode (gröna produktionen [i] [j]);
pinMode (röda produktionen [i] [j]);
}
}

Definiera gröna och röda win lampor som utgångar
pinMode (greenWin, produktionen);
pinMode (redWin, produktionen);
Definiera knappar som insatsvaror
för (int jag = 0; jag < 3; i ++) {
för (int j = 0; j < 3; j ++) {
pinMode (knappen [i] [j], ingång);
}
}

Definiera återställningsknappen som indata
pinMode (resetButton, ingång);

initialise();

Göra start flash
startupFlash();
}

void initialise() {
Förbereda styrelsen för ett spel
Disp ("TIC TAC TOE");

Iväg för gröna och röda lysdioder
för (int jag = 0; jag < 3; i ++) {
för (int j = 0; j < 3; j ++) {
digitalWrite (grön [i] [j], låg);
digitalWrite (röd [i] [j], låg);
Spel [i] [j] = 0;
}
}

Ställ in win lysdioder av
digitalWrite (greenWin, låg);
digitalWrite (redWin, låg);

Återställ variabler
squaresLeft = 9;

Berätta spelaren är det deras tur
Disp ("din tur...");
}

void loop() {
sätta din huvudsakliga kod här, för att köra flera gånger:
Väntar på indata och kallar den buttonPress rutinen om du trycker
för (int jag = 0; jag < 3; i ++) {
för (int j = 0; j < 3; j ++) {
om ((digitalRead(button[i][j]) == HIGH) & & (gamePlay [i] [j] == 0)) {
buttonPress (i, j); Passera x och y av knappen intryckt
bryta;
}
}
}
}

void buttonPress (int i, int j) {
Knappen är nedtryckt, ljus grön LED och observera torget som tagit
Serial.Print ("knapptryckning"); Serial.Print(i); Serial.println(j);
digitalWrite (grön [i] [j], hög);
Spel [i] [j] = 1; Observera torget spelade
squaresLeft-= 1; Uppdatera antalet kvadrater kvar
printGame(); Skriva ut spelet till seriell monitor
checkGame(); Kontrollera om det finns en vinnare
arduinosTurn(); Arduinos tur
}

void arduinosTurn() {
Arduino tar en sväng
Serial.println ("Arduino's turn");
Disp ("min tur...");
checkPossiblities(); Kontrollera om ett vinnande drag kan spelas
om (spelade == 0) {
checkBlockers(); Om ingen vinnande drag spelade, kontrollera för att se om vi kan blockera en vinst
}
om (spelade == 0) {
randomPlay(); I annat fall plocka en random kvadrat
}
squaresLeft-= 1; Uppdatera antalet kvadrater kvar
spelade = 0; Återställa om spelade eller inte
printGame(); Skriva ut spelen följetong Monitor
checkGame(); Kontrollera om det finns en vinnare
Disp ("din tur..."); Berätta spelaren är det deras tur
}

void checkPossiblities() {
Kontrollera alla rader, då kolumner, då diagonalerna att se om det finns två röda lyser och en fri ruta för att göra en linje av tre
Serial.println ("Kontrollera möjligheter att vinna...");
Disp ("kan jag vinna?");
int poss = 0; Används för att räkna om möjligt - om det blir till 2 så är det en möjlig
int x = 0; X-position att spela
int y = 0; Y-position att spela
int utrymme = 0; Finns det en gratis kvadrat ska spelas
Kolla rader
för (int jag = 0; jag < 3; i ++) {
för (int j = 0; j < 3; j ++) {
om (gamePlay [i] [j] == 2) {
Poss + = 1; Torget är röd. Ökar värdet för räknaren detta kunde
}
om (gamePlay [i] [j] == 0) {
Space = 1; Torget är tom. Obs detta och position
x = i.
y = j;
}
om ((poss == 2) & & (utrymme == 1)) {/ / 2 röda fyrkanter och en gratis square
Serial.Print ("hittades en rad där uppenbara!"); Serial.Print(x); Serial.println(y);
playPoss (x, y);
}
}
Poss = 0;
x = 0;
y = 0;
Space = 0;
}

Kolla har kolumner - samma som för rader men "för" slingorna återförts för att gå till kolumner
för (int jag = 0; jag < 3; i ++) {
för (int j = 0; j < 3; j ++) {
om (gamePlay [j] [i] == 2) {
Poss + = 1;
}
om (gamePlay [j] [i] == 0) {
Space = 1;
x = j;
y = i.
}
om ((poss == 2) & & (utrymme == 1) & & (spelade == 0)) {/ / Detta tid också kontrollera om vi har redan spelat
Serial.Print ("hittades en uppenbart kolumn!"); Serial.Print(x); Serial.println(y);
playPoss (x, y);
}
}
Återställ variabler
Poss = 0;
x = 0;
y = 0;
Space = 0;
}

Kolla kors - som för rader och kolumner men "för" loopar förändrats
Kolla diagonal övre vänstra till nedre högra
för (int jag = 0; jag < 3; i ++) {
om (gamePlay [i] [i] == 2) {
Poss + = 1;
}
om (gamePlay [i] [i] == 0) {
Space = 1;
x = i.
y = i.
}
om ((poss == 2) & & (utrymme == 1) & & (spelade == 0)) {
Serial.Print ("hittades en uppenbart kors!"); Serial.Print(x); Serial.println(y);
playPoss (x, y);
}
}
Återställ variabler
Poss = 0;
x = 0;
y = 0;
Space = 0;

Check diagonalt upp till höger till längst ner till vänster
int rad = 0; Används för att räkna raderna
för (int jag = 2; jag > = 0; i--) {/ / vi räkna ner kolumnerna
om (gamePlay [rad] [i] == 2) {
Poss + = 1;
}
om (gamePlay [rad] [i] == 0) {
Space = 1;
x = rad;
y = i.
}
om ((poss == 2) & & (utrymme == 1) & & (spelade == 0)) {
Serial.Print ("hittades en uppenbart kors!"); Serial.Print(x); Serial.println(y);
playPoss (x, y);
}
rad + = 1; Ökar värdet för räknaren rad
}
Återställ variabler
Poss = 0;
x = 0;
y = 0;
Space = 0;
}

void checkBlockers() {
Som för checkPossibilites() men denna gång kontrollera spelare kvadraterna för ställen att blockera en rad tre
Serial.println ("Kontrollera möjligheter att blockera...");
Disp ("kan jag blockera?");
int poss = 0;
int x = 0;
int y = 0;
int utrymme = 0;

Kolla rader
för (int jag = 0; jag < 3; i ++) {
för (int j = 0; j < 3; j ++) {
om (gamePlay [i] [j] == 1) {
Poss + = 1;
}
om (gamePlay [i] [j] == 0) {
Space = 1;
x = i.
y = j;
}
om ((poss == 2) & & (utrymme == 1) & & (spelade == 0)) {
Serial.Print ("hittades en rad där blocker!"); Serial.Print(x); Serial.println(y);
playPoss (x, y);
}
}
Poss = 0;
x = 0;
y = 0;
Space = 0;
}

Kolla kolumner
för (int jag = 0; jag < 3; i ++) {
för (int j = 0; j < 3; j ++) {
om (gamePlay [j] [i] == 1) {
Poss + = 1;
}
om (gamePlay [j] [i] == 0) {
Space = 1;
x = j;
y = i.
}
om ((poss == 2) & & (utrymme == 1) & & (spelade == 0)) {
Serial.Print ("hittades en blockerare kolumn!"); Serial.Print(x); Serial.println(y);
playPoss (x, y);
}
}
Poss = 0;
x = 0;
y = 0;
Space = 0;
}

Kolla kors
för (int jag = 0; jag < 3; i ++) {
om (gamePlay [i] [i] == 1) {
Poss + = 1;
}
om (gamePlay [i] [i] == 0) {
Space = 1;
x = i.
y = i.
}
om ((poss == 2) & & (utrymme == 1) & & (spelade == 0)) {
Serial.Print ("hittades en blockerare kors!"); Serial.Print(x); Serial.println(y);
playPoss (x, y);
}
}
Poss = 0;
x = 0;
y = 0;
Space = 0;
int rad = 0;
för (int jag = 2; jag > = 0; i--) {
om (gamePlay [rad] [i] == 1) {
Poss + = 1;
}
om (gamePlay [rad] [i] == 0) {
Space = 1;
x = rad;
y = i.
}
om ((poss == 2) & & (utrymme == 1) & & (spelade == 0)) {
Serial.Print ("hittades en blockerare kors!"); Serial.Print(x); Serial.println(y);
playPoss (x, y);
}
rad + = 1;
}
Poss = 0;
x = 0;
y = 0;
Space = 0;
}

void randomPlay() {
Ingen vinst eller blockera att spela... Låt oss bara plocka en kvadrat på måfå
Serial.println ("du väljer slumpmässigt...");
int val = random (1, squaresLeft); Vi hämtar ett nummer från 0 till antalet rutor kvar i styrelsen
Serial.Print ("Arduino väljer"); Serial.println(Choice);
int pos = 1; Lagrar gratis torget vi är för närvarande på
för (int jag = 0; jag < 3; i ++) {
för (int j = 0; j < 3; j ++) {
om (gamePlay [i] [j] == 0) {/ / kontrollera för att se om fyrkantig tomt
om (pos == val) {/ / spela Tom torget som motsvarar att slumptal
playPoss (i, j);
}
POS + = 1; Ökar värdet för räknaren gratis square
}
}
}
}

void playPoss (int x, int y) {
Simulera tanken och sedan spela upp valt kvadrat
Disp("hmmm...");
Delay(arduinoDelay);
Disp("OK");
digitalWrite (röd [x] [y], hög);
gamePlay [x] [y] = 2; Uppdatera spelet matrisen
spelade = 1; Observera att vi har spelat
}

void checkGame() {
När spelet på en vinnare

Kontrollera om spelaren har vunnit
Serial.println ("kontrollera för en vinnare");
Disp("Checking...");
int spelare = 1;
int vinnare = 0;
för (int jag = 0; jag < 8; i ++) {/ / vi gå igenom alla vinnande kombinationer i 4D matrisen och kontrollera om de motsvarar det aktuella spelet
Kontrollera spelet
int winCheck = 0;
för (int j = 0; j < 3; j ++) {
för (int k = 0; k < 3; k ++) {
om ((win [i] [j] [k] == 1) & & (gamePlay [j] [k] == spelare)) {
winCheck + = 1;
}
}
}
om (winCheck == 3) {
vinnare = 1;
Serial.Print ("spelaren vann spelet"); Serial.println(i);
endGame(1);
}
}

Gör samma sak att kontrollera om Arduino har vunnit
Player = 2;
vinnare = 0;
för (int jag = 0; jag < 8; i ++) {
Kontrollera spelet
int winCheck = 0;
för (int j = 0; j < 3; j ++) {
för (int k = 0; k < 3; k ++) {
om ((win [i] [j] [k] == 1) & & (gamePlay [j] [k] == spelare)) {
winCheck + = 1;
}
}
}
om (winCheck == 3) {
vinnare = 1;
Serial.Print ("Arduino vann spelet"); Serial.println(i);
endGame(2);
}
}
om (squaresLeft == -1) {
endGame(0);
}
}

void printGame() {
Skriver ut spelet till seriell bildskärmen
för (int jag = 0; jag < 3; i ++) {
för (int j = 0; j < 3; j ++) {
Serial.Print(gamePlay[i][j]); Serial.Print("");
}
Serial.println("");
}
Serial.Print(squaresLeft); Serial.println ("rutor kvar");
}

Annullera endGame (int vinnare) {
Anropas när en vinnare finns
Växla (vinnare) {
fall 0:
Serial.println ("det är oavgjort");
digitalWrite (greenWin, hög);
digitalWrite (redWin, hög);
Disp ("det är oavgjort!");
bryta;
fall 1:
Serial.println ("spelaren vinner");
digitalWrite (greenWin, hög);
Disp ("du vinna!");
bryta;
fall 2:
Serial.println ("Arduino vinner");
digitalWrite (redWin, hög);
Disp ("jag vinna!");
bryta;
}
lcd.setCursor (0, 1);
LCD.Print ("Tryck återställa...");
medan (digitalRead(resetButton) == låg) {
}
initialise();
}

void disp(String message) {
Används för att snabbt visa ett meddelande på LCD-
LCD.Clear();
lcd.setCursor (0, 0);
LCD.Print(Message);
}

void startupFlash() {
Flash i början
för (int jag = 0; jag < 3; i ++) {
för (int j = 0; j < 3; j ++) {
digitalWrite (grön [i] [j], hög);
digitalWrite (greenWin, hög);
Delay(startupFlashSpeed);
digitalWrite (grön [i] [j], låg);
digitalWrite (greenWin, låg);
digitalWrite (röd [i] [j], hög);
digitalWrite (redWin, hög);
Delay(startupFlashSpeed);
digitalWrite (röd [i] [j], låg);
digitalWrite (redWin, låg);
}
}
för (int jag = 0; jag < 3; i ++) {
för (int j = 0; j < 3; j ++) {
digitalWrite (grön [j] [i], hög);
Delay(startupFlashSpeed);
digitalWrite (grön [j] [i], låg);
}
}
för (int jag = 0; jag < 3; i ++) {
för (int j = 0; j < 3; j ++) {
digitalWrite (röd [i] [j], hög);
Delay(startupFlashSpeed);
digitalWrite (röd [i] [j], låg);
}
}
för (int jag = 0; jag < 3; i ++) {
digitalWrite (röd [i] [i], hög);
Delay(startupFlashSpeed);
digitalWrite (röd [i] [i], låg);
}
int rad = 0;
för (int jag = 2; jag > = 0; i--) {
digitalWrite (grön [rad] [i], hög);
Delay(startupFlashSpeed);
digitalWrite (grön [rad] [i], låg);
rad + = 1;
}
}

För Arduino Uno:

< p > / / TIC TAC TOE för Arduino Uno < br > / / av Nick Harvey < /p >< p > #include < charlieplex.h >
byte stift [5] = {5, 6, 9, 10, 11};
Charlieplex charlie (stift, sizeof(pins)); < /charlieplex.h >< /p >< p > / / Definiera lysdioder
CONST int gröna [3] [3] = {/ / grön är spelaren
{0, 8, 14},
{2, 10, 16},
{4, 12, 6}
};
CONST int röd [3] [3] = {/ / röd är Arduino
{1, 9, 15},
{3, 11, 17},
{5, 13, 7}
};
CONST int knappen = A0; Den analoga pin knappen matrisen är ansluten till < /p >< p > const int resButtons [3] [3] = {/ / motstånd trösklarna för knapparna
{800, 400, 200},
{160, 140, 120},
{90, 85, 70}
}; < /p >< p > const int greenWin = 18; Lyser om spelaren vinner
CONST int redWin = 19. Lyser om Arduino vinner
CONST int resetButton = 13. Knappen för att starta ett nytt spel < /p >< p > const int win [8] [3] [3] = {/ / här 4D matrisen definierar alla möjliga vinnande kombinationer
{
{1, 1, 1},
{0, 0, 0},
{0, 0, 0}
},
{
{0, 0, 0},
{1, 1, 1},
{0, 0, 0}
},
{
{0, 0, 0},
{0, 0, 0},
{1, 1, 1}
},
{
{1, 0, 0},
{1, 0, 0},
{1, 0, 0}
},
{
{0, 1, 0},
{0, 1, 0},
{0, 1, 0}
},
{
{0, 0, 1},
{0, 0, 1},
{0, 0, 1}
},
{
{1, 0, 0},
{0, 1, 0},
{0, 0, 1}
},
{
{0, 0, 1},
{0, 1, 0},
{1, 0, 0}
}
}; < /p >< p > / / globala variabler
int gamePlay [3] [3] = {/ / innehar det aktuella spelet
{0, 0, 0},
{0, 0, 0},
{0, 0, 0}
};
int squaresLeft = 9; Antalet fria rutor kvar i styrelsen
int spelade = 0; Har Arduino spelade eller inte < /p >< p > / / globala konstanter
CONST int arduinoDelay = 3000; Hur länge Arduino väntar innan du spelar (simulerar tanken) < /p >< p > void setup() {
sätta din installation kod här, om du vill köra en gång: < /p >< p > / / Start seriell kommunikation
Serial.BEGIN(9600); < /p >< p > / / Definiera knappar som insatsvaror
pinMode (knapp, indata); < /p >< p > //Define återställningsknapp som indata
pinMode(resetButton, INPUT); < /p >< p > initialise();
} < /p >< p > void initialise() {
Förbereda styrelsen för ett spel
Serial.println("Initialising...");
Iväg för gröna och röda lysdioder
för (int jag = 0; jag < 3; i ++) {
för (int j = 0; j < 3; j ++) {
charlie.setLed (grön [i] [j], falsk);
charlie.setLed (röd [i] [j], falsk);
Spel [i] [j] = 0;
}
}
Ställ in win lysdioder av
charlie.setLed (greenWin, falsk);
charlie.setLed (redWin, falsk); < /p >< p > / / Reset variabler
squaresLeft = 9;
}
void loop() {
sätta din huvudsakliga kod här, för att köra flera gånger:
Väntar på indata och kallar den buttonPress rutinen om du trycker
int övre = 10000;
om (analogRead(button)! = 0) {
int x;
int y;
för (int jag = 0; jag < 3; i ++) {
för (int j = 0; j < 3; j ++) {
om (gamePlay [i] [j] == 0) {
om ((analogRead(button) > resButtons[i][j]) & & (analogRead(button) < övre)) {
buttonPress (i, j);
}
}
övre = resButtons [i] [j];
}
}
}
Charlie.loop();
} < /p >< p > void buttonPress (int i, int j) {
Knappen är nedtryckt, ljus grön LED och observera torget som tagit
Serial.Print ("knapptryckning"); Serial.Print(i); Serial.Print(":"); Serial.println(j);
charlie.setLed (grön [i] [j], true);
Spel [i] [j] = 1; Observera torget spelade
squaresLeft-= 1; Uppdatera antalet kvadrater kvar
printGame(); Skriva ut spelet till seriell monitor
checkGame(); Kontrollera om det finns en vinnare
arduinosTurn(); Arduinos tur
} < /p >< p > void arduinosTurn() {
Arduino tar en sväng
Serial.println ("Arduino's turn");
checkPossiblities(); Kontrollera om ett vinnande drag kan spelas
om (spelade == 0) {
checkBlockers(); Om ingen vinnande drag spelade, kontrollera för att se om vi kan blockera en vinst
}
om (spelade == 0) {
randomPlay(); I annat fall plocka en random kvadrat
}
squaresLeft-= 1; Uppdatera antalet kvadrater kvar
spelade = 0; Återställa om spelade eller inte
printGame(); Skriva ut spelen följetong Monitor
checkGame(); Kontrollera om det finns en vinnare
} < /p >< p > void checkPossiblities() {
Kontrollera alla rader, då kolumner, då diagonalerna att se om det finns två röda lyser och en fri ruta för att göra en linje av tre
Serial.println ("Kontrollera möjligheter att vinna...");
int poss = 0; Används för att räkna om möjligt - om det blir till 2 så är det en möjlig
int x = 0; X-position att spela
int y = 0; Y-position att spela
int utrymme = 0; Finns det en gratis kvadrat ska spelas
Kolla rader
för (int jag = 0; jag < 3; i ++) {
för (int j = 0; j < 3; j ++) {
om (gamePlay [i] [j] == 2) {
Poss + = 1; Torget är röd. Ökar värdet för räknaren detta kunde
}
om (gamePlay [i] [j] == 0) {
Space = 1; Torget är tom. Obs detta och position
x = i.
y = j;
}
om ((poss == 2) & & (utrymme == 1)) {/ / 2 röda fyrkanter och en gratis square
Serial.Print ("hittades en rad där uppenbara!"); Serial.Print(x); Serial.println(y);
playPoss (x, y);
}
}
Poss = 0;
x = 0;
y = 0;
Space = 0;
} < /P >< p > / / Kontrollera kolumner - samma som för rader men "för" slingorna har återförts för att gå till kolumner
för (int jag = 0; jag < 3; i ++) {
för (int j = 0; j < 3; j ++) {
om (gamePlay [j] [i] == 2) {
Poss + = 1;
}
om (gamePlay [j] [i] == 0) {
Space = 1;
x = j;
y = i.
}
om ((poss == 2) & & (utrymme == 1) & & (spelade == 0)) {/ / Detta tid också kontrollera om vi har redan spelat
Serial.Print ("hittades en uppenbart kolumn!"); Serial.Print(x); Serial.println(y);
playPoss (x, y);
}
}
Återställ variabler
Poss = 0;
x = 0;
y = 0;
Space = 0;
} < /P >< p > / / kolla kors - som för rader och kolumner men "för" loopar förändrats
Kolla diagonal övre vänstra till nedre högra
för (int jag = 0; jag < 3; i ++) {
om (gamePlay [i] [i] == 2) {
Poss + = 1;
}
om (gamePlay [i] [i] == 0) {
Space = 1;
x = i.
y = i.
}
om ((poss == 2) & & (utrymme == 1) & & (spelade == 0)) {
Serial.Print ("hittades en uppenbart kors!"); Serial.Print(x); Serial.println(y);
playPoss (x, y);
}
}
Återställ variabler
Poss = 0;
x = 0;
y = 0;
Space = 0;
Check diagonalt upp till höger till längst ner till vänster
int rad = 0; Används för att räkna raderna
för (int jag = 2; jag > = 0; i--) {/ / vi räkna ner kolumnerna
om (gamePlay [rad] [i] == 2) {
Poss + = 1;
}
om (gamePlay [rad] [i] == 0) {
Space = 1;
x = rad;
y = i.
}
om ((poss == 2) & & (utrymme == 1) & & (spelade == 0)) {
Serial.Print ("hittades en uppenbart kors!"); Serial.Print(x); Serial.println(y);
playPoss (x, y);
}
rad + = 1; Ökar värdet för räknaren rad
}
Återställ variabler
Poss = 0;
x = 0;
y = 0;
Space = 0;
} < /p >< p > void checkBlockers() {
Som för checkPossibilites() men denna gång kontrollera spelare kvadraterna för ställen att blockera en rad tre
Serial.println ("Kontrollera möjligheter att blockera...");
int poss = 0;
int x = 0;
int y = 0;
int utrymme = 0;
Kolla rader
för (int jag = 0; jag < 3; i ++) {
för (int j = 0; j < 3; j ++) {
om (gamePlay [i] [j] == 1) {
Poss + = 1;
}
om (gamePlay [i] [j] == 0) {
Space = 1;
x = i.
y = j;
}
om ((poss == 2) & & (utrymme == 1) & & (spelade == 0)) {
Serial.Print ("hittades en rad där blocker!"); Serial.Print(x); Serial.println(y);
playPoss (x, y);
}
}
Poss = 0;
x = 0;
y = 0;
Space = 0;
} < /P >< p > / / Kontrollera kolumner
för (int jag = 0; jag < 3; i ++) {
för (int j = 0; j < 3; j ++) {
om (gamePlay [j] [i] == 1) {
Poss + = 1;
}
om (gamePlay [j] [i] == 0) {
Space = 1;
x = j;
y = i.
}
om ((poss == 2) & & (utrymme == 1) & & (spelade == 0)) {
Serial.Print ("hittades en blockerare kolumn!"); Serial.Print(x); Serial.println(y);
playPoss (x, y);
}
}
Poss = 0;
x = 0;
y = 0;
Space = 0;
} < /P >< p > / / kolla kors
för (int jag = 0; jag < 3; i ++) {
om (gamePlay [i] [i] == 1) {
Poss + = 1;
}
om (gamePlay [i] [i] == 0) {
Space = 1;
x = i.
y = i.
}
om ((poss == 2) & & (utrymme == 1) & & (spelade == 0)) {
Serial.Print ("hittades en blockerare kors!"); Serial.Print(x); Serial.println(y);
playPoss (x, y);
}
}
Poss = 0;
x = 0;
y = 0;
Space = 0;
int rad = 0;
för (int jag = 2; jag > = 0; i--) {
om (gamePlay [rad] [i] == 1) {
Poss + = 1;
}
om (gamePlay [rad] [i] == 0) {
Space = 1;
x = rad;
y = i.
}
om ((poss == 2) & & (utrymme == 1) & & (spelade == 0)) {
Serial.Print ("hittades en blockerare kors!"); Serial.Print(x); Serial.println(y);
playPoss (x, y);
}
rad + = 1;
}
Poss = 0;
x = 0;
y = 0;
Space = 0;
} < /p >< p > void randomPlay() {
Ingen vinst eller blockera att spela... Låt oss bara plocka en kvadrat på måfå
Serial.println ("du väljer slumpmässigt...");
int val = random (1, squaresLeft); Vi hämtar ett nummer från 0 till antalet rutor kvar i styrelsen
Serial.Print ("Arduino väljer"); Serial.println(Choice);
int pos = 1; Lagrar gratis torget vi är för närvarande på
för (int jag = 0; jag < 3; i ++) {
för (int j = 0; j < 3; j ++) {
om (gamePlay [i] [j] == 0) {/ / kontrollera för att se om fyrkantig tomt
om (pos == val) {/ / spela Tom torget som motsvarar att slumptal
playPoss (i, j);
}
POS + = 1; Ökar värdet för räknaren gratis square
}
}
}
} < /p >< p > void playPoss (int x, int y) {
Simulera tanken och sedan spela upp valt kvadrat
int delayStop = millis() + arduinoDelay;
medan (millis() < delayStop) {
Charlie.loop();
}
charlie.setLed (röd [x] [y], true);
gamePlay [x] [y] = 2; Uppdatera spelet matrisen
spelade = 1; Observera att vi har spelat
} < /p >< p > void checkGame() {
När spelet på en vinnare
Kontrollera om spelaren har vunnit
Serial.println ("kontrollera för en vinnare");
int spelare = 1;
int vinnare = 0;
för (int jag = 0; jag < 8; i ++) {/ / vi gå igenom alla vinnande kombinationer i 4D matrisen och kontrollera om de motsvarar det aktuella spelet
Kontrollera spelet
int winCheck = 0;
för (int j = 0; j < 3; j ++) {
för (int k = 0; k < 3; k ++) {
om ((win [i] [j] [k] == 1) & & (gamePlay [j] [k] == spelare)) {
winCheck + = 1;
}
}
}
om (winCheck == 3) {
vinnare = 1;
Serial.Print ("spelaren vann spelet"); Serial.println(i);
endGame(1);
}
}
Gör samma sak att kontrollera om Arduino har vunnit
Player = 2;
vinnare = 0;
för (int jag = 0; jag < 8; i ++) {
Kontrollera spelet
int winCheck = 0;
för (int j = 0; j < 3; j ++) {
för (int k = 0; k < 3; k ++) {
om ((win [i] [j] [k] == 1) & & (gamePlay [j] [k] == spelare)) {
winCheck + = 1;
}
}
}
om (winCheck == 3) {
vinnare = 1;
Serial.Print ("Arduino vann spelet"); Serial.println(i);
endGame(2);
}
}
om (squaresLeft == -1) {
endGame(0);
}
} < /p >< p > void printGame() {
Skriver ut spelet till seriell bildskärmen
för (int jag = 0; jag < 3; i ++) {
för (int j = 0; j < 3; j ++) {
Serial.Print(gamePlay[i][j]); Serial.Print("");
}
Serial.println("");
}
Serial.Print(squaresLeft); Serial.println ("rutor kvar");
} < /p >< p > void endGame (int vinnare) {
Anropas när en vinnare finns
Växla (vinnare) {
fall 0:
Serial.println ("det är oavgjort");
charlie.setLed (greenWin, true);
charlie.setLed (redWin, true);
bryta;
fall 1:
Serial.println ("spelaren vinner");
charlie.setLed (greenWin, true);
bryta;
fall 2:
Serial.println ("Arduino vinner");
charlie.setLed (redWin, true);
bryta;
}
medan (digitalRead(resetButton) == låg) {
Charlie.loop();
}
initialise();
} < /p >