
«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 .
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:

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

I to je to. Da li ste očekivali više? 🙂
Skillbox preporučuje:
- Praktični kurs .
- Praktični online kurs .
- Dvogodišnji praktični kurs .
Izvor: habr.com
