The Statistics of War (the card game)

(function() {
	var NUM_TRIALS = 100000, // # games to simulate
		MAX_TURNS = 5000; // maximum # of turns to avoid infinite loops

	// From http://stackoverflow.com/a/2450976
	function shuffle(array) {
		var currentIndex = array.length,
			temporaryValue,
			randomIndex;

		// While there remain elements to shuffle...
		while (0 !== currentIndex) {
			// Pick a remaining element...
			randomIndex = Math.floor(Math.random() * currentIndex);
			currentIndex -= 1;
			// And swap it with the current element.
			temporaryValue = array[currentIndex];
			array[currentIndex] = array[randomIndex];
			array[randomIndex] = temporaryValue;
		}
		return array;
	}

	function Card(o) {
		var self = this;
		self.suit = o.suit;
		self.value = o.value;

		// Generate a string representation of the card
		self.toString = function() {
			var displayValue = self.value;
			switch (self.value) {
				case 11:
					displayValue = 'J';
					break;
				case 12:
					displayValue = 'Q';
					break;
				case 13:
					displayValue = 'K';
					break;
				case 14:
					displayValue = 'A';
					break;
			}
			return self.suit + displayValue;
		};

		// Return a negative number if compare is higher than this card.
		// Return a positive number if this card is higher than compare.
		// Return zero if the cards are equal.
		self.compare = function(/*Card*/ compare) {
			return self.value - compare.value;
		};

		return self;
	}

	function Player(o) {
		var self = this,
			hand = [],
			discard = [];

		self.name = o.name || 'Player';

		// Draw one card from the player's hand
		self.draw = function() {
			if (hand.length === 0) {
				// Version 1: The discard pile is shuffled before using				//hand = shuffle(discard).concat(hand);				// Version 2: The discard pile is used in the order that it was created				hand = discard.concat(hand);				discard = [];
			}
			return hand.pop();
		};

		// Add one or more cards to the player's discard pile
		self.discard = function(cards) {
			if (Array.isArray(cards)) {
				discard = cards.concat(discard);
			} else {
				discard.push(cards);
			}
		};

		// Count the total number of cards in this player's possession
		self.numCards = function() {
			return hand.length + discard.length;
		};

		// Does the user have any cards remaining?
		self.hasCards = function() {
			return self.numCards() > 0;
		};

		// Generate a string representation of the player
		self.toString = function() {
			return self.name + ' (' + self.numCards() + ' cards)';
		};

		return self;
	}

	function Game(o) {
		var self = this,
			deck = shuffle(o.deck);

		// The number of turns that have elapsed in this game
		self.numTurns = 0;

		// Simulate a single game
		self.play = function() {
			var player1 = new Player({ name: 'John' }),
				player2 = new Player({ name: 'Jane' });

			// Split the deck between the two players
			var iDeck;
			for (iDeck = 0; iDeck < deck.length; iDeck++) {
				if (iDeck % 2) {
					player1.discard(deck[iDeck]);
				} else {
					player2.discard(deck[iDeck]);
				}
			}

			var player1Card,
				player2Card,
				cardCompare,
				winnings,
				isWar,
				numWarCards,
				iWarCards;

			while (player1.hasCards() && player2.hasCards()) {
				self.numTurns++;

				// End this game if it's taking too long, to avoid potentially infinite loops
				if (self.numTurns > MAX_TURNS) {
					return;
				}

				player1Card = player1.draw();
				player2Card = player2.draw();
				winnings = [player1Card, player2Card];

				cardCompare = player1Card.compare(player2Card);

				if (cardCompare > 0) {
					// Player 1 wins this turn
					player1.discard(winnings);
				} else if (cardCompare < 0) {
					// Player 2 wins this turn
					player2.discard(winnings);
				} else {
					// War!
					do {
						// If a player is completely out of cards now, they lose the game
						if (!player1.hasCards()) {
							// Player 2 wins this game
							isWar = false;
							player2.discard(winnings);
						} else if (!player2.hasCards()) {
							// Player 1 wins this game
							isWar = false;
							player1.discard(winnings);
						} else {
							isWar = true;

							// If either player doesn't have enough cards for war, bet what they have
							numWarCards = Math.min(
								player1.numCards() - 1,
								player2.numCards() - 1,
								3,
							);

							for (iWarCards = 0; iWarCards < numWarCards; iWarCards++) {
								winnings.push(player1.draw());
								winnings.push(player2.draw());
							}

							player1Card = player1.draw();
							player2Card = player2.draw();
							winnings.push(player1Card);
							winnings.push(player2Card);

							cardCompare = player1Card.compare(player2Card);

							if (cardCompare > 0) {
								// Player 1 wins the war and this turn
								isWar = false;
								player1.discard(winnings);
							} else if (cardCompare < 0) {
								// Player 2 wins the war and this turn
								isWar = false;
								player2.discard(winnings);
							} else {
								// The card values are equal again, continue the war
							}
						}
					} while (isWar);
				}
			}

			// Note: this is erroneous if MAX_TURNS was reached
			self.winner = player1.hasCards() ? player1 : player2;
		};

		return self;
	}

	// Generate the master deck of all 52 cards.
	// It will be reused and shuffled in each Game instance.
	var suits = ['&spadesuit;', '&clubsuit;', '&heartsuit;', '&diamondsuit;'],
		deck = [];

	var iSuit, iValue;
	for (iSuit = 0; iSuit < suits.length; iSuit++) {
		// J = 11, Q = 12, K = 13, A = 14
		for (iValue = 2; iValue <= 14; iValue++) {
			deck.push(new Card({ suit: suits[iSuit], value: iValue }));
		}
	}

	// Run the desired number of trials.
	// Populate wins with the number of turns and frequency of that outcome.
	var iTrials,
		thisGame,
		wins = [];
	for (iTrials = 0; iTrials < NUM_TRIALS; iTrials++) {
		thisGame = new Game({ deck: deck });
		thisGame.play();

		if (!wins[thisGame.numTurns]) {
			wins[thisGame.numTurns] = 1;
		} else {
			wins[thisGame.numTurns]++;
		}
	}
})();