Ever heard of the card game, ‘War’?
A deck of cards is evenly split between two players. The players compare the top cards from their respective piles. Comparison is performed by rank alone; suit is irrelevant. The player with the higher ranking card collects both cards and places them at the bottom of their pile. In the event that both cards have equal rank (a “War” situation), both players set aside three cards from their piles, and compare the new top card of their piles. The winner of this second comparison collects the other card, as well as all the cards laid aside, and the cards from the orignal comparison. Should the cards in the second comparison be equal, an additional three cards from each player’s pile are set aside, and another comparison is made, etc. etc.
In the event that a comparison causes one player’s pile to run out of cards, they lose the game.
According to some house rules, if a player has insufficient cards to lay aside for a “War” and its ensuing secondary comparison, they take the required cards from the other player’s pile.
It’s kind of a stupid game. Arguably it’s not a game at all. The winner and loser are determined entirely by the deal of the cards. No decision-making takes place; players cannot alter the outcome of the game in any fashion. Play amounts to a revelation of who was dealt the winning pile; nothing more. My (admittedly verbose) implementation comes in at a little under 100 lines of code and there’s one special case it doesn’t handle.
War has always fascinated me. Since players’ actions don’t affect the outcome, it’s not really a game as we understand games. But the social experience of it is very much a game; ask any kid and he’ll tell you.
Version 1
class WarGame
attr_accessor :log_file
def initialize(deck_size = 52, suit_count = 4)
@deck_size = deck_size
@suit_count = suit_count
@rank = @deck_size / @suit_count
@deck = nil
@p1_deck = nil
@p2_deck = nil
@compare_count = 0
@log_file = File.new("logfile.txt","w")
end
#expects an even deck size
def shuffle_up_and_deal
@deck = (1..@deck_size).to_a.sort_by {rand}
@p1_deck = @deck[0,@deck_size/2]
@p2_deck = @deck[@deck_size/2,@deck_size/2]
@compare_count = 0
end
def play_the_game
game_over = false
while(!game_over)
#cards currently at stake are broken off into stacks
#usually this is just the single card being matched
#but this could conceivably be a large stack in the case of many 'wars'
p1_stack = Array.new
p2_stack = Array.new
p1_stack << @p1_deck.slice!(0)
p2_stack << @p2_deck.slice!(0)
#start the (possibly) recursive comparison for this turn
compare_stacks(p1_stack,p2_stack)
@compare_count += 1
if(@p1_deck.length == 0)
puts "Player 2 wins"
puts @compare_count
game_over = true
end
if(@p2_deck.length == 0)
puts "Player 1 wins"
game_over = true
puts @compare_count
end
end
end
#not truly functional, depends on the (class) globals @p1_deck,@p2_deck
def compare_stacks(p1_stack,p2_stack)
@log_file.puts "Stack1 length: " + p1_stack.length.to_s
@log_file.puts "Stack2 length: " + p2_stack.length.to_s
p1_rank = p1_stack.last % @rank
p2_rank = p2_stack.last % @rank
if(p1_rank > p2_rank)
@p1_deck.concat(p2_stack)
@p1_deck.concat(p1_stack)
elsif(p2_rank > p1_rank)
@p2_deck.concat(p1_stack)
@p2_deck.concat(p2_stack)
else
#WAR!
@log_file.puts "WAR"
if(@p1_deck.length < 4)
@log_file.puts "P1 stealing from P2"
to_steal = 4 - @p1_deck.length
@p1_deck.concat(@p2_deck.slice!(0,to_steal))
end
if(@p2_deck.length < 4)
@log_file.puts "P2 stealing from P1"
to_steal = 4 - @p2_deck.length
@p2_deck.concat(@p1_deck.slice!(0,to_steal))
end
p1_stack.concat(@p1_deck.slice!(0,4))
p2_stack.concat(@p2_deck.slice!(0,4))
compare_stacks(p1_stack,p2_stack)
end
end
end
wg = WarGame.new
wg.shuffle_up_and_deal
wg.play_the_game
wg.log_file.close
Version 2
result = rand(2)
puts "Player 1 wins" if(result == 0)
puts "Player 2 wins" if(result == 1)
To a computer, the only difference between the two is that the first one takes longer 
