def createdata(dataset): depth = 53 dataset["all"] = set([]) for i in range(1,depth): dataset[i] = set([]) for i in range(1,depth): sys.stdout.writelines(["\n",str(i)]) for j in range(i+1,depth): sys.stdout.write(".") for k in range(j+1,depth): for l in range(k+1,depth): for m in range(l+1,depth): res = "N" st = stacks.stack([card(i),card(j),card(k),card(l),card(m)]) if hands.isRoyalFlush(st): res = "R" elif hands.isStraightFlush(st): res = "T" elif hands.isFourOAK(st): res = "4" elif hands.isFullHouse(st): res = "H" elif hands.isFlush(st): res = "F" elif hands.isStraight(st): res = "S" elif hands.isThreeOAK(st): res = "3" elif hands.isTwoPair(st): res = "X" elif hands.isPair(st): res = "P" t = (i,j,k,l,m,res) dataset[i].add(t) dataset[j].add(t) dataset[k].add(t) dataset[l].add(t) dataset[m].add(t) dataset["all"].add(t)
def testAB(self): '''Flush_testAB: Two cards different suits should return nothing''' teststack = stacks.stack() teststack.add(card(1,1)) teststack.add(card(2,2)) result = hands.toMakeFlush(teststack) self.assertEqual(result,stacks.stack())
def end(): answer = input('\n' + classes.player1 + "'s card (1)," + classes.player2 + "'s card (2), or play (a)gain (1/2/a) ") while (answer != '1'.lower().strip()) and ( answer != '2'.lower().strip()) and (answer != 'a'.lower().strip()): answer = input( '\n' + classes.player1 + "'s card (1), ", classes.player2 + "'s card (2), or play (a)gain (1/2/a) ") else: if answer == '1'.lower().strip(): classes.active_player1 = True card.card() classes.active_player1 = False end() elif answer == '2'.lower().strip(): classes.active_player2 = True card.card() classes.active_player2 = False end() else: classes.player1_var.reset() classes.player2_var.reset() classes.active_player1 = True classes.num_players = 0 play()
def player2(): print('\n') print(classes.player2 + "'s turn!") card.card() while classes.active_player2: if classes.player2_var.full_upper == False or classes.player2_var.full_lower == False: #initial roll if classes.player2_var.kept_dice_list == [] or classes.player2_var.kept_dice_list == 5: dice_roll.roll(5) classes.player2_var.roll_counter += 1 else: dice_roll.roll(5 - len(classes.player2_var.kept_dice_list)) for i in classes.player2_var.kept_dice_list: classes.player2_var.dice_list.append(i) classes.player2_var.roll_counter += 1 classes.player2_var.kept_dice_list = [] #view dice view_dice_p2.view_dice_p2() #prompt user to choose between score, roll again or keep dice if classes.player2_var.roll_counter < 3: choice_p2.choice_p2() else: upper_lower_p2.upper_lower_p2() #check to see if counters are 6 and 7 respectively in which case full equals True and the loop breaks. if classes.player2_var.counter_upper == 6: classes.player2_var.full_upper = True if classes.player2_var.counter_lower == 7: classes.player2_var.full_lower = True #reinitialize lists classes.player2_var.ones_list = [] classes.player2_var.twos_list = [] classes.player2_var.threes_list = [] classes.player2_var.fours_list = [] classes.player2_var.fives_list = [] classes.player2_var.sixes_list = [] classes.player2_var.dice_list = [] classes.player2_var.dice_hist = [] #check subtotal to see if the bonus is achieved if classes.player2_var.full_upper: if classes.player2_var.subtotal > 63: classes.player2_var.upper_bonus = 35 classes.player2_var.total_upper = classes.player2_var.subtotal + classes.player2_var.upper_bonus else: classes.player2_var.upper_bonus = 0 classes.player2_var.total_upper = classes.player2_var.subtotal if classes.player2_var.full_lower: classes.player2_var.total_lower = sum( classes.player2_var.lower_sub_list) if classes.player2_var.full_lower and classes.player2_var.full_upper: classes.player2_var.grand_total = classes.player2_var.total_lower + classes.player2_var.total_upper card.card()
def main(): village = card("village", 'a', 3, 2, 0, 1, 0, 0) my_dom = dominion([village] * 10) copper = card("copper", "t", 0, treasure=1) estate = card("estate", "v", 2, victory=1) my_player = player([copper] * 7 + [estate] * 3) my_dom.turn(None, my_player)
def choice_p1(): answer = input( '\n(s)core, (r)oll again, (k)eep dice, or (v)iew card? (s/r/k/v) ') while (answer != 's'.lower().strip()) and (answer != 'r'.lower().strip( )) and (answer != 'k'.lower().strip()) and (answer != 'v'.lower().strip()): choice_p1() else: if answer == 's'.lower().strip(): upper_lower_p1.upper_lower_p1() elif answer == 'r'.lower().strip(): return elif answer == 'k'.lower().strip(): print("Which dice would you like to keep?") #shows each dice and asks player to keep or not for i in classes.player1_var.dice_list: dice_mod.dice(i) keep = input(' (y/n) ') #each dice kept is appended to the kept dice list if keep == 'y'.lower().strip(): classes.player1_var.kept_dice_list.append(i) #dice list now contains kept dice list classes.player1_var.dice_list = classes.player1_var.kept_dice_list elif answer == 'v'.lower().strip(): card.card() choice_p1()
def main(): while True: first_hand = input("Input the first hand:") if first_hand == ' ': break if not check_input(first_hand): continue second_hand = input("Input the second hand:") if first_hand == ' ': break if not check_input(first_hand, second_hand): continue first_hand = first_hand.split(" ") A0 = card(int(first_hand[0]), int(first_hand[1])) A1 = card(int(first_hand[2]), int(first_hand[3])) second_hand = second_hand.split(" ") B0 = card(int(second_hand[0]), int(second_hand[1])) B1 = card(int(second_hand[2]), int(second_hand[3])) print("P1: " + str(A0) + " " + str(A1)) print("P2: " + str(B0) + " " + str(B1)) random_pick(A0, A1, B0, B1) # bruce_pick(A0, A1, B0, B1) sys.exit(0)
def deal(self): #print('dealing') type = random.choice(self.deck) self.deck.remove(type) self.top = card(375, 250, 0, 375, 250, 0, 0, type, None, False) for p in self.players: for c in range(0, 3): type = random.choice(self.deck) self.deck.remove(type) self.lastcard = None if c == 0: self.lastcard = self.players[self.players.index(p) - 1].cards[2] else: self.lastcard = p.cards[c - 1] p.cards[c] = card(375, 250, 0, p.cardp[c][0], p.cardp[c][1], p.cardp[c][2], 10.5, type, self.lastcard, False) #print('flipping') type = random.choice(self.deck) self.deck.remove(type) self.bottom = card(375, 250, 0, 325, 250, 0, 10.5, type, self.players[len(self.players) - 1].cards[2], True) self.newturn = 0
def choice_p2(): if classes.active_player2: answer = input( '\n(s)core, (r)oll again, (k)eep dice, or (v)iew card? (s/r/k/v) ') while (answer != 's'.lower().strip()) and (answer != 'r'.lower().strip()) and ( answer != 'k'.lower().strip()) and (answer != 'v'.lower().strip()): choice_p2() else: if answer == 's'.lower().strip(): upper_lower_p2.upper_lower_p2() elif answer == 'r'.lower().strip(): return elif answer == 'k'.lower().strip(): print("Which dice would you like to keep?") for i in classes.player2_var.dice_list: dice_mod.dice(i) keep = input(' (y/n) ') if keep == 'y'.lower().strip(): classes.player2_var.kept_dice_list.append(i) classes.player2_var.dice_list = classes.player2_var.kept_dice_list elif answer == 'v'.lower().strip(): card.card() choice_p2()
def toMakeStraightFlush(cards): if not isinstance(cards,stacks.stack): raise NotImplementedError, "toMakeStraightFlush only works on stacks" rset = stacks.stack() exclude = stacks.stack() rset.populate("Full Deck") if (len(cards) < 1): #No cards played yet - anything will work return rset if (len(cards) > 4): #Five cards played - nothing else will work rset.clear() return rset if len(cards) == 1 and list(cards)[0].rank() == 1: #Special case for single ace rset.clear() for rank in range(10,14)+range(2,6): rset.add(card(rank,list(cards)[0].suit())) return rset if len(cards) == 4 and len(toMakeRoyalFlush(cards)) != 0: exclude = toMakeRoyalFlush(cards) invalid = set([-3,-2,-1,0,15,16,17,18]) grouped = groups(cards) wset = stacks.stack() maxgroup = max([len(v) for v in grouped]) #Calculates the number of cards in the rank with the most cards if maxgroup > 1: #If there's more than one in the maxgroup, can't continue to make a straight rset.clear() return rset flushed = flushes(cards) maxflush = max([len(v) for v in flushed]) if maxflush != len(cards): rset.clear() return rset #Calculate max and min rank ranks = [group[0].rank() for group in grouped if len(group) != 0] mn = min(ranks) mx = max(ranks) ranks.sort() if 1 in ranks: spanlo = abs(1-max(ranks)) spanhi = abs(ranks[1]-14) if min(spanhi,spanlo) == spanlo: mx = max(ranks) mn = 1 else: mx = 14 mn = ranks[1] span = abs(mx-mn) else: span = abs(min(ranks)-max(ranks)) if span > 4: #No good - cards we have are too far apart rset.clear() return rset rset.clear() adj = 4-span for rank in set(range(mn-adj,mx+adj+1)).difference(invalid): rset.add(card(rank,list(cards)[0].suit())) for crd in cards: wset.add(crd) return rset.difference(wset).difference(exclude)
def playCards(handOfCards, othersCards, overAllScore, playerNum, ifShootMoon = False, ifCanHearts = False): 'the ai algorithm for playing out cards' ########################################################################################## # try to play the lowest high cards # get rid of high cards as fast as possible, maybe taking some risks # get rid of hearts (and high spades) first # if other people play harmless cards, play highest # if inevitable gain of score, play highest # account for probability of upcoming people playing low cards, and decide #+ whether play low or high cards (the risk-taking part) ########################################################################################## # try not to finish a suite # determine if possible (whether hand is high enouth, & whether someone else got scores) # save 1/2 high cards for each suite for score-gaining # for scoreless turns play lowest card # if negative-value cards' amount reduces to 5, start to play highest cards ########################################################################################## sleep(sleepTime) if _ifDebug: print(handOfCards.str() + ' ' + str(len(handOfCards))) othersHighest = lambda othersCards = othersCards: card() if not len(othersCards) else \ sorted([crd for crd in othersCards], key = card.sortKey)[-1] sameSuite = lambda handOfCards = handOfCards, othersCards = othersCards: \ [crd for crd in handOfCards if crd.getMN()[0] == (othersCards[0] if len(othersCards) else card()).getMN()[0]] lessThanOthers = lambda handOfCards = handOfCards, ifRisking = False: \ [crd for crd in sameSuite(handOfCards) if crd.getMN()[1] <= \ othersHighest(othersCards).getMN()[1] + (3 if ifRisking else 0)] handAfterHearts = lambda handOfCards: \ [crd for crd in handOfCards if ifCanHearts or crd.getMN()[0] != 1] limitHandWithHearts = lambda handOfCards, removeOrKeepOnly: \ [crd for crd in handOfCards if removeOrKeepOnly ^ (crd.getMN()[0] == 1)] if len(handOfCards) == 13 and (2, 0) in handOfCards: return card().setMN(2, 0) canPlay = sameSuite() if not len(canPlay): if len(othersCards) or ifCanHearts: canPlay = handOfCards else: canPlay = limitHandWithHearts(handOfCards, True) if ifShootMoon: # returns the highest scored card return sorted(canPlay, key = lambda crd: cardValues[crd.getMN()])[-1] else: if not len(othersCards) and len(canPlay): return sorted(canPlay, key = lambda crd: cardValues[crd.getMN()])[0] # output the highest of card that avoids score gaining if possible elif len([c for c in sameSuite(canPlay) if c.getMN() != (0, 10)]) and 3 == len(othersCards) and \ not sum([crd.score() for crd in othersCards]): return [c for c in sameSuite(canPlay) if c.getMN() != (0, 10)][-1] # if safe, play highest elif len(lessThanOthers(canPlay)): return lessThanOthers(canPlay)[-1] elif len(lessThanOthers(canPlay, True)): # if has cards that greater by 3, play the lowest of these (risking) return lessThanOthers(canPlay, True)[0] elif len(sameSuite(canPlay)): return sameSuite(canPlay)[-1] # if any same suite, return highest try: if [i for i in range(4) if overAllScore[i] == min(overAllScore)][0] == \ ([i for i in range(len(othersCards)) if othersHighest() == othersCards[i]][0] + playerNum - len(othersCards)) % 4: # go for the lowest score player return sorted(limitHandWithHearts(canPlay, True), key = lambda crd: cardValues[crd.getMN()])[-1] else: return sorted(limitHandWithHearts(canPlay, False), key = lambda crd: cardValues[crd.getMN()])[-1] except IndexError: try: return sorted(canPlay, key = lambda crd: cardValues[crd.getMN()])[-1] except: return sorted(handOfCards, key = lambda crd: cardValues[crd.getMN()])[-1]
def testABC(self): '''FourOAK_testABC: Should return nothing''' teststack = stacks.stack() teststack.add(card(1,1)) teststack.add(card(2,1)) teststack.add(card(3,1)) result = hands.toMakeFourOAK(teststack) self.assertEqual(result,stacks.stack())
def testStraightFlushLow(self): self.teststack.add(card(1,1)) self.teststack.add(card(2,1)) self.teststack.add(card(3,1)) self.teststack.add(card(4,1)) result = hands.toMakeStraightFlush(self.teststack) self.workstack.add(card(5,1)) self.assertEqual(result,self.workstack)
def testAAA(self): '''Pair_testAAA: Should return nothing (more than a pair)''' teststack = stacks.stack() teststack.add(card(1,1)) teststack.add(card(1,2)) teststack.add(card(1,3)) result = hands.toMakePair(teststack) self.assertEqual(result,stacks.stack())
def challenge_with_2_values(self, player, value, value2): answer = "" answer2 = "" answer3 = "" for i in self.player_list: if i != player: game_challenge = self.challenge_part1(i) if game_challenge == True: v = self.yes_challenge_with_2_values(player,value, value2) if v == True: print(f'\n{player.name}, you won the challenge') answer = True self.log.append(f"{i.name} challenged {player.name} and lost, so he/she lost an influence") if v == 5: self.dealer.deck.append(card(value)) print(card(value).type) elif v == 6: self.dealer.deck.append(card(value2)) print(card(value2).type) j = 0 for p in player.hand: if p.type == value or p.type == value2: player.hand.pop(j) j+=1 self.dealer.deal_card(player) print(f'\n{i.name}, you lost the challenge, turn up a card!') i.look_at_the_hand() answer = int(input('Choose a card: ')) self.dealer.dead_deck.append(i.hand[answer]) i.hand.pop(answer) self.you_lost(i) answer3 = 1 break else: print(f'\n{player.name} you lost the challenge, turn up a card:') answer = int(input('Choose a card: ')) self.dealer.dead_deck.append(player.hand[answer]) self.log.append(f"{i.name} challenged {player.name} and won, so {player.name} lost an influence") player.hand.pop(answer) answer = False self.you_lost(player) answer3 = 1 break elif game_challenge == False: answer2 = True if answer == True: return True elif answer2 == True: return 0 elif answer3 == 1: return 1 else: return False
def __init__(self, lib_dir): self.lib_dir = lib_dir self.name = "" self.cards_count = {} self.cards = [] self.supervilains = [] self.starter_cards = {} self.curse_card = None self.buyable_power = None self.superheroes = [] self.first_supervilain = None fp = open(os.path.join(lib_dir, "library"), "r") lines = fp.readlines() fp.close() for l in lines: l = l.rstrip('\n').rstrip('\r') if not l.startswith("#"): if l.startswith("name:"): self.name = l[5:] elif l.startswith("count:"): l = l[6:] data = l.split(",") self.cards_count[data[0]] = int(data[1]) elif l.startswith("starter:"): l = l[8:] data = l.split(",") self.starter_cards[data[0]] = int(data[1]) elif l.startswith("curse:"): self.curse_card = l[6:] elif l.startswith("buyable_power:"): self.buyable_power = l[14:] elif l.startswith("first_supervilain:"): self.first_supervilain = l[18:] files = os.listdir(lib_dir) for f in files: path = os.path.join(lib_dir, f) if os.path.isfile(path) and path.endswith(".card"): #card to load c = card.card() c.from_file(path) self.cards.append(c) elif os.path.isfile(path) and path.endswith(".superhero"): s = superhero.superhero(self) s.from_file(path) self.superheroes.append(s) elif os.path.isfile(path) and path.endswith(".supervilain"): sv = card.card() sv.from_file(path) self.supervilains.append(sv)
def testABCD(self): '''FullHouse_testABCD: Should return nothing''' teststack = stacks.stack() teststack.add(card(1,1)) teststack.add(card(2,1)) teststack.add(card(3,1)) teststack.add(card(4,1)) result = hands.toMakeFullHouse(teststack) self.assertEqual(result,stacks.stack())
def testRoyalFlush(self): '''StraightFlush_testRoyalFlush: Should return cards on suits that don't complete Royal Flush''' self.teststack.add(card(10,1)) self.teststack.add(card(11,1)) self.teststack.add(card(12,1)) self.teststack.add(card(13,1)) result = hands.toMakeStraightFlush(self.teststack) self.goodstack.add(card(9,1)) self.assertEqual(result,self.goodstack)
def testAAAA(self): '''ThreeOAK_testAAAA: Should return nothing''' teststack = stacks.stack() teststack.add(card(1,1)) teststack.add(card(1,2)) teststack.add(card(1,3)) teststack.add(card(1,4)) result = hands.toMakeThreeOAK(teststack) self.assertEqual(result,stacks.stack())
def testA(self): '''Flush_testA: Single card should return all cards in that suit minus card given''' teststack = stacks.stack() teststack.add(card(1,1)) result = hands.toMakeFlush(teststack) goodstack = stacks.stack() goodstack.populate("Suit",card(1,1)) goodstack = goodstack.difference([card(1,1)]) self.assertEqual(result,goodstack)
def testFive(self): '''Straight_testFive: Should return nothing''' self.teststack.add(card(1,1)) self.teststack.add(card(1,2)) self.teststack.add(card(1,3)) self.teststack.add(card(1,4)) self.teststack.add(card(2,1)) result = hands.toMakeStraight(self.teststack) self.assertEqual(result,self.emptystack)
def testA(self): '''Pair_testA: Should return full deck except A''' teststack = stacks.stack() teststack.add(card(1,1)) result = hands.toMakePair(teststack) workstack = stacks.stack() workstack.populate("Full Deck") workstack = workstack.difference([card(1,1)]) self.assertEqual(result,workstack)
def testOneAce(self): '''StraightFlush_testOneAce: Should return 10-J-Q-K and 2-3-4-5 in one suit''' self.teststack.add(card(1,1)) result = hands.toMakeStraightFlush(self.teststack) for rank in (range(10,14)+range(2,6)): self.goodstack.add(card(rank,1)) self.workstack.add(card(1,1)) self.goodstack = self.goodstack.difference(self.workstack) self.assertEqual(result,self.goodstack)
def testFourCardRF(self): '''RoyalFlush_testFourcardRF: Should return the one remaining royal flush card''' teststack = stacks.stack() teststack.populate("Face Cards",1) teststack.add(card(10,1)) result = hands.toMakeRoyalFlush(teststack) goodstack = stacks.stack() goodstack.add(card(1,1)) self.assertEqual(result,goodstack)
def testAABB(self): '''ThreeOAK_testAABB: Should return nothing (anything from either rank makes a full house)''' teststack = stacks.stack() teststack.add(card(1,1)) teststack.add(card(1,2)) teststack.add(card(2,1)) teststack.add(card(2,2)) result = hands.toMakeThreeOAK(teststack) self.assertEqual(result,stacks.stack())
def testAAAB(self): '''TwoPair_testAAAB: Should return nothing''' teststack = stacks.stack() teststack.add(card(1,1)) teststack.add(card(1,2)) teststack.add(card(1,3)) teststack.add(card(2,1)) result = hands.toMakeTwoPair(teststack) self.assertEqual(result,stacks.stack())
def mock_royal(): return [[ card('10', 'Spades', 8), card('J', 'Spades', 9), card('Q', 'Spades', 10), card('K', 'Spades', 11), card('A', 'Spades', 12), ], 10, get_game_name(10)]
def mock_fullhouse(): return [[ card('2', 'Spades', 0), card('2', 'Clubs', 0), card('3', 'Clubs', 1), card('3', 'Spades', 1), card('3', 'Hearts', 1), ], 7, get_game_name(7)]
def mock_highcard(): return [[ card('A', 'Hearts', 14), card('2', 'Spades', 0), card('3', 'Spades', 1), card('4', 'Spades', 2), card('5', 'Spades', 3), ], 1, get_game_name(1)]
def mock_four(): return [[ card('2', 'Spades', 0), card('2', 'Clubs', 0), card('2', 'Diamonds', 0), card('2', 'Hearts', 0), card('3', 'Spades', 1), ], 8, get_game_name(8)]
def mock_flush(): return [[ card('2', 'Spades', 0), card('3', 'Spades', 1), card('4', 'Spades', 2), card('5', 'Spades', 3), card('A', 'Spades', 14), ], 6, get_game_name(6)]
def mock_street(): return [[ card('2', 'Spades', 0), card('3', 'Spades', 1), card('4', 'Spades', 2), card('5', 'Spades', 3), card('6', 'Spades', 4), ], 9, get_game_name(9)]
def mock_pair(): return [[ card('2', 'Spades', 0), card('2', 'Clubs', 0), card('3', 'Spades', 1), card('4', 'Spades', 2), card('5', 'Spades', 3), ], 2, get_game_name(2)]
def mock_twopairs(): return [[ card('2', 'Spades', 0), card('2', 'Clubs', 0), card('3', 'Spades', 1), card('3', 'Clubs', 1), card('4', 'Spades', 2), ], 3, get_game_name(3)]
def mock_straight(): return [[ card('2', 'Spades', 0), card('3', 'Spades', 1), card('4', 'Spades', 2), card('5', 'Clubs', 3), card('6', 'Spades', 4), ], 5, get_game_name(5)]
def mock_three(): return [[ card('2', 'Spades', 0), card('2', 'Clubs', 0), card('2', 'Hearts', 0), card('3', 'Spades', 1), card('4', 'Spades', 2), ], 4, get_game_name(4)]
def testAA(self): '''FourOAK_testAA: Should return all cards except A's''' teststack = stacks.stack() teststack.add(card(1,1)) teststack.add(card(1,2)) result = hands.toMakeFourOAK(teststack) workstack = stacks.stack() workstack.populate("Full Deck") workstack = workstack.difference(teststack) self.assertEqual(result,workstack)
def testFive(self): '''Flush_testFive: Five cards should return nothing (even if they're the same suit)''' teststack = stacks.stack() teststack.add(card(1,1)) teststack.add(card(2,1)) teststack.add(card(3,1)) teststack.add(card(4,1)) teststack.add(card(5,1)) result = hands.toMakeFlush(teststack) self.assertEqual(result,stacks.stack())
def testFive(self): '''Pair_testFive: Should return nothing''' teststack = stacks.stack() teststack.add(card(1,1)) teststack.add(card(2,2)) teststack.add(card(3,3)) teststack.add(card(4,4)) teststack.add(card(5,5)) result = hands.toMakePair(teststack) self.assertEqual(result,stacks.stack())
def getNewCards(self): self.cards[0] = card(random.randint(0, 19)) self.cards[1] = card(random.randint(0, 19)) self.cards[2] = card(random.randint(0, 19)) self.cards[0].position = (0, 133) self.cards[1].position = (300, 133) self.cards[2].position = (600, 133) self.cards[0].onScreen = True self.cards[1].onScreen = True self.cards[2].onScreen = True
def test1(self): self.teststack.populate("Full Deck") result = hands.canMakeRoyalFlush(self.teststack) self.assertTrue(result) self.teststack.remove(card(13,1)) self.teststack.remove(card(13,2)) self.teststack.remove(card(13,3)) self.teststack.remove(card(13,4)) result = hands.canMakeRoyalFlush(self.teststack) self.assertFalse(result)
def testAB(self): '''TwoPair_testAB: Should return all cards except A and B''' teststack = stacks.stack() teststack.add(card(1,1)) teststack.add(card(2,2)) result = hands.toMakeTwoPair(teststack) workstack = stacks.stack() workstack.populate("Full Deck") workstack = workstack.difference(teststack) self.assertEqual(result,workstack)
def __init__(self): self.deck = [] for x in range(2,15): self.deck.append(card( x, ' of spades')) for y in range(2,15): self.deck.append(card(y, ' of clubs' )) for z in range(2,15): self.deck.append(card(z, ' of diamonds' )) for xx in range(2,15): self.deck.append(card( xx,' of hearts'))
def testAB(self): '''Pair_testAB: Should return full deck minus cards given''' teststack = stacks.stack() teststack.add(card(1,1)) teststack.add(card(2,2)) result = hands.toMakePair(teststack) workstack = stacks.stack() workstack.populate("Full Deck") workstack = workstack.difference(teststack) self.assertEqual(result,workstack)
def testAAAB(self): '''FourOAK_testAAAB: Should only return remaining card in same rank as A's''' teststack = stacks.stack() teststack.add(card(1,1)) teststack.add(card(1,2)) teststack.add(card(1,3)) teststack.add(card(2,1)) result = hands.toMakeFourOAK(teststack) workstack = stacks.stack() workstack.add(card(1,4)) self.assertEqual(result,workstack)
def testAB(self): '''FourOAK_testAB: Should return cards from both A/B ranks except A/B''' teststack = stacks.stack() teststack.add(card(1,1)) teststack.add(card(2,1)) result = hands.toMakeFourOAK(teststack) workstack = stacks.stack() workstack.populate("Rank",card(1,1)) workstack.populate("Rank",card(2,1)) workstack = workstack.difference(teststack) self.assertEqual(result,workstack)
def testAAA(self): '''FullHouse_testAAA: Should return all cards except those in A rank''' teststack = stacks.stack() teststack.add(card(1,1)) teststack.add(card(1,2)) teststack.add(card(1,3)) result = hands.toMakeFullHouse(teststack) workstack = stacks.stack() workstack.populate("Full Deck") workstack = workstack.difference(teststack).difference([card(1,4)]) self.assertEqual(result,workstack)
def testAABB(self): '''FullHouse_testAABB: Should return A/B ranks except A/B''' teststack = stacks.stack() teststack.add(card(1,1)) teststack.add(card(1,2)) teststack.add(card(2,1)) teststack.add(card(2,2)) result = hands.toMakeFullHouse(teststack) workstack = stacks.stack() workstack.populate("Rank",card(1,1)) workstack.populate("Rank",card(2,1)) workstack = workstack.difference([card(1,1),card(1,2),card(2,1),card(2,2)]) self.assertEqual(result,workstack)
def upper_lower(): card.card() if global_var.counter_lower == 7: upper_score.upper_score() if global_var.counter_upper == 6: lower_score.lower_score() answer = input('\nWhere would you like to score? Upper or Lower? (u/l) ') while (answer != 'u'.lower().strip()) and (answer != 'l'.lower().strip()): answer = input('Please enter Upper or Lower (u/l) ') else: if answer == 'u'.lower().strip(): upper_score.upper_score() else: lower_score.lower_score()
def __init__(self, deck): super(BuildDeck, self).__init__() self.cards = [] self.cards.append(card(random.randint(0, 19))) self.cards.append(card(random.randint(0, 19))) self.cards.append(card(random.randint(0, 19))) self.cards[0].position = (0, 133) self.cards[1].position = (300, 133) self.cards[2].position = (600, 133) self.cards[0].onScreen = True self.cards[1].onScreen = True self.cards[2].onScreen = True self.deck = deck random.seed(time.time)
def gen_card_pack(self): suits = ['H', 'S', 'C', 'D'] cards = ['A', '2', '3', '4', '5', '6', '7', '8', '9', 'X', 'J', 'Q', 'K'] for suit in suits: for value in cards: self.card_pack.append(card(value, suit)) return
def deal_card(self, list_of_cards=None, number_of_cards=1): ''' deals a card from the deck. This returns a card or list of cards. list_of_cards is built to work with self.find_card() in mind. self.find_card returns a list of cards based on input given. Example: a = carddeck() a.deal_card(a.find_card("A","S")) would return the Ace of Spades ''' if type(list_of_cards) == list: temp = [] index_holder = [] for i in list_of_cards: index_holder.append(self.deck.index(i)) for i in sorted(index_holder)[::-1]: temp.append(self.deck.pop(i)) return temp or [card()] if self.is_deck_empty(): return [] if number_of_cards <= 1: return [self.deck.pop()] or [] else: return [self.deck.pop() for i in range(number_of_cards)] or []
def deal(self): import card mycard = self.maze.pop(0) name = mycard[0] suit = mycard[1] mycard = card.card(name, suit) return mycard
def createuser(self): #向用户字典中添加一对键值对(卡号-用户) name = input('请输入您的姓名:') idcard = input('请输入您的身份证号:') phone = input('请输入您的电话号码:') prestoremony = int(input('请输入预存款金额:')) if prestoremony < 0: print('预存款输入有误') return -1 onepasswd = input('请设置密码:') if not self.checkpasswd(onepasswd): print('密码输入错误,开户失败') return -1 cardid = self.randomcardid() card1 = card(cardid, onepasswd, prestoremony) user0 = user(name, idcard, phone, card1) #0-身份证号,1-密码,2-余额,3-锁定状态 alluser = [ user0.idcard, user0.card.cardpasswd, user0.card.cardmoney, user0.card.lock ] #0-用户名,1-电话号码,2-卡号 userinfo = [user0.name, user0.phone, user0.card.cardid] #print(list(user1)) self.alluser[cardid] = alluser self.userinfo[idcard] = userinfo print('开户成功!请记住卡号(%s)' % cardid)
def find_card_by_ID(self, ID=None): if not ID: return None else: for i in self.deck: if i.get_ID() == ID: return i or card() return None
def upper_lower_p1(): if classes.active_player1: card.card() if classes.player1_var.counter_lower == 7: upper_score.upper_score() return if classes.player1_var.counter_upper == 6: lower_score.lower_score() return answer = input('\nWhere would you like to score? Upper or Lower? (u/l) ') while (answer != 'u'.lower().strip()) and (answer != 'l'.lower().strip()): answer = input('Please enter Upper or Lower (u/l) ') else: if answer == 'u'.lower().strip(): upper_score.upper_score() else: lower_score.lower_score()
def __init__(self): self.cardsInDeck = [] # Initialized blank deck to hold cards upon instancing for suit in card.suits: for name in card.names: self.cardsInDeck.append(card(name, suit)) self.shuffle() # Surely we're not just starting with an unshuffled deck...
def __init__(self): # we will create a standard 52 deck card self.deck = [] self.play = [] self.discard = [] # loop suits for s in range(0, 4): # loop values for v in range(1, 14): self.deck.append(card.card(s, v))
def load_deck(self): card_list = [] raw_list = get_card_list() for _card in raw_list: card_obj = card(_card['label'], _card['suit'], _card['value']) card_list.append(card_obj) return card_list