यह कैसे किया जाता है: हम 4 मिनट में "माइनस्वीपर" लिखते हैं

अनुवादक से: यह पोस्ट एक अनुभवी कोडर मैकी चेज़ के मूल लेख का अनुवाद है, जो न केवल महान कार्यक्रम लिखते हैं, बल्कि शुरुआती और पेशेवरों दोनों के लिए अपने सहयोगियों को विभिन्न भाषाओं की क्षमताओं को प्रदर्शित करते हैं।

माइनस्वीपर एक मजेदार खेल है, हम में से कई इसे खेलते हैं। हो सकता है कि आप खुद ही माइनस्वीपर बनाना चाहें?

स्किलबॉक्स सलाह देता है: ऑनलाइन पेशा "वेब डेवलपर पेशा" ।

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

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

मैं सुझाव देता हूं कि प्रसंस्करण पर "माइनस्वीपर" लिखने की कोशिश कर रहा हूं। यह एक महान उपकरण है जो आपको जावा में ग्राफिकल एप्लिकेशन बनाने की अनुमति देता है। इसे यहां लिंक करें ।

शुरू करने से पहले, मैं कहता हूँ कि यह ट्यूटोरियल उन लोगों के लिए है जो पहले से ही जावा को जानते हैं। प्रसंस्करण के साथ अनुभव वैकल्पिक है।

तो यहाँ हम चलते हैं। पहला चरण खेल की स्थिति को निर्धारित करना है। मैंने इसे इस तरह लागू करने का फैसला किया।

int gridW; // grid width int gridH; // grid height int numMines; // number of mines on the board int[][] mines; // entry is 1 for having a mine and 0 for not boolean[][] flags; // entry is true if you have flagged that spot boolean[][] revealed; // entry is true if that spot is revealed 

इस खंड को छोड़कर सब कुछ यहाँ समझ में आता है: int [] [] खानों । खदान एक पूर्णांक क्यों है और एक बूलियन नहीं है? तथ्य यह है कि यह गणना करना आसान बनाता है कि कितनी खदानें एक निश्चित स्थिति के करीब हैं।

 int calcNear(int x, int y) { int i=0; for (int offsetX=-1; offsetX<=1; offsetX++) { for (int offsetY=-1; offsetY<=1; offsetY++) { i+=mines[offsetX+x][offsetY+y]; } } return i; } 

यह कोड निर्धारित करता है कि एक विशिष्ट साइट के पास कितनी खदानें हैं। अपवादों को हटाने के बाद, हमें इसके समान कुछ मिलता है:

 boolean outBounds(int x,int y){ return x<0||y<0||x>=gridW||y>=gridH; } int calcNear(int x, int y) { if(outBounds(x,y))return 0; int i=0; for (int offsetX=-1; offsetX<=1; offsetX++) { for (int offsetY=-1; offsetY<=1; offsetY++) { if (outBounds(offsetX+x, offsetY+y))continue; i+=mines[offsetX+x][offsetY+y]; } } return i; } 

खेल का मुख्य कार्य खुद ही बिंदु x, y पर शुरू होने वाले वर्गों को प्रकट करना है।

 void reveal(int x, int y){ if(outBounds(x,y))return; if(revealed[x][y])return; revealed[x][y]=true; if(calcNear(x,y)!=0)return; reveal(x-1,y-1); reveal(x-1,y+1); reveal(x+1,y-1); reveal(x+1,y+1); reveal(x-1,y); reveal(x+1,y); reveal(x,y-1); reveal(x,y+1); } 

परिणामस्वरूप, हमारे पास निम्न एल्गोरिथम है:

• यदि स्थिति फ़ील्ड के बाहर है, तो अंत;
• यदि स्थिति का खुलासा किया जाता है, तो अंत;
• हम वर्तमान स्थिति को खोलते हैं;
• अगर हमारे पास मौजूदा स्थिति के पास बम है, तो अंत;
• यदि हम फ़ंक्शन के निष्पादन के दौरान इस बिंदु पर पहुंच गए, तो खेल के मैदान के भीतर की वर्तमान स्थिति पाई गई और इसके बगल में कोई बम नहीं हैं, आसन्न वर्ग खोलें।

मूल रूप से, बाकी खेल एक ही है। इस लिंक पर क्लिक करके पूरा कोड पाया जा सकता है।

यदि आप विज़ुअलाइज़ेशन के बारे में जानना चाहते हैं, तो पढ़ें।

दृश्य

यहां सब कुछ स्पष्ट होना चाहिए, लेकिन मैं कठिन भागों की व्याख्या करूंगा।

तो, हमारे पास एक परिवर्तनशील सेलसाइज़ है, जो प्रत्येक वर्ग में पिक्सेल की संख्या निर्धारित करता है।

 void settings(){ size(gridW*cellSize, gridH*cellSize); } 

इस प्रकार, हम पक्षों के साथ एक फ़ील्ड बनाते हैं ग्रिड डब्ल्यू एक्स ग्रिड, जहां प्रत्येक वर्ग का आकार सेलसाइज़ के मूल्य के बराबर होगा।

फिर हम चर को उनकी मूल स्थिति में लौटाते हैं।

 void setup(){ //initialize and clear the arrays mines=new int[gridW][gridH]; flags=new boolean[gridW][gridH]; revealed=new boolean[gridW][gridH]; for(int x=0;x<gridW;x++){ for(int y=0;y<gridH;y++){ mines[x][y]=0; flags[x][y]=false; revealed[x][y]=false; } } } 

किसी फ़ील्ड को प्रारंभ करने के लिए:

 //Place numMines mines on the grid void placeMines(){ int i=0; while(i<numMines){//We don't want mines to overlap, so while loop int x=int(random(gridW)); int y=int(random(gridH)); if(mines[x][y]==1)continue; mines[x][y]=1; i++; } } //Clear the mines void clearMines() { for (int x=0; x<gridW; x++) { for (int y=0; y<gridH; y++) { mines[x][y]=0; } } } 

और फिर माउस क्लिक की प्रतिक्रिया को चालू करें।

 //We don't want the first click to be a mine boolean firstClick=true; void mousePressed() { int x=int(mouseX/cellSize); int y=int(mouseY/cellSize); //Right-click is flagging or de-flagging a square if (mouseButton==RIGHT) { flags[x][y]=!flags[x][y]; return; } else {//left-click //Avoid making the first click a mine if (firstClick) { firstClick=false; do { clearMines(); placeMines(); } while (calcNear(x,y)!=0); } //Check for game loss if (mines[x][y]!=0) { println("Dang!"); exit(); } else {//If game not lost, reveal starting from that square reveal(x, y); } } } 

और प्रदर्शन समारोह, हम इसे प्रत्येक फ्रेम के लिए एक बार कहते हैं।

 void draw() { background(0); //For each cell for (int x=0; x<gridW; x++) { for (int y=0; y<gridH; y++) { //The colors alternate for texture color col1=color(2*255/5); color col2=color(3*255/5); color txtColor=color(0); int near=calcNear(x, y); if (flags[x][y]) { col1=color(255, 0, 0); col2=color(4*255/5, 255/5, 255/5); } else if (revealed[x][y]) { col1=color(255/2); col2=color(255/2); } if (near==1)txtColor=color(255*1/4, 255*1/4, 255*3/4); if (near==2)txtColor=color(255*1/4, 255*3/4, 155*1/4); if (near==3)txtColor=color(255, 0, 0); if (near==4)txtColor=color(0, 0, 255); if (near==5)txtColor=color(255, 0, 0); boolean alternate=(x+y)%2==0; if (alternate) { fill(col2); stroke(col2); } else { fill(col1); stroke(col1); } //if(mines[x][y]>0){ //fill(0,255,0); //stroke(0,255,0); //} rect(x*cellSize, y*cellSize, cellSize, cellSize); //If there is a mine near this spot and it is revealed if (near>0&&revealed[x][y]) { fill(txtColor); noStroke(); textAlign(LEFT, TOP); textSize(cellSize); text(""+near, x*cellSize, y*cellSize); } } } } 

और यह सब, यहाँ हमारे Minesweeper है।

खेल सरल दिखता है, लेकिन कुल मिलाकर यह पूरी तरह कार्यात्मक है। और याद रखें: माइनस्वीपर नशे की लत है!

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

• ऑनलाइन कोर्स "प्रोफेशन फ्रंटेंड-डेवलपर । "
• व्यावहारिक एक वर्षीय पाठ्यक्रम PHP डेवलपर ।
• व्यावहारिक पाठ्यक्रम "मोबाइल डेवलपर प्रो" ।