Ride the Bus testing

ridethebus.py

import itertools, random, csv

suits = ["Spades", "Diamonds", "Hearts", "Clubs"]
values = ["Ace", "2", "3", "4", "5", "6", "7", "8", "9", "10", "Jack", "Queen", "King"]

class InfiDeck:
  def __init__(self):
    self.deck = self.new_deck()
    self.new_decks = 0
    self.cards = 0

  def new_deck(self):
    cards = list(itertools.product(suits, values))
    random.shuffle(cards)
    deck = []
    for card in cards:
      deck.append(Card(card[0], card[1]))
    return deck

  def get_card(self):
    if len(self.deck) == 0:
      self.deck = self.new_deck()
      self.new_decks += 1
    self.cards += 1
    return self.deck.pop()

class Card:
  def __init__(self, suit, value):
    self.suit = suit
    self.value = value
    if (suit in ["Hearts", "Diamonds"]):
      self.color = "Red"
    else:
      self.color = "Black"

  def val(self):
    return values.index(self.value)

  def __repr__(self):
    return self.value + " of " + self.suit

class Game:
  def __init__(self):
    self.first = 0
    self.first_correct = 0

    self.second = 0
    self.second_correct = 0

    self.third = 0
    self.third_correct = 0

    self.fourth = 0
    self.fourth_correct = 0

  def stats(self):
    return {
      'first': self.first,
      'first_correct': self.first_correct,
      'second': self.second,
      'second_correct': self.second_correct,
      'third': self.third,
      'third_correct': self.third_correct,
      'fourth': self.fourth,
      'fourth_correct': self.fourth_correct,
    }

  def correct_color(self, card, choice):
    self.first += 1
    correct = card.color == choice
    if (correct):
      self.first_correct += 1
    return correct

  def over_under(self, card1, card2, over = True):
    self.second += 1
    if over:
      correct = card2.val() >= card1.val()
    else:
      correct = card2.val() < card1.val()
    if (correct):
      self.second_correct += 1
    return correct

  def inside_outside(self, card1, card2, card3, outside = True):
    self.third += 1
    if card1.val() < card2.val():
      inside_range = range(card1.val(), card2.val() + 1)
    else:
      inside_range = range(card2.val(), card1.val() + 1)
    if outside:
      correct = card3.val() not in inside_range
    else:
      correct = card3.val() in inside_range
      
    if (correct):
      self.third_correct += 1
    return correct

  def correct_suit(self, card, guess):
    self.fourth += 1
    correct = (card.suit == guess)
    if (correct):
      self.fourth_correct += 1
    return correct

class DumbPlayer:
  def choose_color(self, deck):
    return random.choice(["Red", "Black"])

  # Above 7 guess lower, below 7 guess higher, 7 guess randomly
  def guess_higher(self, deck, card1):
    if (card1.val() == 6):
      return random.choice([True, False])
    else:
      return card1.val() < 6

  def guess_outside(self, deck, card1, card2):
    return (abs(card2.val() - card1.val()) <= 6)

  def guess_suit(self, deck):
    return random.choice(suits)

class SmartPlayer:
  def choose_color(self, deck):
    num_red = 0
    num_black = 0
    for card in deck.deck:
      if card.color == "Red":
        num_red += 1
      else:
        num_black += 1
    if num_red > num_black:
      return "Red"
    else:
      return "Black"

  def guess_higher(self, deck, card1):
    compare = card1.val()
    higher = 0
    lower = 0
    for card in deck.deck:
      if card.val() >= card1.val():
        higher += 1
      else:
        lower += 1
    return higher > lower

  def guess_outside(self, deck, card1, card2):
    if card1.val() < card2.val():
      inside_range = range(card1.val(), card2.val() + 1)
    else:
      inside_range = range(card2.val(), card1.val() + 1)
    in_range = 0
    out_of_range = 0
    for card in deck.deck:
      if card.val() in inside_range:
        in_range += 1
      else:
        out_of_range += 1
    return in_range < out_of_range

  def guess_suit(self, deck):
    suits_count = {
      "Diamonds": 0,
      "Hearts": 0,
      "Spades": 0,
      "Clubs": 0
    }
    for card in deck.deck:
      suits_count[card.suit] += 1

    return max(suits_count, key=suits_count.get)

def play_game_dumb():
  game = Game()
  deck = InfiDeck()
  player = SmartPlayer() # or DumbPlayer()
  drinks = 0

  finished = False

  while not finished:
    # Guess the suit
    color = player.choose_color(deck)
    card1 = deck.get_card()
    if (game.correct_color(card1, color)):
      # Guess higher/lower
      guess_higher = player.guess_higher(deck, card1)
      card2 = deck.get_card()
      if game.over_under(card1, card2, guess_higher):
        # Guess inside_outside
        guess_outside = player.guess_outside(deck, card1, card2)
        card3 = deck.get_card()
        if game.inside_outside(card1, card2, card3, guess_outside):
          # Guess the suit
          guess_suit = player.guess_suit(deck)
          card4 = deck.get_card()
          if game.correct_suit(card4, guess_suit):
            finished = True
          else:
            drinks += 1
        else:
          drinks += 1
      else:
        drinks += 1
    else:
      drinks += 1

  stats = {
    'drinks': drinks,
    'cards': deck.cards,
  }
  stats.update(game.stats())
  return stats

aggregated_results = {}
all_results = []

count = 100000
for i in xrange(count):
  result = play_game_dumb()
  all_results.append(result)

  for stat in result:
    if stat in aggregated_results:
      aggregated_results[stat] += result[stat]
    else:
      aggregated_results[stat] = result[stat]

for stat,value in sorted(aggregated_results.items()):
  print stat
  print float(value) / count
  if ('correct' in stat):
    print str(round(float(value)/float(aggregated_results[stat[:-8]]) * 100)) + '%'
  print ""

# Write all results to Excel file
keys = all_results[0].keys()
with open('trials.csv', 'wb') as output_file:
  dict_writer = csv.DictWriter(output_file, keys)
  dict_writer.writeheader()
  dict_writer.writerows(all_results)