"Viisteist" Java's — kuidas arendada täielikku mängu

«Viisteist», või «Viisteistk» on suurepärane näide lihtsast loogikapallist, mis on populaarne üle kogu maailma. Mõistatuse lahendamiseks tuleb numbrilised ruudud paigutada õigesse järjestusse, alates väiksemast kuni suuremani. See pole lihtne, kuid on huvitav.

Käesolevas õpetuses näitame, kuidas arendada «Viisteist» Java 8 ja Eclipse'i abil. Kasutame kasutajaliidese loomiseks Swing API-d.

Tuletame meelde: kõigile «Habr» lugejatele – 10 000 rubla allahindlus igale Skillboxi kursusele, kasutades sooduskoodi «Habr».

Skillbox soovitab: Haridusalane veebikursus «Java-arendaja amet».

Mängu kavandamine

Selles etapis tuleb määratleda omadused:

• Size — mänguvälja suurus;
• nbTiles — ruutude arv mänguväljal. nbTiles = size*size — 1;
• Tiles — viisteist, mis on ühe mõõtmega täisarvude massiiv. Igal viisteistk on ainulaadne väärtus vahemikus [0, nbTiles]. Null tähistab tühja ruutu;
• blankPos — tühja ruudu positsioon.

Mängu loogika

Peab määratlema nullimise (reset) meetodi, mida kasutatakse uue mänguasendi initsialiseerimiseks. Nii seadistame väärtuse iga viisteistk massiivi elemendi jaoks. Seejärel paneme blankPos massiivi viimasesse positsiooni.

Vajame ka segamise meetodit, et viisteiste massiivi segada. Jätame tühja viisteistk segamisprotsessist välja, et see jääks oma kohale.

Kuna ainult pool võimalikest mänguasenditest on lahendatavad, tuleb kontrollida saadud segamise tulemust, et veenduda, et praegune paigutus on tõesti lahendatav. Selleks määratleme meetodi isSolvable.

Kui konkreetsele viisteistk'le eelneb viisteistk, mille väärtus on kõrgem, loetakse seda inversiooniks. Kui tühja viisteistk on oma kohas, peab inversioonide arv olema paarisarv, et mõistatus oleks lahendatav. Seega loeme inversioonide arvu ja tagastame true, kui arv on paarisarv.

Seejärel on oluline määratleda meetod isSolved, et kontrollida, kas meie viisteistk paigutus on lahendatud. Esiteks vaatame, kus asub tühja viisteistk. Kui algasendis, siis on praegune paigutus uus, mitte kunagi lahendatud. Seejärel vaatame üle plaatide väärtused vastupidises järjekorras ning kui viisteistk'i väärtus erineb vastavast indeksist +1, tagastame false. Vastupidiselt tagastame meetodi lõpus true, kuna mõistatus on juba lahendatud.

Teine meetod, mida tuleb määratleda, on newGame. Seda vajatakse uue mängu eksemplari loomiseks. Selleks lähtestame mänguvälja, segame seda ja jätkame, kuni mängupositsioon on lahendatav.

Siin on koodinäide, mis sisaldab peamist loogikat viiekümnese mängu jaoks:

private void newGame() {
  do {
    reset(); // lähtesta algseisund
    shuffle(); // sega
  } while(!isSolvable()); // jätka, kuni ruut on lahendatav
 
  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;
  }
}
 
// Ainult pool puzzle permutatsioonidest on lahendatavad/
// Iga kord, kui plaat on eelnevalt kõrgema väärtusega plaadi ees,
// loetakse see pöördeks. Meie puhul, kui tühi plaat on lahendatud positsioonis,
// peavad pöörded olema paarisarv, et puzzle oleks lahendatav
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) // kui tühi plaat ei ole lahendatud positsioonis == mitte lahendatud
    return false;
 
  for (int i = nbTiles - 1; i >= 0; i--) {
    if (tiles[i] != i + 1)
      return false;
  }
 
  return true;
}

Lõpuks tuleb programmeerida viiekümnese mängu liikuvad plaadid massiivis. Seda koodi kutsutakse hiljem tagasi (callback), et reageerida kursori liikumisele. Meie mäng toetab mitme plaadi liikumist samaaegselt. Seega, pärast selle leidmist, et vajutatud positsioon ekraanil vastab viiekümnesele plaadile, leiame tühja plaadi positsiooni ja otsime liikumise suunda, et toetada mitme plaadi liikumist samaaegselt.

Siin on koodinäide:

// 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;

Arendame kasutajaliidese Swing API-l

On aeg tegeleda liidesega. Alustame Jpanel klassist. Siis joonistame mängulaudadele viiekümneseid — iga plaadi suuruse arvutamiseks kasutame andmeid, mis on määratud mängu konstruktoriparameetris:

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

Margin on samuti paramater, mis on määratud mängu konstruktoris.

Nüüd tuleb määratleda meetod drawGrid, et joonistada ruut ja viiekümnesed ekraanile. Analüüsime viiekümneste massiivi ja muundame koordinaadid kasutajaliidese koordinaatideks. Seejärel joonistame iga viiekümnese vastava numbri keskele:

private void drawGrid(Graphics2D g) {
  for (int i = 0; i < tiles.length; i++) {
    // me konverteerime 1D koordinaadid 2D koordinaatideks, arvestades 2D massiivi suurust
    int r = i / size;
    int c = i % size;
    // me konverteerime UI koordinaatideks
    int x = margin + c * tileSize;
    int y = margin + r * tileSize;
 
    // kontrollime, kas on eriline juhtum tühja plaadi puhul
    if(tiles[i] == 0) {
      if (gameOver) {
        g.setColor(FOREGROUND_COLOR);
        drawCenteredString(g, "u2713", x, y);
      }
 
      continue;
    }
 
    // teiste plaatide puhul
    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);
  }
}

Lõpuks ületame paintComponent meetodi, mis pärineb JPane klassist. Seega kasutame drawGrid meetodit, ning seejärel drawStartMessage meetodit, et kuvada sõnum, mis kutsub klikkima mängu alustamiseks:

private void drawStartMessage(Graphics2D g) {
  if (gameOver) {
    g.setFont(getFont().deriveFont(Font.BOLD, 18));
    g.setColor(FOREGROUND_COLOR);
    String s = "Kliki, et alustada uut mängu";
    g.drawString(s, (getWidth() - g.getFontMetrics().stringWidth(s)) / 2,
        getHeight() - margin);
  }
}
 
private void drawCenteredString(Graphics2D g, String s, int x, int y) {
  // tsenterime stringi s antud plaadi (x,y) osas
  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);
}

Reageerime kasutaja toimingutele UI-s

Kuna mäng peab oma rada käima, on vajalik kasutaja toimingute töötlemine UI-s. Selleks lisame MouseListeneri rakenduse Jpanelile ja koodi, et viia viieplaate, nagu eelnevalt näidatud:

addMouseListener(new MouseAdapter() {
  @Override
  public void mousePressed(MouseEvent e) {
    // võimaldab kasutajatel suhelda ruudustiku kaudu klikkides
    // on aeg rakendada kasutaja interaktsiooni plaatide liigutamiseks mängu lahendamiseks!
    if (gameOver) {
      newGame();
    } else {
      // saadakse klikikoht
      int ex = e.getX() - margin;
      int ey = e.getY() - margin;
 
      // klikiti ruudustikus?
      if (ex  gridSize || ey  gridSize)
        return;
 
      // saadakse positsioon ruudustikus
      int c1 = ex / tileSize;
      int r1 = ey / tileSize;
 
      // saadakse tühja ruudu positsioon
      int c2 = blankPos % size;
      int r2 = blankPos / size;
 
      // me konverteerime 1D koordinaati
      int clickPos = r1 * size + c1;
 
      int dir = 0;
 
      // otsime suunda mitme plaadi liikumiseks korraga
      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) {
        // liigutame plaate suunas
        do {
          int newBlankPos = blankPos + dir;
          tiles[blankPos] = tiles[newBlankPos];
          blankPos = newBlankPos;
        } while(blankPos != clickPos);
 
        tiles[blankPos] = 0;
      }
 
      // kontrollime, kas mäng on lahendatud
      gameOver = isSolved();
    }
 
    // uuendame paneeli
    repaint();
  }
});

Kood loome klassi GameOfFifteen konstruktoris. Lõpus kutsume üles meetodi newGame, et alustada uut mängu.

Täielik mängu kood

Viimane samm enne mängu nägemist on kokku koguda kõik koodi elemendid. Siin on, mis meid ootab:

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;
 
// Loome 15-tükki mõistatus mängu Java 8 ja Swingiga
// Kui teil on küsimusi, siis looge julgelt kommentaare ;)
public class GameOfFifteen extends JPanel { // meie ruudustik joonistatakse spetsiaalses paneelis
 
  // Meie 15-tükki mängu eksemplari suurus
  private int size;
  // Plaatide arv
  private int nbTiles;
  // Ruudustiku UI mõõtmed
  private int dimension;
  // Esimene värv
  private static final Color FOREGROUND_COLOR = new Color(239, 83, 80); // kasutame suvalist värvi
  // Plaatide segamiseks suvaline objekt
  private static final Random RANDOM = new Random();
  // Plaatide salvestamine 1D täisarvude massiivi
  private int[] tiles;
  // Plaadi suurus UI-s
  private int tileSize;
  // Tühja plaadi asukoht
  private int blankPos;
  // Ruudustiku servad raamile
  private int margin;
  // Ruudustiku UI suurus
  private int gridSize;
  private boolean gameOver; // tõene, kui mäng on läbi, vale vastasel juhul
 
  public GameOfFifteen(int size, int dim, int mar) {
    this.size = size;
    dimension = dim;
    margin = mar;
    
    // algatame plaadid
    nbTiles = size * size - 1; // -1, sest me ei arvesse tühja plaati
    tiles = new int[size * size];
    
    // arvutame ruudustiku suuruse ja plaadi suuruse
    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) {
        // kasutame, et lasta kasutajatel ruudustikus klõpsata
        // on aeg rakendada kasutajatega suhtlemist, et liikuda plaate mängu lahendamiseks!
        if (gameOver) {
          newGame();
        } else {
          // saadud klõpsu positsioon
          int ex = e.getX() - margin;
          int ey = e.getY() - margin;
          
          // klõps ruudustikus?
          if (ex  gridSize  || ey  gridSize)
            return;
          
          // saadud positsioon ruudustikus
          int c1 = ex / tileSize;
          int r1 = ey / tileSize;
          
          // saadud tühja ruumi positsioon
          int c2 = blankPos % size;
          int r2 = blankPos / size;
          
          // teisendame 1D koordinaatidesse
          int clickPos = r1 * size + c1;
          
          int dir = 0;
          
          // otsime suunda, et mitu plaati korraga liikuda
          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) {
            // liigutame plaate suunas
            do {
              int newBlankPos = blankPos + dir;
              tiles[blankPos] = tiles[newBlankPos];
              blankPos = newBlankPos;
            } while(blankPos != clickPos);
            
            tiles[blankPos] = 0;
          }
          
          // kontrollime, kas mäng on lahendatud
          gameOver = isSolved();
        }
        
        // uuendame paneeli
        repaint();
      }
    });
    
    newGame();
  }
 
  private void newGame() {
    do {
      reset(); // lähtestamine algseisundisse
      shuffle(); // segamine
    } while(!isSolvable()); // teeme, kuni ruut on lahendatav
    
    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;
    }
  }
 
  // Ainult pool mõistatuse permutatsioonidest on lahendatavad.
  // Iga kord, kui plaat eelneb kõrgema väärtusega plaadile, siis loetakse
  // selleks inversioon. Meie puhul peab lahendatud positsiooniga
  // tühja plaadi puhul olema inversioonide arv paaris, et mõistatus oleks lahendatav
  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) // kui tühi plaat ei ole lahendatud positsioonis ==> pole lahendatud
      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("15 Plaadi Mäng");
      frame.setResizable(false);
      frame.add(new GameOfFifteen(4, 550, 30), BorderLayout.CENTER);
      frame.pack();
      // keskendame ekraanil
      frame.setLocationRelativeTo(null);
      frame.setVisible(true);
    });
  }
 
 
}

Lõpuks mängime!

On just õige aeg mängu käivitamiseks ja selle toimimist kontrollimiseks. Väli peaks välja nägema järgmiselt:

Püüame mõistatusi lahendada. Kui kõik läheb hästi, saame sellise tulemuse:

Nii ongi. Kas ootasite rohkem? 🙂

Skillbox soovitab:

• Praktiline kursus «Mobiilne arendaja PRO».
• Rakenduslik veebikursus «Andmeanalüütik Pythonis».
• Kaks aastat praktilist kursust „Mina olen PRO veebiarendaja“.

Allikas: habr.com