खेल कैसे बनाएँ सासो, कार्डा, जावा में कैंची

स्टोन, कागज, कैंची एक गेम है जो दो लोगों के हाथों का उपयोग करते हुए खेला जाता है। दोनों खिलाड़ियों को तो एक साथ चुन सकते हैं और वे एक ओर तीन खेल में उपलब्ध वस्तुओं में से एक (वास्तव में रॉक, कागज या कैंची) के साथ क्या करेंगे, सूत्र "रॉक, कागज, कैंची" उच्चारण करना होगा। वस्तुओं के परिणामस्वरूप संयोजन के आधार पर विजेता निर्धारित किया जाएगा। कैंची ने कागज को हराया, पत्थर कैंची को धड़कता है, और कार्ड पत्थर की धड़कता है यदि दोनों खिलाड़ियों ने एक ही आइटम को चुना है, तो खेल के मोड़ को बाध्य माना जाता है इस ट्यूटोरियल से पता चलता है कि जावा में एक प्रोग्राम कैसे लिखा जाए जो इस गेम की गतिशीलता को दोहराता है। एक खिलाड़ी का प्रतिनिधित्व उपयोगकर्ता द्वारा किया जाएगा, जबकि बाद में कंप्यूटर द्वारा नियंत्रित किया जाएगा।

कदम

1
कार्यक्रम का मुख्य वर्ग बनाएं और उसे नाम दें RockPaperScissors. यह मुख्य वर्ग होगा जहां हम पूरे कार्यक्रम का कोड दर्ज करेंगे। आप इस वर्ग के लिए एक अलग नाम चुन सकते हैं, जैसे कि खेल या मुख्य. निर्माता और मुख्य "मुख्य" विधि से संबंधित विधियों की घोषणा लिखें।

सार्वजनिक वर्ग RockPaperScissors {सार्वजनिक RockPaperScissors () {} सार्वजनिक स्थिर शून्य मुख्य (स्ट्रिंग [] args) {}}
  • 2
    गेम (पत्थर, कागज़, कैंची) में तीन वस्तुओं का वर्णन करने वाली एक संख्या बनाएं। हम पत्थर, कागज और कैंची का प्रतिनिधित्व करने के लिए तीन सरल स्ट्रिंग्स का इस्तेमाल कर सकते हैं, लेकिन एक गणण हमें हमारे स्थिरांक को परिभाषित करने की अनुमति देता है - इसलिए कोड डिजाइन के संदर्भ में गणण का उपयोग करना बेहतर विकल्प है। हमारी कॉल गणना चाल निम्नलिखित मान होंगे: रॉक (रॉक) पेपर (पेपर) ई कैंची (कैंची)।

    निजी एंमा ले जाएँ (रॉक, पेपर, स्किसर)
  • 3
    दो "निजी" वर्ग बनाएं, एक कॉल करें उपयोगकर्ता और दूसरे कंप्यूटर. ये वर्ग उन खिलाड़ियों का प्रतिनिधित्व करते हैं जो वास्तविक गेम में एक-दूसरे का सामना करते हैं। यदि आप चाहें तो आप इन वर्गों को "सार्वजनिक" के रूप में घोषित करने का विकल्प चुन सकते हैं। कक्षा उपयोगकर्ता वह एक है जो उपयोगकर्ता को पत्थर, कागज या कैंची के बीच अपनी चाल का उद्देश्य चुनने के लिए कहता है, तो हमें विधि लिखना होगा getMove () हमारे चाल को निष्पादित करने के लिए इसके अलावा कक्षा कंप्यूटर एक विधि की आवश्यकता होगी getMove (), क्योंकि यहां तक ​​कि कंप्यूटर को भी उसकी चाल करना होगा इन दो तरीकों का कोड बाद में लागू किया जाएगा, इस समय हम अपने घोषणा के लिए खुद को सीमित कर देंगे। कक्षा उपयोगकर्ता वस्तु बनाने के लिए एक निर्माता की आवश्यकता है स्कैनर उपयोगकर्ता इनपुट पढ़ने के लिए इस्तेमाल किया फ़ील्ड स्कैनर यह "उपयोगकर्ता" वर्ग के लिए निजी के रूप में घोषित किया जाएगा और क्लास कन्स्ट्रक्टर के अंदर आरंभ किया जाएगा। चूंकि हम डिफ़ॉल्ट जावा वर्ग का उपयोग कर रहे हैं, स्कैनर, हमें अपने कोड की शुरुआत में संबंधित "आयात" पंक्ति डालने से इसे अपने कार्यक्रम में आयात करना होगा। कक्षा कंप्यूटर इसे किसी निर्माता के उपयोग की आवश्यकता नहीं है, इसलिए हमें इस तत्व के लिए कोड लिखना नहीं होगा। जब हम वस्तु को प्रारंभ करते हैं कंप्यूटर, जावा डिफ़ॉल्ट कन्स्ट्रक्टर का उपयोग करेगा नीचे हमारी कक्षा का कोड है RockPaperScissors अब तक लिखी गई:

    जावा आयात करते हैं-सार्वजनिक वर्ग RockPaperScissors निजी enum {{ले जाएँ रॉक, कागज, कैंची} निजी वर्ग उपयोगकर्ता {निजी सार्वजनिक inputScanner स्कैनर उपयोगकर्ता () {inputScanner = नया स्कैनर (System.in) -} सार्वजनिक getMove ले जाएँ () {) सार्वजनिक getMove Move ({// विधि कोड seguitoreturn अशक्त में लागू करने के लिए -}} निजी वर्ग कंप्यूटर - {// विधि कोड seguitoreturn अशक्त में लागू करने के लिए})} सार्वजनिक RockPaperScissors ({} public static void (String [ ] आर्ग्स) {}}
  • 4
    विधि बनाएँ getMove () कक्षा से संबंधित कंप्यूटर. यह विधि गणना के भीतर चुनी गई यादृच्छिक चाल का मान वापस करेगी चाल. हम गणनाओं के "सरणी" बना सकते हैं चाल विधि को याद करते हुए मूल्यों () इस तरह से: Move.values ​​(). एक गणन का चयन करने के लिए चाल हमारे "सरणी" में उपस्थित उन लोगों के बीच यादृच्छिक रूप से यादृच्छिक सूचकांक उत्पन्न करने की आवश्यकता है, जो कि 0 के बीच पूर्णांक और हमारे "सरणी" में मौजूद सभी तत्वों की संख्या के द्वारा प्रतिनिधित्व किया जाएगा। ऐसा करने के लिए हम विधि का उपयोग कर सकते हैं nextInt () कक्षा का बिना सोचे समझे कि हम पैकेज से आयात कर सकते हैं java.util. यादृच्छिक सूचकांक प्राप्त करने के बाद, हम गणन के मूल्य को वापस कर सकते हैं चाल इसी, हमारे "सरणी" के भीतर मौजूद

    सार्वजनिक हटो मिलम () [ले जाएँ] चालें = मूवें। मूल्य () - यादृच्छिक यादृच्छिक = नया रैंडम () - इंट इंडेक्स = यादृच्छिक। एक्सएक्सआईनेट (चालें लेती हैं। लम्बाई) -रिटर्न चालें [अनुक्रमणिका] -}
  • 5
    विधि कोड लिखें getMove () कक्षा के लिए उपयोगकर्ता. इस पद्धति को उपयोगकर्ता द्वारा दर्ज किए गए कदम से संबंधित मूल्य वापस करना चाहिए। हमें उम्मीद है कि उपयोगकर्ता निम्न मानों में से एक लिख: "पत्थर", "कागज" या "कैंची" पहला कदम उपयोगकर्ता को मान दर्ज करने के लिए पूछना है। ऐसा करने के लिए हम निम्नलिखित कोड का उपयोग करते हैं: System.out.print ("स्टोन, कागज या कैंची?"). तब हम विधि का उपयोग करते हैं nextLine () मद स्कैनर उपयोगकर्ता इनपुट को पढ़ने और इसे "स्ट्रिंग" ऑब्जेक्ट में संग्रहीत करने के लिए अब हमें यह जांचना होगा कि उपयोगकर्ता ने एक वैध चाल दर्ज कर ली है, जबकि टाइपो के मामले में क्षमाशील शेष। तो हम यह जांच करेंगे कि टाइप किया गया पहला अक्षर "एस" ("पत्थर" के मामले में), "सी" ("कागज" के मामले में) या "एफ" ("कैंची" के मामले में) से मेल खाती है। हमें चिंता नहीं है कि उपयोगकर्ता ने पूंजी या लोअरकेस अक्षर टाइप किया है, क्योंकि हम विधि का उपयोग करेंगे toUpperCase () कक्षा का तार उपयोगकर्ता द्वारा दर्ज किए गए सभी वर्णों को कैपिटल करने के लिए यदि उपयोगकर्ता ने कोई मान्य चाल नहीं दर्ज की है, तो हम उसे फिर से करने के लिए अपनी चाल कहेंगे। फिर, उपयोगकर्ता इनपुट के आधार पर, हम चुने गए चाल से संबंधित मूल्य वापस करेंगे।

    सार्वजनिक हटो getMove () {// हम उपयोगकर्ता से इनपुट का अनुरोध System.out.print ("स्टोन, कागज या कैंची? ") - UserInput = userInput.toUpperCase () - - चार firstLetter = userInput.charAt (0) -यदि (firstLetter == `एस` || firstLetter = // इनपुट में प्रवेश किया dall`utenteString UserInput = inputScanner.nextLine () पढ़ा `सी` लौट Move.ROCK दर-मामला: वापसी Move.PAPER-घरों `=` ​​सी `|| firstLetter ==` एफ `) {// Validiamo इनपुट dall`utenteswitch (firstLetter) {मामले` एस `में प्रवेश किया एफ `: वापसी Move.SCISSORS -}} // उपयोगकर्ता द्वारा दर्ज एक वैध कदम नहीं है, हम एक mossareturn getMove () दर्ज करने के लिए फिर से पूछा -}
  • 6
    विधि लिखें PlayAgain () कक्षा के लिए उपयोगकर्ता. उपयोगकर्ता को अनिश्चित काल तक खेलने में सक्षम होना चाहिए। यह निर्धारित करने के लिए कि उपयोगकर्ता फिर से खेलना चाहता है, हमें विधि लिखना होगा PlayAgain () कि एक बूलियन मान वापस करना होगा जो बता सकता है कि उपयोगकर्ता खेल को जारी रखना चाहता है या नहीं। इस पद्धति के भीतर, हम वस्तु का उपयोग करेंगे स्कैनर जो हमने उपयोगकर्ता से "हां" या "नहीं" पाने के लिए पहले "उपयोगकर्ता" वर्ग के निर्माता में बनाया था। इस मामले में हम केवल तभी जांचेंगे यदि पहले अक्षर में प्रवेश किया गया "वाई" है, यह निर्धारित करने के लिए कि उपयोगकर्ता फिर से खेलना चाहता है या नहीं। कोई दूसरा चरित्र, संख्या या प्रतीक डाला जाएगा जो खिलाड़ी को रोकने के लिए खेल को रोकने के लिए होगा।

    सार्वजनिक बूलियन प्लेअगेन () {System.out.print ("क्या आप फिर से खेलना चाहते हैं? ") -String userInput = inputScanner.nextLine () - userInput = userInput.toUpperCase () - यूज़रइनपुट.चार्ट वापसी (0) == `वाई` -}
  • 7
    कक्षाओं को एक साथ लिंक करें उपयोगकर्ता और कंप्यूटर कक्षा के भीतर RockPaperScissors. अब जब हमने क्लास कोड लिखना समाप्त कर दिया है उपयोगकर्ता और कंप्यूटर, हम वास्तविक गेम कोड पर ध्यान केंद्रित कर सकते हैं। कक्षा के अंदर RockPaperScissors, दो निजी वस्तुओं, एक तरह का एक घोषित करता है उपयोगकर्ता और एक प्रकार का एक कंप्यूटर. खेल के निष्पादन के दौरान, हमें दो तरीकों तक पहुंचने की आवश्यकता होगी getMove () संबंधित "उपयोगकर्ता" और "कंप्यूटर" कक्षाओं का ये दो ऑब्जेक्ट क्लास कन्स्ट्रक्टर के अंदर आरंभीकृत किए जाएंगे RockPaperScissors. हमें स्कोर का ट्रैक रखने की भी आवश्यकता होगी ऐसा करने के लिए हम खेतों का उपयोग करेंगे userScore और computerScore कि हम क्लास कन्स्ट्रक्टर के भीतर 0 को प्रारंभ करेंगे। अंत में, हमारे पास ऐसे खेल की संख्या को ट्रैक करने की आवश्यकता होगी जिनके फील्ड numberOfGames यह क्लास कन्स्ट्रक्टर के भीतर 0 में आरंभ किया जाएगा।

    निजी उपयोगकर्ता उपयोगकर्ता के निजी कंप्यूटर-निजी कंप्यूटर पूर्णांक userScore-निजी पूर्णांक computerScore-निजी पूर्णांक numberOfGames-सार्वजनिक RockPaperScissors () {उपयोगकर्ता = नया उपयोगकर्ता () - कंप्यूटर = नए कंप्यूटर () - userScore = 0-computerScore = 0-numberOfGames = 0 -}
  • 8



    गणना को बढ़ाएं चाल ताकि इसमें उन विधियों को शामिल किया गया जो हमें बताती है कि प्रत्येक गेम के जीतने की चाल क्या है ऐसा करने के लिए हमें विधि लिखना चाहिए compareMoves () जो मान 0 देता है यदि चाल समान होती है, 1 यदि मौजूदा चाल पिछले एक और -1 को मारता है तो यदि पिछला कदम मौजूदा एक को धराशायी करता है यह योजना गेम के विजेता कौन होगा, यह निर्धारित करने के लिए उपयोगी है। इस पद्धति के कार्यान्वयन में, पहले हम मान 0 लौटाएंगे, यदि चाल समान होती है और फिर हम समानता की स्थिति में होते हैं। फिर हम 1 और 1 के मूल्यों की वापसी से संबंधित कोड ब्लॉक लिखेंगे।

    निजी enum {ले जाएँ रॉक, कागज, कैंची - / *** हम पिछले चाल के साथ मौजूदा चाल, की तुलना अगर यह एक आकर्षण है निर्धारित करने के लिए * जीत या @parametro otherMove ** * * @return तुलना 1 प्रदर्शन करने के लिए करता है, तो खो देता है अगर यह एक ड्रॉ * / सार्वजनिक पूर्णांक compareMoves (ले जाने के otherMove) {paritàif प्रकरण की // (इस otherMove ==) वापसी 0-स्विच है इस कदम, अन्य लेता -1 अगर इस कदम अन्य * 0 पर पीटा जाता है (यह) {मामले रॉक: वापसी (otherMove == कैंची 1:? -1) -case पेपर: वापसी वापसी (otherMove == पेपर 1: (otherMove == रॉक 1:? -1) कैंची -case? -1 ) -} // इस कार्यक्रम को कभी भी इस पोंटेरटरन तक नहीं पहुंचाना चाहिए 0-}}
  • 9
    कक्षा के अंदर RockPaperScissors, विधि बनाओ startgame (). यह हमारी पद्धति है जो हमें हमारे गेम खेलने की अनुमति देती है। निम्नलिखित पंक्ति को दर्ज करके विधि कोड को प्रारंभ करें System.out.println.

    सार्वजनिक शून्य प्रारंभसमयी () {System.out.println ("स्टोन, पेपर, कैंची!") -}
  • 10
    उपयोगकर्ता द्वारा और कंप्यूटर द्वारा की गई चालें पढ़ें विधि के भीतर startgame (), विधि याद करें getMove () कक्षाओं का उपयोगकर्ता और कंप्यूटर. इस तरह आप उपयोगकर्ता को एक कदम और कंप्यूटर पर एक कर देंगे।

    उपयोगकर्ता को निकालें = user.getMove () - कंप्यूटर को ले जाएं = कंप्यूटर = निकालें () - System.out.println (" n आप खेला " + userMove + "।") -System.out.println ("कंप्यूटर खेला गया है " + कंप्यूटरमॉव + "। N") -
  • 11
    यह निर्धारित करने के लिए कि उपयोगकर्ता और कंप्यूटर के बीच की बारी किसने जीती है, दो चुने चाल की तुलना करें। ऐसा करने के लिए, विधि का उपयोग करें compareMoves () गणना चाल. यदि उपयोगकर्ता जीतता है, तो वह 1 से अपना स्कोर बढ़ाता है। यदि उपयोगकर्ता खो गया है, तो कंप्यूटर स्कोर 1 से बढ़ाएं। अगर यह एक टाई है, तो खिलाड़ियों के स्कोर को बदलना नहीं है। तुलना के अंत में, 1 द्वारा निभाई गई खेलों की संख्या में वृद्धि।

    int compareMoves = userMove.compareMoves (कंप्यूटरमॉव) -स्विच (तुलना करेंमौव्स) {केस 0: // पारेगियोसिस्टम.आउट.प्रिंटएलएन ("ड्रा!") -ब्रेक-केस 1: // जीतता है userSystem.out.println (userMove + " धड़क रहा है " + कंप्यूटरमॉव + "। आपने जीता है!") -जररसकोर ++ - ब्रेक-केस -1: // कम्प्यूटरसिस्टम.आउट.प्रिंटलाइन (कंप्यूटरमॉव +) जीतता है " धड़क रहा है " + userMove + "। आपने खो दिया है") -computerScore ++ - ++ BREAK-} numberOfGames -
  • 12
    उपयोगकर्ता से पूछें कि वह फिर से खेलना चाहता है। यदि हां, तो विधि को फिर से कॉल करें startgame (). नकारात्मक मामले में, विधि कॉल करें printGameStats () स्क्रीन पर मैच के आंकड़े प्रिंट करने के लिए हम इस पद्धति को अगले चरण में बनाएंगे।

    अगर (user.playAgain ()) {System.out.println () - startGame () -} अन्य {printGameStats () -}
  • 13
    विधि कोड लिखें printGameStats (). इस पद्धति को स्क्रीन पर मैच के आंकड़े प्रिंट करना चाहिए: जीत की संख्या, हार की संख्या, ड्रॉ की संख्या, खेला गया मुकाबला की संख्या और उपयोगकर्ता द्वारा जीता जाने वाले दौर का प्रतिशत। जीत का प्रतिशत इस तरह से गणना किया जाता है (जीत का # + (ड्रॉ / संख्या का # नंबर)) / (# खेला जाता है)। यह विधि कोड का उपयोग करता है System.out.printf स्वरूपित पाठ प्रदर्शित करने के लिए

    निजी शून्य प्रिंट गेमस्टैट्स ()% 6s 
  • 14
    "मुख्य" वर्ग के अंदर गेम शुरू करने के लिए कोड लिखें "मुख्य" वर्ग के अंदर कक्षा का एक उदाहरण आरंभ किया जाएगा RockPaperScissors और विधि को याद किया जाएगा startgame ().

    सार्वजनिक स्थिर शून्य मुख्य (स्ट्रिंग [] आर्ग्स) {RockPaperScissors खेल = नया RockPaperScissors () - game.startGame () -}
  • 15
    अपने कार्यक्रम का एक परीक्षण चलाएं अब हमने हमारे कार्यक्रम से संबंधित सभी कोड लिखना समाप्त कर दिया है जो खेल "स्टोन, पेपर, कैंची" की प्रतिकृति करता है। यह पूरा करने और सत्यापित करने का समय है कि सब कुछ ठीक से काम कर रहा है।
  • उदाहरण कार्यक्रम

    java.util.Random आयात जावा आयात करते हैं-सार्वजनिक वर्ग उपयोगकर्ता {निजी RockPaperScissors उपयोगकर्ता के निजी कंप्यूटर-निजी पूर्णांक कंप्यूटर userScore-निजी पूर्णांक computerScore-निजी पूर्णांक numberOfGames-निजी enum {ले जाएँ रॉक, कागज, कैंची - / * ** हम पिछले चाल के साथ मौजूदा चाल की तुलना अगर यह एक आकर्षण है निर्धारित करने के लिए * जीत या, इस कदम अन्य लेता है, तो @parametro otherMove ** * * @return तुलना 1 प्रदर्शन करने के लिए खो देता है -1 इस कदम अगर अन्य * 0 पीटा जाता है अगर यह एक ड्रॉ * / सार्वजनिक पूर्णांक compareMoves (otherMove ले जाएँ) {// Pareggioif (इस == otherMove) वापसी 0-स्विच (इस) {मामले रॉक है: वापसी (otherMove == कैंची? ? 1: -1) -case पेपर: वापसी (otherMove == रॉक 1: -1) -case कैंची: वापसी (otherMove == पेपर 1:? -1) -} // कार्यक्रम इस puntoreturn तक पहुँचने कभी नहीं करना चाहिए 0 -}} निजी वर्ग उपयोगकर्ता {निजी सार्वजनिक inputScanner स्कैनर उपयोगकर्ता () {inputScanner = नया स्कैनर (System.in) -} सार्वजनिक getMove ले जाएँ () {// एक प्रदर्शन करने के लिए उपयोगकर्ता से पूछो mossaSystem.out.print में ("स्टोन, कागज या कैंची? ") - // dell`utenteString इनपुट पढ़ें UserInput inputScanner.nextLine = () - UserInput userInput.toUpperCase = () - चार = firstLetter userInput.charAt (0) -यदि (firstLetter == `एस` || == firstLetter वापसी Move.ROCK-केस `सी`: `सी` || firstLetter == `एफ`) {// उपयोगकर्ता एक वैध inputswitch (firstLetter) {मामले `एस` में प्रवेश किया है लौट Move.PAPER-केस `एफ`: वापसी Move.SCISSORS -}} // उपयोगकर्ता द्वारा दर्ज एक वैध कदम नहीं किया। एक नया mossa.return getMove () के शामिल किए जाने का अनुरोध करें -} सार्वजनिक बूलियन PlayAgain () {System.out.print ("क्या आप फिर से खेलना चाहते हैं? ") -String UserInput inputScanner.nextLine = () - UserInput userInput.toUpperCase = () - वापसी userInput.charAt (0) == `वाई` -}} निजी वर्ग कंप्यूटर {सार्वजनिक getMove ले जाएँ () {ले जाएं [] = चाल ले जाएँ .values ​​() - रैंडम यादृच्छिक = नई यादृच्छिक () - पूर्णांक सूचकांक = random.nextInt (moves.length) -Return चाल [सूचकांक] -}} सार्वजनिक RockPaperScissors () {उपयोगकर्ता = नया उपयोगकर्ता () - = नए कंप्यूटर कंप्यूटर ( ) -userScore-computerScore = 0 = 0 = 0 - numberOfGames startgame} सार्वजनिक शून्य () {println ("SASSO, पेपर, कैंची!") - // चालें चलाएंउप userMove = user.getMove () - कंप्यूटर को ले जाएं कंप्यूटर = निकालें। () - System.out.println (" n आप खेला " + userMove + "।") -System.out.println ("कंप्यूटर खेला गया है " + कंप्यूटरमॉव + "। N") - // विजेता बनने के लिए किए जाने वाली चाल की तुलना करेंमॉव्स = यूजरमेव.कॉयरमॉव्स (कम्प्यूटर मैव) -स्विच (तुलना करें) (मामला 0: // पारेगियोसिस्टम। आउट.प्रिंटएलएन ("ड्रा!") -ब्रेक-केस 1: // जीतता है userSystem.out.println (userMove + " धड़क रहा है " + कंप्यूटरमॉव + "। आपने जीता है!") -उसेरसकोर ++ - ब्रेक-केस -1: // कम्प्यूटरसिस्टम.आउट.प्रिंटएलएन (कंप्यूटरमैव +) जीत " धड़क रहा है " + userMove + "। आपने खो दिया है") -computerScore ++ - ++ numberOfGames BREAK-} - // उपयोगकर्ता पूछें कि क्या वे ancoraif (user.playAgain ()) {println () खेलना चाहते हैं - startgame () -} else {printGameStats () -}} / * ** प्रिंट खेल आँकड़े। ड्रॉ के रूप में वे * 1/2 बिंदु थे जीतने प्रतिशत खाते लेता है। * / निजी शून्य printGameStats ()% निजी शून्य 6s printDashes (numberOfDashes पूर्णांक) {के लिए (int i = मैं 0- < numberOfDashes-i ++) {System.out.print ("-") -}} सार्वजनिक स्थिर शून्य मुख्य (स्ट्रिंग [] आर्ग्स) {RockPaperScissors खेल = नया RockPaperScissors () - game.startGame () -}}
    सामाजिक नेटवर्क पर साझा करें:

    संबद्ध

    © 2011—2022 GnuMani.com