„Pjatnaška“ na Javi — kako razviti punu igru

„Pjatnaška“ na Javi — kako razviti punu igru

«Petnaest», ili «Petnaška» — odličan primer jednostavne logičke igre, popularne širom sveta. Da biste rešili zagonetku, potrebno je rasporediti kvadrate sa brojevima po redosledu, od manjeg ka većem. To nije lako, ali je zanimljivo.

U današnjem tutorijalu pokazujemo kako razviti „Petnašku” na Javi 8 koristeći Eclipse. Za razvoj UI koristićemo Swing API.

Podsećamo: za sve čitaoce „Habra“ — popust od 10.000 rubalja prilikom upisa na bilo koji kurs Skillbox uz promo kod „Habr“.

Skillbox preporučuje: Online obrazovni kurs „Zanimanje Java-programer“.

Projektovanje igre

U ovoj fazi potrebno je odrediti svojstva:

  • Size — veličina igrališta;
  • nbTiles — broj petnaeski u polju. nbTiles = size*size — 1;
  • Tiles — petnaeska, koja predstavlja jednodimenzionalni niz celih brojeva. Svaka od petnaeski će dobiti jedinstvenu vrednost u opsegu [0, nbTiles]. Nula označava prazni kvadrat;
  • blankPos — pozicija praznog kvadrata.

Logika igre

Potrebno je definisati metodu za resetovanje (reset), koja se koristi za inicijalizaciju nove pozicije igre. Tako postavljamo vrednost za svaki element niza petnaeski. A zatim postavljamo blankPos na poslednju poziciju niza.

Takođe je potrebna metoda shuffle za mešanje niza petnaeski. Ne uključujemo praznu petnaesku u proces mešanja, kako bismo je ostavili na istom mestu.

Pošto samo polovina mogućih početnih pozicija zagonetke ima rešenje, potrebno je proveriti rezultat mešanja kako bismo se uverili da je trenutni raspored uopšte rešiv. Da bismo to uradili, definišemo metodu isSolvable.

Ako određenoj petnaeski prethodi petnaeska sa višom vrednošću, to se smatra obrnutošću. Kada se prazna petnaeska nalazi na svom mestu, broj obrnutosti treba biti paran, da bi zagonetka bila rešljiva. Tako da brojimo broj obrnutosti i vraćamo true ako je broj paran.

Zatim je važno definisati metodu isSolved, kako bismo proverili da li je naš raspored Game Of Fifteen rešen. Prvo gledamo gde se nalazi prazna petnaeska. Ako je na početnoj poziciji, tada je trenutni raspored novi, ranije nerešen. Zatim prolazimo kroz kockice unazad, i, ako se vrednost petnaeske razlikuje od odgovarajućeg indeksa +1, vraćamo false. U suprotnom, na kraju metode treba da vratimo true, jer je zagonetka već rešena.

Još jedna metoda koju treba definirati je newGame. Ona je potrebna za stvaranje novog primjerka igre. Za to resetujemo igralište, zatim ga miješamo i nastavljamo sve dok pozicija igre ne bude rješiva.

Evo primjera koda s ključnom logikom za igru s petnalicama:

private void newGame() {
  do {
    reset(); // reset u početno stanje
    shuffle(); // miješanje
  } while(!isSolvable()); // nastaviti sve dok rešetka ne bude rješiva
 
  gameOver = false;
}
 
private void reset() {
  for (int i = 0; i  1) {
    int r = RANDOM.nextInt(n--);
    int tmp = tiles[r];
    tiles[r] = tiles[n];
    tiles[n] = tmp;
  }
}
 
// Samo polovina permutacija slagalice je rješiva/
// Kad god je pločica prethodi pločici s višom vrijednošću, to se računa
// kao inverzija. U našem slučaju, s praznom pločicom na rješenoj poziciji,
// broj inverzija mora biti paran da bi slagalica bila rješiva
private boolean isSolvable() {
  int countInversions = 0;
 
  for (int i = 0; i < nbTiles; i++) {
    for (int j = 0; j  tiles[i])
        countInversions++;
    }
  }
 
  return countInversions % 2 == 0;
}
 
private boolean isSolved() {
  if (tiles[tiles.length - 1] != 0) // ako prazna pločica nije na rješenoj poziciji ==>
    return false;
 
  for (int i = nbTiles - 1; i >= 0; i--) {
    if (tiles[i] != i + 1)
      return false;
  }
 
  return true;
}

Konačno, potrebno je isprogramirati kretanje petnalica u nizu. Ovaj kod će biti pozivan kasnije putem povratnog poziva (callback) kako bi reagovao na kretanje kursora. Naša igra će podržavati višestruka pomjeranja pločica istovremeno. Tako, nakon što konvertujemo pritisnutu poziciju na ekranu u petnalicu, dobijamo poziciju prazne petnalice i tražimo pravac kretanja kako bismo podržali višestruka njena pomjeranja istovremeno.

Evo primjera koda:

// get position of the click
int ex = e.getX() - margin;
int ey = e.getY() - margin;
 
// click in the grid ?
if (ex < 0 || ex > gridSize  || ey < 0  || ey > gridSize)
  return;
 
// get position in the grid
int c1 = ex / tileSize;
int r1 = ey / tileSize;
 
// get position of the blank cell
int c2 = blankPos % size;
int r2 = blankPos / size;
 
// we convert in the 1D coord
int clickPos = r1 * size + c1;
 
int dir = 0;
 
// we search direction for multiple tile moves at once
if (c1 == c2  &&  Math.abs(r1 - r2) > 0)
  dir = (r1 - r2) > 0 ? size : -size;
else if (r1 == r2 && Math.abs(c1 - c2) > 0)
  dir = (c1 - c2) > 0 ? 1 : -1;
 
if (dir != 0) {
  // we move tiles in the direction
  do {
    int newBlankPos = blankPos + dir;
    tiles[blankPos] = tiles[newBlankPos];
    blankPos = newBlankPos;
  } while(blankPos != clickPos);
 
tiles[blankPos] = 0;

Razvijamo UI koristeći Swing API

Vrijeme je da se pozabavimo interfejsom. Prvo uzimamo klasu Jpanel. Zatim na polju crtamo petnalice — za izračunavanje veličina svake iskoristićemo podatke zadane u parametrima konstruktora igre:

gridSize = (dim - 2 * margin);
tileSize = gridSize / size;

Margin je takođe parametar koji je zadan u konstruktoru igre.

Sada je potrebno definirati metodu drawGrid za crtanje mreže i petnalica na ekranu. Analiziramo niz petnalica i konvertujemo koordinate u koordinate korisničkog interfejsa. Zatim ćemo nacrtati svaku petnalicu sa odgovarajućim brojem u centru:

private void drawGrid(Graphics2D g) {
  for (int i = 0; i < tiles.length; i++) {
    // konvertujemo 1D koordinate u 2D koordinate na osnovu veličine 2D niza
    int r = i / size;
    int c = i % size;
    // konvertujemo u UI koordinate
    int x = margin + c * tileSize;
    int y = margin + r * tileSize;
 
    // provjeravamo posebnu situaciju za praznu pločicu
    if(tiles[i] == 0) {
      if (gameOver) {
        g.setColor(FOREGROUND_COLOR);
        drawCenteredString(g, "u2713", x, y);
      }
 
      continue;
    }
 
    // za ostale pločice
    g.setColor(getForeground());
    g.fillRoundRect(x, y, tileSize, tileSize, 25, 25);
    g.setColor(Color.BLACK);
    g.drawRoundRect(x, y, tileSize, tileSize, 25, 25);
    g.setColor(Color.WHITE);
 
    drawCenteredString(g, String.valueOf(tiles[i]), x , y);
  }
}

Na kraju, override-ujemo metodu paintComponent, koja je naslijeđena iz klase JPane. Zatim koristimo metodu drawGrid, a nakon toga — metodu drawStartMessage za prikazivanje poruke koja poziva da kliknete za pokretanje igre:

private void drawStartMessage(Graphics2D g) {
  if (gameOver) {
    g.setFont(getFont().deriveFont(Font.BOLD, 18));
    g.setColor(FOREGROUND_COLOR);
    String s = "Kliknite za početak nove igre";
    g.drawString(s, (getWidth() - g.getFontMetrics().stringWidth(s)) / 2,
        getHeight() - margin);
  }
}
 
private void drawCenteredString(Graphics2D g, String s, int x, int y) {
  // centriramo string s za date koordinate (x,y)
  FontMetrics fm = g.getFontMetrics();
  int asc = fm.getAscent();
  int desc = fm.getDescent();
  g.drawString(s,  x + (tileSize - fm.stringWidth(s)) / 2,
      y + (asc + (tileSize - (asc + desc)) / 2));
}
 
@Override
protected void paintComponent(Graphics g) {
  super.paintComponent(g);
  Graphics2D g2D = (Graphics2D) g;
  g2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
  drawGrid(g2D);
  drawStartMessage(g2D);
}

Reagiramo na radnje korisnika u UI

Kako bi igra napredovala, potrebno je obrađivati radnje korisnika u UI. Za to dodajemo implementaciju MouseListener na Jpanel i kod za pomjeranje pločica, koji smo već prikazali ranije:

addMouseListener(new MouseAdapter() {
  @Override
  public void mousePressed(MouseEvent e) {
    // koristi se za omogućavanje interakcije korisnika na mreži klikom
    // vrijeme je da implementiramo interakciju korisnika za pomjeranje pločica kako bismo riješili igru!
    if (gameOver) {
      newGame();
    } else {
      // dobijamo poziciju klika
      int ex = e.getX() - margin;
      int ey = e.getY() - margin;
 
      // da li je klik u mreži?
      if (ex  gridSize  || ey  gridSize)
        return;
 
      // dobijamo poziciju u mreži
      int c1 = ex / tileSize;
      int r1 = ey / tileSize;
 
      // dobijamo poziciju prazne ćelije
      int c2 = blankPos % size;
      int r2 = blankPos / size;
 
      // konvertujemo u 1D koordinatu
      int clickPos = r1 * size + c1;
 
      int dir = 0;
 
      // tražimo pravac za multiple pomjeranje pločica odjednom
      if (c1 == c2  &&  Math.abs(r1 - r2) > 0)
        dir = (r1 - r2) > 0 ? size : -size;
      else if (r1 == r2 && Math.abs(c1 - c2) > 0)
        dir = (c1 - c2) > 0 ? 1 : -1;
 
      if (dir != 0) {
        // pomjeramo pločice u tom pravcu
        do {
          int newBlankPos = blankPos + dir;
          tiles[blankPos] = tiles[newBlankPos];
          blankPos = newBlankPos;
        } while(blankPos != clickPos);
 
        tiles[blankPos] = 0;
      }
 
      // provjeravamo da li je igra riješena
      gameOver = isSolved();
    }
 
    // ponovo iscrtaj panel
    repaint();
  }
});

Kod stavljamo u konstruktor klase GameOfFifteen. Na kraju pozivamo metodu newGame za započinjanje nove igre.

Potpun kod igre

Zadnji korak, prije nego što vidite igru u akciji, je spojiti sve elemente koda zajedno. Evo što će biti:

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.Random;
 
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;
 
// Kreiramo igru Pitalica 15 uz pomoć Jave 8 i Swing-a
// Ako imate pitanja, slobodno pročitajte komentare ;)
public class GameOfFifteen extends JPanel { // Naša mreža će biti prikazana u posebnoj paneli
 
  // Veličina naše igre Pitalica 15
  private int size;
  // Broj pločica
  private int nbTiles;
  // Dimenzija UI mreže
  private int dimension;
  // Boja izloga
  private static final Color FOREGROUND_COLOR = new Color(239, 83, 80); // Koristimo proizvoljnu boju
  // Random objekat za miješanje pločica
  private static final Random RANDOM = new Random();
  // Čuvanje pločica u 1D nizu celih brojeva
  private int[] tiles;
  // Veličina pločice na UI
  private int tileSize;
  // Pozicija prazne pločice
  private int blankPos;
  // Margina za mrežu na okviru
  private int margin;
  // Veličina UI mreže
  private int gridSize;
  private boolean gameOver; // true ako je igra gotova, false inače
 
  public GameOfFifteen(int size, int dim, int mar) {
    this.size = size;
    dimension = dim;
    margin = mar;
    
    // inicijalizuj pločice
    nbTiles = size * size - 1; // -1 jer ne računamo praznu pločicu
    tiles = new int[size * size];
    
    // izračunaj veličinu mreže i veličinu pločice
    gridSize = (dim - 2 * margin);
    tileSize = gridSize / size;
    
    setPreferredSize(new Dimension(dimension, dimension + margin));
    setBackground(Color.WHITE);
    setForeground(FOREGROUND_COLOR);
    setFont(new Font("SansSerif", Font.BOLD, 60));
    
    gameOver = true;
    
    addMouseListener(new MouseAdapter() {
      @Override
      public void mousePressed(MouseEvent e) {
        // koriste se za omogućavanje korisnicima da interaguju s mrežom klikom
        // vreme je da implementiramo interakciju s korisnicima radi pomjeranja pločica kako bi rešili igru!
        if (gameOver) {
          newGame();
        } else {
          // dobij poziciju klika
          int ex = e.getX() - margin;
          int ey = e.getY() - margin;
          
          // klik u mreži?
          if (ex  gridSize  || ey  gridSize)
            return;
          
          // dobij poziciju u mreži
          int c1 = ex / tileSize;
          int r1 = ey / tileSize;
          
          // dobij poziciju prazne ćelije
          int c2 = blankPos % size;
          int r2 = blankPos / size;
          
          // konvertujemo u 1D koordinate
          int clickPos = r1 * size + c1;
          
          int dir = 0;
          
          // tražimo pravac za višestruke pomake pločica
          if (c1 == c2  &&  Math.abs(r1 - r2) > 0)
            dir = (r1 - r2) > 0 ? size : -size;
          else if (r1 == r2 && Math.abs(c1 - c2) > 0)
            dir = (c1 - c2) > 0 ? 1 : -1;
            
          if (dir != 0) {
            // premještamo pločice u smjeru
            do {
              int newBlankPos = blankPos + dir;
              tiles[blankPos] = tiles[newBlankPos];
              blankPos = newBlankPos;
            } while(blankPos != clickPos);
            
            tiles[blankPos] = 0;
          }
          
          // provjeravamo da li je igra rešena
          gameOver = isSolved();
        }
        
        // ponovo iscrtavamo panel
        repaint();
      }
    });
    
    newGame();
  }
 
  private void newGame() {
    do {
      reset(); // resetujemo u početno stanje
      shuffle(); // miješamo
    } while(!isSolvable()); // radimo dok mreža ne bude rješiva
    
    gameOver = false;
  }
 
  private void reset() {
    for (int i = 0; i  1) {
      int r = RANDOM.nextInt(n--);
      int tmp = tiles[r];
      tiles[r] = tiles[n];
      tiles[n] = tmp;
    }
  }
 
  // Samo polovina permutacija slagalice je rješiva.
  // Kad god je pločica prethodila pločici većeg broja, to se računa
  // kao obrnuta. U našem slučaju, sa praznom pločicom u rešenom položaju,
  // broj obrnutih mora biti paran da bi slagalica bila rješiva
  private boolean isSolvable() {
    int countInversions = 0;
    
    for (int i = 0; i < nbTiles; i++) {
      for (int j = 0; j  tiles[i])
          countInversions++;
      }
    }
    
    return countInversions % 2 == 0;
  }
 
  private boolean isSolved() {
    if (tiles[tiles.length - 1] != 0) // ako prazna pločica nije u rešenom položaju ==> nije rešena
      return false;
    
    for (int i = nbTiles - 1; i >= 0; i--) {
      if (tiles[i] != i + 1)
        return false;      
    }
    
    return true;
  }
 
  private void drawGrid(Graphics2D g) {
    for (int i = 0; i  {
      JFrame frame = new JFrame();
      frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
      frame.setTitle("Igra Pitalica 15");
      frame.setResizable(false);
      frame.add(new GameOfFifteen(4, 550, 30), BorderLayout.CENTER);
      frame.pack();
      // centriraj na ekranu
      frame.setLocationRelativeTo(null);
      frame.setVisible(true);
    });
  }
 
 
}

Napokon, igramo!

Pravo je vreme da pokrenemo igru i vidimo kako funkcioniše. Polje bi trebalo da izgleda ovako:

„Pjatnaška“ na Javi — kako razviti punu igru

Pokušajmo da rešimo zagonetku. Ako je sve prošlo dobro, dobijamo ovo:

„Pjatnaška“ na Javi — kako razviti punu igru

I to je to. Da li ste očekivali više? 🙂

Skillbox preporučuje:

Izvor: habr.com

Kupite pouzdan hosting za sajtove uz zaštitu od DDoS, VPS VDS servere 🔥 Kupite pouzdan hosting za sajtove uz zaštitu od DDoS, VPS VDS servere | ProHoster