SeaWolf tengeri szimulációs játék Arduino-ra

/* Seawolf game - Tengeri üldözéses szimulátor játék  v 0.9 beta
  Készítette: Szerzetes, 2018.06.19.
  Licenc megkötés: A program bármely része vagy egésze bármilyen célra szabadon felhasználható. A szerző feltüntetése nem kötelező, csak illendő :)

  A játék menete egy válaszható méretű négyzethálón játszódik (ez most 20*20). Maximum 4 darab hajó üldöz egy víz alatti felderítő tengeralattjárót, mely 3 különbözű féle mélységben
  közlekedhet. A pozícióját és a mélységet nem ismejük. Viszont minden körben a sonár jelzi, hogy milyen távolságban van tőlünk. Ez alapján kell megtalálni és
  hatástalanítani egy víz alatti bombával, mely csak akkor hatásos, ha eltaláljuk a mélységet. Egy pozíción csak egy hajó tartózkodhat. A hajók minden körben 1 egységet
  képesek mozogni bármelyik irányban. Ha nem találjuk el a célpont mélységét, akkor visszakerül a hajó az előző pozícióra, hogy egy másik hajó is tüzelhessen.
  A tengeralattjáró mélysége a játék kezdetétől fogva nem változik, kivéve a legnehezebb fokozatot.
  A tengeralattjáró kezdeti pozíciója nem lehet a bal alsó 10*10-es négyzetben.
  A nehézségi fokozatok a felderítő tengeralattjáró mozgásában különböznek:
  1 - A gyakorló módban nem mozog, csak helyben áll.
  2 - A könnyű módban csak 2 irányban halad, csak jobbar-balra, vagy csak le-fel, a pálya széléhez érve pedig ellenkező irányt vált.
  3 - A közepes fokozaton bármilyen irányban mozoghat és a pálya széléhez érve szintén bármilyen irányban haladhat tovább, de mindig csak egyenes vonalban.
  4 - A nehéz fokozatban legalább 3 körig egy irányban halad, után irányt változtathat.
  5 - A hardcore fokozatban bármikor irányt változtathat és csak ebben a fokozatban változtathat mélységet is.
  A hajók mindig a következő pozícióról indulnak:
  1. X=5, Y=0
  2. X=10, Y=0
  3. X=0, Y=5
  4. X=0, Y=10
  A hardver igény a következő:
    1 db 4*16-os I2C vezérlővel ellátott LCD kijelző
    1 db 4*4-es nyomógomb mátrix (elvileg elégséges a 3*4-es is, de a kijelzővel és I2C illesztővel együtt a HE Store-ból 4*4-es nyomógomb szerezhető be, ezért ez van használva)
 */
#include <Wire.h>
#include <LiquidCrystal_I2C.h> // https://bitbucket.org/fmalpartida/new-liquidcrystal/downloads

// A gombokhoz hozzárendelünk neveket. Az A,B,C,D,* és a 0 gombok nincsenek használva.
//  '1','2','3','A'
//  '4','5','6','B'
//  '7','8','9','C'
//  '*','0','#','D'

byte aa[8] = {    // Egyéni karakter definiálásához szükséges adatok. á karakter
  B00110,
  B00000,
  B01110,
  B00001,
  B11111,
  B10001,
  B01111,
};
byte ee[8] = {      // é
  B00110,
  B00000,
  B01110,
  B10001,
  B11111,
  B10000,
  B01110,
};
byte oo[8] = {      // ó
  B00110,
  B00000,
  B01110,
  B10001,
  B10001,
  B10001,
  B01110,
};

// Beállítjuk, hogy az I2C illesztő áramkör mely címen érhető el és az illesztő panelen található IC mely kivezetéseihez csatlakozik a kijelző:
//                    addr, en,rw,rs,d4,d5,d6,d7,bl,blpol
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE); // lcd néven létrehozunk egy úgynevezett objektumot. A továbbiakban lcd névre való hivatkozással érhetjük el a kijelzőt.

byte meret=20;    // A pálya mérete 20*20
byte szint,hajokszama,irany; // Sorban: nehézségi szint, a hajók száma, a tengeralattjáró iránya
byte minimumlepes=1;   // A minimum lépések száma magasabb nehézségi szinten, hogy mikortól lehetséges az irányváltoztatás és mélység változtatás
byte minimumlepes1=1;
int X1,Y1,tavolsag,Xe,Ye,tavolsage,lepes;   // Sorban: átmeneti koordináta tárolás, távolság érték, átmeneti koordináta tárolás, korábbi távolság érték, lépések számlálása
byte melyseg;   // Tengeralattjáró mélysége
// Az első elem a hajó száma, a második dimenzió 1-2 rekesze az x,y koordináta, 3-irány. Az 5. hajó a tengeralattjáró.
byte hajok[6][4] {      // A hajók koordinátáinak és irány érték adatainak tárolása
  {5,0,5,0},
  {10,0,5,0},
  {0,5,5,0},
  {0,10,5,0},
};
bool fut=0,Xhiba,Yhiba;   // Sorban: Elindulthat-e a játék, A tengaralattjáró következő pozíciója a pályán kívül van-e.
byte GOMB;      // A billentyűzet mátrix beolvasása utáni megynomott gomb értéke

void setup()   // SETUP: csak egyszer hajtódik végre az itteni programrész
{
  Serial.begin(115200);   // Soros monitor indítása
  Serial.println("Start"); // Jelezzük, hogy elindult a programunk
  pinMode(6,INPUT);     // A billentyűzet mátrixra csatlakozó portok beállítása
  pinMode(7,INPUT);     // A 6,7,8,9 a sorokra csatlakoznak
  pinMode(8,INPUT);     // Míg a 2,3,4,5 az oszlopokra
  pinMode(9,INPUT);
  pinMode(2,INPUT);
  pinMode(3,INPUT);
  pinMode(4,INPUT);
  pinMode(5,INPUT);
  digitalWrite(6,HIGH); // Ezeken a portokon olvassuk le a gombok állapotát. Bekapcsoljuk a felhúzó ellenállásokat
  digitalWrite(7,HIGH); // Így alap értékként magas szint lesz rajtuk.
  digitalWrite(8,HIGH); // A megnyomott gombok alacsony szinre állítják a megfelelő bemenetet.
  digitalWrite(9,HIGH);
  lcd.begin(16,4);   // LCD kijelző alaphelyzetbe állítása és típusának megadása. Jelen esetben 4 soros és soronként 16 karakteres.
  lcd.createChar(1, aa);  // Egyéni karakterek beállítása az LCD kijelző memóriájában
  lcd.createChar(2, ee);  // Ezt minden bekapcsoláskor újra kell írni, mivel a kijelző kikapcsolásakor törlődik.
  lcd.createChar(3, oo);

// A háttérvilágítás ki/be kapcsolása
// A kijelző fényének 3-szor gyors ki-be kapcsolásával jelezzük, hogy elindult a játék.
  for(int i = 0; i< 3; i++) // Egy for ciklus létrehozása: 3 paramétert kell megadni. Az elsőben létrehozzuk a ciklusváltozót, megadva a típusát és kezdő értékét, a második paraméterben a ciklus futásának a feltételét és a harmadik paraméter tartalmazza a ciklusváltozó változásának a mértékét.
  {
    lcd.backlight();  // A háttérvilágítás bekapcsolása
    delay(250);       //Várakozás. Ilyenkor az Arduinó látszólag nem csinál semmit mindaddig, amíg a megadott időtartam véget nem ér.
    lcd.noBacklight(); // A háttérvilágítás kikapcsolása
    delay(250);       // A várakozás hosszát milliszekundumban adjuk meg.
  }
  lcd.backlight();

// A kijelzőre az üdvözlő szöveg kiírása
// A SetCursor(oszlop, sor) parancs használata: először az oszlop, majd utána a sor pozíciója következik vesszővel elválasztva.
  lcd.setCursor(5,0); // A kiírási pozíció, más néven kurzor (Cursor) pozíció megadása. Jelen esetben az első sor 6. oszlopa. A számozás nullától kezdődik!
  lcd.print("HELLO!");  // A kijelzőre való kiírás a kurzor pozíciótól. A  kurzor pozíciója automatikusan az utoljára kiírt szöveg utáni pozícióra módosul.
  delay(100);  // 1 másodperces várakozás, ami 1000 milliszekundumnak felel meg.
  lcd.setCursor(2,1);
  lcd.print("Seawolf game");    // Itt maradt az angol elnevezés, nincs ötletem magyarra
  delay(1000);
  lcd.setCursor(3,3);
  lcd.print("Good luck!");      // Ha már angol a név, maradjon ez is
  delay(2000);
  lcd.clear();  // A kijelző törlése (szóköz karakterekkel való feltöltése, így látszólag üres lesz).
  lcd.setCursor(0,0); // Az első sor első oszlopra kerül a következő kiírás

} // setup vége

void loop()   // LOOP: a program futása, folyamatosan újra és újra végrehajtódik ez a programrész
{
  if (fut==0) {
    kezd();
  }
for (byte i=1 ; i<=hajokszama ; i++) {  // Sorra vesszük a hajókat
  ujra:     // Megjelöljük ezt a sort, hogy szükség esetén vissza tudjunk térni
  lcd.clear();    // A kezdő "képernyő" kiírása.
  lcd.print(i);
  lcd.print(".haj");
  lcd.write(3);
  lcd.print(" X=");
  lcd.print(hajok[i][1]);
  lcd.print(" Y=");
  lcd.print(hajok[i][2]);
  lcd.setCursor(0,1);
  lcd.print("Ir");
  lcd.write(1);
  lcd.print("ny:  1 2 3");
  lcd.setCursor(8,2);
  lcd.print("4 5 6");
  lcd.setCursor(8,3);
  lcd.print("7 8 9");
  tavol(i);   // A hajó és a tengeralattjáró távolságának számítása és kiírása
  GOMB=0;     // A megnyomott gomb értékének alphelyzetbe állítása, hogy a vizsgálatkor ne egy előzőleg megnyomott gomb értékét vegye. Itt a gombnyomás() függvény meghívása is jó megoldás lenne.
  while (GOMB!=1 and GOMB!=2 and GOMB!=3 and GOMB!=4 and GOMB!=5 and GOMB!=6 and GOMB!=7 and GOMB!=8 and GOMB!=9) // Az irány gombok valamelyikének a megnyomására való várakozás
  {
    gombnyomas();   // A billenytűzet mátrix kezelése
  }
  irany=GOMB;
  Xe=hajok[i][1];   // A hajó pillanatnyi pozíciójának az eltárolása
  Ye=hajok[i][2];
  switch (irany) {  // A kívánt irány vizsgálata
    case 1:   // Az 1-es irány a bal-fel
      Serial.print("1. irany ");
      X1=hajok[i][1]-1;   // Az új X pozíció kiszámítása
      if (X1<=-1) {       // A pályán belül van-e
        Y1=hajok[i][2];   // A nem változó tengely koordinátájának beírása, mivel az X,Y koordináták együtt vannak kezelve (X a vizsgált, X1-ben van adat. az Y1-be változatlanül betöltjük a hajó Y adatát).
        nemjo(i);         // A kívánt pozíció nem lehetséges, mivel pályán kívül van
        delay(2000);      // Várakozás
        goto  ujra;       // Az irány ismételt megadása, azaz vissza az irány megadásának a kezdetére
      }
      Y1=hajok[i][2]+1;   // Az új Y pozíció kiszámítása
      if (Y1>=meret) {
        X1=hajok[i][1];
        nemjo(i);
        delay(2000);
        goto  ujra;
      }
      if (!utkozes()) {   // A kívánt pozíción van-e már egy másik hajó
        goto ujra;        // Ha van, akkor újra a pozíció megadására
      }
      hajok[i][1]=X1;     // Az új X pozíció végelegesítése
      hajok[i][2]=Y1;     // Az új Y pozíció végelegesítése
      break;
    case 2:
      Serial.println("2. irany");
      X1=hajok[i][1];
      Y1=hajok[i][2]+1;
      if (Y1>=meret) {
        nemjo(i);
        delay(2000);
        goto  ujra;
      }
      if (!utkozes()) {
        goto ujra;
      }
      hajok[i][2]=Y1;
      break;
    case 3:
      Serial.println("3. irany");
      X1=hajok[i][1]+1;
      if (X1>=meret) {
        Y1=hajok[i][2];
        nemjo(i);
        delay(2000);
        goto  ujra;
      }
      Y1=hajok[i][2]+1;
      if (Y1>=meret) {
        X1=hajok[i][1];
        nemjo(i);
        delay(2000);
        goto  ujra;
      }
      if (!utkozes()) {
        goto ujra;
      }
      hajok[i][1]=X1;
      hajok[i][2]=Y1;
      break;
    case 4:
      Serial.println("4. irany");
      X1=hajok[i][1]-1;
      Y1=hajok[i][2];
      if (X1<=-1) {
        nemjo(i);
        delay(2000);
        goto  ujra;
      }
      if (!utkozes()) {
        goto ujra;
      }
      hajok[i][1]=X1;
      break;
    case 5:     // 5-ös iránynál nincs vizsgálat, mivel nem lép a hajó.
      Serial.println("5. irany");
      break;
    case 6:
      Serial.println("6. irany");
      X1=hajok[i][1]+1;
      Y1=hajok[i][2];
      if (X1>=meret) {
        nemjo(i);
        delay(2000);
        goto  ujra;
      }
      if (!utkozes()) {
        goto ujra;
      }
      hajok[i][1]=X1;
      break;
    case 7:
      Serial.println("7. irany");
      X1=hajok[i][1]-1;
      if (X1<=-1) {
        Y1=hajok[i][2];
        nemjo(i);
        delay(2000);
        goto  ujra;
      }
      Y1=hajok[i][2]-1;
      if (Y1<=-1) {
        X1=hajok[i][1];
        nemjo(i);
        delay(2000);
        goto  ujra;
      }
      if (!utkozes()) {
        goto ujra;
      }
      hajok[i][1]=X1;
      hajok[i][2]=Y1;
      break;
    case 8:
      Serial.println("8. irany");
      X1=hajok[i][1];
      Y1=hajok[i][2]-1;
      if (Y1<=-1) {
        nemjo(i);
        delay(2000);
        goto  ujra;
      }
      if (!utkozes()) {
        goto ujra;
      }
      hajok[i][2]=Y1;
      break;
    case 9:
      Serial.println("9. irany");
      X1=hajok[i][1]+1;
      if (X1>=meret) {
        Y1=hajok[i][2];
        nemjo(i);
        delay(2000);
        goto  ujra;
      }
      Y1=hajok[i][2]-1;
      if (Y1<=-1) {
        X1=hajok[i][1];
        nemjo(i);
        delay(2000);
        goto  ujra;
      }
      if (!utkozes()) {
        goto ujra;
      }
      hajok[i][1]=X1;
      hajok[i][2]=Y1;
      break;
  }
  jo(i);  // Az irány megadása sikeres volt, az új pozíció kiírása
  lcd.setCursor(0,1);
  lcd.print("Tovabb: #");
  while (GOMB!=12) {  // Várakozás a # gomb megnyomására
    gombnyomas();
    }
  irany=GOMB;
  if (tavolsag==0) {    // Ha a távolság a hajó és a tengeralattjáró között 0, akkor azonos pozíción vannak, meg lehet próbálni megsemmisíteni
    lcd.setCursor(0,1);
    lcd.print("FIRE!   1 2 3   ");
    lcd.setCursor(0,2);
    lcd.print("                ");
    lcd.setCursor(0,3);
    while (GOMB!=1 and GOMB!=2 and GOMB!=3) {   // Várakozás az 1,2, gomb megnyomására, ezek a 3 különböző lehetséges mélységek
      gombnyomas();
      }
    irany=GOMB;
    lcd.setCursor(0,1);
    lcd.print("FIRE! : ");
    lcd.print(irany);
    lcd.print("       ");
    lcd.setCursor(0,2);
    lcd.print("                ");
    lcd.setCursor(0,3);
    lcd.print("                ");
    if (irany==melyseg) {   // Eltaláltuk-e a mélységet vizsgálat
      lcd.setCursor(6,2);   // Ha igen, akkor a győzelem felirat kiírása
      lcd.print("WIN!");
      lcd.setCursor(0,3);
      lcd.print("Tovabb: #");
      while (GOMB!=12) {  // És várakozás a # gomb megnyomására
        gombnyomas();
      }
      asm volatile ( "jmp 0");  // Ezzel az assembler utasítással a reset vektor címére állítjuk a program számlálót, ami a teljes program újraindítását eredményezi (olyan, mintha most kapcsoltuk volna be vagy megnyomtuk volna a reset gombot az Arduino-n)
      }
    else {    // Nem sikerült eltalálni a célpontot
      hajok[i][1]=Xe; // A lövés előtti pozícióra kerül vissza a hajó
      hajok[i][2]=Ye;
      jo(i);
      lcd.setCursor(0,2);   // Hogy ne kelljen külön kiírni a hajó új koordinátáját, ezért a jo() függvényt használjuk, de ilyenkor az X1,Y1 adatok nem helyesek, mivel ez a 2 változó itt nincs használva
      lcd.print("      MISS!     ");  // Ezért azt a sort letakarjuk a MISS felirattal.
      while (GOMB!=12) {  // Várakozás a # gomb megnyomására
        gombnyomas();
        }
      }
    }

  }

  if (szint!=1){  // 1-es nehézségi szinten nem mozog a tengeralattjáró, így nincs szükség a lépésének a kiszámítására
    geplep();     // A tengeralattjáró lépésének kiszámítása
  }

}  /* --( loop vége )-- */

void geplep() {   // A tengeralattjáró lépésének kiszámítása
  if (szint==4 or szint==5) { // 4-es és 5-ös nehézségi szinten néha irányt változtathat menet közben
    minimumlepes++;
    if (minimumlepes>=4) {  // Lehetséges-s az irányváltoztatás. Ez minden 4-ik lépésben lehet csak
      minimumlepes=1;       // A számláló visszaállítása a kezdeti értékére
      hajok[5][3]=random(1,9);   // Tengeralattjáró új haladási irányának a generálása (ami kis eséllyel lehet az előző is)
      if (hajok[5][3]==5) {      // Ha 5 az irány, akkor az utolsó, a 9-es irány lesz helyette, hogy mozogjon
        hajok[5][3]=9;
      }
    }
  }
  if (szint==5) {   // Az 5-ös nehézségi fokozatban a tengeralattjáró változtathatja a mélységét is
    minimumlepes1++;
    if (minimumlepes1>=2) {  //
      melyseg=random(1,4);   // Új mélység generálása
      minimumlepes1=1;       // A számláló visszaállítása a kezdeti értékre
    }
  }
  ujra1:    // Az új pozíció sikeres kiszámításához megjelüljük ezt a sort
  Serial.print("irany: ");
  Serial.println(hajok[5][3]);
  X1=hajok[5][1];   // A tengeralattjáró pozíciójának tárolása
  Y1=hajok[5][2];
  Serial.print("sub X: ");
  Serial.print(X1);
  Serial.print(" Y: ");
  Serial.println(Y1);
  switch (hajok[5][3]) {  // Megvizsgáljuk, hogy milyen irányban halad a tengeralattjáró
    case 2:
    Serial.println("fel");
    if (fel()) {      // A fel() függvénnye negvizsgáljuk, hogy lehetséges-e a felfelé mozgás
      hajok[5][3]=8;  // Nem lehetséges, ezért irányt kell változtatni. A 2-es irány ellentéte a 8-as irány
      goto ujra1;     // Újra kezdjük a vizsgálatot
    }
    break;
    case 4:
    Serial.println("bal");
    if (balra()) {
      hajok[5][3]=6;
      goto ujra1;
    }
    break;
    case 6:
    Serial.println("jobb");
    if (jobbra()) {
      hajok[5][3]=4;
      goto ujra1;
    }
    break;
    case 8:
    Serial.println("le");
    if (le()) {
      hajok[5][3]=2;
      goto ujra1;
    }
    break;
    case 1:   // Az 1-es irány átlós, így mind a 2 tengely vizsgálatára szükség van
    Serial.println("bal-fel");
    Xhiba=balra();  // Az X tengelyen lehetséges-e a lépés vizsgálata
    Yhiba=fel();    // Az Y tengelyen lehetséges-e a lépés vizsgálata
    if (Xhiba==1 and Yhiba==1) {  // Ha egyik tengelyen sem lehetséges, akkor az átló ellenkező irányába mozoghat csak. Ez a helyzet csak a bal felső sarokban fordulhat elő.
        hajok[5][3]=9;      // Az 1-es irány ellenkező iránya a 9-es irány
        goto ujra1;         // Újra kezdjük a vizsgálatot
      }
    if (Xhiba==1) {         // Ha az X tengelyen nem lehetséges a mozgás, akkor az Y irányt változatlanul hagyjuk és így az átló másik X iránya a 3-as irány. Ez a helyzet a pálya bal szélén fordulhat elő.
        hajok[5][3]=3;
        goto ujra1;
      }
    if (Yhiba==1) {         // Ha az Y tengelyen nem lehetséges a mozgás, akkor az X irányt változatlanul hagyjuk és így az átló másik Y iránya a 7-es irány. Ez a helyzet a pálya tetején fordulhat elő.
        hajok[5][3]=7;
        goto ujra1;
      }
    break;    // Az 1-es irány vizsgálatának a vége. Vegyük észre, hogy átlós mozgásnál elhelyezkedéstől függően mind a 3 maradék átlós irányban haladhat tovább.
    case 3:
    Serial.println("jobb-fel");
    Xhiba=jobbra();
    Yhiba=fel();
    if (Xhiba==1 and Yhiba==1) {
        hajok[5][3]=7;
        goto ujra1;
      }
    if (Xhiba==1) {
        hajok[5][3]=1;
        goto ujra1;
      }
    if (Yhiba==1) {
        hajok[5][3]=9;
        goto ujra1;
      }
    break;
    case 7:
    Serial.println("bal-le");
    Xhiba=balra();
    Yhiba=le();
    if (Xhiba==1 and Yhiba==1) {
        hajok[5][3]=3;
        goto ujra1;
      }
    if (Xhiba==1) {
        hajok[5][3]=9;
        goto ujra1;
      }
    if (Yhiba==1) {
        hajok[5][3]=1;
        goto ujra1;
      }
    break;
    case 9:
    Serial.println("jobb-le");
    Xhiba=jobbra();
    Yhiba=le();
    if (Xhiba==1 and Yhiba==1) {
        hajok[5][3]=1;
        goto ujra1;
      }
    if (Xhiba==1) {
        hajok[5][3]=7;
        goto ujra1;
      }
    if (Yhiba==1) {
        hajok[5][3]=3;
        goto ujra1;
      }
    break;
  }   //switch vége
  hajok[5][1]=X1;   // Az új pozíció megadása a tegngeralattjárónak
  hajok[5][2]=Y1;
  Serial.print("sub X: ");
  Serial.print(X1);
  Serial.print(" Y: ");
  Serial.println(Y1);
}

bool jobbra() {   // Jobbra irányban lehetséges-e a mozgás. Ez egy BOOL (logikai) típusú függvény, ami azt jelenti, hogy a visszatérési értéke vagy igaz (1) vagy hamis (0) állapottal lehetséges
  bool hiba=0;    // A hibajelző alacsony szintre állítása, feltételezve, hogy nem lesz hiba
  X1=hajok[5][1]+1;   // A pillanatnyi pozíciót jobbra 1-el megnöveljük
  if (X1>=meret) {    // Megvizsgáljuk, hogy a pályán belül van-e az új pozíció
    hiba=1;           // Ha kívülre esik, akkor hibajelzőt magas szintre állítjuk
  }
  return hiba;        // A vizsgálatból való visszatérés a hibajelző állapotával.
}

bool balra() {
  bool hiba=0;
  X1=hajok[5][1]-1;
  if (X1<=-1) {
    hiba=1;
  }
  return hiba;
}

bool fel() {
  bool hiba=0;
  Y1=hajok[5][2]+1;
  if (Y1>=meret) {
    hiba=1;
  }
  return hiba;
}

bool le() {
  bool hiba=0;
  Y1=hajok[5][2]-1;
  if (Y1<=-1) {
    hiba=1;
  }
  return hiba;
}

int utkozes() {  // Az éppen pozíciót változtatní kívánó hajó a többi hajóval való ütközésének a vizsgálata, mivel egy koordinátán csak 1 hajó tartózkodhat
  bool ok=1;     // Alapértelmezésként a logikai állapotú (BOOL) változó értéke igaz, ha nincs ütközés
  for (byte i=0;i<=hajokszama;i++) {  // A pályán lévő hajókat sorra vesszük
      if (hajok[i][1]==X1 and hajok[i][2]==Y1) {
        ok=0;
        lcd.setCursor(0,1);
        lcd.print("!!!             ");
        lcd.setCursor(0,2);
        lcd.print("                ");
        lcd.setCursor(0,3);
        lcd.print("   Collison!    ");
        delay(1000);
      }
  }
  return ok;
}

void jo(byte i)
{
  tavol(i);
  lcd.setCursor(7,0);
  lcd.print("         ");
  lcd.setCursor(0,1);
  lcd.print("                ");
  lcd.setCursor(0,2);
  lcd.print("T:");
  lcd.print(tavolsage);
  lcd.setCursor(7,2);
  lcd.print("X=");
  lcd.print(Xe);
  lcd.print(" Y=");
  lcd.print(Ye);
  lcd.setCursor(7,3);
  lcd.print("X=");
  lcd.print(hajok[i][1]);
  lcd.print(" Y=");
  lcd.print(hajok[i][2]);
}


void nemjo(byte i)
{
  lcd.clear();
  lcd.print(i);
  lcd.print(".haj");
  lcd.write(3);
  lcd.print(" X=");
  lcd.print(hajok[i][1]);
  lcd.print(" Y=");
  lcd.print(hajok[i][2]);
  lcd.setCursor(0,1);
  lcd.print(" !!!   X=");
  lcd.print(X1);
  lcd.print(" Y=");
  lcd.print(Y1);
  lcd.setCursor(0,3);
  lcd.print(" Out of field! ");
}

void kezd() {  // Kezdő paraméterek beállítása ill. generálása
  randomSeed(analogRead(0));    // A randomgenerátor a nullás analóg bemeneten véletlenszerű értékű jellel inicializálódik
  lcd.clear();      // Az lcd kijelző törlése
  lcd.print("Neh"); // "Nehézségi fokozat (1-5: )" szöveg kiírása
  lcd.write(2);     // Az é betű, mint egyedileg definiált karakter
  lcd.print("zs");
  lcd.write(2);
  lcd.print("gi");
  lcd.setCursor(0,1);
  lcd.print("fokozat (1-5): ");

  while (GOMB!=1 and GOMB!=2 and GOMB!=3 and GOMB!=4 and GOMB!=5) // Az 1,2,3,4,5-ös gombok valamelyikének a megnyomására való várakozás
  {
    gombnyomas();   // A megnyomott gomb lekérdezése, ha volt egyáltalán
  }
  szint=GOMB;       // A megnyomott gomb értéke lesz a nehézségi szint értéke
  GOMB=0;           // Újabb gombnyomás előkészítése, hogy ne a korábban megnyomott gomb értékét adja vissza a gombnyomas() függvény
  lcd.setCursor(15,1);    // Az LCD kijelzőn beállítjuk a következő karakter helyét, ami a szöveg után éesz
  lcd.print(szint);       // Az LCD kijelzőre kiírjuk a választott nehézségi szintet
  Serial.print("szint "); // Majd Ezeket kiírjuk a soros monitorra
  Serial.println(szint);
  delay(1000);            // Várakozás 1 másodpercig
  lcd.setCursor(0,2);     // Az újabb szöveg kezdetének meghatározása
  lcd.print("Haj");       // "Hajók száma: (1-4): " szöveg kiírása
  lcd.write(3);           // Az ó betű, mint egyedileg definiált karakter
  lcd.print("k sz");
  lcd.write(1);           // Az á betű, mint egyedileg definiált karakter
  lcd.print("ma");
  lcd.setCursor(0,3);
  lcd.print("(1-4): ");
  while (GOMB!=1 and GOMB!=2 and GOMB!=3 and GOMB!=4)     // Az 1,2,3,4-es gombok valamelyikének a megnyomására való várakozás
  {
    gombnyomas();     // A megnyomott gomb lekérdezése, ha volt egyáltalán
  }
  hajokszama=GOMB;    // A megnyomott gomb értéke lesz a hajók száma
  GOMB=0;
  Serial.print("hajo ");    // A soros monitorra kiírjuk ezt is
  Serial.println(hajokszama);
  lcd.print(hajokszama);    // Majd Az LCD kijelzőre is
  melyseg=random(1,4);      // A tengeralattjáró mélységének 1-3 közötti értékének véletlenszerű beállítása
  hajocimke:                // Ezt a sort meglelöljük egy címkével, hogy szükség esetén vissza tudjunk ide térni
  hajok[5][1]=random(1,meret);   // Tengeralattjáró X pozíciója
  hajok[5][2]=random(1,meret);   // Tengeralattjáró Y pozíciója
  Serial.print("Generált új pozíció: ");    // A tengeralattjáró pozícióját kiírjuk a soros monitorra
  Serial.print(hajok[5][1]);
  Serial.print("-");
  Serial.println(hajok[5][2]);
  if (hajok[5][1]<=9 or hajok[5][2]<=9) {   // Ellenőrizzük, hogy a tengeralattjáró pozíciója nincs-e a bal alsó 10*10-es négyzetben
    goto hajocimke;                         // Ha igen, akkor új koordinátákat generálunk, mindaddig, amíg a fenti feltétel nem teljesül
  }

  hajok[5][3]=random(1,9);   // Tengeralattjáró haladási iránya, 8 irány van összesen

//  hajok[5][1]=2;   // Tengeralattjáró X pozíciója
//  hajok[5][2]=2;   // Tengeralattjáró Y pozíciója
//  hajok[5][3]=7;   // Tengeralattjáró haladási iránya

  if (hajok[5][3]==5) {   // Ha 5 az irány, akkor az utolsó, a 9-es irány lesz helyette, hogy mozogjon, mivel az 5-ös irány a nem mozgás
    hajok[5][3]=9;
  }
  if (szint==1) {    // A 1-es nehézségi szinten nem mozog a tengeralattjáró
    hajok[5][3]=5;
  }
  if (szint==2) {    // A 2-es nehézségi szinten csak bal-jobb vagy le-fel irányban mozog a tengeralattjáró
    hajok[5][3]=random(1,5)*2;  // Ez 4 irány, a 2,4,6,8, amik páros számok, ezért megszorozzuk a generált számot 2-vel, hogy megkapjuk az első 4 páros számot
  }
  Serial.print("Melyseg, irany: ");
  Serial.print(melyseg);
  Serial.print(" - ");
  Serial.println(hajok[5][3]);
  hajok[1][1]=5;    // A játékos által irányított hajók kezdő pozícióinak megadása
  hajok[1][2]=0;
  hajok[2][1]=10;
  hajok[2][2]=0;
  hajok[3][1]=0;
  hajok[3][2]=5;
  hajok[4][1]=0;
  hajok[4][2]=10;
  for (byte i=1; i<=4 ; i++){   // Kezdetben minden hajó áll, azaz az irány értéke 5
    hajok[i][3]=5;
  }
  fut=1;    // A főprogramban jelezzük, hogy indulhat a játék

  delay(1000);    // Még várunk 1 másodpercet
}

void gombnyomas()   // A 4*4-es nyomógomb mátrix gombjainak lekérdezése
{
  GOMB=0;           // A kimeneti változó törlése
  pinMode(5,OUTPUT);    // A nyomógombmátrix első sorára csatlakozó port kimenetként való beállítása
  digitalWrite(5,LOW);  // És alacsony szintre húzása
  if (digitalRead(6)==0) {  // Vizsgálat, hogy az első sorban első oszlopában lett-e megnyomva gomb. Nulla jelszintet vizsgálunk, mivel a kivezetésre kapcsolt jel alacsony logikai szintű.
      GOMB=1;               // Ha igen, akkor értéket adunk neki
  }
  if (digitalRead(7)==0) {  // A második oszlopban található gomb. Ezeken gombnyomás nélkül magas szint található, mivel a kezdeti beállításoknál bekapcsoltuk a felhúzó ellenállást.
      GOMB=2;
  }
  if (digitalRead(8)==0) {  // A harmadik oszlopban található gomb
      GOMB=3;
  }
  if (digitalRead(9)==0) {  // A negyedik oszlopban található gomb
      GOMB=13;
  }
  pinMode(5,INPUT);         // Az első sorra csatlakozó kivezetést visszaállítjuk bemenetre, hogy úgynevezett nagyimpedanciás állapotba kerüljön.
  pinMode(4,OUTPUT);        // A második sorra csatlakozó portot állítjuk kimenetként
  digitalWrite(4,LOW);      // Majd alacsony szintet állítunk be rajta
  if (digitalRead(6)==0) {  // A korábban leírtaknek megfelelő a további működés
      GOMB=4;
  }
  if (digitalRead(7)==0) {
      GOMB=5;
  }
  if (digitalRead(8)==0) {
      GOMB=6;
  }
  if (digitalRead(9)==0) {
      GOMB=14;
  }
  pinMode(4,INPUT);
  pinMode(3,OUTPUT);
  digitalWrite(3,LOW);
  if (digitalRead(6)==0) {
      GOMB=7;
  }
  if (digitalRead(7)==0) {
      GOMB=8;
  }
  if (digitalRead(8)==0) {
      GOMB=9;
  }
  if (digitalRead(9)==0) {
      GOMB=15;
  }
  pinMode(3,INPUT);
  pinMode(2,OUTPUT);
  digitalWrite(2,LOW);
  if (digitalRead(6)==0) {
      GOMB=11;
  }
  if (digitalRead(7)==0) {
      GOMB=10;
  }
  if (digitalRead(8)==0) {
      GOMB=12;
  }
  if (digitalRead(9)==0) {
      GOMB=16;
  }
  pinMode(2,INPUT);
}  // gombnyomás() függvény vége

void tavol(byte hajo)   // A tengeralattjáró és a hajo változóban megadott számú hajó távolságát számoló függvény
{
  int x,y;    // Csak ebben a függvényben érvényes változók
  x=hajok[hajo][1]-hajok[5][1];   // A két vizsgálni kívánt objektum X koordinátájának különbsége. Az előjelnek nincs jelentősége. mivel később négyzetre emeljük.
  y=hajok[hajo][2]-hajok[5][2];   // A két vizsgálni kívánt objektum Y koordinátájának különbsége
  x=x*x;    // A számolást Pitagorasz tételével (a2+b2=c2) oldjuk meg
  y=y*y;    // Ezért a két koordináta különbségeit négyzetre emeljük
  lcd.setCursor(0,3);   // Az LCD kijelzőn beállítjuk a kiírandó szám pozícióját
  lcd.print("T:");      // Majd "T: "-vel jelezzük, mint távolság
  tavolsage=tavolsag;   // Eltároljuk a korábban számított értéket
  tavolsag=sqrt(x+y);   // Kiszámoljuk a távolságot úgy, hogy a különségek négyzetének összegéből négyzetgyököt vonunk.
  lcd.print(tavolsag);  // Majd kiírjuk a kapott értéket a kijelzőre.
  lcd.print(" ");       // Kiírunk egy szóközt, hogy ha a korábbi érték 2 digites volt (pl. 10), akkor ne maradjon a kijelzőn a második digit (egy nulla)
}  // tavol() függvény vége