जावा में "पंद्रह" - एक पूर्ण गेम कैसे विकसित किया जाए

पंद्रह, या पंद्रह, दुनिया भर में लोकप्रिय एक सरल तर्क खेल का एक बड़ा उदाहरण है। पहेली को हल करने के लिए, आपको छोटे से बड़े तक क्रम में संख्याओं के साथ वर्गों को व्यवस्थित करने की आवश्यकता है। यह आसान नहीं है, लेकिन दिलचस्प है।

आज के ट्यूटोरियल में, हम दिखाते हैं कि ग्रहण के साथ जावा 8 में पंद्रह को कैसे विकसित किया जाए। UI विकसित करने के लिए, हम स्विंग एपीआई का उपयोग करेंगे।

हम आपको याद दिलाते हैं: "हैबर" के सभी पाठकों के लिए - "हैबर" प्रोमो कोड का उपयोग करके किसी भी स्किलबॉक्स कोर्स के लिए पंजीकरण करते समय 10,000 रूबल की छूट।

स्किलबॉक्स अनुशंसा करता है: ऑन-लाइन शैक्षिक पाठ्यक्रम "प्रोफेशन जावा-डेवलपर" ।

खेल डिजाइन

इस स्तर पर, आपको गुणों को परिभाषित करने की आवश्यकता है:

• आकार - खेल के मैदान का आकार;
• nbTiles - क्षेत्र में स्पॉट की संख्या। nbTiles = आकार * आकार - 1;
• टाइल एक टैग है, जो पूर्णांकों का एक आयामी आयाम है। प्रत्येक टैग को रेंज में एक अद्वितीय मूल्य प्राप्त होगा [0, nbTiles]। शून्य एक खाली वर्ग को दर्शाता है;
• blankPos - रिक्त वर्ग की स्थिति।

खेल तर्क

आपको एक नई गेम पोजिशन को इनिशियलाइज़ करने के लिए उपयोग किए जाने वाले रीसेट विधि को परिभाषित करने की आवश्यकता है। इसलिए हम टैग सरणी के प्रत्येक तत्व के लिए मूल्य निर्धारित करते हैं। ठीक है, तो हम सरणी की अंतिम स्थिति में ब्लैंकपोस लगाते हैं।

आपको टैग की एक सरणी में फेरबदल करने के लिए फेरबदल विधि की भी आवश्यकता है। हम इसे पूर्व स्थिति में छोड़ने के लिए फेरबदल प्रक्रिया में एक खाली टैग शामिल नहीं करते हैं।

चूंकि पहेली के संभावित शुरुआती पदों में से केवल आधे का ही समाधान है, इसलिए आपको यह सुनिश्चित करने के लिए परिणामी मिश्रण परिणाम की जांच करनी होगी कि वर्तमान लेआउट आमतौर पर हल हो। ऐसा करने के लिए, हम isSolvable पद्धति को परिभाषित करते हैं।

यदि कोई विशिष्ट टैग किसी उच्च मान के साथ टैग से पहले है, तो इसे उलटा माना जाता है। जब खाली टैग की जगह होती है, तो पहेली को हल करने के लिए व्युत्क्रमों की संख्या भी होनी चाहिए। इसलिए, हम संख्याओं की संख्या को गिनते हैं और यदि संख्या सम है तो वापस लौटते हैं।

फिर यह जाँचने के लिए कि हमारे पंद्रह संरेखण का समाधान है, यह निर्धारित करने के लिए isSolved विधि को परिभाषित करना महत्वपूर्ण है। सबसे पहले, हम देखते हैं कि खाली टैग कहां है। यदि प्रारंभिक स्थिति में है, तो वर्तमान संरेखण एक नया है, जो पहले तय नहीं किया गया है। फिर हम उल्टे क्रम में टाइलों पर पुनरावृति करते हैं, और यदि टैग मान संबंधित +1 इंडेक्स से भिन्न होता है, तो झूठे वापस आ जाते हैं। अन्यथा, यह विधि के अंत में सच लौटने का समय है, क्योंकि पहेली पहले ही हल हो चुकी है।

परिभाषित करने के लिए एक और तरीका नया नाम है। खेल का एक नया उदाहरण बनाना आवश्यक है। ऐसा करने के लिए, हम खेल के क्षेत्र को रीसेट करते हैं, फिर इसे फेरबदल करते हैं और तब तक जारी रखते हैं जब तक कि खेल की स्थिति फिर से शुरू न हो जाए।

यहां कुंजी टैग तर्क के साथ एक उदाहरण कोड दिया गया है:

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

अंत में, आपको सरणी में स्पॉट के आंदोलन को प्रोग्राम करने की आवश्यकता है। कर्सर संचलन का जवाब देने के लिए कॉलबैक के माध्यम से इस कोड को बाद में कॉल किया जाएगा। हमारा खेल एक साथ कई टाइल चालों का समर्थन करेगा। इस प्रकार, हमने स्क्रीन पर दबाए गए स्थान को टैग में बदलने के बाद, हम खाली टैग की स्थिति प्राप्त करते हैं और एक ही समय में इसके कई आंदोलनों का समर्थन करने के लिए आंदोलन की दिशा की तलाश करते हैं।

यहाँ एक नमूना कोड है:

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

हम स्विंग एपीआई पर यूआई विकसित करते हैं

यह इंटरफ़ेस करने का समय है। सबसे पहले हम Jpanel क्लास लेते हैं। फिर हम मैदान पर स्पॉट बनाते हैं - प्रत्येक के आकार की गणना करने के लिए, हम गेम के कंस्ट्रक्टर पैरामीटर में निर्दिष्ट डेटा का उपयोग करेंगे:

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

मार्जिन भी गेम कंस्ट्रक्टर में निर्दिष्ट पैरामीटर है।

अब आपको स्क्रीन पर ग्रिड और स्पॉट खींचने के लिए drawGrid विधि को परिभाषित करने की आवश्यकता है। हम टैग की सरणी का विश्लेषण करते हैं और निर्देशांक को उपयोगकर्ता इंटरफ़ेस के निर्देशांक में परिवर्तित करते हैं। फिर केंद्र में संबंधित संख्या के साथ प्रत्येक टैग बनाएं:

 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); } 

हम यूआई में उपयोगकर्ता कार्यों का जवाब देते हैं

खेल को अपना कोर्स लेने के लिए, यूआई में उपयोगकर्ता कार्यों को संसाधित करना आवश्यक है। ऐसा करने के लिए, ऊपर दिखाए गए स्पॉट को स्थानांतरित करने के लिए जेपनेल और कोड पर माउस लिस्टनर को लागू करें:

 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(); } }); 

हम GameOfFifteen क्लास के कंस्ट्रक्टर में कोड रखते हैं। बहुत अंत में, हम एक नया गेम शुरू करने के लिए newGame विधि कहते हैं।

पूर्ण खेल कोड

अंतिम चरण, इससे पहले कि आप गेम को कार्रवाई में देखें, सभी कोड तत्वों को एक साथ इकट्ठा करना है। यहाँ परिणाम है:

 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); }); } } 

अंत में, खेलते हैं!

खेल शुरू करने और कार्रवाई में इसकी जांच करने का समय आ गया है। फ़ील्ड को इस तरह दिखना चाहिए:



पहेली को हल करने की कोशिश कर रहा है। यदि सब कुछ ठीक रहा, तो हमें यह मिला:



वह सब है। क्या आपको ज्यादा उम्मीद थी? :)

स्किलबॉक्स अनुशंसा करता है:

• व्यावहारिक पाठ्यक्रम "मोबाइल डेवलपर प्रो" ।
• एप्लाइड पायथन डेटा विश्लेषक ऑनलाइन पाठ्यक्रम।
• दो वर्षीय व्यावहारिक पाठ्यक्रम "मैं एक प्रो वेब डेवलपर हूं । "