Advertisement
brilliant_moves

PlayingCards.java

Jan 28th, 2013
228
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 5 5.02 KB | None | 0 0
  1. import java.util.Scanner; // for user input
  2.  
  3. public class PlayingCards {
  4.  
  5.     /**
  6.     *   Program:    PlayingCards.java (formerly TestCards.java)
  7.     *   Purpose:    Playing card program
  8.     *   Creator:    Chris Clarke
  9.     *   Created:    28.01.2013
  10.     */
  11.  
  12.     public static void main(String[] args) {
  13.  
  14.         final int CARDS_IN_PACK = 52;
  15.  
  16.         Card example = new Card("2", "Clubs"); // example of constructor
  17.  
  18.         Card[] c = new Card[CARDS_IN_PACK]; // array of 52 Cards
  19.         int[] cardArray = new int[CARDS_IN_PACK];
  20.  
  21.         int count=0;
  22.         int p, i;
  23.         int s, r;
  24.         int card=0;
  25.         String in;
  26.         int players;
  27.         int strongest;
  28.  
  29.         // set up array with values 0 to CARDS_IN_PACK-1 inclusive
  30.         for (i=0; i<cardArray.length; i++) {
  31.             cardArray[i] = i;
  32.         }
  33.  
  34.         for (s=0; s<4; s++) {       // suit
  35.             for (r=0; r<13; r++) {  // rank
  36.                 c[count] = new Card(example.ranks[r], example.suits[s]);
  37.                 //System.out.println(c[count].toString());
  38.                 count++;
  39.             }//end for r
  40.         }//end for s
  41.  
  42.         System.out.println("Shuffling deck...");
  43.         // create shuffled pack
  44.         cardArray = randomizeOrder(CARDS_IN_PACK, cardArray);
  45.         System.out.println("Deck shuffled.");
  46.  
  47.         //create Scanner object
  48.         Scanner scan = new Scanner(System.in);
  49.  
  50.         do {
  51.             System.out.print("How many players? Must be between 2 & 10: ");
  52.             players = scan.nextInt();
  53.         } while (players < 2 || players > 10);
  54.  
  55.         // create test array to find strongest card per deal
  56.         Card[] test = new Card[players];
  57.  
  58.         do {
  59.             System.out.print("Deal? (y/n) ");
  60.             in = scan.next().toLowerCase();
  61.             if (!in.startsWith("n")) {
  62.                 // deal a round of cards, 1 to each player
  63.                 for (p=0; p<players; p++) {
  64.                     test[p] = c[cardArray[card]];
  65.                     System.out.print(c[cardArray[card]].toString()+"\t");
  66.                     if (card < CARDS_IN_PACK-1) {
  67.                         card++;
  68.                     } else {
  69.                         break;
  70.                     }//end if card
  71.                 }//end for p
  72.  
  73.                 strongest = 0;
  74.  
  75.                 // break if deal was incomplete
  76.                 if (p<players-1) break;
  77.  
  78.                 // find strongest card
  79.                 for (i=1; i<players; i++) {
  80.                     if (i != strongest) {
  81.                         if (test[i].stronger(test[strongest])) {
  82.                             strongest = i;
  83.                         }//end if test[i]
  84.                     }//end if i
  85.                 }//end for
  86.  
  87.                 System.out.println("Winner: "+test[strongest].toString());
  88.  
  89.             }// end if in
  90.         } while (!in.startsWith("n"));         
  91.     }//end main
  92.  
  93.     public static int getRandomNumber(int minimum, int maximum) {
  94.     // get a random number between minimum and maximum-1 (minimum <= r < maximum)
  95.  
  96.         return (int) (minimum+( maximum-minimum) * Math.random());
  97.  
  98.     }//end getRandomNumber
  99.  
  100.     public static int[] randomizeOrder(int n, int[] theArray) {
  101.     // re-arrange array into random order
  102.         /**
  103.         *   n is the number of numbers to choose, usually n = theArray.length;
  104.         */
  105.            
  106.         int r;
  107.         int max = theArray.length;
  108.         int[] results = new int[n];
  109.  
  110.         // pick n numbers
  111.         for (int i=0; i<n; i++) {
  112.             // range 1 to 49, 1 to 48 etc
  113.             r = getRandomNumber(0, (max-i));
  114.             // store results
  115.             results[i] = theArray[r];
  116.             // move last number in theArray to position r
  117.             theArray[r] = theArray[max-1-i];
  118.         }//end for
  119.  
  120.         return results;
  121.  
  122.     }//end randomizeOrder
  123. }//end class
  124.  
  125. class Card {
  126.  
  127.     /**
  128.     *   Class:      Card.java
  129.     *   Purpose:    Playing card (for Yahoo! Answers)
  130.     *   Creator:    Chris Clarke
  131.     *   Created:    28.01.2013
  132.     */
  133.  
  134.     public Card (String r, String s) { // constructor
  135.         rank = r;
  136.         suit = s;
  137.     }
  138.  
  139.     public int getRankNumber(String r) {
  140.         for (int i=0; i<ranks.length; i++) {
  141.             if (r.equalsIgnoreCase(ranks[i])) return i;
  142.         }
  143.         return -1;
  144.     }//end getRankNumber
  145.  
  146.     public int getSuitNumber(String s) {
  147.         for (int i=0; i<suits.length; i++) {
  148.             if (s.equalsIgnoreCase(suits[i])) return i;
  149.         }
  150.         return -1;
  151.     }//end getSuitNumber
  152.  
  153.     public boolean isOfSuit(String s) {
  154.     // checks if card is of given suit
  155.         if (suit.equalsIgnoreCase(s)) {
  156.             return true;
  157.         }
  158.         return false;
  159.     }//end isOfSuit
  160.  
  161.     public boolean stronger(Card c) {
  162.     // is current card is stronger than Card c?
  163.  
  164.         if (this.getRankNumber(rank) == -1 || this.getSuitNumber(suit) == -1
  165.          || c.getRankNumber(c.rank) == -1 || c.getSuitNumber(c.suit) == -1) {
  166.             System.out.println("Card error!");
  167.             System.exit(0);
  168.         }
  169.  
  170.         if (this.getRankNumber(rank) > c.getRankNumber(c.rank)) {
  171.             return true;
  172.         } else if (this.getRankNumber(rank) == c.getRankNumber(c.rank)) {
  173.             if (this.getSuitNumber(suit) > c.getSuitNumber(c.suit)) {
  174.                 return true;
  175.             }
  176.  
  177.             if (this.getSuitNumber(suit) == c.getSuitNumber(c.suit)) {
  178.                 System.out.println("Duplicate card error!");
  179.                 System.exit(0);
  180.             }
  181.         }//end if/else
  182.         return false;
  183.     }//end stronger
  184.  
  185.     public String toString() {  // returns a printed representation
  186.                     // in the form "8S", "10D", "KC",...
  187.         String printed = rank;
  188.         printed += suit.charAt(0);
  189.         return printed;
  190.     }//end toString
  191.  
  192.     private String rank = "";
  193.     private String suit = "";
  194.  
  195.     // ranks are in order
  196.     public String[] ranks = {"2", "3", "4", "5", "6", "7", "8", "9", "10",
  197.      "J", "Q", "K", "A"};
  198.  
  199.     // suits are in order: Spades beat Hearts beat Diamonds beat Clubs
  200.     public String[] suits = {"Clubs", "Diamonds", "Hearts", "Spades"};
  201. }//end class
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement