"viisitoista" tai "viisitoista" on erinomainen esimerkki yksinkertaisesta logiikkapelistä, joka on suosittu kaikkialla maailmassa. Palapelin ratkaisemiseksi sinun on järjestettävä neliöt numeroineen järjestykseen pienimmästä suurimpaan. Se ei ole helppoa, mutta se on mielenkiintoinen.
Tämän päivän opetusohjelmassa näytämme, kuinka Fifteen kehitetään Java 8:ssa Eclipsen avulla. Käyttöliittymän kehittämiseen käytämme Swing API:ta.
Muistutamme sinua: kaikille "Habrin" lukijoille - 10 000 ruplan alennus ilmoittautuessaan mille tahansa Skillbox-kurssille "Habr" -tarjouskoodilla.
Skillbox suosittelee: Kouluttava verkkokurssi .
Pelin suunnittelu
Tässä vaiheessa sinun on määritettävä ominaisuudet:
- Koko — pelikentän koko;
- nbTiles — tunnisteiden määrä kentässä. nbTiles = koko*koko - 1;
- Laatat on tunniste, joka on yksiulotteinen kokonaislukutaulukko. Jokainen tunniste saa yksilöllisen arvon alueella [0, nbTiles]. Nolla tarkoittaa tyhjää neliötä;
- blankPos — tyhjän neliön sijainti.
Pelin logiikka
Meidän on määritettävä nollausmenetelmä, jota käytetään uuden pelipaikan alustamiseen. Tällä tavalla asetamme arvon jokaiselle tag-taulukon elementille. No, sitten sijoitamme blankPosin taulukon viimeiseen kohtaan.
Tarvitsemme myös sekoitusmenetelmän tagijoukon sekoittamiseen. Emme sisällytä tyhjää tagia sekoitusprosessiin jättääksemme sen samaan paikkaan.
Koska vain puolella pulman mahdollisista aloituspaikoista on ratkaisu, sinun on tarkistettava saatu sekoitustulos varmistaaksesi, että nykyinen asettelu on tasainen. Tätä varten määrittelemme isSolvaable-menetelmän.
Jos tiettyä tunnistetta edeltää tagi, jolla on korkeampi arvo, se katsotaan käänteiseksi. Kun tyhjä kohta on paikallaan, käännösten lukumäärän on oltava tasainen, jotta pulma olisi ratkaistavissa. Joten laskemme inversioiden määrän ja palautamme tosi, jos luku on parillinen.
Sitten on tärkeää määrittää isSolved-menetelmä tarkistaaksesi, onko Game Of Fifteen -asettelumme ratkaistu. Ensin katsotaan, missä on tyhjä paikka. Jos alkuasennossa, nykyinen kohdistus on uusi, ei aiemmin päätetty. Toistamme sitten ruudut käänteisessä järjestyksessä, ja jos tagin arvo poikkeaa vastaavasta indeksistä +1, palautetaan false. Muussa tapauksessa menetelmän lopussa on aika palauttaa tosi, koska arvoitus on jo ratkaistu.
Toinen menetelmä, joka on määriteltävä, on newGame. Pelin uusi esiintymä on luotava. Tätä varten nollaamme pelikentän, sekoitamme sen ja jatkamme, kunnes pelipaikka on ratkaistavissa.
Tässä on esimerkkikoodi tagin avainlogiikalla:
private void newGame() {
do {
reset(); // reset in initial state
shuffle(); // shuffle
} while(!isSolvable()); // make it until grid be solvable
gameOver = false;
}
private void reset() {
for (int i = 0; i < tiles.length; i++) {
tiles[i] = (i + 1) % tiles.length;
}
// we set blank cell at the last
blankPos = tiles.length - 1;
}
private void shuffle() {
// don't include the blank tile in the shuffle, leave in the solved position
int n = nbTiles;
while (n > 1) {
int r = RANDOM.nextInt(n--);
int tmp = tiles[r];
tiles[r] = tiles[n];
tiles[n] = tmp;
}
}
// Only half permutations of the puzzle are solvable/
// Whenever a tile is preceded by a tile with higher value it counts
// as an inversion. In our case, with the blank tile in the solved position,
// the number of inversions must be even for the puzzle to be solvable
private boolean isSolvable() {
int countInversions = 0;
for (int i = 0; i < nbTiles; i++) {
for (int j = 0; j < i; j++) {
if (tiles[j] > tiles[i])
countInversions++;
}
}
return countInversions % 2 == 0;
}
private boolean isSolved() {
if (tiles[tiles.length - 1] != 0) // if blank tile is not in the solved position ==> not solved
return false;
for (int i = nbTiles - 1; i >= 0; i--) {
if (tiles[i] != i + 1)
return false;
}
return true;
}Lopuksi sinun on ohjelmoitava tunnisteiden liike taulukossa. Tätä koodia kutsutaan myöhemmin takaisinsoitolla kursorin liikkeeseen vastaamiseksi. Pelimme tukee useita laattojen liikkeitä samanaikaisesti. Näin ollen, kun olemme muuntaneet painetun asennon näytöllä tunnisteeksi, saamme tyhjän tunnisteen sijainnin ja etsimme liikesuunnan, joka tukee useita sen liikkeitä samanaikaisesti.
Tässä on esimerkkikoodi:
// 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;Kehitämme käyttöliittymää Swing API:lla
On aika työstää käyttöliittymää. Ensin otamme Jpanel-luokan. Sitten piirrämme tunnisteita kentälle - laskeaksemme kunkin koon, käytämme pelin rakentajaparametrissa määritettyjä tietoja:
gridSize = (dim - 2 * margin);
tileSize = gridSize / size;Marginaali on myös pelikonstruktorissa asetettu parametri.
Nyt meidän on määritettävä drawGrid-menetelmä ruudukon ja pisteiden piirtämiseksi näytölle. Analysoimme tunnisteiden joukon ja muunnamme koordinaatit käyttöliittymäkoordinaateiksi. Piirrä sitten jokainen paikka vastaavalla numerolla keskelle:
private void drawGrid(Graphics2D g) {
for (int i = 0; i < tiles.length; i++) {
// we convert 1D coords to 2D coords given the size of the 2D Array
int r = i / size;
int c = i % size;
// we convert in coords on the UI
int x = margin + c * tileSize;
int y = margin + r * tileSize;
// check special case for blank tile
if(tiles[i] == 0) {
if (gameOver) {
g.setColor(FOREGROUND_COLOR);
drawCenteredString(g, "u2713", x, y);
}
continue;
}
// for other tiles
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);
}
}Lopuksi ohitetaan JPane-luokasta peräisin oleva paintComponent-menetelmä. Käytämme sitten drawGrid-menetelmää ja sen jälkeen drawStartMessage-menetelmää näyttääksemme viestin, joka kehottaa meitä napsauttamalla aloittamaan pelin:
private void drawStartMessage(Graphics2D g) {
if (gameOver) {
g.setFont(getFont().deriveFont(Font.BOLD, 18));
g.setColor(FOREGROUND_COLOR);
String s = "Click to start new game";
g.drawString(s, (getWidth() - g.getFontMetrics().stringWidth(s)) / 2,
getHeight() - margin);
}
}
private void drawCenteredString(Graphics2D g, String s, int x, int y) {
// center string s for the given tile (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);
}Reagoi käyttäjien toimiin käyttöliittymässä
Jotta peli etenee, on tarpeen käsitellä käyttäjän toimia käyttöliittymässä. Voit tehdä tämän lisäämällä MouseListener-toteutuksen Jpanelissa ja liikkuvien kohtien koodin, joka näkyy jo yllä:
addMouseListener(new MouseAdapter() {
@Override
public void mousePressed(MouseEvent e) {
// used to let users to interact on the grid by clicking
// it's time to implement interaction with users to move tiles to solve the game !
if (gameOver) {
newGame();
} else {
// 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;
}
// we check if game is solved
gameOver = isSolved();
}
// we repaint panel
repaint();
}
});Asetamme koodin GameOfFifteen-luokan konstruktoriin. Aivan lopussa kutsumme newGame-menetelmää uuden pelin aloittamiseksi.
Koko pelikoodi
Viimeinen vaihe ennen pelin näkemistä toiminnassa on koota kaikki koodielementit yhteen. Tässä on mitä tapahtuu:
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;
// We are going to create a Game of 15 Puzzle with Java 8 and Swing
// If you have some questions, feel free to read comments ;)
public class GameOfFifteen extends JPanel { // our grid will be drawn in a dedicated Panel
// Size of our Game of Fifteen instance
private int size;
// Number of tiles
private int nbTiles;
// Grid UI Dimension
private int dimension;
// Foreground Color
private static final Color FOREGROUND_COLOR = new Color(239, 83, 80); // we use arbitrary color
// Random object to shuffle tiles
private static final Random RANDOM = new Random();
// Storing the tiles in a 1D Array of integers
private int[] tiles;
// Size of tile on UI
private int tileSize;
// Position of the blank tile
private int blankPos;
// Margin for the grid on the frame
private int margin;
// Grid UI Size
private int gridSize;
private boolean gameOver; // true if game over, false otherwise
public GameOfFifteen(int size, int dim, int mar) {
this.size = size;
dimension = dim;
margin = mar;
// init tiles
nbTiles = size * size - 1; // -1 because we don't count blank tile
tiles = new int[size * size];
// calculate grid size and tile size
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) {
// used to let users to interact on the grid by clicking
// it's time to implement interaction with users to move tiles to solve the game !
if (gameOver) {
newGame();
} else {
// 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;
}
// we check if game is solved
gameOver = isSolved();
}
// we repaint panel
repaint();
}
});
newGame();
}
private void newGame() {
do {
reset(); // reset in intial state
shuffle(); // shuffle
} while(!isSolvable()); // make it until grid be solvable
gameOver = false;
}
private void reset() {
for (int i = 0; i < tiles.length; i++) {
tiles[i] = (i + 1) % tiles.length;
}
// we set blank cell at the last
blankPos = tiles.length - 1;
}
private void shuffle() {
// don't include the blank tile in the shuffle, leave in the solved position
int n = nbTiles;
while (n > 1) {
int r = RANDOM.nextInt(n--);
int tmp = tiles[r];
tiles[r] = tiles[n];
tiles[n] = tmp;
}
}
// Only half permutations of the puzzle are solvable.
// Whenever a tile is preceded by a tile with higher value it counts
// as an inversion. In our case, with the blank tile in the solved position,
// the number of inversions must be even for the puzzle to be solvable
private boolean isSolvable() {
int countInversions = 0;
for (int i = 0; i < nbTiles; i++) {
for (int j = 0; j < i; j++) {
if (tiles[j] > tiles[i])
countInversions++;
}
}
return countInversions % 2 == 0;
}
private boolean isSolved() {
if (tiles[tiles.length - 1] != 0) // if blank tile is not in the solved position ==> not solved
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 < tiles.length; i++) {
// we convert 1D coords to 2D coords given the size of the 2D Array
int r = i / size;
int c = i % size;
// we convert in coords on the UI
int x = margin + c * tileSize;
int y = margin + r * tileSize;
// check special case for blank tile
if(tiles[i] == 0) {
if (gameOver) {
g.setColor(FOREGROUND_COLOR);
drawCenteredString(g, "u2713", x, y);
}
continue;
}
// for other tiles
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);
}
}
private void drawStartMessage(Graphics2D g) {
if (gameOver) {
g.setFont(getFont().deriveFont(Font.BOLD, 18));
g.setColor(FOREGROUND_COLOR);
String s = "Click to start new game";
g.drawString(s, (getWidth() - g.getFontMetrics().stringWidth(s)) / 2,
getHeight() - margin);
}
}
private void drawCenteredString(Graphics2D g, String s, int x, int y) {
// center string s for the given tile (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);
}
public static void main(String[] args) {
SwingUtilities.invokeLater(() -> {
JFrame frame = new JFrame();
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setTitle("Game of Fifteen");
frame.setResizable(false);
frame.add(new GameOfFifteen(4, 550, 30), BorderLayout.CENTER);
frame.pack();
// center on the screen
frame.setLocationRelativeTo(null);
frame.setVisible(true);
});
}
}Lopuksi leikitään!
On aika käynnistää peli ja testata sitä toiminnassa. Kentän pitäisi näyttää tältä:
Yritetään ratkaista arvoitus. Jos kaikki meni hyvin, saamme tämän:
Siinä kaikki. Odotitko enemmän? 🙂
Skillbox suosittelee:
- Käytännön kurssi .
- Sovellettu verkkokurssi .
- Kahden vuoden käytännön kurssi .
Lähde: will.com