Esempio n. 1
0
    def calculate_point_delta(declarerID, winningBid, tricks, playerHands, rubberStates):
        pointDeltas = [RubberState(0, 0, False), RubberState(0, 0, False)]
        
        # First check if any player was dealt honors
        for i, p in enumerate(playerHands):
            honorsCheck = set([x.value for x in p if x.suit == winningBid.bidSuit]) & set(RANKS[8:])
            if len(honorsCheck) == 5:
                pointDeltas[i % 2].aboveTheLine += 150

            if len(honorsCheck) == 4:
                pointDeltas[i % 2].aboveTheLine += 100
            
            if winningBid.bidSuit == 'nt' and [x.value for x in p].count('A') == 4:
                pointDeltas[i % 2].aboveTheLine += 150
       
        if tricks - 6 >= winningBid.bidValue:
            pointMultiplier = 1
            # set the point multiplier and add the insult bonus
            if winningBid.bidType == 'double':                
                pointMultiplier = 2
                pointDeltas[declarerID % 2].aboveTheLine += 50
            if winningBid.bidType == 'redouble':
                pointMultiplier = 4
                pointDeltas[declarerID % 2].aboveTheLine += 100
                
            pointDeltas[declarerID % 2].belowTheLine += pointMultiplier * Bid.below_point_delta(winningBid.bidValue, winningBid.bidSuit)
            pointDeltas[declarerID % 2].aboveTheLine += pointMultiplier * Bid.above_point_delta(tricks - 6 - winningBid.bidValue, winningBid.bidSuit)
        else:
            # calculate values for getting set  
            if rubberStates[declarerID % 2].isVulnerable == True:
                 if winningBid.bidType == 'bid':
                     pointDeltas[(declarerID + 1) % 2].aboveTheLine += 100 * ((winningBid.bidValue + 6) - tricks)
                 if winningBid.bidType == 'double':
                     pointDeltas[(declarerID + 1) % 2].aboveTheLine += 200 + 300 * ((winningBid.bidValue + 6) - tricks - 1)
                 if winningBid.bidType == 'redouble':
                     pointDeltas[(declarerID + 1) % 2].aboveTheLine += 400 + 600 * ((winningBid.bidValue + 6) - tricks - 1)
            else:
                 if winningBid.bidType == 'bid':
                     pointDeltas[(declarerID + 1) % 2].aboveTheLine += 50 * ((winningBid.bidValue + 6) - tricks)
                 if winningBid.bidType == 'double':
                     doublePenalties = [100,200,200] + [300] * 10
                     pointDeltas[(declarerID + 1) % 2].aboveTheLine += sum(doublePenalties[:((winningBid.bidValue + 6) - tricks)])
                 if winningBid.bidType == 'redouble':
                     redoublePenalties = [200,400,400] + [600] * 11
                     pointDeltas[(declarerID + 1) % 2].aboveTheLine += sum(redoublePenalties[:((winningBid.bidValue + 6) - tricks)])
                 
        
        for i, delta in enumerate(pointDeltas):
            log.event("Point delta for Team " + str(i) + "... " + str(delta))       
        return pointDeltas
Esempio n. 2
0
    def play(self, rubbers=1):
        self.players = [Player(i, (i+2)%4, x) for i, x in enumerate(self._bots)]        
        dealerID = self.players[0].identifier
        currentHand = 0

        for rubber in range(rubbers):
            newRubber = False 
            hands = 0
            while newRubber == False or hands < 20:
                dealerID = self.players[rubber % 4].identifier
                log.event("Start hand " + str(currentHand))
                game = Game(self.players, self.teamStates, dealerID)
                result = game.play()
                if result is not None:
                    newGame, newRubber = self._update_match_points(result)
                    for i, state in enumerate(self.teamStates):
                        log.event("Current state for Team {0}... {1}".format(i,state))
                    log.event("Hand complete, current score: {0} vs {1}".format(self.teamPoints[0], self.teamPoints[1]))
                    if newGame:
                        log.summary("Game complete, current score: {0} vs {1}".format(self.teamPoints[0], self.teamPoints[1]))
                        matchStatsLog.log(self.teamPoints)
                hands += 1                    
                currentHand += 1
            log.summary("Rubber {0} complete".format(rubber))
        gameStatsLog.dump_log()
        matchStatsLog.dump_log()
        return self.teamPoints
Esempio n. 3
0
    def play(self, rubbers=1):
        self.players = [
            Player(i, (i + 2) % 4, x) for i, x in enumerate(self._bots)
        ]
        dealerID = self.players[0].identifier
        currentHand = 0

        for rubber in range(rubbers):
            newRubber = False
            hands = 0
            while newRubber == False or hands < 20:
                dealerID = self.players[rubber % 4].identifier
                log.event("Start hand " + str(currentHand))
                game = Game(self.players, self.teamStates, dealerID)
                result = game.play()
                if result is not None:
                    newGame, newRubber = self._update_match_points(result)
                    for i, state in enumerate(self.teamStates):
                        log.event("Current state for Team {0}... {1}".format(
                            i, state))
                    log.event(
                        "Hand complete, current score: {0} vs {1}".format(
                            self.teamPoints[0], self.teamPoints[1]))
                    if newGame:
                        log.summary(
                            "Game complete, current score: {0} vs {1}".format(
                                self.teamPoints[0], self.teamPoints[1]))
                        matchStatsLog.log(self.teamPoints)
                hands += 1
                currentHand += 1
            log.summary("Rubber {0} complete".format(rubber))
        gameStatsLog.dump_log()
        matchStatsLog.dump_log()
        return self.teamPoints
Esempio n. 4
0
 def play(self):
     deck = Deck()
     for i, p in enumerate(self.players):
         p.cards = deck.draw()
         log.event('Player ' + str(p) + ' dealt: ' + ' '.join(map(lambda x: str(x), p.cards)))
         p.start(self.states[i % 2], self.states[(i+1) % 2])
         
     bidList=[]
     i = [x.identifier for x in self.players].index(self.dealerID)
     while not Match._bidding_complete(bidList):
         bid = self.players[i].bid(bidList)
         log.event('Player ' + str(self.players[i]) + ' bids: ' + str(bid))
         
         #TODO: handle illegal bids            
         if Match.legal_bid(bid, bidList, self.players[i].identifier, self.players[i].partnerID):
             bidList.append(bid)
         else:
             raise ValueError("{0} is not a valid bid after [{1}]".format(bid, ','.join((str(x) for x in bidList))))
         
         i = (i + 1) % 4
     
     declarerID = None
     winningBid = None        
     
     valueBids = [x for x in bidList if x.bidType == 'bid']
     if len(valueBids) > 0:
         winningBid = valueBids[-1]
         log.event("Final bid is: " + str(winningBid))
         partnershipBids = [x for x in valueBids if x.bidSuit == valueBids[-1].bidSuit]
         declarerID = partnershipBids[0].playerID
         log.event("Declarer is: Player " + str(self.players[declarerID]))
         
     else:
         log.event("Hand was passed out")
     
     # bidding is complete, now lets play
     if declarerID is not None:            
         for player in self.players:
             player.notify_end_bidding(declarerID, winningBid, bidList)
             
         activePlayer = (declarerID + 1) % 4
         takenTricks = defaultdict(int)
         
         for i in range(13):
             playedCards = []
             dummyHand = self.players[self.players[declarerID].partnerID].cards
             for j in range(4):
                 player = self.players[(activePlayer + j) % 4]
                 
                 #TODO: handle illegal throws
                 card = player.play_card(playedCards, dummyHand)
                 log.event("Player " + str(player) + " plays: " + str(card))
                 playedCards.append(card)
            
             trumpSuit = winningBid.bidSuit
             if winningBid.bidSuit == 'nt':
                 trumpSuit = playedCards[0].suit
                 
             winningCard = Match.winning_card(playedCards, trumpSuit)
                 
             log.event("Winning card is: " + str(winningCard))
             activePlayer = (activePlayer + playedCards.index(winningCard)) % 4
             takenTricks[activePlayer] += 1
             
         for player in self.players:
             log.event("Player " + str(player) + " took " + str(takenTricks[player.identifier]) + " tricks")
             
         declarerTricks = takenTricks[declarerID] + takenTricks[self.players[declarerID].partnerID]
         log.event("Declarer needed {0} tricks and took {1}".format(str(winningBid.bidValue + 6), declarerTricks))
         gameStatsLog.log(declarerID, winningBid, takenTricks, self.players)            
         
         pointDeltas = Game.calculate_point_delta(declarerID, 
                                                  winningBid, 
                                                  declarerTricks,
                                                  [x.cards for x in self.players], 
                                                  self.states)
         return pointDeltas
Esempio n. 5
0
    def calculate_point_delta(declarerID, winningBid, tricks, playerHands,
                              rubberStates):
        pointDeltas = [RubberState(0, 0, False), RubberState(0, 0, False)]

        # First check if any player was dealt honors
        for i, p in enumerate(playerHands):
            honorsCheck = set(
                [x.value
                 for x in p if x.suit == winningBid.bidSuit]) & set(RANKS[8:])
            if len(honorsCheck) == 5:
                pointDeltas[i % 2].aboveTheLine += 150

            if len(honorsCheck) == 4:
                pointDeltas[i % 2].aboveTheLine += 100

            if winningBid.bidSuit == 'nt' and [x.value
                                               for x in p].count('A') == 4:
                pointDeltas[i % 2].aboveTheLine += 150

        if tricks - 6 >= winningBid.bidValue:
            pointMultiplier = 1
            # set the point multiplier and add the insult bonus
            if winningBid.bidType == 'double':
                pointMultiplier = 2
                pointDeltas[declarerID % 2].aboveTheLine += 50
            if winningBid.bidType == 'redouble':
                pointMultiplier = 4
                pointDeltas[declarerID % 2].aboveTheLine += 100

            pointDeltas[
                declarerID %
                2].belowTheLine += pointMultiplier * Bid.below_point_delta(
                    winningBid.bidValue, winningBid.bidSuit)
            pointDeltas[
                declarerID %
                2].aboveTheLine += pointMultiplier * Bid.above_point_delta(
                    tricks - 6 - winningBid.bidValue, winningBid.bidSuit)
        else:
            # calculate values for getting set
            if rubberStates[declarerID % 2].isVulnerable == True:
                if winningBid.bidType == 'bid':
                    pointDeltas[(declarerID + 1) % 2].aboveTheLine += 100 * (
                        (winningBid.bidValue + 6) - tricks)
                if winningBid.bidType == 'double':
                    pointDeltas[(declarerID + 1) %
                                2].aboveTheLine += 200 + 300 * (
                                    (winningBid.bidValue + 6) - tricks - 1)
                if winningBid.bidType == 'redouble':
                    pointDeltas[(declarerID + 1) %
                                2].aboveTheLine += 400 + 600 * (
                                    (winningBid.bidValue + 6) - tricks - 1)
            else:
                if winningBid.bidType == 'bid':
                    pointDeltas[(declarerID + 1) % 2].aboveTheLine += 50 * (
                        (winningBid.bidValue + 6) - tricks)
                if winningBid.bidType == 'double':
                    doublePenalties = [100, 200, 200] + [300] * 10
                    pointDeltas[(declarerID + 1) % 2].aboveTheLine += sum(
                        doublePenalties[:((winningBid.bidValue + 6) - tricks)])
                if winningBid.bidType == 'redouble':
                    redoublePenalties = [200, 400, 400] + [600] * 11
                    pointDeltas[(declarerID + 1) % 2].aboveTheLine += sum(
                        redoublePenalties[:((winningBid.bidValue + 6) -
                                            tricks)])

        for i, delta in enumerate(pointDeltas):
            log.event("Point delta for Team " + str(i) + "... " + str(delta))
        return pointDeltas
Esempio n. 6
0
    def play(self):
        deck = Deck()
        for i, p in enumerate(self.players):
            p.cards = deck.draw()
            log.event('Player ' + str(p) + ' dealt: ' +
                      ' '.join(map(lambda x: str(x), p.cards)))
            p.start(self.states[i % 2], self.states[(i + 1) % 2])

        bidList = []
        i = [x.identifier for x in self.players].index(self.dealerID)
        while not Match._bidding_complete(bidList):
            bid = self.players[i].bid(bidList)
            log.event('Player ' + str(self.players[i]) + ' bids: ' + str(bid))

            #TODO: handle illegal bids
            if Match.legal_bid(bid, bidList, self.players[i].identifier,
                               self.players[i].partnerID):
                bidList.append(bid)
            else:
                raise ValueError("{0} is not a valid bid after [{1}]".format(
                    bid, ','.join((str(x) for x in bidList))))

            i = (i + 1) % 4

        declarerID = None
        winningBid = None

        valueBids = [x for x in bidList if x.bidType == 'bid']
        if len(valueBids) > 0:
            winningBid = valueBids[-1]
            log.event("Final bid is: " + str(winningBid))
            partnershipBids = [
                x for x in valueBids if x.bidSuit == valueBids[-1].bidSuit
            ]
            declarerID = partnershipBids[0].playerID
            log.event("Declarer is: Player " + str(self.players[declarerID]))

        else:
            log.event("Hand was passed out")

        # bidding is complete, now lets play
        if declarerID is not None:
            for player in self.players:
                player.notify_end_bidding(declarerID, winningBid, bidList)

            activePlayer = (declarerID + 1) % 4
            takenTricks = defaultdict(int)

            for i in range(13):
                playedCards = []
                dummyHand = self.players[
                    self.players[declarerID].partnerID].cards
                for j in range(4):
                    player = self.players[(activePlayer + j) % 4]

                    #TODO: handle illegal throws
                    card = player.play_card(playedCards, dummyHand)
                    log.event("Player " + str(player) + " plays: " + str(card))
                    playedCards.append(card)

                trumpSuit = winningBid.bidSuit
                if winningBid.bidSuit == 'nt':
                    trumpSuit = playedCards[0].suit

                winningCard = Match.winning_card(playedCards, trumpSuit)

                log.event("Winning card is: " + str(winningCard))
                activePlayer = (activePlayer +
                                playedCards.index(winningCard)) % 4
                takenTricks[activePlayer] += 1

            for player in self.players:
                log.event("Player " + str(player) + " took " +
                          str(takenTricks[player.identifier]) + " tricks")

            declarerTricks = takenTricks[declarerID] + takenTricks[
                self.players[declarerID].partnerID]
            log.event("Declarer needed {0} tricks and took {1}".format(
                str(winningBid.bidValue + 6), declarerTricks))
            gameStatsLog.log(declarerID, winningBid, takenTricks, self.players)

            pointDeltas = Game.calculate_point_delta(
                declarerID, winningBid, declarerTricks,
                [x.cards for x in self.players], self.states)
            return pointDeltas