PlayingCard

SUBMITTED BY: Guest

DATE: May 11, 2016, 3:59 p.m.

FORMAT: Java

SIZE: 7.5 kB

Raw Download

HITS: 556

Report
  1. /**
  2. *
  3. */
  4. package ats_jp.activity.cardgame;
  6. import java.util.HashMap;
  7. import java.util.HashSet;
  8. import java.util.Map.Entry;
  9. import java.util.Set;
  11. import ats_jp.activity.profile.PlayerProfile;
  13. /**
  14. * @author TMS
  15. *
  16. */
  17. public class PlayingCard implements Card
  18. {
  19. // constant field
  21. public static final int RANK=200;
  22. public static final int ACE = 1;
  23. public static final int TWO = 2;
  24. public static final int THREE = 3;
  25. public static final int FOUR = 4;
  26. public static final int FIVE = 5;
  27. public static final int SIX = 6;
  28. public static final int SEVEN = 7;
  29. public static final int EIGHT = 8;
  30. public static final int NINE = 9;
  31. public static final int TEN = 10;
  32. public static final int JACK = 11;
  33. public static final int QUEEN = 12;
  34. public static final int KING = 13;
  36. public static final int SUIT = 201;
  37. public static final int SPADES = 100;
  38. public static final int HEARTS = 101;
  39. public static final int DIAMOND = 102;
  40. public static final int CLUBS = 103;
  42. public static final int STR_RANK=202;
  43. public static final String STR_ACE = "Ace";
  44. public static final String STR_TWO = "Two";
  45. public static final String STR_THREE = "Three";
  46. public static final String STR_FOUR = "Four";
  47. public static final String STR_FIVE = "Five";
  48. public static final String STR_SIX = "Six";
  49. public static final String STR_SEVEN = "Seven";
  50. public static final String STR_EIGHT = "Eight";
  51. public static final String STR_NINE = "Nine";
  52. public static final String STR_TEN = "Ten";
  53. public static final String STR_JACK = "Jack";
  54. public static final String STR_QUEEN = "Queen";
  55. public static final String STR_KING = "King";
  57. public static final int STR_SUIT=203;
  58. public static final String STR_SPADES = "Spades";
  59. public static final String STR_HEARTS = "Hearts";
  60. public static final String STR_DIAMONDS = "Diamonds";
  61. public static final String STR_CLUBS = "Clubs";
  63. private static final HashMap<String, String> STR_RANK_MAP= new HashMap<String, String>() {{
  65. put("STR_ACE","Ace");
  66. put("STR_TWO","Two");
  67. put("STR_THREE","Three");
  68. put("STR_FOUR","Four");
  69. put("STR_FIVE","Five");
  70. put("STR_SIX","Six");
  71. put("STR_SEVEN","Seven");
  72. put("STR_EIGHT","Eight");
  73. put("STR_NINE","Nine");
  74. put("STR_TEN","Ten");
  75. put("STR_JACK","Jack");
  76. put("STR_QUEEN","Queen");
  77. put("STR_KING","King");
  79. }};
  81. private static final HashMap<String, String> STR_SUIT_MAP= new HashMap<String, String>() {{
  83. put("STR_SPADES","Spades");
  84. put("STR_HEARTS","Hearts");
  85. put("STR_DIAMONDS","Diamonds");
  86. put("STR_CLUBS","Clubs");
  88. }};
  90. // normal attribute
  92. private static HashMap<Integer, PlayingCard> myMapDeck = new HashMap<Integer, PlayingCard>();
  94. private int rank;
  95. private int suit;
  97. @Override
  98. public Object getCardAttribute(int attribute) throws CardException {
  100. Object resultObj=null;
  102. switch (attribute)
  103. {
  105. case PlayingCard.RANK:
  106. resultObj=(Integer) getRank();
  107. break;
  108. case PlayingCard.SUIT:
  109. resultObj=(Integer) getSuit();
  110. break;
  111. case PlayingCard.STR_RANK:
  112. resultObj= (String) getStrRank(getRank());
  113. // come faccio??? Utilizzo una EnumTable???
  114. break;
  115. case PlayingCard.STR_SUIT:
  116. resultObj=(String) getStrSuit(getSuit());
  117. // come faccio??? Problema analogo a sopra...
  118. break;
  120. default:
  121. throw new IllegalArgumentException("Invalid argument");
  122. }
  124. return resultObj;
  125. }
  127. private String getStrRank(int paramRank)
  128. {
  129. String result="";
  131. switch (paramRank)
  132. {
  134. case PlayingCard.ACE:
  135. result = PlayingCard.STR_ACE;
  136. break;
  137. case PlayingCard.TWO:
  138. result = PlayingCard.STR_TWO;
  139. break;
  140. case PlayingCard.THREE:
  141. result = PlayingCard.STR_THREE;
  142. break;
  143. case PlayingCard.FOUR:
  144. result = PlayingCard.STR_FOUR;
  145. break;
  146. case PlayingCard.FIVE:
  147. result = PlayingCard.STR_FIVE;
  148. break;
  149. case PlayingCard.SIX:
  150. result = PlayingCard.STR_SIX;
  151. break;
  152. case PlayingCard.SEVEN:
  153. result = PlayingCard.STR_SEVEN;
  154. break;
  155. case PlayingCard.EIGHT:
  156. result = PlayingCard.STR_EIGHT;
  157. break;
  158. case PlayingCard.NINE:
  159. result = PlayingCard.STR_NINE;
  160. break;
  161. case PlayingCard.TEN:
  162. result = PlayingCard.STR_TEN;
  163. break;
  164. case PlayingCard.JACK:
  165. result = PlayingCard.STR_JACK;
  166. break;
  167. case PlayingCard.QUEEN:
  168. result = PlayingCard.STR_QUEEN;
  169. break;
  170. case PlayingCard.KING:
  171. result = PlayingCard.STR_KING;
  172. break;
  174. default:
  175. throw new IllegalArgumentException("Invalid rank (doesn't exist!)");
  176. }
  178. return result;
  179. }
  181. private String getStrSuit(int paramSuit)
  182. {
  183. String result = "";
  184. switch (paramSuit)
  185. {
  187. case PlayingCard.SPADES:
  188. result = PlayingCard.STR_SPADES;
  189. break;
  190. case PlayingCard.HEARTS:
  191. result = PlayingCard.STR_HEARTS;
  192. break;
  193. case PlayingCard.DIAMOND:
  194. result = PlayingCard.STR_DIAMONDS;
  195. break;
  196. case PlayingCard.CLUBS:
  197. result = PlayingCard.STR_CLUBS;
  198. break;
  200. default:
  201. throw new IllegalArgumentException("Invalid suit (doesn't exist!)");
  202. }
  204. return result;
  205. }
  207. private PlayingCard(int rank, int suit)
  208. {
  209. if((rank>0 && rank<14) && (suit>99 && suit<104)){
  210. this.setRank(rank);
  211. this.setSuit(suit);
  212. } else {
  213. throw new IllegalArgumentException("Invalid rank's value or suit's value");
  214. }
  216. }
  218. /**
  219. * @return the rank
  220. */
  221. public int getRank() {
  222. return rank;
  223. }
  225. /**
  226. * @param rank the rank to set
  227. */
  228. private void setRank(int rank) {
  229. this.rank = rank;
  230. }
  232. /**
  233. * @return the suit
  234. */
  235. public int getSuit() {
  236. return suit;
  237. }
  239. /**
  240. * @param suit the suit to set
  241. */
  242. private void setSuit(int suit) {
  243. this.suit = suit;
  244. }
  246. public String toString()
  247. {
  248. String resultString="";
  249. try {
  250. resultString=getCardAttribute(PlayingCard.STR_RANK)+" of "+getCardAttribute(PlayingCard.STR_SUIT);
  251. } catch (CardException e) {
  252. e.printStackTrace();
  253. System.out.println("Invalid attribute");
  254. }
  256. return resultString;
  257. }
  259. public boolean equals(PlayingCard card)
  260. {
  261. boolean flag=false;
  262. try
  263. {
  264. if(getCardAttribute(PlayingCard.RANK)==card.getCardAttribute(PlayingCard.RANK)
  265. && getCardAttribute(PlayingCard.RANK)==card.getCardAttribute(PlayingCard.RANK))
  266. {
  267. flag=true;
  268. }
  269. } catch(CardException exc) {
  270. exc.printStackTrace();
  271. System.out.println("Invalid attribute");
  272. }
  274. return flag;
  275. }
  277. public static PlayingCard getCard(int paramRank, int paramSuit)
  278. {
  279. //**************************************//
  280. // start my beautiful code :D (I hope!) //
  281. //**************************************//
  283. // creo la carta coi parametri forniti
  285. PlayingCard paramPlayingCard = new PlayingCard(paramRank, paramSuit);
  287. // devo vedere se รจ presente
  289. Integer nextPos=null;
  291. if(!myMapDeck.containsValue(paramPlayingCard))
  292. {
  293. nextPos=new Integer(myMapDeck.size()+1);
  295. myMapDeck.put(nextPos, paramPlayingCard);
  296. } else {
  297. Set<Integer> tmpSet=myMapDeck.keySet();
  298. for(Integer pc : tmpSet)
  299. {
  300. if(myMapDeck.get(pc).equals(paramPlayingCard))
  301. {
  302. nextPos=pc;
  303. System.out.print("\n"+nextPos+"\n");
  304. break;
  305. }
  306. }
  307. }
  309. System.out.println(myMapDeck.get(nextPos));
  311. return myMapDeck.get(nextPos);
  313. }
  315. }
comments powered by Disqus