fork download
copy 
  1. /* package whatever; // don't place package name! */
  2.  
  3. import java.util.*;
  4. import java.lang.*;
  5. import java.io.*;
  6.  
  7. class Main {
  8. 	public static void main(String[] args) {
  9. 		long t = System.nanoTime();
  10. 		Controller c = new Controller();
  11. 		c.playGames();
  12.  
  13. 		c.printResults();
  14. 		//System.out.println("");
  15. 		//System.out.println("Time (in ns): "+(System.nanoTime()-t));
  16. 	}
  17. }
  18.  
  19. class Controller {
  20. 	private static final int NUMBER_OF_GAMES = 100;
  21. 	public Game game;
  22. 	private int[][] results;
  23.  
  24. 	Controller() {
  25. 		game = new Game();
  26. 		game.players = new LinkedHashMap<String, Player>();
  27. 		game.remainingPlayers = new LinkedHashMap<String, Player>();
  28. 		Player[] players = getPlayers();
  29. 		// TODO: Worry about player order
  30. 		for (int i = 0; i < players.size(); i++) {
  31. 			game.players.put(players[i].getName(), players[i]);
  32. 			game.remainingPlayers.put(players[i].getName(), players[i]);
  33. 		}
  34. 		results = new int[players.length()][NUMBER_OF_GAMES];
  35. 	}
  36.  
  37. 	public Player[] getPlayers() {
  38. 		Player[] players = new Player[] { /* PLAYERS */ };
  39. 	}
  40.  
  41. 	void playGames() {
  42.  
  43. 	}
  44.  
  45. 	int playGame() {
  46.  
  47.  
  48. 		return 0;
  49. 	}
  50.  
  51. 	void playTurn(Player player) {
  52. 		Action action;
  53. 		Player target;
  54. 		while (player.turnsToTake > 0) {
  55. 			action = player.playCard();
  56. 			target = null;
  57.  
  58. 			if (action == null || action.card == null) {
  59. 				// Player decided to draw a card, ending this turn.
  60. 				player.turnsToTake -= 1;
  61. 			}
  62. 			else {
  63. 				// Player played a card.
  64. 				if (game.remainingPlayers.containsKey(action.target)) {
  65. 					target = game.remainingPlayers.get(action.target);
  66. 				}
  67.  
  68. 				// Remove card/pair played.
  69. 				if (!player.hand.remove(action.card)) {
  70. 					throw new IllegalArgumentException(
  71. 						"Player "+player.getName()+" played a card they don't have: "+action.card.name());
  72. 				}
  73. 				player.removeCard(action.card);
  74. 				if (action.card >= Card.BEARD_CAT) {
  75. 					if (!player.hand.remove(action.card)) {
  76. 						throw new IllegalArgumentException(
  77. 							"Player "+player.getName()+" played a card they don't have: "+action.card.name());
  78. 					}
  79. 					player.removeCard(action.card);
  80. 				}
  81.  
  82. 				// See who wants to play a NOPE
  83. 				if resolveNopes(player, target) {
  84. 					action.card.play(game, player, target);
  85. 				}
  86. 			}
  87. 		} // end while
  88. 	}
  89.  
  90. 	boolean resolveNopes(Player player, Player target) {
  91.  
  92. 	}
  93.  
  94. 	void printResults() {
  95.  
  96. 	}
  97. }
  98.  
  99. /* Game info. Bots have read-only access. */
  100. class Game {
  101. 	public final long MAX_TURN_TIME = 100 * 1000000; // 100ms
  102. 	LinkedHashMap<String, Player> players;
  103. 	LinkedHashMap<String, Player> remainingPlayers;
  104. 	List<Card> deck;
  105. 	List<Card> discardPile;
  106. 	Random rnd;
  107.  
  108. 	public List<String> getPlayers() {
  109. 		return Collections.unmodifiableMap(players);
  110. 	}
  111. 	public List<String> getRemainingPlayers() {
  112. 		return Collections.unmodifiableMap(remainingPlayers);
  113. 	}
  114. 	public List<String> getDiscardPile() {
  115. 		return Collections.unmodifiableList(discardPile);
  116. 	}
  117. 	public int getDeckSize() {
  118. 		return deck.size();
  119. 	}
  120. 	public int getDrawPileSize() {
  121. 		return deck.size() - discardPile.size();
  122. 	}
  123. }
  124.  
  125. /* Goes in the Controller's package */
  126. enum Card {
  127. 	EXPLODING_KITTEN,
  128. 	DIFFUSE,
  129. 	NOPE,
  130.  
  131. 	// All of the below may be played as an action:
  132. 	ATTACK,
  133. 	SKIP
  134. 	SHUFFLE,
  135. 	SEE_THE_FUTURE,
  136.  
  137. 	// All of the below require a target:
  138. 	FAVOR,
  139.  
  140. 	// All of the below require a pair to play:
  141. 	BEARD_CAT,
  142. 	CATERMELON,
  143. 	HAIRY_POTATOCAT,
  144. 	RAINBOW_RALPHING_CAT,
  145. 	TACOCAT // I'm a PALINDROME!
  146.  
  147. 	void play(Game game, Player player, Player target) {
  148.  
  149. 		switch(this) {
  150. 			case EXPLODING_KITTEN, DIFFUSE, NOPE:
  151. 				throw new UnsupportedOperationException(
  152. 					"Cannot play reaction card from hand: "+player.getName());
  153. 				break;
  154.  
  155. 			case ATTACK:
  156. 				player.turnsToTake = 0;
  157. 				// TODO: Get next player and set their turnsToTake = 2;
  158.  
  159. 				break;
  160.  
  161. 			case SKIP:
  162. 				player.turnsToTake -= 1;
  163. 				break;
  164.  
  165. 			case SHUFFLE:
  166. 				Collections.shuffle(game.deck, game.rnd);
  167. 				break;
  168.  
  169. 			case SEE_THE_FUTURE:
  170. 				player.seeTheFuture(game.deck.subList(0, 3));
  171. 				break;
  172.  
  173. 			case FAVOR:
  174. 				Card card = target.giveFavor(player.getName());
  175. 				target.hand.remove(card);
  176. 				target.removeCard(card);
  177. 				player.hand.add(card);
  178. 				player.addCard(card);
  179. 				break;
  180.  
  181. 			default:
  182. 				// Collections.shuffle(target.hand, game.rnd);
  183. 				Card card = target.hand.get(game.rnd.nextInt(target.hand.size()));
  184. 				target.hand.remove(card);
  185. 				target.removeCard(card);
  186. 				player.hand.add(card);
  187. 				player.addCard(card);
  188. 				break;
  189. 		} // switch
  190. 	} // play()
  191. }
  192.  
  193. /*
  194. 	Put this class into the Controller's package, 
  195. 	but subclasses must be in a separate package.
  196. */
  197. /*public*/ 
  198. abstract class Player {
  199. 	List<Card> hand;
  200. 	int turnsToTake = 0;
  201. 	boolean hasNope = false;
  202.  
  203. 	protected String getName() {
  204. 		return this.getClass().getName();
  205. 	}
  206.  
  207. 	protected List<Card> getHand() {
  208. 		return Collections.unmodifiableList(this.hand);
  209. 	}
  210.  
  211. 	/* 	Called after any card is added to your hand, including cards you are dealt. */
  212. 	protected void addCard(Card card) {}
  213.  
  214. 	/* 	Called after any card is removed from your hand. */
  215. 	protected void removeCard(Card card) {}
  216.  
  217. 	/* 	Number of turns you have left. (2 if you were ATTACKed) */
  218. 	protected int turnsToTake() {
  219. 		return this.turnsToTake;
  220. 	}
  221.  
  222. 	/* 	Returns a list of playable cards requiring at least a pair to play. */
  223. 	protected List<Card> getPlayablePairs() {
  224. 		List<Card> pairs = new List<Card>();
  225. 		Card c = null;
  226. 		Card prev = null;
  227.  
  228. 		ListIterator li = this.hand.listIterator(this.hand.size());
  229. 		if (li.hasPrevious()) {
  230. 			c = li.previous();
  231. 		} else {
  232. 			return pairs;
  233. 		}
  234.  
  235. 		while (li.hasPrevious()) {
  236. 			if (c < Card.BEARD_CAT) {
  237. 				return pairs;
  238. 			}
  239. 			else {
  240. 				prev = c
  241. 				c = li.previous();
  242. 				if (c == prev) {
  243. 					pairs.add(c);
  244. 					while (li.hasPrevious() && c == prev) {
  245. 						c = li.previous();
  246. 					}
  247. 				}
  248. 			}
  249. 		}
  250. 		return pairs;
  251. 	}
  252.  
  253. 	/* 	When will you play a DIFFUSE (you can diffuse any card you draw)? 
  254. 		Played automatically upon drawing an EXPLODING_KITTEN. */
  255. 	protected boolean playDiffuse() { return false; }
  256.  
  257. 	/*	Where in the deck to put the card you just used a DIFFUSE on. 
  258. 		@param	card	Probably an EXPLODING_KITTEN.
  259. 		@return Range of indices to randomly insert the card between, inclusive.
  260. 			[0, 0] = top
  261. 			[drawPileSize, drawPileSize] = bottom
  262. 			[0, drawPileSize] = anywhere
  263. 			[drawPileSize/3, 2*drawPileSize/3+1] = somewhere in the middle third
  264. 	*/
  265. 	abstract int[] diffuseCard(Card card);
  266.  
  267. 	/* 	Called after you play SEE_THE_FUTURE.
  268. 		@param	future	The top three cards of the deck, ordered top first.
  269. 	*/
  270. 	protected void seeTheFuture(List<Card> future) {}
  271.  
  272. 	/* 	What player to take a card from if you play FAVOR. */
  273. 	abstract String takeFavor();
  274.  
  275. 	/* 	What card to give if an opponent plays FAVOR on you. */
  276. 	abstract Card giveFavor(String opponent);
  277.  
  278. 	/*	When will you play a NOPE on another player? 
  279. 		This is called if and only if you have a NOPE, 
  280. 			after any other player takes an action or plays a NOPE.
  281. 		If more than one player would play a NOPE, 
  282. 			the player who's next turn is earlier plays theirs.
  283. 		This will never be called for a DIFFUSE.
  284. 		If you are the passed player, this will only be called if your card will otherwise fail...
  285. 			so if one player used a NOPE then another NOPEs that NOPE, then your play will succeed, 
  286. 			since the second NOPE negated the first.
  287. 			In short, you cannot accidentally negate your own play.
  288. 		@param	card		The card that was just played.
  289. 		@param	player 		Name of player that just played the card.
  290. 		@param	target		Their target. No target is "" (a SHUFFLE, for example).
  291. 		@return	Whether you want to play your NOPE.
  292. 	*/
  293. 	abstract boolean playNope(Card card, String player, String target);
  294.  
  295. 	/*	This is the most important method.
  296. 		Called on your turn repeatedly until you return null, 
  297. 		thus drawing a card and ending your turn. */
  298. 	abstract Action playCard();
  299. }
  300.  
  301. /* Used to return the card played and its target, if needed. */
  302. /*public*/
  303. class Action {
  304. 	Card card;
  305. 	String target;
  306.  
  307. 	Action(Card card) {
  308. 		this(card, "")
  309. 	}
  310.  
  311. 	Action(Card card, String target) {
  312. 		this.card = card;
  313. 		this.target = target;
  314. 	}
  315. }
  316.  
Success #stdin #stdout 0.1s 320576KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
Time (in ns): 1585087
https://ideone.com/1rY7Kt
Exploding Kittens
language:
Java (HotSpot 12)
created:
9 years ago
visibility:
secret

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!