Arduino - Klaverfliser: 16 trin (med billeder)

2024 Forfatter: John Day | [email protected]. Sidst ændret: 2024-01-30 08:28

Hej internetfolk, Det her handler om, hvordan man laver det, der DEFINITIVT ikke er et rip off af et mobilspil på en arduino uno r3.

så til at begynde med får du brug for alle dele, som er som følger! 1x Arduino Uno r3 ($ 42)

2x LCD -tastaturskærm ($ 19 pr. Stk.)

5x knapper

5x 220Ω modstande

28x ledninger

Okay, når du har fået alle delene, er det tid til at komme i gang!

Trin 1: Ledningsføring

Begynd med at tilslutte din arduino og venner som vist i diagrammet, Sørg for, at knapperne er forbundet den rigtige vej rundt med A0-4-åbningerne på bundskærmen på knapskinnerne, eller arduinoen vil i stedet tro, at knapperne holdes nede konstant i stedet for kun ved et tryk.

Trin 2: Erklæringserklæringer

Al kode her skal gå før dit hulrumsopsætning og tomrumsløjfe, det er fordi alle disse variabler og objekter bruges i flere af de funktioner, vi vil oprette.

Start med at sætte:

#omfatte

øverst i din kode fortæller dette arduinoen at bruge biblioteket "LiquidCrystal.h" og de funktioner, der er en del af det.

Det næste trin er at definere de ben, vi bruger til vores knapper ved at sætte denne kode under vores #include:

#define btnEnter A0 #define btn1 15 #define btn2 16 #define btn3 17 #define btn4 18

Vi definerer udtrykkene btnEnter og btn1 til btn 4 for at gøre koden lettere for os at læse, eller ændre om nødvendigt. Det betyder, at når vi skriver btn1, vil arduinoen vide, at vi faktisk mener knappen 15. Selvom vi kalder portene 15, 16, 17 og 18, er de mærket på arduinoen som A1 A2 A3 og A4, men det er fordi de er porte, der specifikt bruges til analoge indgange, selvom vi kun bruger dem til digitale indgange.

Dernæst skal vi oprette de objekter, der skal styre Liquid Crystal Displays. For at gøre dette skal du sætte denne kode under vores definitioner

LiquidCrystal lcdLeft (8, 9, 12, 10, 11, 13); LiquidCrystal lcdRight (2, 3, 4, 5, 6, 7);

Hvad dette gør, fortæller arduinoen, at når vi kalder lcdLeft eller lcdRight, henviser vi til et LiquidCrystal -objekt. Tallene i de vedhæftede parenteser fortæller arduinoen, hvilken port objektet skal bruge til at sende meddelelser til LCD, når vi bruger deres funktioner.

Nu skal vi deklarere variablerne ved at sætte den næste bit kode under objektdeklarationerne:

// disse variabler er muligheder, som du kan ændre - højere tal = hurtigere spilhastighed upint intGameSpeedEasy = 10; int intGameSpeedMedium = 25; int intGameSpeedHard = 80;

// opsæt variabler til den gameboolske bolPlay; // spor, hvis spilleren int intScore; // sporer spillerens score int intDiff; // bare en æstetisk ting til at fortælle, hvor svært spillet er på // konfigurere variabler til input int intEnter; // sporer, hvis brugeren trykker på enter -knappen int intInput; // sporer hvilke knapper brugeren trykker på boolean bolTilePressed; // sikre, at afspilleren ikke ved et uheld trykker på en knap 5x og taber // konfigurer variabler for turn int intTick; // tæller millies (pr. loop) op til intDelay int intDelay; // den tid programmet venter til den næste tur i millis int intGameSpeed; // abit of debug options boolean bolSerialBoard; // når true udskriver kortet i den serielle skærm

Vi erklærer en variabel ved at angive datatypen og derefter variabelens navn, f.eks. int thisIsAnInteger

Boolske variabler, f.eks. BolSerialBoard og bolPlay, kan kun have en af to værdier, sand eller falsk.

Heltalvariabel (int) som intScore og intInput kan tage hele tal som værdier, f.eks. 1, 5 eller 100.

Nogle andre bemærkelsesværdige datatyper, som vi ikke bruger her, er en streng, som er en klump tekst og en float, som er et decimaltal.

Hver af variablerne her bruges på flere forskellige steder af programmet, her er en oversigt over, hvad hver enkelt gør

bolPlay fortæller programmet, om menuen skal vises, eller om det egentlige spil skal køre.

intScore sporer spillerens score, når de rammer fliser, intDiff bruges i hovedmenuen til at fortælle programmet, hvilken bit tekst der skal udskrives på LCD'erne, intEnter bruges til at fortælle programmet, om der trykkes på enter -knappen (længst til venstre), intInput bruges til at fortælle programmet, hvilken af de andre 4 knapper der trykkes på.

bolTilePressed bruges til at sikre, at programmet kun læser videre, når der trykkes på knappen, og ikke når det holdes nede.

intGameSpeed, intGameSpeedEasy, intGameSpeedMedium og intGameSpeedHard bruges til at styre, hvor hurtigt spillet skal fremskynde baseret på hvilken sværhedsgrad der vælges.

intTick og intDelay bruges til at stoppe programmet fra at flytte kortet hver gang det går i loop.

bolSerialBoard bruges til at give dig mulighed for at få programmet til at sende kortet til arduinoens serielle skærm som en række numre til testformål.

Endelig er det tid til at erklære vores board som et array ved hjælp af denne kode:

// opsæt game arrayint arrGame [16] [4] = {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}};

En matrix er en matrix, som ethvert punkt, som kan kaldes til matematik eller skal ændres.

Din kode skal nu se sådan ud;

// inkludere biblioteker#inkludere

// disse variabler er muligheder, som du kan ændre - højere tal = hurtigere spilhastighed

int intGameSpeedEasy = 10; int intGameSpeedMedium = 25; int intGameSpeedHard = 80;

// Definer stifter

#define btnEnter A0 #define btn1 15 #define btn2 16 #define btn3 17 #define btn4 18

// opret LCD -objekter (n, ~, n, ~, ~, n)

LiquidCrystal lcdLeft (8, 9, 12, 10, 11, 13); LiquidCrystal lcdRight (2, 3, 4, 5, 6, 7);

// opsæt spilarray

int arrGame [16] [4] = {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}};

// opsæt variabler til spillet

boolsk bolPlay; // spor, hvis spilleren int intScore; // sporer spillerens score int intDiff; // bare en æstetisk ting til at fortælle, hvor svært spillet er

// opsæt variabler til input

int intEnter; // sporer, hvis brugeren trykker på enter -knappen int intInput; // sporer hvilke knapper brugeren trykker på boolean bolTilePressed; // sikre, at spilleren ikke ved et uheld trykker på en knap 5x og taber

// opsæt variabler til tur

int intTick; // tæller millies (pr. loop) op til intDelay int intDelay; // den tid programmet venter til den næste tur i millis int intGameSpeed;

// abit af fejlfindingsmuligheder

boolsk bolSerialBoard; // når true udskriver kortet i den serielle skærm

Trin 3: Opsætningsfunktionen

Setup loop er en funktion, der læses af arduinoen kun én gang, når den oprindeligt starter.

I opsætningsløkken sætter vi bare værdierne for et par af vores variabler, fordi vi i stedet for at sætte dem en værdi, når vi erklærer dem, gør det her.

Begynd med at sætte denne kode i dit ugyldige setup.

bolPlay = false; intScore = 0; intTick = 0; intDelay = 1000; intDiff = 1; intGameSpeed = intGameSpeedMedium;

Hver linje sætter bare en variabel til en værdi.

bolPlay er sat til falsk, så spillet ikke begynder at spille.

intScore er sat til 0, fordi din score naturligvis starter på 0.

intTick starter ved 0, fordi programmet i øjeblikket ikke tæller noget.

intDelay er sat til 1000, fordi det er den hastighed fliserne starter med.

intDiff er bare en asketisk ting, så programmet ved, hvad man skal skrive for spillets vanskeligheder.

intGameSpeed er indstillet til, hvad intGameSpeedMedium er, hvilket betyder, at det er indstillet til medium sværhedsgrad.

Sæt derefter denne kode i den ugyldige opsætning under den kode, du lige har indsat.

lcdLeft.begin (16, 2); lcdRight.begin (16, 2);

Serial.begin (9600);

Dette fortæller arduinoen at begynde at kommunikere med computeren via den serielle skærm (synlig ved at klikke på knappen øverst til højre i arduino IDE).

Din ugyldige opsætning skal nu se sådan ud!

ugyldig opsætning () {Serial.begin (9600); // start den serielle skærm // opsæt variablerne bolPlay = false; intScore = 0; intTick = 0; intDelay = 1000; intDiff = 1; intGameSpeed = intGameSpeedMedium; // begynde lcd's lcdLeft.begin (16, 2); lcdRight.begin (16, 2); }

Trin 4: Loop -funktionen

Loop -funktionen drives af arduino hver iteration af arduinoen.

Kopier følgende kode til din Void Loop.

void loop () {input (); // tjek for afspilningsinput, hvis (bolPlay == true) {if (intTick> = intDelay) {// kontroller, om spillet skal spille en omgang, eller fortsæt med at vente Serial.println ("~~~~~~~ ~~ "); // udskriv for at angive, at kortet går videre // writeSerial (); // hvis indstillingen er aktiveret, skriv tavlen ind i serielle knapperGame (); // tjek for spillerindgange playBoard (); // flyt tavlen og tilføj en ny flise clearLcd (); // rengør LCD -skærmene, før du tegner drawBoard (); // træk tavlen ind på lcd'ens bundCheck (); intTick = 0; // reset intTick} else {buttonsGame (); // tjek for spillerindgange clearLcd (); // rengør LCD -skærmene, før du tegner drawBoard (); // træk tavlen ind på lcd'ens intTick = intTick + intGameSpeed; // tilføj til kryds}} else {clearLcd (); // rengør LCD -skærmene, før du tegner titel (); // vis titel og score info knapperMenu (); // læs afspillerindgang clearBoard (); // sikre hele kortet = 0} forsinkelse (10); // forsink arduinoen med et kort øjeblik}

når bolPlay er lig med sand betyder det, at spillet spiller, og al koden til, når spillet skal spilles, skal køres, men vi ønsker kun, at brættet tilføjer en ny flise og flytter ned, når intTick er større end vores intDelay, ellers vil vi stadig tillade brugeren at trykke på en knap for at ramme en flise og for intTick at stige i hastighed.

Det meste af denne kode bruger funktioner, vi endnu ikke skal lave, og vi vil lave dem i de næste trin. Formålet med disse funktioner er som følger.

Input læser, hvilke knapper brugeren har trykket på.

buttonsGame styrer, hvad knapperne gør, når de er i spillet og ikke i menuen

playBoard tilføjer en ny flise til brættet og flytter derefter alt i brættet ned et mellemrum

clearLCD renser LCD'erne for at sikre, at ingen spøgelser efterlades bag fliserne

drawBoard går gennem arrGame og udskriver det på LCD'erne

clearBoard sletter hele arrGame, når spillet ikke er i spil

bottomCheck kontrollerer bunden af arrGame for en fejltilstand

titel viser spillets titel og scoreoplysninger, når de er i menuen

knapperne menu styrer, hvad brugerens input gør i menuen.

gameOver er en anden funktion, selvom den ikke kaldes her, som den i stedet kaldes i bunden Check og knapper Spilfunktioner.

Trin 5: ClearLCD -funktionen

for at oprette en funktion starter vi med at tilføje dette til koden

void functionName () {

}

"funktionsnavn" kan være hvad som helst, så længe det ikke allerede findes.

Kopier denne kode til dit program:

void clearLcd () {for (int i = 0; i <= 15; i ++) {for (int ii = 0; ii <= 1; ii ++) {lcdLeft.setCursor (i, ii); lcdLeft.write (""); lcdRight.setCursor (i, ii); lcdRight.write (""); }}}

dette løber gennem hele arrayet ved at bruge 2 tællede sløjfer til at gå gennem hvert punkt på LCD'erne og skrive et mellemrum.

Uden at blive nulstillet til ingenting vil LCD'erne opretholde det, der tidligere blev skrevet

Trin 6: DrawBoard -funktionen

kopier denne kode til dit program

void drawBoard () {for (int i = 1; i <= 15; i ++) {// draw collums 1 and 2 on the left LCD // if the tile = 0 write nothing, = 1 write "#", = 2 skriv "@" lcdLeft.setCursor (i, 1); // indstillet til den første kolonne (længst til venstre) hvis (arrGame [0] == 1) {lcdLeft.write ("#");} if (arrGame [0] == 2) {lcdLeft.write ("@");} lcdLeft.setCursor (i, 0); // indstil til den anden kolonne (i midten til venstre) hvis (arrGame [1] == 1) {lcdLeft.write ("#");} if (arrGame [1] == 2) {lcdLeft.write ("@");} lcdRight.setCursor (i, 1); // indstil til den tredje kolonne (i midten til højre) hvis (arrGame [2] == 1) {lcdRight.write ("#");} if (arrGame [2] == 2) {lcdRight.write ("@");} lcdRight.setCursor (i, 0); // indstil til fjerde kolonne (længst til højre) hvis (arrGame [3] == 1) {lcdRight.write ("#");} if (arrGame [3] == 2) {lcdRight.write ("@");}}}

dette bruger en sløjfe til at gå gennem hver række af brættet, det kontrollerer derefter om en kolonne i rækken er lig med 1 eller 2, baseret på at den derefter udskriver på LCD'et enten en hashtag, for at en flise endnu ikke skal være hit eller en @ for en hitflise.

Trin 7: PlayBoard -funktionen

kopier denne kode til dit program.

void playBoard () {for (int i = 0; i <= 3; i ++) {arrGame [0] = 0;} // ryd den øverste række arrGame [0] [random (0, 4)] = 1; // indstil et tilfældigt punkt på den øverste række til at være en flise for (int i = 15; i> = 1; i-) {// arbejde fra bunden af brættet til toppen for (int ii = 0; ii <= 3; ii ++) {// for hver collum arrGame [ii] = arrGame [i - 1] [ii]; }}}

denne kode begynder med at rydde hele den øverste række til 0, eller ingen flise, og sætter derefter en tilfældig flise til at være en 1, og uhit flise.

Det går derefter gennem en talt sløjfe i omvendt, fra 15 til 1, og sætter rækken til at være lig med uanset rækken over den er lig med, hvilket får tavlen til at bevæge sig ned ad LCD'erne

Trin 8: ClearBoard -funktionen

kopier denne kode til dit program.

void clearBoard () {// nulstil kryds og forsink værdier intTick = 0; intDelay = 1000; // gå gennem tavlen og sæt alt til 0 for (int i = 0; i <= 15; i ++) {for (int ii = 0; ii <= 3; ii ++) {arrGame [ii] = 0; }}}

Denne kode køres, når spillet ikke spiller for at sikre, at hele arrGame er indstillet til 0, eller ingen brikker, ved at bruge tællede sløjfer til at gå gennem arrayet.

Koden nulstiller også værdierne for intDelay og intTick.

Trin 9: Titelfunktionen

kopier følgende kode til dit program

void title () {// skriv titel på LCD og plads til score lcdRight.setCursor (0, 0); lcdRight.write ("klaverfliser"); lcdRight.setCursor (0, 1); lcdRight.write ("Score:"); // konverter partituret til en string char strScore [3]; sprintf (strScore, "%d", intScore); // vis score på LCD lcdRight.write (strScore); // tilføj diffictuly lcdRight.setCursor (10, 1); hvis (intDiff == 0) {lcdRight.write ("Let"); } hvis (intDiff == 1) {lcdRight.write ("Medium"); } hvis (intDiff == 2) {lcdRight.write ("Hard"); } // Tryk på en lille smule instruktion lcdLeft.setCursor (0, 0); lcdLeft.write ("Tryk på Enter"); lcdLeft.setCursor (0, 1); lcdLeft.write ("at begynde!"); }

Denne kode skriver titlen på spillet og partituret på LCD'erne, det gør det ved at fortælle LCD'en, hvor man skal begynde at skrive ved hjælp af LCD.setCursor og derefter skrive strengen i LCD.write.

En ny variabel oprettes også her, strScore, den bruges til at konvertere intScore til en streng- eller char -datatype ved hjælp af sprintf -funktionen.

intDiff bruges også her, baseret på dets værdier udskriver det de forskellige sværhedsgrader.

Trin 10: ButtonsMenu -funktionen

indsæt følgende kode i dit program

void buttonsMenu () {// når der trykkes på enter, start spillet og nulstil scoreværdien, hvis (intEnter == 1) {bolPlay = true; intScore = 0; playBoard (); drawBoard (); } // når der trykkes på knap 3, skal du slå fejlfinding til ved at udskrive kortet i serie hvis (intInput == 3) {if (bolSerialBoard == false) {Serial.println ("Serial Board Active"); bolSerialBoard = true; } else {Serial.println ("Serial Board deaktiveret"); bolSerialBoard = false; }} // indstil spilhastighed til let vanskeligheder, hvis (intInput == 0) {Serial.print ("Game set to easy ("); Serial.print (intGameSpeedEasy); Serial.println ("ms acceleration)"); intDiff = 0; intGameSpeed = intGameSpeedEasy; } // indstil spilhastighed til medium sværhedsgrad, hvis (intInput == 1) {Serial.print ("Spil indstillet til medium ("); Serial.print (intGameSpeedMedium); Serial.println ("ms acceleration)"); intDiff = 1; intGameSpeed = intGameSpeedMedium; } // indstil spilhastighed til svær vanskelighed, hvis (intInput == 2) {Serial.print ("Game sat til hard ("); Serial.print (intGameSpeedHard); Serial.println ("ms acceleration)"); intDiff = 2; intGameSpeed = intGameSpeedHard; }}

denne kode køres kun, når bolPlay er lig med falsk i tomrumsløkken

hvis intEnter er indstillet til 1 betyder det, at enter -knappen er blevet skubbet, hvis der trykkes på den, sætter programmet bolPlay til true, og spillet starter.

Programmet læser derefter, hvad intInput er lig med. hvis den er lig med 0, trykkes der på den første knap fra venstre og går op til højre op til 3. Hvis intInput er lig med 4, trykkes der ikke på en knap.

hvis der trykkes på knapperne 0-2, ændrer spillet sværhedsgraden og justerer også spilhastighedsværdien, hvilket betyder, at det vil accelerere hurtigere.

Hvis der trykkes på knap 3, aktiverer eller deaktiverer spillet en fejlfindingstilstand, hvor hele kortet er udskrevet i den serielle skærm for at hjælpe med at finde problemer i programmet.

Trin 11: ButtonsGame -funktionen

kopier følgende kode til dit program

void buttonsGame () {if (intInput! = 4) {// hvis der trykkes på en knap, hvis (bolTilePressed == false) {// kun hvis bolTilePressed er en falsk udløserhandling for at kontrollere et knaptryk bolTilePressed = true; // sæt derefter bolTilePressed til true for at sikre, at det ikke ved et uheld udløses igen int intLowestTile = 0; // skal indstilles til flisen med den laveste flise int intCheckedTile = 15; // for at holde styr på, hvilke fliser der er blevet kontrolleret, mens (intLowestTile == 0) {// så længe det ikke er indstillet til noget, tjek fliser for (int i = 0; i 100) {// så længe int forsinkelse er ikke lavere end 100 intDelay = intDelay - 20; // tag en værdi fra det}} else {Serial.println ("Forkerte knap trykket"); gameOver (); // ellers er spillet slut}}}}}

Koden køres kun, når bolPlay er lig med sand i tomrumsløkken.

Ligesom knapper Meny baseret på værdien af intInput kontrollerer den, om spilleren har ramt en flise eller savnet en.

Det gør dette ved at gå gennem arrGame fra bund til top ved hjælp af en while -sløjfe for at lede efter hvilken række, der er den laveste med en unhit -flise. Det kontrollerer derefter, om stedet i den række, der svarer til knappen, der er skubbet, er en unhit -flise eller ej, hvis den er unhit, sætter den den til 2 i stedet for 1, hvilket betyder, at den vises som en @, ellers udløser det gameOver funktion, som vi endnu ikke skal skabe.

Denne funktion udnytter også variablen bolTilePressed ved at indstille den til sand, når der trykkes på en knap og falsk, når der ikke trykkes på en knap. Dette er for at sikre, at brugeren ikke ved et uheld mister spillet, fordi programmet troede, at de trykkede på knappen flere gange, da de holdt det nede.

Trin 12: GameOver -funktionen

Kopier følgende kode til dit program

void gameOver () {Serial.println ("Game Over!"); Serial.print ("Din score var:"); Serial.println (intScore); Serial.print ("Din hastighed var:"); Serial.println (intDelay); bolPlay = falsk; }

Dette udløses af enten checkBottom eller buttonsGame -funktionerne og udløser slutningen af spillet ved at indstille bolPlay til at være falsk.

Det udskriver også en besked i den serielle skærm for brugernes score, og hastighedsfliserne blev tilføjet i millisekunder.

Trin 13: Inputfunktionen

Kopier følgende kode til dit program.

void input () {intEnter = digitalRead (btnEnter); // læs enter // læs hvilken af de andre input, eller hvis ingen er sat til 4 if (digitalRead (btn1) == HIGH) {intInput = 0;} else {if (digitalRead (btn2) == HIGH) {intInput = 1;} else {if (digitalRead (btn3) == HIGH) {intInput = 2;} else {if (digitalRead (btn4) == HIGH) {intInput = 3;} else {intInput = 4; }}}}} // seriel udskriv inputene (if (intEnter == 1) {Serial.println ("Enter Pressed!");} if (intInput! = 4) {Serial.print ("Button Press:"); Serial.println (intInput); } ellers {// hvis der ikke trykkes på en knap, nulstill bolTilePressed bolTilePressed = false; }}

Denne kode bruges sammen med knapperne Spil og knapper Menufunktioner. baseret på de knapper, brugeren har trykket på, indstiller den værdien af intInput, eller hvis der ikke trykkes på en knap, indstiller den intInput til 4.

Hvis der ikke trykkes på en knap, nulstilles bolTilePressed for knapperneGame -funktionen.

Det udskriver også en meddelelse til den serielle skærm, hvorpå der trykkes på knappen.

Trin 14: BottomCheck -funktionen

kopier følgende kode til dit program.

void bottomCheck () {for (int i = 0; i <= 3; i ++) {// for de 4 kolonner, hvis (arrGame [15] == 1) {// hvis en flise er nederst i serienummeret.println ("Flise nederst"); arrGame [15] = 2; drawBoard (); forsinkelse (400); arrGame [15] = 1; drawBoard (); forsinkelse (400); arrGame [15] = 2; drawBoard (); forsinkelse (400); arrGame [15] = 1; drawBoard (); forsinkelse (400); gameOver (); }}}

ved hjælp af en loop kontrollerer denne kode den nederste række af arrGame for eventuelle unhit -brikker (brikker svarende til 1), hvis der er en unhit -flise i bunden af skærmen, vil den blinke flisen og derefter udløse game over -funktionen.

Trin 15: WriteSerial -funktionen

kopier følgende kode til dit program

void writeSerial () {if (bolSerialBoard == true) {for (int i = 0; i <= 15; i ++) {for (int ii = 0; ii <= 3; ii ++) {Serial.print (arrGame [ii]); Serial.print (","); } Serial.println (""); }}}

Dette er funktionen efterfulgt af fejlfindingsindstillingen, der kan aktiveres i knapperneMenu -funktion. Hvis bolSerialBoard er indstillet til sand i denne funktion, går det gennem arrGame og udskriver hele kortet på den serielle skærm til testformål ved hjælp af en matrix.

Trin 16: Afslutning

Hele din kode bør ikke være komplet og se sådan ud!

/ * * Navn - Klaverfliser; Arduino * Af - Domenic Marulli * Dato - 11/ *

/ omfatte biblioteker

#omfatte

// disse variabler er muligheder, som du kan ændre - højere tal = hurtigere spilhastighed

int intGameSpeedEasy = 10; int intGameSpeedMedium = 25; int intGameSpeedHard = 80;

// Definer stifter

#define btnEnter A0 #define btn1 15 #define btn2 16 #define btn3 17 #define btn4 18

// opret LCD -objekter (n, ~, n, ~, ~, n)

LiquidCrystal lcdLeft (8, 9, 12, 10, 11, 13); LiquidCrystal lcdRight (2, 3, 4, 5, 6, 7);

// opsæt spilarray

int arrGame [16] [4] = {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}};

// opsæt variabler til spillet

boolsk bolPlay; // spor, hvis spilleren int intScore; // sporer spillerens score int intDiff; // bare en æstetisk ting til at fortælle, hvor svært spillet er

// opsæt variabler til input

int intEnter; // sporer, hvis brugeren trykker på enter -knappen int intInput; // sporer hvilke knapper brugeren trykker på boolean bolTilePressed; // sikre, at spilleren ikke ved et uheld trykker på en knap 5x og taber

// opsæt variabler til tur

int intTick; // tæller millies (pr. loop) op til intDelay int intDelay; // den tid programmet venter til den næste tur i millis int intGameSpeed;

// abit af fejlfindingsmuligheder

boolsk bolSerialBoard; // når true udskriver kortet i den serielle skærm

// opsætningen, der køres en gang

ugyldig opsætning () {Serial.begin (9600); // start den serielle skærm // opsæt variablerne bolPlay = false; intScore = 0; intTick = 0; intDelay = 1000; intDiff = 1; intGameSpeed = intGameSpeedMedium; // begynde lcd's lcdLeft.begin (16, 2); lcdRight.begin (16, 2); }

// sløjfen, der køres hver 10. millisekon

void loop () {input (); // tjek for afspilningsinput, hvis (bolPlay == true) {if (intTick> = intDelay) {// kontroller, om spillet skal spille en omgang, eller fortsæt med at vente Serial.println ("~~~~~~~ ~~ "); // udskriv for at angive, at kortet går videre // writeSerial (); // hvis indstillingen er aktiveret, skriv tavlen ind i serielle knapperGame (); // tjek for spillerindgange playBoard (); // flyt tavlen og tilføj en ny flise clearLcd (); // rengør LCD -skærmene, før du tegner drawBoard (); // træk tavlen ind på lcd'ens bundCheck (); intTick = 0; // reset intTick} else {buttonsGame (); // tjek for spillerindgange clearLcd (); // rengør LCD -skærmene, før du tegner drawBoard (); // træk tavlen ind på lcd'ens intTick = intTick + intGameSpeed; // tilføj til kryds}} else {clearLcd (); // rengør LCD -skærmene, før du tegner titel (); // vis titel og score info knapperMenu (); // læs afspillerindgang clearBoard (); // sikre hele kortet = 0} forsinkelse (10); // forsink arduinoen med et kort øjeblik}

// renser lcd'en, så eventuelle ikke -indtastede celler ikke efterlades der

void clearLcd () {for (int i = 0; i <= 15; i ++) {for (int ii = 0; ii <= 1; ii ++) {lcdLeft.setCursor (i, ii); lcdLeft.write (""); lcdRight.setCursor (i, ii); lcdRight.write (""); }}}

// tegner tavlen ind på lcd'erne

void drawBoard () {for (int i = 1; i <= 15; i ++) {// draw collums 1 and 2 on the left LCD // if the tile = 0 write nothing, = 1 write "#", = 2 skriv "@" lcdLeft.setCursor (i, 1); // indstillet til den første kolonne (længst til venstre) hvis (arrGame [0] == 1) {lcdLeft.write ("#");} if (arrGame [0] == 2) {lcdLeft.write ("@");} lcdLeft.setCursor (i, 0); // indstil til den anden kolonne (i midten til venstre) hvis (arrGame [1] == 1) {lcdLeft.write ("#");} if (arrGame [1] == 2) {lcdLeft.write ("@");} lcdRight.setCursor (i, 1); // indstil til den tredje kolonne (i midten til højre) hvis (arrGame [2] == 1) {lcdRight.write ("#");} if (arrGame [2] == 2) {lcdRight.write ("@");} lcdRight.setCursor (i, 0); // indstil til fjerde kolonne (længst til højre) hvis (arrGame [3] == 1) {lcdRight.write ("#");} if (arrGame [3] == 2) {lcdRight.write ("@");}}}

// flytter tavlen ned og placerer en tilfældig værdi som en flise

void playBoard () {for (int i = 0; i <= 3; i ++) {arrGame [0] = 0;} // ryd den øverste række arrGame [0] [random (0, 4)] = 1; // indstil et tilfældigt punkt på den øverste række til at være en flise for (int i = 15; i> = 1; i-) {// arbejde fra bunden af brættet til toppen for (int ii = 0; ii <= 3; ii ++) {// for hver collum arrGame [ii] = arrGame [i - 1] [ii]; }}}

// indstiller hele tavlen til 0 og nulstiller variabler til forudspil

void clearBoard () {// nulstil kryds og forsink værdier intTick = 0; intDelay = 1000; // gå gennem tavlen og sæt alt til 0 for (int i = 0; i <= 15; i ++) {for (int ii = 0; ii <= 3; ii ++) {arrGame [ii] = 0; }}}

// viser hovedmenuen på LCD'erne

void title () {// skriv titel på LCD og plads til score lcdRight.setCursor (0, 0); lcdRight.write ("klaverfliser"); lcdRight.setCursor (0, 1); lcdRight.write ("Score:"); // konverter partituret til en string char strScore [3]; sprintf (strScore, "%d", intScore); // vis score på LCD lcdRight.write (strScore); // tilføj diffictuly lcdRight.setCursor (10, 1); hvis (intDiff == 0) {lcdRight.write ("Let"); } hvis (intDiff == 1) {lcdRight.write ("Medium"); } hvis (intDiff == 2) {lcdRight.write ("Hard"); } // Tryk på en lille smule instruktion lcdLeft.setCursor (0, 0); lcdLeft.write ("Tryk på Enter"); lcdLeft.setCursor (0, 1); lcdLeft.write ("at begynde!"); }

// tjekker knapperne, og hvad de skal gøre for dem, når de er ude af spillet

void buttonsMenu () {// når der trykkes på enter, start spillet og nulstil scoreværdien, hvis (intEnter == 1) {bolPlay = true; intScore = 0; playBoard (); drawBoard (); } // når der trykkes på knap 3, skal du slå fejlfinding til ved at udskrive kortet i serie hvis (intInput == 3) {if (bolSerialBoard == false) {Serial.println ("Serial Board Active"); bolSerialBoard = true; } else {Serial.println ("Serial Board deaktiveret"); bolSerialBoard = false; }} // indstil spilhastighed til let vanskeligheder, hvis (intInput == 0) {Serial.print ("Game set to easy ("); Serial.print (intGameSpeedEasy); Serial.println ("ms acceleration)"); intDiff = 0; intGameSpeed = intGameSpeedEasy; } // indstil spilhastighed til medium sværhedsgrad, hvis (intInput == 1) {Serial.print ("Spil indstillet til medium ("); Serial.print (intGameSpeedMedium); Serial.println ("ms acceleration)"); intDiff = 1; intGameSpeed = intGameSpeedMedium; } // indstil spilhastighed til svær vanskelighed, hvis (intInput == 2) {Serial.print ("Game sat til hard ("); Serial.print (intGameSpeedHard); Serial.println ("ms acceleration)"); intDiff = 2; intGameSpeed = intGameSpeedHard; }}

// kontrollerer knapperne, og hvad de skal gøre for dem, mens de er i spil

void buttonsGame () {if (intInput! = 4) {// hvis der trykkes på en knap, hvis (bolTilePressed == false) {// kun hvis bolTilePressed er falsk triggerhandling for at kontrollere et knap tryk bolTilePressed = true; // sæt derefter bolTilePressed til true for at sikre, at det ikke ved et uheld udløses igen int intLowestTile = 0; // skal indstilles til flisen med den laveste flise int intCheckedTile = 15; // for at holde styr på, hvilke fliser der er blevet kontrolleret, mens (intLowestTile == 0) {// så længe det ikke er indstillet til noget, tjek fliser for (int i = 0; i 100) {// så længe int forsinkelse er ikke lavere end 100 intDelay = intDelay - 20; // tag en værdi fra det}} else {Serial.println ("Forkerte knap trykket"); gameOver (); // ellers er spillet slut}}}}}

void gameOver () {

Serial.println ("Game Over!"); Serial.print ("Din score var:"); Serial.println (intScore); Serial.print ("Din hastighed var:"); Serial.println (intDelay); bolPlay = falsk; }

// kontrollerer spillerens input

void input () {intEnter = digitalRead (btnEnter); // læs enter // læs hvilken af de andre input, eller hvis ingen er sat til 4 if (digitalRead (btn1) == HIGH) {intInput = 0;} else {if (digitalRead (btn2) == HIGH) {intInput = 1;} else {if (digitalRead (btn3) == HIGH) {intInput = 2;} else {if (digitalRead (btn4) == HIGH) {intInput = 3;} else {intInput = 4; }}}}} // seriel udskriv inputene (if (intEnter == 1) {Serial.println ("Enter Pressed!");} if (intInput! = 4) {Serial.print ("Button Press:"); Serial.println (intInput); } ellers {// hvis der ikke trykkes på en knap, nulstill bolTilePressed bolTilePressed = false; }}

// kontrollerer bunden af tavlen for fejl

void bottomCheck () {for (int i = 0; i <= 3; i ++) {// for de 4 kolonner, hvis (arrGame [15] == 1) {// hvis en flise er nederst i serienummeret.println ("Flise nederst"); arrGame [15] = 2; drawBoard (); forsinkelse (400); arrGame [15] = 1; drawBoard (); forsinkelse (400); arrGame [15] = 2; drawBoard (); forsinkelse (400); arrGame [15] = 1; drawBoard (); forsinkelse (400); gameOver (); }}}

// udskriver kortet ind i den serielle skærm, hvis bolSerialBoard er sandt

void writeSerial () {if (bolSerialBoard == true) {for (int i = 0; i <= 15; i ++) {for (int ii = 0; ii <= 3; ii ++) {Serial.print (arrGame [ii]); Serial.print (","); } Serial.println (""); }}}

Når al koden er indtastet, skal du uploade til din arduino og nyde!