Ejemplo n.º 1
0
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)
Ejemplo n.º 2
0
 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())
Ejemplo n.º 3
0
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()
Ejemplo n.º 4
0
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()
Ejemplo n.º 5
0
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)
Ejemplo n.º 6
0
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()
Ejemplo n.º 7
0
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)
Ejemplo n.º 8
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
Ejemplo n.º 9
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()
Ejemplo n.º 10
0
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)
Ejemplo n.º 11
0
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]
Ejemplo n.º 12
0
 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())
Ejemplo n.º 13
0
 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)
Ejemplo n.º 14
0
 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())
Ejemplo n.º 15
0
    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
Ejemplo n.º 16
0
    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)
Ejemplo n.º 17
0
    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)
Ejemplo n.º 18
0
 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())
Ejemplo n.º 19
0
 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)
Ejemplo n.º 20
0
 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())
Ejemplo n.º 21
0
 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)
Ejemplo n.º 22
0
 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)
Ejemplo n.º 23
0
 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)
Ejemplo n.º 24
0
 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)    
Ejemplo n.º 25
0
 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)
Ejemplo n.º 26
0
 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())
Ejemplo n.º 27
0
 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())
Ejemplo n.º 28
0
 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)]
Ejemplo n.º 29
0
 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)]
Ejemplo n.º 30
0
 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)]
Ejemplo n.º 31
0
 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)]
Ejemplo n.º 32
0
 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)]
Ejemplo n.º 33
0
 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)]
Ejemplo n.º 34
0
 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)]
Ejemplo n.º 35
0
 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)]
Ejemplo n.º 36
0
 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)]
Ejemplo n.º 37
0
 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)]
Ejemplo n.º 38
0
 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)
Ejemplo n.º 39
0
 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())
Ejemplo n.º 40
0
 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())
Ejemplo n.º 41
0
 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
Ejemplo n.º 42
0
 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)
Ejemplo n.º 43
0
 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)
Ejemplo n.º 44
0
 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')) 
Ejemplo n.º 45
0
 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)
Ejemplo n.º 46
0
 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)
Ejemplo n.º 47
0
 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)
Ejemplo n.º 48
0
 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)
Ejemplo n.º 49
0
 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)
Ejemplo n.º 50
0
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()
Ejemplo n.º 51
0
 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)
Ejemplo n.º 52
0
 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    
Ejemplo n.º 53
0
    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 []
Ejemplo n.º 54
0
 def deal(self):
     import card
     mycard = self.maze.pop(0)
     name = mycard[0]
     suit = mycard[1]
     mycard = card.card(name, suit)
     return mycard
Ejemplo n.º 55
0
 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)
Ejemplo n.º 56
0
 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
Ejemplo n.º 57
0
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()
Ejemplo n.º 58
0
	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...
Ejemplo n.º 59
0
 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))
Ejemplo n.º 60
0
    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