def calculateHandStrength(hand, numberOfOpponents, tableCards):
table = tableCards[:]
numberOfWins = 0
numberOfTies = 0
numberOfLosses = 0
remainingCards = cards.gen_52_cards()
for c in hand:
remainingCards.remove(c)
for c in tableCards:
remainingCards.remove(c)
remainingHoleCombinations = list(itertools.combinations(remainingCards, 2)) # Her lages alle mulige par med hullkort motstanderne kan ha
for comb in remainingHoleCombinations:
playerHand = hand[:]
combination = list(comb)
for card in tableCards:
playerHand.append(card)
combination.append(card)
outcome = calculateOutcome(playerHand, combination)
if outcome == 1:
numberOfWins += 1
elif outcome == 0:
numberOfTies += 1
else:
numberOfLosses += 1
# Base strength = (#Wins + 0.5#Ties) / (#Wins + #Ties #Losses)
base_strength = float(float(float(numberOfWins) + float(float(numberOfTies)/float(2))) / float(float(numberOfWins + float(numberOfTies) + float(numberOfLosses))))
# Hand strength = base_strength opphoyd i antall spillere
hand_strength = float(1)
for i in range(numberOfOpponents):
hand_strength = hand_strength * base_strength
return hand_strength
def generate_lists(self):
# fill out a list of cards.
card_list = cards.gen_52_cards();
for i in range(13): # Check with the first suit
for j in range(13, 26): # Check with the rest of the suits
if cards.card_value(card_list[i]) == cards.card_value(card_list[j]):
continue
is_in_list = False
for k in self.unsuited:
if cards.card_value(card_list[j]) == cards.card_value(k[0]):
is_in_list = True
break
if not is_in_list:
self.unsuited.append([card_list[i], card_list[j]])
for j in range(13):
if cards.card_value(card_list[i]) == cards.card_value(card_list[j]):
continue
is_in_list = False
for k in self.suited:
if cards.card_value(card_list[j]) == cards.card_value(k[0]):
is_in_list = True
break
if not is_in_list:
self.suited.append([card_list[i], card_list[j]])
self.pairs.append([card_list[i], card_list[i+13]])
def main():
start = datetime.datetime.now()
stdout.write("Start time: ")
stdout.write(str(start) + "\n")
kortstokk = cards.gen_52_cards() # Ny kortstokk
pre_flop_table = makePreFlopTable() # Her lages pre-flop tabellen der sansynlighetene for aa vinne skal legges inn
allHoleCombinations = list(itertools.combinations(kortstokk, 2)) # Liste med alle mulige hullkombinasjoner
# allHoleCombinations = [([14,'D'], [14,'H']), ([2,'D'], [3, 'D']), ([2, 'D'], [4, 'S'])]
calculateProbabilities(
allHoleCombinations, pre_flop_table
) # Her regner man ut de faktiske sansynlighetene for aa vinne for hver mulige hullkortkombinasjon
makePreFlopFile(pre_flop_table) # Her lages det en fil av tabellen med sansynlighetene
end = datetime.datetime.now()
stdout.write("End time: ")
stdout.write(str(end) + "\n")
def main():
start = datetime.datetime.now()
stdout.write("Start time: ")
stdout.write(str(start) + '\n')
kortstokk = cards.gen_52_cards() # Ny kortstokk
pre_flop_table = makePreFlopTable(
) # Her lages pre-flop tabellen der sansynlighetene for aa vinne skal legges inn
allHoleCombinations = list(itertools.combinations(
kortstokk, 2)) # Liste med alle mulige hullkombinasjoner
#allHoleCombinations = [([14,'D'], [14,'H']), ([2,'D'], [3, 'D']), ([2, 'D'], [4, 'S'])]
calculateProbabilities(
allHoleCombinations, pre_flop_table
) # Her regner man ut de faktiske sansynlighetene for aa vinne for hver mulige hullkortkombinasjon
makePreFlopFile(
pre_flop_table) # Her lages det en fil av tabellen med sansynlighetene
end = datetime.datetime.now()
stdout.write("End time: ")
stdout.write(str(end) + '\n')
def calculate(self, player_cards, shared_cards):
# calculate a table of all different combinations of hole cards except player_cards and shared cards
card_list = cards.gen_52_cards();
# Remove cards in use.
for c in player_cards + shared_cards:
self.remove_card_from_deck(card_list, c)
# Generate a list of all combinations of hole cards (permutations of the deck)
opponents = []
for c1 in card_list: # Check with the first suit
for c2 in card_list: # Check with the rest of the suits
if c1 != c2 and not [c2, c1] in opponents and not [c1, c2] in opponents:
opponents.append([c1, c2]);
results = self.calculate_results(player_cards, opponents, shared_cards)
hand_ranking = pow(((results["win"]+0.5*results["tie"])/(results["win"]+results["tie"]+results["loss"])), self.num_players)
return hand_ranking
def calculate(self, player_cards, shared_cards):
# calculate a table of all different combinations of hole cards except player_cards and shared cards
card_list = cards.gen_52_cards();
# Remove cards in use.
for c in player_cards + shared_cards:
self.remove_card_from_deck(card_list, c)
# Generate a list of all combinations of hole cards (permutations of the deck)
opponents = []
for c1 in card_list: # Check with the first suit
for c2 in card_list: # Check with the rest of the suits
if c1 != c2 and not [c2, c1] in opponents and not [c1, c2] in opponents:
opponents.append([c1, c2]);
results = self.calculate_results(player_cards, opponents, shared_cards)
hand_ranking = pow(((results["win"]+0.5*results["tie"])/(results["win"]+results["tie"]+results["loss"])), self.num_players)
return hand_ranking
def generate_lists(self):
# fill out a list of cards.
card_list = cards.gen_52_cards()
for i in range(13): # Check with the first suit
for j in range(13, 26): # Check with the rest of the suits
if cards.card_value(card_list[i]) == cards.card_value(
card_list[j]):
continue
is_in_list = False
for k in self.unsuited:
if cards.card_value(card_list[j]) == cards.card_value(
k[0]):
is_in_list = True
break
if not is_in_list:
self.unsuited.append([card_list[i], card_list[j]])
for j in range(13):
if cards.card_value(card_list[i]) == cards.card_value(
card_list[j]):
continue
is_in_list = False
for k in self.suited:
if cards.card_value(card_list[j]) == cards.card_value(
k[0]):
is_in_list = True
break
if not is_in_list:
self.suited.append([card_list[i], card_list[j]])
self.pairs.append([card_list[i], card_list[i + 13]])
import cards
from rollout_player import Player
from os import sys
deck = cards.gen_52_cards()
players = []
table = []
no_rollouts = 100
def create_players(no_players):
del players[:]
for i in range(no_players):
players.append(Player(i+1))
def flop(deck):
c = deck.deal_n_cards(3)
for card in c:
table.append(card)
def river(deck): table.append(deck.deal_one_card())
def turn(deck): table.append(deck.deal_one_card())
def find_winners(winners):
if len(winners) > 1 and players[0] in winners:
#print "draw"
return "d"
elif len(winners) == 1 and winners[0] == players[0]:
#print "won"
return "w"
elif len(winners) > 0 and players[0] not in winners:
def tryit(p, t, no):
global deck
global player_hand
global table
#deck = cards.card_deck()
#player_hand = deck.deal_n_cards(2)
#table = deck.deal_n_cards(3)
deck = cards.card_deck()
player_hand = p
table = t
no_players = no
#print "Player:", player_hand
#print "Table:", table
deck = cards.gen_52_cards()
for card in player_hand:
#print "player:HAND: ", player_hand
deck.remove(card)
for card in table:
#print "**********************"
#print card
#print deck
#print "**********************"
deck.remove(card)
possible_hands = []
for i in range(len(deck)-1):
for j in range(i+1, len(deck)):
h = [deck[i], deck[j]]
possible_hands.append(h)
#print len(possible_hands)
#for i in range(2):
# print "Opponent:", possible_hands[i]
result = []
for o in possible_hands:
players_power = []
#o = possible_hands[i]
r = []
r.append(player_hand)
r.append(o)
s = showdown(r)
result.append(s)
#print len(result)
wins = 0
draws = 0
losses = 0
for e in result:
if e == "w":
wins += 1
elif e == "d":
draws += 1
elif e == "l":
losses += 1
#print wins, draws, losses
strength = (((wins+draws/2.0)/(wins+draws+losses))**no_players)*100
return strength
