Ang Rock, Paper, Gunting ay isang larong kamay na nilalaro ng dalawang tao. Ang parehong mga tao ay sasabihin na "bato, papel, gunting" at pagkatapos ay sabay na bumubuo ng isa sa tatlong mga bagay (bato, papel, o gunting) na may nakaunat na kamay. Ang nagwagi ay natutukoy ng mga hand formation. Pinuputol ng gunting ang papel, mga beats ng papel na bato, at mga gunting na beats ng bato. Kung ang parehong mga manlalaro ay naglalaro ng parehong pagbuo ng kamay, ito ay itinuturing na isang kurbatang. Susulat kami ng isang simpleng laro sa Java upang gayahin ang Rock, Paper, Gunting kung saan ang isang manlalaro ay ang gumagamit at ang iba pang manlalaro ay ang computer.
Mga hakbang
Hakbang 1. Lumikha ng pangunahing klase at tawagan ito
Bato papel gunting
.
Ito ang magiging klase kung saan kami magsusulat ng laro. Maaari kang pumili upang pangalanan ito ng ibang bagay tulad ng
Laro
o
Pangunahin
. Sumulat sa mga pagdedeklara ng pamamaraan para sa tagapagbuo at pangunahing pamamaraan.
pampublikong klase RockPaperScissors {public RockPaperScissors () {} public static void main (String args) {}}
Hakbang 2. Lumikha ng isang bilang para sa mga kilos ng kamay (bato, papel, o gunting)
Maaari kaming gumamit ng mga string upang kumatawan sa bato, papel, o gunting, ngunit pinapayagan kami ng isang pag-enumerate na tukuyin ang aming mga Constant na nangangahulugang ang paggamit ng pag-isa ay isang mas mahusay na disenyo. Tatawagan namin ang aming uri ng enum
Gumalaw
na may mga halaga
ROCK
PAPEL
at
GUNTING
pribadong enum Ilipat ang {ROCK, PAPER, SCISSORS}
Hakbang 3. Lumikha ng dalawang pribadong klase
Gumagamit
at
Computer
.
Ang mga klase ay kumakatawan sa aming mga manlalaro sa laro. Maaari kang pumili upang gawing pampubliko ang mga klase na ito. Ang
Gumagamit
ang klase ang magiging klase na mag-uudyok sa gumagamit para sa alinman sa bato, papel, o gunting, kaya kakailanganin naming magsulat ng a
getMove ()
pamamaraan Ang
Computer
kakailanganin ding magkaroon ng isang klase
getMove ()
pamamaraan upang ang computer ay maaari ring gumawa ng isang paglipat. Ilalagay namin ang mga placeholder sa mga pamamaraang ito at ipapatupad ang mga ito sa paglaon. Ang
Gumagamit
mangangailangan ang klase ng isang tagapagbuo na nagtatakda ng
Scanner
object na kukunin sa input ng gumagamit. Ilalagay namin ang
Scanner
bilang isang pribadong larangan para sa gumagamit at pagkatapos ay pasimulan ito sa tagapagbuo. Dahil ginagamit namin ang
Scanner
klase, kailangan naming magsulat ng isang pahayag ng pag-import para sa mga ito sa tuktok ng aming code. Ang
Computer
Ang klase ay hindi nangangailangan ng isang tagapagbuo, kaya hindi namin kailangang magsulat ng isa; kapag pinasimulan natin ang
Computer
object, tatawag lang kami sa default na tagapagbuo. Narito kung ano ang aming
Bato papel gunting
parang klase ngayon:
import java.util. Scanner; pampublikong klase RockPaperScissors {pribadong enum Ilipat {ROCK, PAPER, SCISSORS} pribadong klase ng User {pribadong Scanner inputScanner; pampublikong Gumagamit () {inputScanner = bagong Scanner (System.in); } public Move getMove () {// TODO: Ipatupad ang pamamaraang ito na bumalik nang walang bisa; }} pribadong klase Computer {public Move getMove () {// TODO: Ipatupad ang pamamaraang ito ibalik ang null; }} pampublikong RockPaperScissors () {} pampublikong static void main (String args) {}}
Hakbang 4. Isulat ang
getMove ()
pamamaraan para sa
Computer
klase
Ang pamamaraang ito ay magbabalik ng isang random
Gumalaw
. Maaari kaming makakuha ng isang hanay ng
Gumalaw
enumerasyon sa pamamagitan ng pagtawag sa
halaga ()
pamamaraan:
Ilipat.values ()
. Upang pumili ng isang random
Gumalaw
ang pag-enumerate sa array na ito ng mga halaga, kailangan naming makabuo ng isang random index na isang integer sa pagitan ng 0 at ang haba ng aming array na halaga. Upang magawa ito, maaari nating gamitin ang
susunodInt ()
pamamaraan ng
Random
klase kung saan kailangan nating mag-import
java.util
. Matapos naming makuha ang random index, maaari nating ibalik ang
Gumalaw
ng index na iyon mula sa aming mga halaga ng array.
publiko Ilipat getMove () {Ilipat ilipat = ilipat.values (); Random random = bagong Random (); int index = random.nextInt (galaw. haba); bumalik na gumagalaw [index]; }
Hakbang 5. Isulat ang
getMove ()
pamamaraan para sa
Gumagamit
klase
Babalik ang pamamaraang ito a
Gumalaw
naaayon sa kung ano ang may input ng gumagamit. Inaasahan naming magsulat ang gumagamit ng alinman sa "rock", "papel", o "gunting". Una, kailangan naming i-prompt ang gumagamit para sa isang input:
System.out.print ("Bato, papel, o gunting?")
. Pagkatapos gamitin ang
nextLine ()
pamamaraan ng
Scanner
object upang makuha ang input ng gumagamit bilang isang string. Kailangan namin ngayon upang suriin kung ang gumagamit ay nagsumite ng isang wastong paglipat, ngunit maaari kaming maging maluwag kung ang gumagamit ay may maling pagbaybay ng isang salita. Susuriin lamang namin kung ang unang titik ng pag-input ng gumagamit ay alinman sa "R" (para sa bato), "P" (para sa papel), o "S" (para sa gunting), at hindi namin alintana ang kaso dahil gagamitin muna namin ang
toUpperCase ()
pamamaraan ng
String
klase upang gawin ang string ng input ng gumagamit sa lahat ng uppercase. Kung ang gumagamit ay hindi nagpasok ng malayuang tama ang pag-input, i-prompt namin muli ang gumagamit. Pagkatapos, depende sa kung ano ang inilagay ng gumagamit, ibabalik namin ang isang kaukulang paglipat.
public Move getMove () {// I-prompt ang user System.out.print ("Bato, papel, o gunting?"); // Get the user input String userInput = inputScanner.nextLine (); userInput = userInput.toUpperCase (); char firstLetter = userInput.charAt (0); kung (firstLetter == 'R' || firstLetter == 'P' || firstLetter == 'S') {// Ang gumagamit ay nagpasok ng isang wastong input switch (firstLetter) {case 'R': return Move. ROCK; case 'P': ibalik ang Move. PAPER; kaso 'S': bumalik Ilipat. SCISSORS; }} // Ang gumagamit ay hindi nagpasok ng wastong input. Prompt ulit. ibalik ang getMove (); }
Hakbang 6. Isulat ang a
Maglaro ulit()
pamamaraan para sa
Gumagamit
klase
Dapat na mai-play ng user ang laro nang paulit-ulit. Upang matukoy kung nais na muling maglaro ng gumagamit, kailangan naming magsulat ng a
Maglaro ulit()
paraan na nagbabalik ng isang boolean na nagsasabi sa laro kung natukoy ng gumagamit na maglaro muli o hindi. Sa pamamaraang ito, ginagamit namin ang
Scanner
na dati naming pinasimulan sa tagabuo upang makakuha ng isang "Oo" o isang "Hindi" mula sa gumagamit. Susuriin lamang namin kung ang unang titik ay 'Y' upang matukoy kung ang gumagamit ay nais na maglaro muli. Anumang iba pang input ay nangangahulugan na ang gumagamit ay hindi nais na maglaro muli.
public boolean playAgain () {System.out.print ("Gusto mo bang maglaro muli?"); String userInput = inputScanner.nextLine (); userInput = userInput.toUpperCase (); ibalik ang userInput.charAt (0) == 'Y'; }
Hakbang 7. Ikonekta ang
Gumagamit
at
Computer
magkaklase sa
Bato papel gunting
klase
Ngayong natapos na namin ang pagsusulat ng
Gumagamit
at
Computer
mga klase, maaari kaming tumuon sa pagtatrabaho sa aming aktwal na laro. Lumikha ng pribadong mga patlang para sa
Gumagamit
at
Computer
klase sa
Bato papel gunting
klase Kakailanganin naming i-access ang mga patlang na ito upang ma-access ang
getMove ()
mga pamamaraan kapag nilalaro namin ang laro. Sa tagatayo para sa
Bato papel gunting
klase, simulan ang mga patlang na ito. Kakailanganin din naming subaybayan ang iskor sa
userScore
at
computerScore
mga patlang, na kailangan naming simulan bilang 0 sa tagapagbuo. Kailangan nating subaybayan din ang bilang ng mga laro, na magiging isang patlang na pinasimulan din bilang 0.
pribadong Gumagamit ng gumagamit; pribadong Computer computer; pribadong int userScore; pribadong int computerScore; pribadong int numberOfGames; publiko RockPaperScissors () {user = bagong User (); computer = bagong Computer (); userScore = 0; computerScore = 0; numberOfGames = 0; }
Hakbang 8. Palawakin ang
Gumalaw
enum upang magsama ng isang pamamaraan na nagsasabi sa amin kung aling paglipat ang nanalo sa bawat kaso.
Kailangan nating magsulat a
ihambingMove ()
paraan na nagbabalik ng 0 kung ang mga galaw ay pareho, 1 kung ang kasalukuyang paglipat ay pinalo ang iba pang paglipat, at -1 kung ang kasalukuyang paglipat ay natalo sa iba pang paglipat. Ito ay magiging kapaki-pakinabang para sa pagtukoy ng nagwagi sa laro. Upang maipatupad ang pamamaraang ito, ibabalik muna namin ang 0 kung ang paggalaw ay pareho at samakatuwid mayroon kaming isang kurbatang. Pagkatapos ay sumulat ng isang switch statement para sa pagbabalik ng 1 o -1.
pribadong enum Ilipat {ROCK, PAPER, SCISSORS; / ** * Kinukumpara ang paglipat na ito sa isa pang paglipat sa pagtukoy ng isang kurbatang, isang panalo, o * isang pagkawala. * * @param otherMove * ilipat upang ihambing sa * @return 1 kung ang kilos na ito ay matalo sa iba pang paglipat, -1 kung ang paglipat na ito ay natalo sa * iba pang paglipat, 0 kung ang mga gumagalaw na ito ay nakatali * / public int CompareMove (Ilipat ang ibangMove) {/ / Tie kung (ito == otherMove) ibalik ang 0; lumipat (ito) {case ROCK: return (otherMove == SCISSORS? 1: -1); case PAPER: return (otherMove == ROCK? 1: -1); case SCISSORS: return (otherMove == PAPER? 1: -1); } // Hindi dapat umabot dito bumalik 0; }}
Hakbang 9. Lumikha a
startGame ()
pamamaraan sa
Bato papel gunting
klase
Ang pamamaraang ito ay ang paglalaro ng laro. Magsimula sa pamamagitan ng paglalagay ng isang simple
System.out.println
sa pamamaraan.
public void startGame () {System.out.println ("ROCK, PAPER, SCISSORS!"); }
Hakbang 10. Kumuha ng mga paggalaw mula sa gumagamit at computer
Nasa
startGame ()
paraan, gamitin ang
getMove ()
pamamaraan mula sa
Gumagamit
klase at ang
Computer
klase upang makuha ang gumagalaw ng gumagamit at computer.
Ilipat ang userMove = user.getMove (); Ilipat ang computerMove = computer.getMove (); System.out.println ("\ nPaglaro mo ng" + userMove + "."); System.out.println ("Pinatugtog ng computer" + computerMove + ". / N");
Hakbang 11. Paghambingin ang dalawang galaw at tukuyin kung nanalo ang gumagamit o nanalo ang computer
Gamitin ang
ihambingMove ()
pamamaraan mula sa
Gumalaw
enum upang matukoy kung nanalo ang gumagamit o hindi. Kung nanalo ang gumagamit, dagdagan ang marka ng gumagamit ng 1. Kung natalo ang gumagamit, dagdagan ang marka ng computer ng 1. Kung mayroong isang kurbatang, huwag dagdagan ang alinman sa mga marka. Pagkatapos dagdagan ang bilang ng mga laro na nilalaro ng isa.
int CompareMove = userMove.compareMove (computerMove); switch (CompareMove) {case 0: // Tie System.out.println ("Tie!"); pahinga; case 1: // Nanalo ang User System.out.println (userMove + "beats" + computerMove + ". Nanalo ka!"); userScore ++; pahinga; case -1: // Computer won System.out.println (computerMove + "beats" + userMove + ". Nawala ka."); computerScore ++; pahinga; } numberOfGames ++;
Hakbang 12. Tanungin kung nais na muling maglaro ng gumagamit
Kung nais ng user na maglaro muli, tumawag
startGame ()
muli Kung hindi man, tumawag ka
printGameStats ()
na mai-print ang mga istatistika ng laro. Isusulat namin ang pamamaraang ito sa susunod na hakbang.
kung (user.playAgain ()) {System.out.println (); startGame (); } iba pa {printGameStats (); }
Hakbang 13. Isulat ang
printGameStats ()
pamamaraan
Ipapakita ng pamamaraang ito ang mga istatistika ng laro: bilang ng mga panalo, bilang ng pagkalugi, bilang ng mga ugnayan, bilang ng mga larong nilalaro, at porsyento ng mga larong napanalunan ng gumagamit. Ang porsyento ng mga larong napanalunan ay kinakalkula ng (# panalo + (# kurbatang / 2)) / (# larong nilalaro). Gumagamit ang pamamaraang ito
System.out.printf
upang mai-print ang na-format na teksto.
pribadong void printGameStats () {int win = userScore; int pagkalugi = computerScore; int ties = numberOfGames - userScore - computerScore; dobleng porsyentoWon = (panalo + ((dobleng) ugnayan) / 2) / numberOfGames; // Line System.out.print ("+"); printDashes (68); System.out.println ("+"); // Print heading System.out.printf ("|% 6s |% 6s |% 6s |% 12s |% 14s | / n", "WINS", "LOSSES", "TIES", "GAMES PLAYED", "PERCENTAGE MANALO "); // Line System.out.print ("|"); printDashes (10); System.out.print ("+"); printDashes (10); System.out.print ("+"); printDashes (10); System.out.print ("+"); printDashes (16); System.out.print ("+"); printDashes (18); System.out.println ("|"); // Print halaga System.out.printf ("|% 6d |% 6d |% 6d |% 12d |% 13.2f %% | / n", mga panalo, pagkalugi, ugnayan, numberOfGames, porsyentoWon * 100); // Line System.out.print ("+"); printDashes (68); System.out.println ("+"); }
Hakbang 14. Simulan ang laro sa pangunahing klase
Sa pangunahing klase, simulan ang isang halimbawa ng
Bato papel gunting
klase at tawagan ang
startGame ()
pamamaraan
pampublikong static void main (String args) {RockPaperScissors game = bagong RockPaperScissors (); game.startGame (); }
Hakbang 15. Subukan ang iyong laro
Ngayon na dumaan kami sa lahat ng pagsisikap na magsulat ng larong Rock, Papel, Gunting, oras na upang ipunin at subukan ang lahat!
Sample Program
import java.util. Random; import java.util. Scanner; pampublikong klase RockPaperScissors {pribadong gumagamit ng User; pribadong Computer computer; pribadong int userScore; pribadong int computerScore; pribadong int numberOfGames; pribadong enum Ilipat {ROCK, PAPER, SCISSORS; / ** * Kinukumpara ang paglipat na ito sa isa pang paglipat sa pagtukoy ng isang kurbatang, isang panalo, o * isang pagkawala. * * @param otherMove * ilipat upang ihambing sa * @return 1 kung ang kilos na ito ay matalo sa iba pang paglipat, -1 kung ang paglipat na ito ay natalo sa * iba pang paglipat, 0 kung ang mga gumagalaw na ito ay nakatali * / public int CompareMove (Ilipat ang ibangMove) {/ / Tie kung (ito == otherMove) ibalik ang 0; lumipat (ito) {case ROCK: return (otherMove == SCISSORS? 1: -1); case PAPER: return (otherMove == ROCK? 1: -1); case SCISSORS: return (otherMove == PAPER? 1: -1); } // Hindi dapat umabot dito bumalik 0; }} pribadong klase ng User {pribadong Scanner inputScanner; pampublikong Gumagamit () {inputScanner = bagong Scanner (System.in); } pampublikong Ilipat getMove () {// I-prompt ang user System.out.print ("Bato, papel, o gunting?"); // Get the user input String userInput = inputScanner.nextLine (); userInput = userInput.toUpperCase (); char firstLetter = userInput.charAt (0); kung (firstLetter == 'R' || firstLetter == 'P' || firstLetter == 'S') {// Ang gumagamit ay nagpasok ng isang wastong input switch (firstLetter) {case 'R': bumalik ang Move. ROCK; case 'P': ibalik ang Move. PAPER; kaso 'S': bumalik Ilipat. SCISSORS; }} // Ang gumagamit ay hindi nagpasok ng wastong input. Prompt ulit. ibalik ang getMove (); } public boolean playAgain () {System.out.print ("Gusto mo bang maglaro muli?"); String userInput = inputScanner.nextLine (); userInput = userInput.toUpperCase (); ibalik ang userInput.charAt (0) == 'Y'; }} pribadong klase Computer {public Move getMove () {Ilipat gumalaw = Mov.values (); Random random = bagong Random (); int index = random.nextInt (gumagalaw. haba); bumalik na gumagalaw [index]; }} pampublikong RockPaperScissors () {user = bagong User (); computer = bagong Computer (); userScore = 0; computerScore = 0; numberOfGames = 0; } public void startGame () {System.out.println ("ROCK, PAPER, SCISSORS!"); // Kumuha ng mga galaw Ilipat ang userMove = user.getMove (); Ilipat ang computerMove = computer.getMove (); System.out.println ("\ nPaglaro mo ng" + userMove + "."); System.out.println ("Pinatugtog ng computer" + computerMove + ". / N"); // Paghambingin ang mga galaw at matukoy ang nagwagi int CompareMove = userMove.compareMove (computerMove); switch (CompareMove) {case 0: // Tie System.out.println ("Tie!"); pahinga; case 1: // Nanalo ang User System.out.println (userMove + "beats" + computerMove + ". Nanalo ka!"); userScore ++; pahinga; case -1: // Computer won System.out.println (computerMove + "beats" + userMove + ". Nawala ka."); computerScore ++; pahinga; } numberOfGames ++; // Hilingin sa gumagamit na maglaro muli kung (user.playAgain ()) {System.out.println (); startGame (); } iba pa {printGameStats (); }} / ** * Nai-print ang mga istatistika ng laro. Kinakalkula ang mga ugnayan bilang 1/2 isang panalo sa * porsyento na nanalo. * / pribadong void printGameStats () {int win = userScore; int pagkalugi = computerScore; int ties = numberOfGames - userScore - computerScore; dobleng porsyentoWon = (panalo + ((dobleng) ugnayan) / 2) / numberOfGames; // Line System.out.print ("+"); printDashes (68); System.out.println ("+"); // Print heading System.out.printf ("|% 6s |% 6s |% 6s |% 12s |% 14s | / n", "WINS", "LOSSES", "TIES", "GAMES PLAYED", "PERCENTAGE MANALO "); // Line System.out.print ("|"); printDashes (10); System.out.print ("+"); printDashes (10); System.out.print ("+"); printDashes (10); System.out.print ("+"); printDashes (16); System.out.print ("+"); printDashes (18); System.out.println ("|"); // Print halaga System.out.printf ("|% 6d |% 6d |% 6d |% 12d |% 13.2f %% | / n", mga panalo, pagkalugi, ugnayan, numberOfGames, porsyentoWon * 100); // Line System.out.print ("+"); printDashes (68); System.out.println ("+"); } pribadong void printDashes (int numberOfDashes) {para (int i = 0; i <numberOfDashes; i ++) {System.out.print ("-"); }} pampublikong static void main (String args) {RockPaperScissors game = bagong RockPaperScissors (); game.startGame (); }}
