«Kümme» Java-s — kuidas arendada täisväärtuslikku mängu

«Viisakus» või «Viiekas» on suurepärane näide lihtsast loogika mängust, mis on populaarsuselt üle kogu maailma. Probleemi lahendamiseks tuleb numbrikastid paigutada järjestikku, alates väiksemast kuni suuremani. See ei ole lihtne, aga huvitav.

Käesolevas õpetuses näitame, kuidas luua «Viiekas» Java 8-ga Eclipse’is. Kasutame kasutajaliidese arendamiseks Swing API-d.

Tuletame meelde: kõigile «Habra» lugejatele — 10 000 rubla soodustus, kui registreerite end Skillboxi mis tahes kursusele promokoodi «Habr» abil.

Skillbox soovitab: Hariduslik veebikursus „Java-arendaja amet“.

Mängu disainimine

Selles etapis tuleb määratleda omadused:

• Size — mänguvälja suurus;
• nbTiles — mängunuppude arv mänguväljal. nbTiles = size*size — 1;
• Tiles — nupp, mis kujutab endast ühemõõtmelist täisarvude massiivi. Iga nupp saab ainulaadse väärtuse vahemikus [0, nbTiles]. Null tähistab tühja kasti;
• blankPos — tühja kasti positsioon.

Mängu loogika

Tuleb määratleda nullimismeetod (reset), mida kasutatakse uue mängupositsiooni algatamiseks. Nii paneme väärtuse igasse mängunupu massiivi elemendisse. Siis paigutame blankPos massiivi viimasesse positsiooni.

Samuti on vajalik shuffle meetod mängunuppude massiivi segamiseks. Me ei kaasata tühja nuppu segamisse, et hoida see endises positsioonis.

Kuna vaid pool võimalikest mõistatuste algpositsioonidest on lahendatavad, tuleb segunemise tulemus kontrollida, et veenduda, kas praegune asetuse olukord on üleüldse lahendatav. Selleks määratleme meetodi isSolvable.

Kui konkreetse viiese enne on viies, mille väärtus on suurem, loetakse seda inversiooniks. Kui tühi viies on oma kohas, peab inversioonide arv olema paarisarv, et mõistatus oleks lahendatav. Seega loendame inversioonide arvu ja tagastame true, kui arv on paarisarv.

Seejärel on oluline määratleda meetod isSolved, et kontrollida, kas meie mängu Game Of Fifteen asetuse olek on lahendatud. Esiteks vaatame, kus asub tühi viies. Kui algasendis, siis on praegune asetuse olek uus, varem lahendamata. Seejärel läbime plaadid vastupidises järjestuses ja kui viie väärtus erineb vastava indeksi +1-st, tagastame false. Kui mitte, on lõpuks meetodis aeg tagastada true, sest mõistatus on juba lahendatud.

Teine meetod, mille määratlemine on vajalik, on newGame. See on vajalik uue mängu eksemplari loomiseks. Selleks lähtestame mänguvälja, seejärel segame selle ja jätkame, kuni mängupositsioon on lahendatav.

Siin on näide koodist, kus on peamine loogika viiekesi mängus:

private void newGame() {
  do {
    reset(); // lähtesta algses olekus
    shuffle(); // sega
  } while(!isSolvable()); // tee, kuni ruudustik 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 püsivast mängust on lahendatavad/
// Iga kord, kui plaat eelneb kõrgema väärtusega plaadile, loetakse see
// pöördeks. Meie juhul, kui tühja plaat on lahendatud positsioonis,
// peab pöördepunkte olema paarisarv, et mäng 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ühja plaat ei ole lahendatud positsioonis ==>
    return false;
 
  for (int i = nbTiles - 1; i >= 0; i--) {
    if (tiles[i] != i + 1)
      return false;
  }
 
  return true;
}

Lõpuks tuleb programmeerida klotside liikumine massiivis. Seda koodi kutsutakse hiljem välja tagasikutsumise (callback) teel, et reageerida hiirekursori liikumisele. Meie mäng toetab mitme klotsi liikumist samaaegselt. Seega, pärast seda, kui oleme muundanud ekraanil vajutatud positsiooni klotsiks, saame tühja klotsi positsiooni ja otsime liikumissuunda, et toetada selle korraga mitut liikumist.

Siin on koodi nä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 UI-d Swing API abil

On aeg tegeleda liidese kujundamisega. Esiteks võetakse klass Jpanel. Seejärel joonistame klotse mänguväljakule — iga klotsi mõõtmete arvutamiseks kasutame mängu konstruktori parameetrites määratletud andmeid:

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

Margin on samuti parameeter, mis on määratud mängu konstruktori kaudu.

Nüüd tuleb määrata meetod drawGrid, et joonistada võrk ja klotsid ekraanile. Analüüsime klotside massiivi ja muundame koordinaadid kasutajaliidese koordinaatideks. Seejärel joonistame iga klotsi keskmesse vastava numbri:

private void drawGrid(Graphics2D g) {
  for (int i = 0; i < tiles.length; i++) {
    // me konverteerime 1D koordinadid 2D koordinatideks vastavalt 2D massiivi suurusele
    int r = i / size;
    int c = i % size;
    // me konverteerime sisendkoordinadid UI-s
    int x = margin + c * tileSize;
    int y = margin + r * tileSize;

    // kontrollime erijuhtumit tühja plaadi jaoks
    if(tiles[i] == 0) {
      if (gameOver) {
        g.setColor(FOREGROUND_COLOR);
        drawCenteredString(g, "u2713", x, y);
      }

      continue;
    }

    // teiste plaatide jaoks
    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 üle kirjutame paintComponent meetodi, mis pärineb JPane klassist. Seejärel kasutame meetodit drawGrid ja seejärel meetodit drawStartMessage, 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) {
  // keskenda string s antud ruudule (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);
}

Kasutaja tegevusele reageerimine kasutajaliideses

Kuna mäng peab sujuvalt kulgema, on vajalik kasutaja tegevuste töötlemine kasutajaliideses. Selleks lisame Jpanelile MouseListener'i ja koodi viie tükki liigutamiseks, nagu on juba ülal näidatud:

addMouseListener(new MouseAdapter() {
  @Override
  public void mousePressed(MouseEvent e) {
    // kasulik kasutaja liikumiseks ruudustikul hiireklikkide kaudu
    // on aeg rakendada kasutajate interaktsiooni, et liikuda plaatide vahel mängu lahendamiseks!
    if (gameOver) {
      newGame();
    } else {
      // võtame kliki positsiooni
      int ex = e.getX() - margin;
      int ey = e.getY() - margin;
 
      // klikk ruudustikus?
      if (ex  gridSize || ey  gridSize)
        return;
 
      // võtame positsiooni ruudustikus
      int c1 = ex / tileSize;
      int r1 = ey / tileSize;
 
      // võtame tühja raku positsiooni
      int c2 = blankPos % size;
      int r2 = blankPos / size;
 
      // muundame 1D koordinaatideks
      int clickPos = r1 * size + c1;
 
      int dir = 0;
 
      // otsime suunda mitme plaadi liigutamiseks 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) {
        // liigume plaatidega 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();
    }
 
    // uuesti joonistame paneeli
    repaint();
  }
});

Kood asetatakse klassi GameOfFifteen konstruktorisse. Lõpus kutsume välja meetodi newGame, et alustada uut mängu.

Mängu täiskood

Viimane samm enne mängu nägemist tegevuses on kõik koodi elemendid kokku panna. Siin on, mida saate:

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 Pusle Mängu Java 8 ja Swingiga
// Küsimuste korral lugege julgelt kommentaare ;)
public class GameOfFifteen extends JPanel { // meie ruudustik joonistatakse spetsiaalses paneelis
 
  // Meie 15 mängu 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 erivärvi
  // Plaatide segamiseks mõeldud juhuslik 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 serv
  private int margin;
  // Ruudustiku UI suurus
  private int gridSize;
  private boolean gameOver; // tõene, kui mäng on läbi, vale vastupidiselt
 
  public GameOfFifteen(int size, int dim, int mar) {
    this.size = size;
    dimension = dim;
    margin = mar;
    
    // initsialiseerime plaadid
    nbTiles = size * size - 1; // -1, sest me ei arvesta tühja plaati
    tiles = new int[size * size];
    
    // arvutame ruudustiku 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) {
        // kasutatakse, et lasta kasutajatel ruudustikku interakteeruda hiireklõpsudega
        // on aeg rakendada kasutajatega interaktsiooni, et liikuda plaatidega mängu lahendamiseks!
        if (gameOver) {
          newGame();
        } else {
          // saame klõpsuse asukoha
          int ex = e.getX() - margin;
          int ey = e.getY() - margin;
          
          // klõps ruudustikus?
          if (ex  gridSize  || ey  gridSize)
            return;
          
          // saame asukoha ruudustikus
          int c1 = ex / tileSize;
          int r1 = ey / tileSize;
          
          // saame tühja ruudu asukoha
          int c2 = blankPos % size;
          int r2 = blankPos / size;
          
          // konverteerime 1D koordinaatides
          int clickPos = r1 * size + c1;
          
          int dir = 0;
          
          // otsime suunda mitme plaadi liigutamiseks 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();
        }
        
        // joonistame paneeli uuesti
        repaint();
      }
    });
    
    newGame();
  }
 
  private void newGame() {
    do {
      reset(); // lähtestame algolekusse
      shuffle(); // segame
    } while(!isSolvable()); // teeme seda seni, kuni ruudustik 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 pooled pusle permutatsioonid on lahendatavad.
  // Iga kord, kui plaat on eelneva suurema väärtusega plaadi ees, loetakse see
  // tagasi pöördumisel. Meie juhul, kui tühja plaat on lahendatud positsioonis,
  // peavad inversioonide arv olema paaris, et pusle 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ühja plaat ei ole lahendatud positsioonis == false
      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 Pusle Mäng");
      frame.setResizable(false);
      frame.add(new GameOfFifteen(4, 550, 30), BorderLayout.CENTER);
      frame.pack();
      // keskele ekraanile
      frame.setLocationRelativeTo(null);
      frame.setVisible(true);
    });
  }
 
 
}

Lõpuks saame mängida!

Nüüd on õige aeg mäng käivitada ja vaadata, kuidas see toimib. Mänguväli peaks välja nägema järgmiselt:

Proovime mõistatust lahendada. Kui kõik läheb hästi, siis saame järgmise tulemuse:

Ja kõik! Kas te ootasite rohkem? 🙂

Skillbox soovitab:

• Praktiline kursus «Mobiilne arendaja PRO».
• Rakenduslik veebikursus „Andmeanalüütik Pythonis“.
• Kaheaastane praktiline kursus „Ma olen PRO veebiarendaja“.

Allikas: habr.com