def test_game_checkFour_method(self):
game = Game_library.Game()
game.addPlayers("Joe")
crd = Card_library.Card('A', '♢')
game.player_list[0].player_hand.addToHand(crd.card_value,
crd.card_suit)
crd2 = Card_library.Card('A', '♤')
game.player_list[0].player_hand.addToHand(crd2.card_value,
crd2.card_suit)
crd3 = Card_library.Card('2', '♡')
game.player_list[0].player_hand.addToHand(crd3.card_value,
crd3.card_suit)
crd4 = Card_library.Card('A', '♧')
game.player_list[0].player_hand.addToHand(crd4.card_value,
crd4.card_suit)
crd5 = Card_library.Card('A', '♡')
game.player_list[0].player_hand.addToHand(crd5.card_value,
crd5.card_suit)
game.checkFour(game.player_list[0])
message = "checkFour did not add to books properly."
self.assertEqual(len(game.player_list[0].books), 1, message)
message2 = "checkFour did not add the proper card_value to books properly."
self.assertEqual(game.player_list[0].books, ['A'], message2)
message3 = "checkFour did not add to score properly."
self.assertEqual(game.player_list[0].score, 1, message3)
def FillDeck(self):
for card_suit in CARD_SUITS:
for card_value in CARD_VALUES:
card = Card(card_suit, card_value, CARD_SCALE)
card.position = START_X, BOTTOM_Y
self.card_list.append(card)
random.shuffle(self.card_list)
def initializeGameBoard(self):
card1 = Stack(Card(67, 5))
card2 = Stack(Card(87, 4))
card3 = Stack(Card(75, 7))
card4 = Stack(Card(48, 2))
cards = [card1, card2, card3, card4]
self.gameBoard = GameBoard(cards)
def __init__(self, interface):
self.player = Card()
self.computer = Card()
self.pscore = 0 #player's score
self.cscore = 0 #computer's score
self.interface = interface
self.hit = 0 # times of player's hitme
def assembleHandsPlayers(self, hand):
#street0VPI/vpip already called in Hand
# sawShowdown is calculated in playersAtStreetX, as that calculation gives us a convenient list of names
#hand.players = [[seat, name, chips],[seat, name, chips]]
for player in hand.players:
self.handsplayers[player[1]]['seatNo'] = player[0]
self.handsplayers[player[1]]['startCash'] = int(100 * Decimal(player[2]))
self.handsplayers[player[1]]['sitout'] = False #TODO: implement actual sitout detection
if hand.gametype["type"]=="tour":
self.handsplayers[player[1]]['tourneyTypeId']=hand.tourneyTypeId
self.handsplayers[player[1]]['tourneysPlayersIds'] = hand.tourneysPlayersIds[player[1]]
else:
self.handsplayers[player[1]]['tourneysPlayersIds'] = None
# XXX: enumerate(list, start=x) is python 2.6 syntax; 'start'
#for i, street in enumerate(hand.actionStreets[2:], start=1):
for i, street in enumerate(hand.actionStreets[2:]):
self.seen(self.hand, i+1)
for i, street in enumerate(hand.actionStreets[1:]):
self.aggr(self.hand, i)
self.calls(self.hand, i)
self.bets(self.hand, i)
if i>0:
self.folds(self.hand, i)
# Winnings is a non-negative value of money collected from the pot, which already includes the
# rake taken out. hand.collectees is Decimal, database requires cents
for player in hand.collectees:
self.handsplayers[player]['winnings'] = int(100 * hand.collectees[player])
#FIXME: This is pretty dodgy, rake = hand.rake/#collectees
# You can really only pay rake when you collect money, but
# different sites calculate rake differently.
# Should be fine for split-pots, but won't be accurate for multi-way pots
self.handsplayers[player]['rake'] = int(100* hand.rake)/len(hand.collectees)
if self.handsplayers[player]['street1Seen'] == True:
self.handsplayers[player]['wonWhenSeenStreet1'] = 1.0
if self.handsplayers[player]['sawShowdown'] == True:
self.handsplayers[player]['wonAtSD'] = 1.0
for player in hand.pot.committed:
self.handsplayers[player]['totalProfit'] = int(self.handsplayers[player]['winnings'] - (100*hand.pot.committed[player])- (100*hand.pot.common[player]))
self.calcCBets(hand)
for player in hand.players:
hcs = hand.join_holecards(player[1], asList=True)
hcs = hcs + [u'0x', u'0x', u'0x', u'0x', u'0x']
#for i, card in enumerate(hcs[:7], 1): #Python 2.6 syntax
# self.handsplayers[player[1]]['card%s' % i] = Card.encodeCard(card)
for i, card in enumerate(hcs[:7]):
self.handsplayers[player[1]]['card%s' % (i+1)] = Card.encodeCard(card)
self.handsplayers[player[1]]['startCards'] = Card.calcStartCards(hand, player[1])
self.setPositions(hand)
self.calcCheckCallRaise(hand)
self.calc34BetStreet0(hand)
self.calcSteals(hand)
def test_from_str(self):
exp = PokerHand([
Card(Rank.Ace, Suit.Club),
Card(Rank.Queen, Suit.Diamond),
Card(Rank.Seven, Suit.Heart)
])
hand = PokerHand.from_string('ACQD7H')
self.assertEqual(exp, hand)
def testRanks(self):
""" creates cards of rank 1 through 13 of clubs and
verifies that the created card's rank is equal to the
rank it was created with """
for i in range(1,14):
myCard = Card(i,'c') # create i of clubs
self.assertEqual(myCard.rank(),i) # verifies that the card's rank is i
def testHandSorted(self):
hand = Hand.Hand([Card.Card(Card.Rank.JACK, Card.Suit.SPADES), \
Card.Card(Card.Rank.ACE, Card.Suit.SPADES), \
Card.Card(Card.Rank.FIVE, Card.Suit.SPADES), \
Card.Card(Card.Rank.QUEEN, Card.Suit.SPADES), \
Card.Card(Card.Rank.FOUR, Card.Suit.SPADES)])
self.assertTrue(hand.cards[0].rank >= hand.cards[1].rank >= \
hand.cards[2].rank >= hand.cards[3].rank >= hand.cards[4].rank)
def testSuits(self):
""" creates cards of rank ... of c (clubs), d (diamonds),
h(hearts) and s (spades), and verifies that the created card's suit
is equal to the suit it was created with (c,d,h,s) """
for i in 'cdhs':
myCard = Card(13,i)
self.assertEqual(myCard.suit(),i)
def test_deck_resets_correct(self):
deck = Deck_library.Deck()
deck.reset()
first_crd = Card_library.Card('A','♧') # test that first card vliue and last card value on the created deck is correct
last_crd = Card_library.Card('K', '♤') # and deck is populated correctly
value_check = [first_crd._card_value, first_crd._card_suit, last_crd._card_value, last_crd._card_suit]
deck_values = [deck._deck_of_cards[0]._card_value, deck._deck_of_cards[0]._card_suit, deck._deck_of_cards[51]._card_value, deck._deck_of_cards[51]._card_suit]
self.assertEqual(deck_values, value_check)
def loadCards(self, file_name):
file = open(file_name, "r")
for line in file:
if line[0] != '#':
#print(line)
card = Card()
card.loadFromFile(line)
self.addCard(card)
def __init__(self):
self.list_member = []
self.list_member.append(Card(1, 2))
self.list_member.append(Card(1, 6))
self.list_member.append(Card(1, 3))
self.list_member.append(Card(1, 8))
self.list_member.append(Card(1, 13))
self.popped_sum = 0
def naiveMaxAIPlay(self):
gameState = self.gameState
validClubs = []
validDiamonds = []
validSpades = []
validHearts = []
validHand = [validClubs, validDiamonds, validSpades, validHearts]
for suit in range(0, 4):
handSuit = self.hand.hand[suit]
for card in handSuit:
if gameState.isValidCard(card, self):
validHand[suit].append(card)
#if first, play highest card in a random suit
if gameState.currentTrick.isUnset():
# print("Going first!")
#include hearts if hearts not broken or only has hearts
if gameState.heartsBroken == True or self.hasOnlyHearts():
suitRange = 3
else:
suitRange = 2
randomSuit = randint(0, suitRange)
#return highest card
# print("Current trick suit is: ", gameState.currentTrick.suit.iden)
# print("Going first and playing highest card")
return Hand.highestCard(validHand[randomSuit])
#if not first:
else:
# print("Not going first!")
trickSuit = gameState.currentTrick.suit.iden
#if there are cards in the trick suit play highest card in trick suit
if (len(validHand[trickSuit]) > 0):
# print("Still cards in trick suit")
return Hand.highestCard(validHand[trickSuit])
else:
# print("No cards in trick suit")
#play cards by points, followed by rank
minPoints = sys.maxsize
minCard = None
for suit in range(0, 4):
for card in validHand[suit]:
cardPoints = -card.rank.rank
if card.suit == Card.Suit(hearts):
cardPoints -= 15 #Greater than rank of all non-point cards
if card.suit == Card.Suit(
spades) and card.rank == Card.Rank(queen):
cardPoints -= 13
if cardPoints < minPoints:
minPoints = cardPoints
minCard = card
return minCard
#should never get here
raise Exception("failed programming")
return None
def testChooseCard(self):
self.initializeGameBoard()
player1 = Player(1)
player1.cards = [Card(25, 2), Card(54, 5), Card(79, 1), Card(17, 6), Card(20, 3)]
bestCard = player1.chooseCard(self.gameBoard)
# Since a Player's strategy can can be altered with a patch, we leave this test out for now
# until we abstract a strategy
# self.assertEquals(bestCard, Card(79, 1))
self.assertEquals(len(player1.cards), 4)
def __init__(self):
self.window = Tk()
self.window.title("Dori")
self.window.geometry("800x600")
self.window.configure(bg="green")
self.fontstyle = font.Font(self.window,
size=24,
weight='bold',
family='Consolas')
self.fontstyle2 = font.Font(self.window,
size=15,
weight='bold',
family='Consolas')
self.fontstyle3 = font.Font(self.window,
size=11,
weight='bold',
family='Consolas')
self.sound = Sound()
# 카드 이미지 + 월 + 조합 + 승패
self.images = {}
for i in range(10):
for j in range(2):
self.images[str(i + 1) + '.' + str(j + 1)] = PhotoImage(
file='resource/doriCards/' + str(i + 1) + '.' +
str(j + 1) + '.gif')
self.images['back'] = PhotoImage(
file='resource/doriCards/cardback.gif')
self.dealer = Player("dealer")
self.players = []
self.players.append(Player("player1"))
self.players.append(Player("player2"))
self.players.append(Player("player3"))
self.money = 1000
self.SetupGUI()
self.Initialize()
l = []
l.append(Card(16, isVisible=True))
l.append(Card(18, isVisible=True))
l.append(Card(0, isVisible=True))
l.append(Card(3, isVisible=True))
l.append(Card(7, isVisible=True))
combos = self.GetCombos(l)
print(combos)
for combo in combos:
print(self.GetComboString(combo))
combos.sort(key=lambda x: x['power'], reverse=False)
print(self.GetComboString(combos[0]))
self.window.mainloop()
def assembleHands(self, hand):
self.hands['tableName'] = hand.tablename
self.hands['siteHandNo'] = hand.handid
self.hands[
'gametypeId'] = None # Leave None, handled later after checking db
self.hands[
'sessionId'] = None # Leave None, added later if caching sessions
self.hands[
'gameSessionId'] = None # Leave None, added later if caching sessions
self.hands['startTime'] = hand.startTime # format this!
self.hands['importTime'] = None
self.hands['seats'] = self.countPlayers(hand)
#self.hands['maxSeats'] = hand.maxseats
self.hands['texture'] = None # No calculation done for this yet.
self.hands['tourneyId'] = hand.tourneyId
# This (i think...) is correct for both stud and flop games, as hand.board['street'] disappears, and
# those values remain default in stud.
boardcards = []
for street in hand.communityStreets:
boardcards += hand.board[street]
boardcards += [u'0x', u'0x', u'0x', u'0x', u'0x']
cards = [Card.encodeCard(c) for c in boardcards[0:5]]
self.hands['boardcard1'] = cards[0]
self.hands['boardcard2'] = cards[1]
self.hands['boardcard3'] = cards[2]
self.hands['boardcard4'] = cards[3]
self.hands['boardcard5'] = cards[4]
self.hands['boards'] = []
self.hands['runIt'] = False
for i in range(hand.runItTimes):
self.hands['runIt'] = True
boardcards = []
for street in hand.communityStreets:
boardId = i + 1
street_i = street + str(boardId)
if street_i in hand.board:
boardcards += hand.board[street_i]
boardcards = [u'0x', u'0x', u'0x', u'0x', u'0x'] + boardcards
cards = [Card.encodeCard(c) for c in boardcards[-5:]]
self.hands['boards'] += [[boardId] + cards]
#print "DEBUG: self.getStreetTotals = (%s, %s, %s, %s, %s)" % hand.getStreetTotals()
totals = hand.getStreetTotals()
totals = [int(100 * i) for i in totals]
self.hands['street1Pot'] = totals[0]
self.hands['street2Pot'] = totals[1]
self.hands['street3Pot'] = totals[2]
self.hands['street4Pot'] = totals[3]
self.hands['showdownPot'] = totals[4]
self.vpip(hand) # Gives playersVpi (num of players vpip)
#print "DEBUG: vpip: %s" %(self.hands['playersVpi'])
self.playersAtStreetX(hand) # Gives playersAtStreet1..4 and Showdown
#print "DEBUG: playersAtStreet 1:'%s' 2:'%s' 3:'%s' 4:'%s'" %(self.hands['playersAtStreet1'],self.hands['playersAtStreet2'],self.hands['playersAtStreet3'],self.hands['playersAtStreet4'])
self.streetXRaises(hand)
def testRankNames(self):
"""test the names of the rank function 'rankName(...)' """
RN = ['Two', 'Three', 'Four', 'Five', 'Six',
'Seven', 'Eight', 'Nine', 'Ten',
'Jack', 'Queen', 'King', 'Ace']
s = "c" #testing rank not suit
for r in range(2,14):
myCard = Card(r,s)
self.assertEqual(myCard.rankName(),RN[r-2]) #index of rank - 2
def afterStay(self): #딜러의 카드 추가
while self.dealer.value() < 17:
self.deckN += 1 # 공개된카드
test = Card(self.cardDeck[self.deckN])
self.dealer.addCard(test.getValue(), test.filename())
self.updateDealerCards(self.dealer.inHand() - 1)
self.LdealerPts.configure(text=str(self.dealer.value() -
self.dealer.cards[0][0]))
self.checkWinner()
async def removeCardsFromPlayer(session, playersConnected, player):
print("remove cards for player ", player["player"].name)
player["cards"] = []
Card.deleteAllCardsForAPlayer(session, player["player"].playerId)
cards = Card.getCards(session)
response = convertToJson({'operation' : 'get', 'table' : 'Cards', 'data' : cards})
for player in filterOpenedConnectionPlayers(playersConnected):
await player['socket'].send(response)
def hitDealer(self, n):
newCard = Card(self.cardDeck[self.deckN])
self.deckN += 1
self.dealer.addCard(newCard)
p = PhotoImage(file="cards/" + newCard.filename())
self.LcardsDealer.append(Label(self.window, image=p))
self.LcardsDealer[self.dealer.inHand() - 1].image = p
self.LcardsDealer[self.dealer.inHand() - 1].place(x=250 + n * 30, y=150)
PlaySound('sounds/cardFlip1.wav', SND_FILENAME)
def createCard(cardId):
card = CardById(cardId)
cardtype = cardType(card)
_card = Card(id(card), name(card), cardtype, manaCost(card))
if cardtype == Cardtype.MINION:
_card._attack = attackValue(card)
_card._health = healthValue(card)
if cardtype == Cardtype.HERO:
_card._health = healthValue(card)
return _card
def hitPlayer(self, n):
newCard = Card(self.cardDeck[self.deckN])
self.deckN += 1
self.player.addCard(newCard)
p = PhotoImage(file="cards/" + newCard.filename())
self.LcardsPlayer.append(Label(self.window, image=p))
self.LcardsPlayer[self.player.inHand() - 1].image = p
self.LcardsPlayer[self.player.inHand() - 1].place(x=250 + n * 30, y=350)
self.LplayerPts.configure(text=str(self.player.value()))
PlaySound('sounds/cardFlip1.wav', SND_FILENAME)
def hitPlayer(self, n): #n은 카드의 위치
#이부분에서 플레이어 포인트가 21 이상일 때 게임오버 먼저 처리#
self.deckN += 1
self.cardsphotoimage[self.deckN] = Card(self.cardDeck[self.deckN])
self.cardsphotoimage[self.deckN] = Card(self.cardDeck[self.deckN])
self.player.addCard(self.cardsphotoimage[self.deckN].getValue(),
self.cardsphotoimage[self.deckN].filename())
self.updatePlayerCards(self.player.inHand() - 1)
self.LplayerPts.configure(text=str(self.player.value()))
PlaySound('Resources/sounds/cardFlip1.wav', SND_FILENAME)
def testClearStack(self):
self.initializeGameBoard()
self.gameBoard.stacks[0].addToStack(Card(30, 7))
self.gameBoard.stacks[0].addToStack(Card(7, 3))
self.gameBoard.stacks[0].addToStack(Card(66, 2))
player1 = Player(1)
self.gameBoard.clearStack(player1, Card(32, 3), 0)
stackResult = Stack(Card(32, 3))
self.assertEquals(stackResult, self.gameBoard.stacks[0])
self.assertEquals(player1.bullPoints, 17)
def setFieldCard(self):
newCard = Card(self.cardDeck[self.deckN])
self.deckN += 1
n = self.deckN - 4
self.fieldCard.append(newCard)
p = PhotoImage(file="cards/" + newCard.filename())
self.LfieldCard.append(Label(self.window, image=p))
self.LfieldCard[n - 1].image = p
self.LfieldCard[n - 1].place(x=130 + n * 80, y=200)
PlaySound('sounds/cardFlip1.wav', SND_FILENAME)
def test_function_count_request_2(self):
rules = Rules()
hand = Hand()
hand += [
Card(rank=Rank.THREE, suit=Suit.DIAMONDS),
Card(rank=Rank.THREE, suit=Suit.SPADES)
]
self.assertEqual(
rules.count_request(hand, Rank.THREE), 2,
"count request not returning 2 for hand with two rank matches")
def assembleHands(self, hand):
self.hands['tableName'] = hand.tablename
self.hands['siteHandNo'] = hand.handid
self.hands['gametypeId'] = None # Leave None, handled later after checking db
self.hands['sessionId'] = None # Leave None, added later if caching sessions
self.hands['gameSessionId'] = None # Leave None, added later if caching sessions
self.hands['startTime'] = hand.startTime # format this!
self.hands['importTime'] = None
self.hands['seats'] = self.countPlayers(hand)
#self.hands['maxSeats'] = hand.maxseats
self.hands['texture'] = None # No calculation done for this yet.
self.hands['tourneyId'] = hand.tourneyId
# This (i think...) is correct for both stud and flop games, as hand.board['street'] disappears, and
# those values remain default in stud.
boardcards = []
for street in hand.communityStreets:
boardcards += hand.board[street]
boardcards += [u'0x', u'0x', u'0x', u'0x', u'0x']
cards = [Card.encodeCard(c) for c in boardcards[0:5]]
self.hands['boardcard1'] = cards[0]
self.hands['boardcard2'] = cards[1]
self.hands['boardcard3'] = cards[2]
self.hands['boardcard4'] = cards[3]
self.hands['boardcard5'] = cards[4]
self.hands['boards'] = []
self.hands['runIt'] = False
for i in range(hand.runItTimes):
self.hands['runIt'] = True
boardcards = []
for street in hand.communityStreets:
boardId = i+1
street_i = street + str(boardId)
if street_i in hand.board:
boardcards += hand.board[street_i]
boardcards = [u'0x', u'0x', u'0x', u'0x', u'0x'] + boardcards
cards = [Card.encodeCard(c) for c in boardcards[-5:]]
self.hands['boards'] += [[boardId] + cards]
#print "DEBUG: self.getStreetTotals = (%s, %s, %s, %s, %s)" % hand.getStreetTotals()
totals = hand.getStreetTotals()
totals = [int(100*i) for i in totals]
self.hands['street1Pot'] = totals[0]
self.hands['street2Pot'] = totals[1]
self.hands['street3Pot'] = totals[2]
self.hands['street4Pot'] = totals[3]
self.hands['showdownPot'] = totals[4]
self.vpip(hand) # Gives playersVpi (num of players vpip)
#print "DEBUG: vpip: %s" %(self.hands['playersVpi'])
self.playersAtStreetX(hand) # Gives playersAtStreet1..4 and Showdown
#print "DEBUG: playersAtStreet 1:'%s' 2:'%s' 3:'%s' 4:'%s'" %(self.hands['playersAtStreet1'],self.hands['playersAtStreet2'],self.hands['playersAtStreet3'],self.hands['playersAtStreet4'])
self.streetXRaises(hand)
def testForPair(self):
cards = []
cards.append(Card.Card(1, SuitEnum.Hearts))
cards.append(Card.Card(3, SuitEnum.Spades))
cards.append(Card.Card(1, SuitEnum.Hearts))
target = PokerCalculator.PokerCalculator(cards)
actual = target.Calculate()
self.assertTrue(actual.result == PokerResultEnum.Pair,
"should be a pair")
def testForThreeOfAKind(self):
cards = []
cards.append(Card.Card(7, SuitEnum.Hearts))
cards.append(Card.Card(7, SuitEnum.Clubs))
cards.append(Card.Card(7, SuitEnum.Clubs))
target = PokerCalculator.PokerCalculator(cards)
actual = target.Calculate()
self.assertTrue(actual.result == PokerResultEnum.ThreeOfAKind,
"should be a Three of a kind")
def test_function_add_card_array_addTest(self):
hand = Hand()
card1 = Card(suit=Suit.SPADES, rank=Rank.TEN)
card2 = Card(suit=Suit.DIAMONDS, rank=Rank.FIVE)
card3 = Card(suit=Suit.SPADES, rank=Rank.THREE)
card4 = Card(suit=Suit.DIAMONDS, rank=Rank.KING)
card5 = Card(suit=Suit.CLUBS, rank=Rank.ACEHIGH)
new_cards = [card1, card2, card3, card4, card5]
hand.add_card(new_cards)
self.assertEqual(hand.card_count, 5,
"Add card not properly adding array")
class Deck:
deck = []
for x in range(52):
if x <= 12:
deck.append(Card.Card(x % 13 + 2, 's'))
elif x <= 25:
deck.append(Card.Card(x % 13 + 2, 'c'))
elif x <= 38:
deck.append(Card.Card(x % 13 + 2, 'h'))
else:
deck.append(Card.Card(x % 13 + 2, 'd'))
def __init__(self): """ Initializes this class and creates a PinochleDeck """ for i in range(52): #goes through all cards if Card(i).rank() < 7: #if the rank is not 9 it passes pass else: self.extend((Card(i),Card(i))) # addeds the 9 or greater card twice to deck self.sort() #sorts the deck return
def get_hero_cards(self, hero):
"""Formats the hero cards for inclusion in the table."""
if hero == '':
return "xxxxxx"
else:
# find the hero's seat from the stat_dict
for stat in self.parent.hud.stat_dict.itervalues():
if stat['screen_name'] == hero:
return Card.valueSuitFromCard(self.parent.hud.cards[stat['seat']][0]) +\
Card.valueSuitFromCard(self.parent.hud.cards[stat['seat']][1]) +\
Card.valueSuitFromCard(self.parent.hud.cards[stat['seat']][2])
return "xxxxxx"
def get_hero_cards(self, hero, cards):
"""Formats the hero cards for inclusion in the tree."""
trans = ('0', 'A', '2', '3', '4', '5', '6', '7', '8', '9', 'T', 'J', 'Q', 'K', 'A')
if hero == '':
return "xxxxxx"
else:
# find the hero's seat from the stat_dict
for stat in self.parent.hud.stat_dict.itervalues():
if stat['screen_name'] == hero:
return Card.valueSuitFromCard(self.parent.hud.cards[stat['seat']][0]) +\
Card.valueSuitFromCard(self.parent.hud.cards[stat['seat']][1]) +\
Card.valueSuitFromCard(self.parent.hud.cards[stat['seat']][2])
return "xxxxxx"
def __init__(self):
"""Initialize a deck of 52 pinochle cards."""
p_deck = []
for i in range(52):
# We only want 9's and above i.e. 9, 10, J, Q, K, A
if i % 13 >= 7:
# We want two copies of each card, so append twice
p_deck.append(Card(i))
p_deck.append(Card(i))
list.__init__(self, p_deck)
def card_renderer_cell_func(tree_column, cell, model, tree_iter, data):
card_width = 30
card_height = 42
col = data
coldata = model.get_value(tree_iter, col)
if coldata == None or coldata == '':
coldata = "0x"
coldata = coldata.replace("'","")
coldata = coldata.replace("[","")
coldata = coldata.replace("]","")
coldata = coldata.replace("'","")
coldata = coldata.replace(",","")
#print "DEBUG: coldata: %s" % (coldata)
cards = [Card.encodeCard(c) for c in coldata.split(' ')]
n_cards = len(cards)
#print "DEBUG: cards: %s" % cards
pixbuf = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, True, 8, card_width * n_cards, card_height)
if pixbuf:
x = 0 # x coord where the next card starts in scratch
for card in cards:
if card == None or card ==0:
card_images[0].copy_area(0, 0, card_width, card_height, pixbuf, x, 0)
card_images[card].copy_area(0, 0, card_width, card_height, pixbuf, x, 0)
x = x + card_width
cell.set_property('pixbuf', pixbuf)
def process_bind_param(self, value, dialect):
if value is None or isinstance(value, int):
return value
elif isinstance(value, basestring) and len(value) == 2:
return Card.encodeCard(str(value))
else:
raise Exception, "Incorrect card value: " + repr(value)
def is_row_in_card_filter(self, row):
""" Returns true if the cards of the given row are in the card filter """
#Does work but all cards that should NOT be displayed have to be clicked.
card_filter = self.filters.getCards()
hcs = row[self.colnum['Street0']].split(' ')
if '0x' in hcs: #if cards are unknown return True
return True
gt = row[self.colnum['Game']]
if gt not in ('holdem', 'omahahi', 'omahahilo'): return True
# Holdem: Compare the real start cards to the selected filter (ie. AhKh = AKs)
value1 = Card.card_map[hcs[0][0]]
value2 = Card.card_map[hcs[1][0]]
idx = Card.twoStartCards(value1, hcs[0][1], value2, hcs[1][1])
abbr = Card.twoStartCardString(idx)
return False if card_filter[abbr] == False else True
def __init__(self, deck):
"""A hand is simply the first five cards in the deck, if there are
five cards available. If not, return None."""
hand = 5 # Number of cards in a hand (int)
self._mysuits = [0] * 4 # a list of 4 zeros used for evaluation
self._myranks = [0] * 13 # a list of 13 zeros used for evaluation
#checks if there are enough cards in deck for a hand
if len(deck) >= hand:
#list to contain cards in hand
self._cards = []
#for each card in hand
for cards in range(hand):
#deal a new card
newCard = deck.deal()
self._cards.append(newCard)
#Get suit and rank for each card in hand
suit = Card.getSuit(newCard)
rank = Card.getRank(newCard)
#increase rank count for evaluation
rank -= 1
self._myranks[rank] += 1
#increase suit count for evaluation
if suit == "Spades":
self._mysuits[0] += 1
if suit == "Diamonds":
self._mysuits[1] += 1
if suit == "Hearts":
self._mysuits[2] += 1
if suit == "Clubs":
self._mysuits[3] += 1
else:
return None
def update_contents(self, container, i):
if not self.hud.cards.has_key(i): return
cards = self.hud.cards[i]
# Here we want to know how many cards the given seat showed;
# board is considered a seat, and has the id 'common'
# 'cards' on the other hand is a tuple. The format is:
# (card_num, card_num, ...)
n_cards = valid_cards(cards)
if n_cards > 1:
# scratch is a working pixbuf, used to assemble the image
scratch = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB,
has_alpha=True, bits_per_sample=8,
width=int(self.card_width)*n_cards,
height=int(self.card_height))
x = 0 # x coord where the next card starts in scratch
for card in cards:
# concatenate each card image to scratch
# flop game never(?) has unknown cards.
# FIXME: if "show one and fold" ever becomes an option,
# this needs to be changed
if card == None or card ==0:
break
# This gives us the card symbol again
(_rank, _suit) = Card.valueSuitFromCard(card)
_rank = Card.card_map[_rank]
# We copy the image data. Technically we __could__ use
# the pixmap directly but it seems there are some subtle
# races and explicitly creating a new pixbuf seems to
# work around most of them.
#
# We also should not use copy_area() but it is far
# easier to work with than _render_to_drawable()
px = self.card_images[_suit][_rank].copy()
px.copy_area(0, 0,
px.get_width(), px.get_height(),
scratch, x, 0)
x += px.get_width()
if container is not None:
container.seen_cards.set_from_pixbuf(scratch)
container.resize(1,1)
container.move(self.positions[i][0] + self.hud.table.x,
self.positions[i][1] + self.hud.table.y) # here is where I move back
container.show()
self.displayed = True
if i != "common":
id = self.get_id_from_seat(i)
# sc: had KeyError here with new table so added id != None test as a guess:
if id is not None:
self.m_windows[i].eb.set_tooltip_text(self.hud.stat_dict[id]['screen_name'])
def init_card_images(self, config):
suits = ('s', 'h', 'd', 'c')
ranks = (14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2)
for j in range(0, 13):
for i in range(0, 4):
loc = Card.cardFromValueSuit(ranks[j], suits[i])
card_im = self.deck_inst.card(suits[i], ranks[j])
#must use copy(), method_instance not usable in global variable
card_images[loc] = card_im.copy()
back_im = self.deck_inst.back()
card_images[0] = back_im.copy()
return card_images
def get_card_images(self, card_width=30, card_height=42):
card_images = 53 * [0]
suits = ('s', 'h', 'd', 'c')
ranks = (14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2)
deckimg = self.params['deck']
try:
pb = gtk.gdk.pixbuf_new_from_file(self.config.execution_path(deckimg))
except:
#FIXME: this can't be right? /usr will not exist on windows
stockpath = '/usr/share/python-fpdb/' + deckimg
pb = gtk.gdk.pixbuf_new_from_file(stockpath)
for j in range(0, 13):
for i in range(0, 4):
card_images[Card.cardFromValueSuit(ranks[j], suits[i])] = self.cropper(pb, i, j, card_width, card_height)
# also pick out a card back and store in [0]
card_images[0] = self.cropper(pb, 2, 13, card_width, card_height)
return(card_images)
def get_card_images(self):
card_images = 53 * [0]
suits = ('s', 'h', 'd', 'c')
ranks = (14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2)
deckimg = self.params['deck']
try:
pb = gtk.gdk.pixbuf_new_from_file(self.config.execution_path(deckimg))
except:
stockpath = '/usr/share/python-fpdb/' + deckimg
pb = gtk.gdk.pixbuf_new_from_file(stockpath)
for j in range(0, 13):
for i in range(0, 4):
card_images[Card.cardFromValueSuit(ranks[j], suits[i])] = self.cropper(pb, i, j)
temp_pb = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, pb.get_has_alpha(), pb.get_bits_per_sample(), 30, 42)
# also pick out a card back and store in [0]
card_images[0] = self.cropper(pb, 2, 13)
return(card_images)
def update_gui(self, new_hand_id):
self.clear()
for c, cards in self.parent.hud.cards.iteritems():
if c == 'common': continue
self.grid_contents[(1, c - 1)].set_text(self.get_screen_name(c))
for i in ((0, cards[0]), (1, cards[1]), (2, cards[2]), (3, cards[3]),
(4, cards[4]), (5, cards[5]), (6, cards[6])):
if not i[1] == 0:
# Pixmaps are stored in dict with rank+suit keys
(_rank, _suit) = Card.valueSuitFromCard(i[1])
_rank = Card.card_map[_rank]
px = self.card_images[_suit][_rank].copy()
self.seen_cards[(i[0], c - 1)].set_from_pixbuf(px)
## action in tool tips for 3rd street cards
for c in (0, 1, 2):
for r in range(0, self.rows):
#self.eb[(c, r)].set_tooltip_text(self.tips[0])
pass
# action in tools tips for later streets
round_to_col = (0, 3, 4, 5, 6)
def assembleHands(self, hand):
self.hands['tableName'] = hand.tablename
self.hands['siteHandNo'] = hand.handid
self.hands['gametypeId'] = None # Leave None, handled later after checking db
self.hands['handStart'] = hand.starttime # format this!
self.hands['importTime'] = None
self.hands['seats'] = self.countPlayers(hand)
self.hands['maxSeats'] = hand.maxseats
self.hands['texture'] = None # No calculation done for this yet.
# This (i think...) is correct for both stud and flop games, as hand.board['street'] disappears, and
# those values remain default in stud.
boardcards = []
for street in hand.communityStreets:
boardcards += hand.board[street]
boardcards += [u'0x', u'0x', u'0x', u'0x', u'0x']
cards = [Card.encodeCard(c) for c in boardcards[0:5]]
self.hands['boardcard1'] = cards[0]
self.hands['boardcard2'] = cards[1]
self.hands['boardcard3'] = cards[2]
self.hands['boardcard4'] = cards[3]
self.hands['boardcard5'] = cards[4]
#print "DEBUG: self.getStreetTotals = (%s, %s, %s, %s, %s)" % hand.getStreetTotals()
totals = hand.getStreetTotals()
totals = [int(100*i) for i in totals]
self.hands['street1Pot'] = totals[0]
self.hands['street2Pot'] = totals[1]
self.hands['street3Pot'] = totals[2]
self.hands['street4Pot'] = totals[3]
self.hands['showdownPot'] = totals[4]
self.vpip(hand) # Gives playersVpi (num of players vpip)
#print "DEBUG: vpip: %s" %(self.hands['playersVpi'])
self.playersAtStreetX(hand) # Gives playersAtStreet1..4 and Showdown
#print "DEBUG: playersAtStreet 1:'%s' 2:'%s' 3:'%s' 4:'%s'" %(self.hands['playersAtStreet1'],self.hands['playersAtStreet2'],self.hands['playersAtStreet3'],self.hands['playersAtStreet4'])
self.streetXRaises(hand) # Empty function currently
def update_data(self, new_hand_id, db_connection):
#this method called once for every hand processed
# self.hud.stat_dict contains the stats information for this hand
if not self.active:
return
if (debugmode):
debugfile=open("~Rushdebug.data", "a")
debugfile.write(new_hand_id+"\n")
now = datetime.now()
debugfile.write(now.strftime("%Y%m%d%H%M%S")+ " update_data begins"+ "\n")
debugfile.write("hero="+str(self.heroid)+"\n")
#debugfile.write(str(self.hud.stat_dict)+"\n")
debugfile.write("table="+self.hud.table.name+"\n")
debugfile.write("players="+str(self.hud.stat_dict.keys())+"\n")
debugfile.write("db="+str(db_connection)+"\n")
if self.hud.table.name not in self.rushtables:
return
#
# Grab a list of player id's
#
handplayers = self.hud.stat_dict.keys()
#
# build a dictionary of stats text for each player in the hand (excluding the hero)
# xmlqueuedict contains {playername : stats text}
#
xmlqueuedict = {}
for playerid in handplayers:
# ignore hero, no notes available for hero at Full Tilt
if playerid == self.heroid: continue
playername=unicode(str(Stats.do_stat(self.hud.stat_dict, player = playerid, stat = 'playername')[1]))
# Use index[3] which is a short description
n=str(Stats.do_stat(self.hud.stat_dict, player = playerid, stat = 'n')[3] + " ")
vpip=str(Stats.do_stat(self.hud.stat_dict, player = playerid, stat = 'vpip')[3] + " ")
pfr=str(Stats.do_stat(self.hud.stat_dict, player = playerid, stat = 'pfr')[3] + " ")
three_B=str(Stats.do_stat(self.hud.stat_dict, player = playerid, stat = 'three_B')[3] + " ")
four_B=str(Stats.do_stat(self.hud.stat_dict, player = playerid, stat = 'four_B')[3] + " ")
cbet=str(Stats.do_stat(self.hud.stat_dict, player = playerid, stat = 'cbet')[3] + " ")
fbbsteal=str(Stats.do_stat(self.hud.stat_dict, player = playerid, stat = 'f_BB_steal')[3] + " ")
f_3bet=str(Stats.do_stat(self.hud.stat_dict, player = playerid, stat = 'f_3bet')[3] + " ")
f_4bet=str(Stats.do_stat(self.hud.stat_dict, player = playerid, stat = 'f_4bet')[3] + " ")
steal=str(Stats.do_stat(self.hud.stat_dict, player = playerid, stat = 'steal')[3] + " ")
ffreq1=str(Stats.do_stat(self.hud.stat_dict, player = playerid, stat = 'ffreq1')[3] + " ")
agg_freq=str(Stats.do_stat(self.hud.stat_dict, player = playerid, stat = 'agg_freq')[3] + " ")
BBper100=str(Stats.do_stat(self.hud.stat_dict, player = playerid, stat = 'BBper100')[3])
if BBper100[6] == "-": BBper100=BBper100[0:6] + "(" + BBper100[7:] + ")"
#
# grab villain known starting hands
# only those where they VPIP'd, so limp in the BB will not be shown
# sort by hand strength. Output will show position too,
# so KK.1 is KK from late posn etc.
# ignore non-rush hands (check against known rushtablenames)
# cards decoding is hard-coded for holdem, so that's tuff atm
# three categories of known hands are shown:
# agression preflop hands
# non-aggression preflop hands
# bigblind called to defend hands
#
# This isn't perfect, but it isn't too bad a starting point
#
PFcall="PFcall"
PFaggr="PFaggr"
PFdefend="PFdefend"
c = db_connection.get_cursor()
c.execute(("SELECT handId, position, startCards, street0Aggr, tableName " +
"FROM Hands, HandsPlayers " +
"WHERE HandsPlayers.handId = Hands.id " +
"AND street0VPI " +
"AND startCards > 0 " +
"AND playerId = %d " +
"ORDER BY startCards DESC " +
";")
% int(playerid))
for (qid, qposition, qstartcards, qstreet0Aggr, qtablename) in c.fetchall():
if (debugmode):
debugfile.write("pid, hid, pos, cards, aggr, table player"+
str(playerid)+"/"+str(qid)+"/"+str(qposition)+"/"+
str(qstartcards)+"/"+str(qstreet0Aggr)+"/"+
str(qtablename)+"/"+str(playername)+
"\n")
humancards = Card.decodeStartHandValue("holdem", qstartcards)
if qtablename not in self.rushtables:
pass
elif qposition == "B" and qstreet0Aggr == False:
PFdefend=PFdefend+"/"+humancards
elif qstreet0Aggr == True:
PFaggr=PFaggr+"/"+humancards+"."+qposition
else:
PFcall=PFcall+"/"+humancards+"."+qposition
c.close
#
# build up final text package (top/tail with ~fpdb~ ~ends~
# for later search/replace by Merge module
#
xmlqueuedict[playername] = ("~fpdb~" + "\n" +
n + vpip + pfr + "\n" +
steal + cbet + fbbsteal + ffreq1 + "\n" +
three_B + four_B + f_3bet + f_4bet + "\n" +
agg_freq + BBper100 + "\n" +
PFcall+"\n"+
PFaggr+"\n"+
PFdefend +"\n"+
"~ends~")
if (debugmode):
now = datetime.now()
debugfile.write(now.strftime("%Y%m%d%H%M%S")+" villain data has been processed" + "\n")
debugfile.write(str(xmlqueuedict)+"\n")
#
# delaying processing of xml until now. Grab current queuefile contents and
# read each existing NOTE element in turn, if matched to a player in xmlqueuedict
# update their text in the xml and delete the dictionary item
#
xmlnotefile = minidom.parse(self.queuefile)
notelist = xmlnotefile.getElementsByTagName('NOTE')
for noteentry in notelist: #for each note in turn
noteplayer = noteentry.getAttribute("PlayerId") #extract the playername from xml
if noteplayer in xmlqueuedict: # does that player exist in the queue?
noteentry.setAttribute("Text",xmlqueuedict[noteplayer])
del xmlqueuedict[noteplayer] #remove from list, does not need to be added later on
#
#create entries for new players (those remaining in the dictionary)
#
if len(xmlqueuedict) > 0:
playerdata=xmlnotefile.lastChild #move to the PLAYERDATA node (assume last one in the list)
notesnode=playerdata.childNodes[0] #Find NOTES node
for newplayer in xmlqueuedict:
newentry = xmlnotefile.createElement("NOTE")
newentry.setAttribute("PlayerId", newplayer)
newentry.setAttribute("Text", xmlqueuedict[newplayer])
notesnode.insertBefore(newentry,None)
newentry = xmlnotefile.createTextNode("\n")
notesnode.insertBefore(newentry,None)
if (debugmode):
now = datetime.now()
debugfile.write(now.strftime("%Y%m%d%H%M%S")+" xml pre-processing complete"+ "\n")
#
# OverWrite existing xml file with updated DOM and cleanup
#
updatednotes = open(self.queuefile, 'w')
xmlnotefile.writexml(updatednotes)
updatednotes.close()
xmlnotefile.unlink
if (debugmode):
now = datetime.now()
debugfile.write(now.strftime("%Y%m%d%H%M%S")+" dom written, process finished"+ "\n")
debugfile.close()
def test_Card3(self):
#same
t1 = Card('H',11)
t2 = Card('H',11)
t4 = t1.__eq__(t2)
self.assertEqual(t4,True)
def testsuitName(self):
c = Card(1, 'c')
self.assertEqual(c.suitName(), 'clubs')
def starthands(stat_dict, player, handid):
#summary of known starting hands+position
# data volumes could get crazy here,so info is limited to hands
# in the current HH file only
# this info is NOT read from the cache, so does not obey aggregation
# parameters for other stats
#display shows 3 categories
# PFcall - limp or coldcall preflop
# PFaggr - raise preflop
# PFdefBB - defended in BB
# hand is shown, followed by position indicator
# (b=SB/BB. l=Button/cutoff m=previous 3 seats to that, e=remainder)
# due to screen space required for this stat, it should only
# be used in the popup section i.e.
# <pu_stat pu_stat_name="starthands"> </pu_stat>
stat_descriptions["starthands"] = _("starting hands at this table") + " (starting hands)"
PFlimp=" PFlimp:"
PFaggr=" PFaggr:"
PFcar=" PFCaRa:"
PFdefend=" PFdefBB:"
count_pfl = count_pfa = count_pfc = count_pfd = 2
if handid == -1:
return ((''),
(''),
(''),
(''),
(''),
(''))
c = Configuration.Config()
db_connection = Database.Database(c)
sc = db_connection.get_cursor()
sc.execute(("SELECT distinct startCards, street0Aggr, street0CalledRaiseDone, " +
"case when HandsPlayers.position = 'B' then 'b' " +
"when HandsPlayers.position = 'S' then 'b' " +
"when HandsPlayers.position = '0' then 'l' " +
"when HandsPlayers.position = '1' then 'l' " +
"when HandsPlayers.position = '2' then 'm' " +
"when HandsPlayers.position = '3' then 'm' " +
"when HandsPlayers.position = '4' then 'm' " +
"when HandsPlayers.position = '5' then 'e' " +
"when HandsPlayers.position = '6' then 'e' " +
"when HandsPlayers.position = '7' then 'e' " +
"when HandsPlayers.position = '8' then 'e' " +
"when HandsPlayers.position = '9' then 'e' " +
"else 'X' end " +
"FROM Hands, HandsPlayers, Gametypes " +
"WHERE HandsPlayers.handId = Hands.id " +
" AND Gametypes.id = Hands.gametypeid "+
" AND Gametypes.type = " +
" (SELECT Gametypes.type FROM Gametypes, Hands " +
" WHERE Hands.gametypeid = Gametypes.id and Hands.id = %d) " +
" AND Gametypes.Limittype = " +
" (SELECT Gametypes.limitType FROM Gametypes, Hands " +
" WHERE Hands.gametypeid = Gametypes.id and Hands.id = %d) " +
"AND Gametypes.category = 'holdem' " +
"AND fileId = (SELECT fileId FROM Hands " +
" WHERE Hands.id = %d) " +
"AND HandsPlayers.playerId = %d " +
"AND street0VPI " +
"AND startCards > 0 " +
"ORDER BY startCards DESC " +
";")
% (int(handid), int(handid), int(handid), int(player)))
for (qstartcards, qstreet0Aggr, qstreet0CalledRaiseDone, qposition) in sc.fetchall():
humancards = Card.decodeStartHandValue("holdem", qstartcards)
if qposition == "B" and qstreet0Aggr == False:
PFdefend=PFdefend+"/"+humancards
count_pfd += 1
if (count_pfd / 8.0 == int(count_pfd / 8.0)):
PFdefend=PFdefend+"\n"
elif qstreet0Aggr == True:
PFaggr=PFaggr+"/"+humancards+"."+qposition
count_pfa += 1
if (count_pfa / 8.0 == int(count_pfa / 8.0)):
PFaggr=PFaggr+"\n"
elif qstreet0CalledRaiseDone:
PFcar=PFcar+"/"+humancards+"."+qposition
count_pfc += 1
if (count_pfc / 8.0 == int(count_pfc / 8.0)):
PFcar=PFcar+"\n"
else:
PFlimp=PFlimp+"/"+humancards+"."+qposition
count_pfl += 1
if (count_pfl / 8.0 == int(count_pfl / 8.0)):
PFlimp=PFlimp+"\n"
sc.close()
returnstring = PFlimp + "\n" + PFaggr + "\n" + PFcar + "\n" + PFdefend #+ "\n" + str(handid)
return ((returnstring),
(returnstring),
(returnstring),
(returnstring),
(returnstring),
(''))
def process_result_value(self, value, dialect):
return Card.valueSuitFromCard( value )
def testSuit(self):
c = Card(1, 'c')
self.assertEqual(c.suit(), 'c')
def addGrid(self, vbox, query, flags, playerids, sitenos, limits, type, seats, groups, dates, games):
counter = 0
row = 0
sqlrow = 0
if not flags: holecards,grid = False,0
else: holecards,grid = flags[0],flags[2]
tmp = self.sql.query[query]
tmp = self.refineQuery(tmp, flags, playerids, sitenos, limits, type, seats, groups, dates, games)
#print "DEBUG: query: %s" % tmp
self.cursor.execute(tmp)
result = self.cursor.fetchall()
colnames = [desc[0].lower() for desc in self.cursor.description]
# pre-fetch some constant values:
colshow = colshowsumm
if groups['posn']: colshow = colshowposn
self.cols_to_show = [x for x in self.columns if x[colshow]]
hgametypeid_idx = colnames.index('hgametypeid')
assert len(self.liststore) == grid, "len(self.liststore)="+str(len(self.liststore))+" grid-1="+str(grid)
self.liststore.append( gtk.ListStore(*([str] * len(self.cols_to_show))) )
view = gtk.TreeView(model=self.liststore[grid])
view.set_grid_lines(gtk.TREE_VIEW_GRID_LINES_BOTH)
#vbox.pack_start(view, expand=False, padding=3)
vbox.add(view)
textcell = gtk.CellRendererText()
textcell50 = gtk.CellRendererText()
textcell50.set_property('xalign', 0.5)
numcell = gtk.CellRendererText()
numcell.set_property('xalign', 1.0)
assert len(self.listcols) == grid
self.listcols.append( [] )
# Create header row eg column: ("game", True, "Game", 0.0, "%s")
for col, column in enumerate(self.cols_to_show):
if column[colalias] == 'game' and holecards:
s = [x for x in self.columns if x[colalias] == 'hand'][0][colheading]
else:
s = column[colheading]
self.listcols[grid].append(gtk.TreeViewColumn(s))
view.append_column(self.listcols[grid][col])
if column[colformat] == '%s':
if column[colxalign] == 0.0:
self.listcols[grid][col].pack_start(textcell, expand=True)
self.listcols[grid][col].add_attribute(textcell, 'text', col)
cellrend = textcell
else:
self.listcols[grid][col].pack_start(textcell50, expand=True)
self.listcols[grid][col].add_attribute(textcell50, 'text', col)
cellrend = textcell50
self.listcols[grid][col].set_expand(True)
else:
self.listcols[grid][col].pack_start(numcell, expand=True)
self.listcols[grid][col].add_attribute(numcell, 'text', col)
self.listcols[grid][col].set_expand(True)
cellrend = numcell
#self.listcols[grid][col].set_alignment(column[colxalign]) # no effect?
self.listcols[grid][col].set_clickable(True)
self.listcols[grid][col].connect("clicked", self.sortcols, (col,grid))
if col == 0:
self.listcols[grid][col].set_sort_order(gtk.SORT_DESCENDING)
self.listcols[grid][col].set_sort_indicator(True)
if column[coltype] == 'cash':
self.listcols[grid][col].set_cell_data_func(numcell, self.ledger_style_render_func)
else:
self.listcols[grid][col].set_cell_data_func(cellrend, self.reset_style_render_func)
rows = len(result) # +1 for title row
while sqlrow < rows:
treerow = []
for col,column in enumerate(self.cols_to_show):
if column[colalias] in colnames:
value = result[sqlrow][colnames.index(column[colalias])]
if column[colalias] == 'plposition':
if value == 'B':
value = 'BB'
elif value == 'S':
value = 'SB'
elif value == '0':
value = 'Btn'
else:
if column[colalias] == 'game':
if holecards:
value = Card.decodeStartHandValue(result[sqlrow][colnames.index('category')], result[sqlrow][hgametypeid_idx] )
else:
minbb = result[sqlrow][colnames.index('minbigblind')]
maxbb = result[sqlrow][colnames.index('maxbigblind')]
value = result[sqlrow][colnames.index('limittype')] + ' ' \
+ result[sqlrow][colnames.index('category')].title() + ' ' \
+ result[sqlrow][colnames.index('name')] + ' $'
if 100 * int(minbb/100.0) != minbb:
value += '%.2f' % (minbb/100.0)
else:
value += '%.0f' % (minbb/100.0)
if minbb != maxbb:
if 100 * int(maxbb/100.0) != maxbb:
value += ' - $' + '%.2f' % (maxbb/100.0)
else:
value += ' - $' + '%.0f' % (maxbb/100.0)
else:
continue
if value and value != -999:
treerow.append(column[colformat] % value)
else:
treerow.append(' ')
iter = self.liststore[grid].append(treerow)
#print treerow
sqlrow += 1
row += 1
tips = DemoTips(column[colformat])
tips.add_view(view)
vbox.show_all()
view.show()
if len(self.liststore) == 1:
#print "view hieght is ", view.get_allocation().height, view.size_request(), view.get_visible_rect().height, view.get_vadjustment().get_value()
self.top_pane_height = view.size_request()[1]
#!/usr/bin/env python2.7
from Card import *
card = Card('31790')
card.print_card()
class App:
def __init__(self, interface):
self.player = Card()
self.computer = Card()
self.pscore = 0 #player's score
self.cscore = 0 #computer's score
self.interface = interface
self.hit = 0 # times of player's hitme
def run(self):
#start game
if self.interface.wantToPlay():
self.player.start()
self.computer.start()
self.interface.setPlayerScore(self.pscore)
self.interface.setComputerScore(self.cscore)
self.interface.computergetCards()
self.interface.playergetCards("%s.gif"%(self.player.showcard(1)),"%s.gif"%(self.player.showcard(2)))
winsound.PlaySound("deal.wav",winsound.SND_FILENAME)
self.interface.setMessage("Do you want more card?")
else:
self.interface.close()
def Hit1(self):
# Offer first hitme
if self.interface.wantToHit():
self.hit += 1
self.player.get1Card()
self.interface.Pget1MoreCard("%s.gif"%(self.player.showcard(3)))
winsound.PlaySound("deal.wav",winsound.SND_FILENAME)
else:
self.ComputerHit()
def Hit2(self):
if self.interface.wantToHit() and self.hit == 1:
self.hit += 1
self.player.get2Card()
self.interface.Pget2MoreCard("%s.gif"%(self.player.showcard(4)))
winsound.PlaySound("deal.wav",winsound.SND_FILENAME)
self.ComputerHit()
else:
self.ComputerHit()
def result(self):
#show the winner and loser
winsound.PlaySound("untap.wav",winsound.SND_FILENAME)
if self.player.score() <= 21 and self.computer.score()<=21:
if self.player.score() - self.computer.score() == 0:
self.interface.setMessage("Well, it's a Tie")
self.interface.ShowResult("%s.gif"%(self.computer.showcard(1)),"%s.gif"%(self.computer.showcard(2)),"%s.gif"%(self.computer.showcard(3)),"%s.gif"%(self.computer.showcard(4)))
winsound.PlaySound("laugh.wav",winsound.SND_FILENAME)
self.pscore += 1
self.cscore += 1
elif self.player.score() - self.computer.score() > 0:
self.interface.setMessage("Yeah, You win")
self.interface.ShowResult("%s.gif"%(self.computer.showcard(1)),"%s.gif"%(self.computer.showcard(2)),"%s.gif"%(self.computer.showcard(3)),"%s.gif"%(self.computer.showcard(4)))
winsound.PlaySound("applause.wav",winsound.SND_FILENAME)
self.pscore += 3
self.cscore += 0
else:
self.interface.setMessage("Oops, You lose")
self.interface.ShowResult("%s.gif"%(self.computer.showcard(1)),"%s.gif"%(self.computer.showcard(2)),"%s.gif"%(self.computer.showcard(3)),"%s.gif"%(self.computer.showcard(4)))
winsound.PlaySound("cryout.wav",winsound.SND_FILENAME)
self.pscore += 0
self.cscore += 3
elif self.player.score() > 21:
self.interface.setMessage("Oops, You lose")
self.interface.ShowResult("%s.gif"%(self.computer.showcard(1)),"%s.gif"%(self.computer.showcard(2)),"%s.gif"%(self.computer.showcard(3)),"%s.gif"%(self.computer.showcard(4)))
winsound.PlaySound("cryout.wav",winsound.SND_FILENAME)
self.pscore += 0
self.cscore += 3
elif self.computer.score() >21:
self.interface.setMessage("Yeah, You win")
self.interface.ShowResult("%s.gif"%(self.computer.showcard(1)),"%s.gif"%(self.computer.showcard(2)),"%s.gif"%(self.computer.showcard(3)),"%s.gif"%(self.computer.showcard(4)))
winsound.PlaySound("applause.wav",winsound.SND_FILENAME)
self.pscore += 3
self.cscore += 0
elif self.player.score() > 21 and self.computer.score() >21:
self.interface.setMessage("Well, it's a Tie")
self.interface.ShowResult("%s.gif"%(self.computer.showcard(1)),"%s.gif"%(self.computer.showcard(2)),"%s.gif"%(self.computer.showcard(3)),"%s.gif"%(self.computer.showcard(4)))
winsound.PlaySound("laugh.wav",winsound.SND_FILENAME)
self.pscore += 1
self.cscore += 1
self.interface.setPlayerScore(self.pscore)
self.interface.setComputerScore(self.cscore)
#self.interface.ShowResult("%s.gif"%(self.computer.showcard(1)),"%s.gif"%(self.computer.showcard(2)),"%s.gif"%(self.computer.showcard(3)),"%s.gif"%(self.computer.showcard(4)))
def ComputerHit(self):
# #This is the step that simulate the computer thinking # #
if 1000*random.random() < 1000*self.computer.score()/21.00:
self.computer.get1Card()
self.interface.Cget1MoreCard()
winsound.PlaySound("deal.wav",winsound.SND_FILENAME)
def allclear(self):
#clear the table
self.player.cardclear()
self.computer.cardclear()
self.hit = 0
self.interface.ClearField()
self.interface.setMessage("Click Deal to Restart or Click Quit to exit...")
def quit(self):
if self.interface.wantToQuit():
return True
else:
return False
import Card
import CurrentScreen
import EnumsCards
# 0: Player, 1: KI
numberOf = []
startPlayer = 0
numberOf.append(int(input("How many players? ")))
numberOf.append(int(input("How many computers? ")))
# direction 1: clockwise, -1: counter-clockwise
pointsOfPlayers = Card.initPointsOfPlayers(numberOf[0] + numberOf[1])
# drawCards[1] 0=> + Cards not drawn, 1=> are drawn
drawCards = [0, 0]
names = Card.getNames(numberOf[0])
names.extend(Card.getKINames(numberOf[1]))
while(Card.someHasEnoughtPoints(pointsOfPlayers) == -1):
cardStack = Card.initStackOfCards()
Card.shuffleDeckofCards(cardStack)
handsOfCards = []
for player in range((numberOf[0] + numberOf[1])):
handsOfCards.append(Card.initHand(cardStack))
direction = 1
otherColor = -1
lastCard = Card.drawCard(cardStack)
whichPlayer = startPlayer % (numberOf[0]+numberOf[1])
startPlayer += 1
if lastCard.getValue() == "draw2":
if lastCard.backInDeck == 1:
drawCards[0] = 0
else:
drawCards[0] += 2
def area_expose(self, area, event):
self.style = self.area.get_style()
self.gc = self.style.fg_gc[gtk.STATE_NORMAL]
if self.tableImage is None or self.playerBackdrop is None:
try:
self.playerBackdrop = gtk.gdk.pixbuf_new_from_file(os.path.join(self.conf.graphics_path, u"playerbackdrop.png"))
self.tableImage = gtk.gdk.pixbuf_new_from_file(os.path.join(self.conf.graphics_path, u"Table.png"))
self.area.set_size_request(self.tableImage.get_width(), self.tableImage.get_height())
except:
return
if self.cardImages is None:
self.cardwidth = CARD_WIDTH
self.cardheight = CARD_HEIGHT
self.cardImages = [gtk.gdk.Pixmap(self.area.window, self.cardwidth, self.cardheight) for i in range(53)]
suits = ('s', 'h', 'd', 'c')
ranks = (14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2)
for j in range(0, 13):
for i in range(0, 4):
index = Card.cardFromValueSuit(ranks[j], suits[i])
image = self.deck_inst.card(suits[i], ranks[j])
self.cardImages[index].draw_pixbuf(self.gc, image, 0, 0, 0, 0, -1, -1)
back_im = self.deck_inst.back()
self.cardImages[0].draw_pixbuf(self.gc, back_im, 0, 0, 0, 0, -1,-1)
self.area.window.draw_pixbuf(self.gc, self.tableImage, 0, 0, 0, 0)
if len(self.states) == 0:
return
state = self.states[int(self.state.get_value())]
padding = 6
communityLeft = int(self.tableImage.get_width() / 2 - 2.5 * self.cardwidth - 2 * padding)
communityTop = int(self.tableImage.get_height() / 2 - 1.5 * self.cardheight)
cm = self.gc.get_colormap() #create colormap toi be able to play with colours
color = cm.alloc_color("white") #defaults to black
self.gc.set_foreground(color)
convertx = lambda x: int(x * self.tableImage.get_width() * 0.8) + self.tableImage.get_width() / 2
converty = lambda y: int(y * self.tableImage.get_height() * 0.6) + self.tableImage.get_height() / 2
for player in state.players.values():
playerx = convertx(player.x)
playery = converty(player.y)
self.area.window.draw_pixbuf(self.gc, self.playerBackdrop, 0, 0, playerx - self.playerBackdrop.get_width() / 2, playery - padding / 2)
if player.action=="folds":
color = cm.alloc_color("grey") #player has folded => greyed out
self.gc.set_foreground(color)
else:
color = cm.alloc_color("white") #player is live
self.gc.set_foreground(color)
if state.gametype == 'holdem':
cardIndex = Card.encodeCard(player.holecards[0:2])
self.area.window.draw_drawable(self.gc, self.cardImages[cardIndex], 0, 0, playerx - self.cardwidth - padding / 2, playery - self.cardheight, -1, -1)
cardIndex = Card.encodeCard(player.holecards[3:5])
self.area.window.draw_drawable(self.gc, self.cardImages[cardIndex], 0, 0, playerx + padding / 2, playery - self.cardheight, -1, -1)
elif state.gametype in ('omahahi', 'omahahilo'):
cardIndex = Card.encodeCard(player.holecards[0:2])
self.area.window.draw_drawable(self.gc, self.cardImages[cardIndex], 0, 0, playerx - 2 * self.cardwidth - 3 * padding / 2, playery - self.cardheight, -1, -1)
cardIndex = Card.encodeCard(player.holecards[3:5])
self.area.window.draw_drawable(self.gc, self.cardImages[cardIndex], 0, 0, playerx - self.cardwidth - padding / 2, playery - self.cardheight, -1, -1)
cardIndex = Card.encodeCard(player.holecards[6:8])
self.area.window.draw_drawable(self.gc, self.cardImages[cardIndex], 0, 0, playerx + padding / 2, playery - self.cardheight, -1, -1)
cardIndex = Card.encodeCard(player.holecards[9:11])
self.area.window.draw_drawable(self.gc, self.cardImages[cardIndex], 0, 0, playerx + self.cardwidth + 3 * padding / 2, playery - self.cardheight, -1, -1)
color_string = '#FFFFFF'
background_color = ''
self.pangolayout.set_markup('<span foreground="%s" size="medium">%s %s%.2f</span>' % (color_string, player.name, self.currency, player.stack))
self.area.window.draw_layout(self.gc, playerx - self.pangolayout.get_pixel_size()[0] / 2, playery, self.pangolayout)
if player.justacted:
color_string = '#FF0000'
background_color = 'background="#000000" '
self.pangolayout.set_markup('<span foreground="%s" size="medium">%s</span>' % (color_string, player.action))
self.area.window.draw_layout(self.gc, playerx - self.pangolayout.get_pixel_size()[0] / 2, playery + self.pangolayout.get_pixel_size()[1], self.pangolayout)
else:
color_string = '#FFFF00'
background_color = ''
if player.chips != 0: #displays amount
self.pangolayout.set_markup('<span foreground="%s" %s weight="heavy" size="large">%s%.2f</span>' % (color_string, background_color, self.currency, player.chips))
self.area.window.draw_layout(self.gc, convertx(player.x * .65) - self.pangolayout.get_pixel_size()[0] / 2, converty(player.y * 0.65), self.pangolayout)
color_string = '#FFFFFF'
self.pangolayout.set_markup('<span foreground="%s" size="large">%s%.2f</span>' % (color_string, self.currency, state.pot)) #displays pot
self.area.window.draw_layout(self.gc,self.tableImage.get_width() / 2 - self.pangolayout.get_pixel_size()[0] / 2, self.tableImage.get_height() / 2, self.pangolayout)
if state.showFlop:
cardIndex = Card.encodeCard(state.flop[0])
self.area.window.draw_drawable(self.gc, self.cardImages[cardIndex], 0, 0, communityLeft, communityTop, -1, -1)
cardIndex = Card.encodeCard(state.flop[1])
self.area.window.draw_drawable(self.gc, self.cardImages[cardIndex], 0, 0, communityLeft + self.cardwidth + padding, communityTop, -1, -1)
cardIndex = Card.encodeCard(state.flop[2])
self.area.window.draw_drawable(self.gc, self.cardImages[cardIndex], 0, 0, communityLeft + 2 * (self.cardwidth + padding), communityTop, -1, -1)
if state.showTurn:
cardIndex = Card.encodeCard(state.turn[0])
self.area.window.draw_drawable(self.gc, self.cardImages[cardIndex], 0, 0, communityLeft + 3 * (self.cardwidth + padding), communityTop, -1, -1)
if state.showRiver:
cardIndex = Card.encodeCard(state.river[0])
self.area.window.draw_drawable(self.gc, self.cardImages[cardIndex], 0, 0, communityLeft + 4 * (self.cardwidth + padding), communityTop, -1, -1)
color = cm.alloc_color("black") #we don't want to draw the filters and others in red
self.gc.set_foreground(color)
def add_card(item_id,tmp):
card = Card(item_id, db)
if not card.name == '':
card.save_card()
working_list.remove(item_id)
#print "load cards in ",f
try :
d = pickle.load( open(f, "rb" ))
except :
print "#### ERROR with ",f
all_cards.update(d)
all_deks={}
for f in glob.glob("Decks/*.dek"):
#print "load cards in ",f
d = pickle.load( open(f, "r" ))
all_deks.update(d)
#print "all_cards = ",all_cards
#print "all_deks = ",all_deks
blocked_decks = Card.get_blocked_decks()
get_blocked_decks = Card. get_blocked_decks
#all_cards = pickle.load( open( "all_monsters.sav", "rb" ))
#all_decks=pickle.load( open( "all_decks.sav", "rb" ))
from PIL import Image, ImageTk
class DeckCreator():
def __init__(self,fenetre):
self.galeries = []
self.all_cards_open = getCards("CardFiles/unknown_monsters.sav")
self.refreshCardSelector(fenetre)
def old_insert_from_Hand(self, db):
""" Function to insert Hand into database
Should not commit, and do minimal selects. Callers may want to cache commits
db: a connected Database object"""
# TODO:
# Players - base playerid and siteid tuple
sqlids = db.getSqlPlayerIDs([p[1] for p in self.players], self.siteId)
#Gametypes
gtid = db.getGameTypeId(self.siteId, self.gametype)
# HudCache data to come from DerivedStats class
# HandsActions - all actions for all players for all streets - self.actions
# Hands - Summary information of hand indexed by handId - gameinfo
#This should be moved to prepInsert
hh = {}
hh['siteHandNo'] = self.handid
hh['handStart'] = self.starttime
hh['gameTypeId'] = gtid
# seats TINYINT NOT NULL,
hh['tableName'] = self.tablename
hh['maxSeats'] = self.maxseats
hh['seats'] = len(sqlids)
# Flop turn and river may all be empty - add (likely) too many elements and trim with range
boardcards = self.board['FLOP'] + self.board['TURN'] + self.board['RIVER'] + [u'0x', u'0x', u'0x', u'0x', u'0x']
cards = [Card.encodeCard(c) for c in boardcards[0:5]]
hh['boardcard1'] = cards[0]
hh['boardcard2'] = cards[1]
hh['boardcard3'] = cards[2]
hh['boardcard4'] = cards[3]
hh['boardcard5'] = cards[4]
# texture smallint,
# playersVpi SMALLINT NOT NULL, /* num of players vpi */
# Needs to be recorded
# playersAtStreet1 SMALLINT NOT NULL, /* num of players seeing flop/street4 */
# Needs to be recorded
# playersAtStreet2 SMALLINT NOT NULL,
# Needs to be recorded
# playersAtStreet3 SMALLINT NOT NULL,
# Needs to be recorded
# playersAtStreet4 SMALLINT NOT NULL,
# Needs to be recorded
# playersAtShowdown SMALLINT NOT NULL,
# Needs to be recorded
# street0Raises TINYINT NOT NULL, /* num small bets paid to see flop/street4, including blind */
# Needs to be recorded
# street1Raises TINYINT NOT NULL, /* num small bets paid to see turn/street5 */
# Needs to be recorded
# street2Raises TINYINT NOT NULL, /* num big bets paid to see river/street6 */
# Needs to be recorded
# street3Raises TINYINT NOT NULL, /* num big bets paid to see sd/street7 */
# Needs to be recorded
# street4Raises TINYINT NOT NULL, /* num big bets paid to see showdown */
# Needs to be recorded
#print "DEBUG: self.getStreetTotals = (%s, %s, %s, %s, %s)" % self.getStreetTotals()
#FIXME: Pot size still in decimal, needs to be converted to cents
(hh['street1Pot'], hh['street2Pot'], hh['street3Pot'], hh['street4Pot'], hh['showdownPot']) = self.getStreetTotals()
# comment TEXT,
# commentTs DATETIME
#print hh
handid = db.storeHand(hh)
# HandsPlayers - ? ... Do we fix winnings?
# Tourneys ?
# TourneysPlayers
pass
def test_Card2(self):
#Make sure that __eq__ that checks if cards are teh same, works
t1 = Card('H',10)
t2 = Card('H',11)
t4 = t1.__eq__(t2)
self.assertEqual(t4,False)