import hand import cv2 import gesture import roi #import Lights cap = cv2.VideoCapture(0) cap.set(cv2.CAP_PROP_FRAME_WIDTH, 1920) cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 1080) hand = hand.Hand() roi = roi.roi() command = 0 fingerCount = 0 lastCount =0 crop=0 while True: t, image = cap.read() if t : try: cv2.setMouseCallback('Hands', roi.getroi) image = cv2.cvtColor(cv2.flip(image, 1), cv2.COLOR_BGR2RGB) image = roi.drawSquare(image) crop = image if roi.isItCropped: image = roi.cropimage(image)
def __init__(self, money=100): self.hand = hand.Hand() self.split = hand.Hand() self.wallet = money
def push(dealer, player): print("Its tie . ") # now its time to play the black jack game :) if __name__ == '__main__': chips = amount_to_chips() while True: # Print an opening statement print('Welcome to BlackJack! Get as close to 21 as you can without going over!\n\ Dealer hits until she reaches 17. Aces count as 1 or 11.') deck1 = deck.Deck() deck1.card_shuffle() # create player hand object player = hand.Hand() # create dealer hand object dealer = hand.Hand() # take bet from player take_bet(chips) # distribute equal cards and hide the dealer's second card for x in range(2): player.add_card(deck1.deal()) player.adjust_for_ace() dealer.add_card(deck1.deal()) dealer.adjust_for_ace() # display cards excluding dealer card display_some_cards(dealer, player) # ask for hit or stay playing = True while playing:
def learning_by_hands(intelligent=True, alternate=True): #Function initializations: setup players, deck, turncard, local variables, determine dealer p1 = players.Computer(difficulty="medium") p2 = players.Computer(difficulty="medium") d = deck.Deck() d.shuffle() crib = [] turncard = d.deal_one() if alternate: is_dealer_p1 = True else: is_dealer_p1 = False #Allows learning Function to focus either on random configurations or heuristically influenced configurations if not intelligent: for i in range(4): p1.cards.append(d.deal_one()) p2.cards.append(d.deal_one()) crib.append(d.deal_one()) p1_discards = crib[0:2] p2_discards = crib[2:4] else: p1_dealt_hand = [] p2_dealt_hand = [] for i in range(6): p1_dealt_hand.append(d.deal_one()) p2_dealt_hand.append(d.deal_one()) h1 = hand.Hand(p1_dealt_hand) h2 = hand.Hand(p2_dealt_hand) #For heuristically influenced hand selection h1_selects = h1.optimize_by_points(2) h2_selects = h2.optimize_by_points(2) p1.cards = list(h1_selects) p2.cards = list(h2_selects) p1_discards = [] p2_discards = [] for cp1, cp2 in zip(p1_dealt_hand, p2_dealt_hand): if cp1 not in h1_selects: p1_discards.append(cp1) if cp2 not in h2_selects: p2_discards.append(cp2) crib.extend(p1_discards) crib.extend(p2_discards) """ h1_combos = combinations(p1_dealt_hand, 4) h2_combos = combinations(p2_dealt_hand, 4) for h1h, h2h in zip(h1_combos, h2_combos): if len(h1h) == 4 and len(h2h) == 4: p1.cards = h1h p2.cards = h2h h1_disc = [] h2_disc = [] for card in p1_dealt_hand: if card not in p1.cards: h1_disc.append(card) for card in p2_dealt_hand: if card not in p2.cards: h2_disc.append(card) crib.extend(h1_disc) crib.extend(h2_disc) is_dealer_p1 = True peg_sequence(is_dealer_p1, turncard, p1, p2) p1_peg = p1.score p2_peg = p2.score show_sequence(turncard, p1, p2) crib_pts = crib_sequence(turncard, crib) if len(p1.cards) == 4 and len(p2.cards) == 4: memorize_results(p1, p2, p1_peg, p2_peg, is_dealer_p1) if len(h1_disc) == 2 and len (h2_disc) == 2: memorize_discards(h1_disc, h2_disc, crib_pts, is_dealer_p1) p1.score = 0 p2.score = 0 is_dealer_p1 = False peg_sequence(is_dealer_p1, turncard, p1, p2) p1_peg = p1.score p2_peg = p2.score show_sequence(turncard, p1, p2) crib_pts = crib_sequence(turncard, crib) if len(p1.cards) == 4 and len(p2.cards) == 4: memorize_results(p1, p2, p1_peg, p2_peg, is_dealer_p1) if len(h1_disc) == 2 and len (h2_disc) == 2: memorize_discards(h1_disc, h2_disc, crib_pts, is_dealer_p1) """ #Main driver block: peg sequence updates player scores; scores stored before updated again in show_sequence peg_sequence(is_dealer_p1, turncard, p1, p2) p1_peg = p1.score p2_peg = p2.score show_sequence(turncard, p1, p2) crib_pts = crib_sequence(turncard, crib) if is_dealer_p1: p1.score += crib_pts else: p2.score += crib_pts #Memorize the results, check for occasionally memory corruption #if len(p1.cards) == 4 and len(p2.cards) == 4: #memorize_results(p1, p2, p1_peg, p2_peg, is_dealer_p1) #memorize_discards(p1_discards, p2_discards, crib_pts, is_dealer_p1) return [p1.score, p2.score]
def setUp(self): # player needs values: [player name, player type, player color] player = ['Red', 0, 'r'] # hand needs values: start position, player self.hand = hand.Hand((0, 0), player)
def show_sequence(turncard, p1, p2): h1 = hand.Hand(p1.cards, turncard=turncard) h2 = hand.Hand(p2.cards, turncard=turncard) p1.score += h1.compute_score() p2.score += h2.compute_score()
def crib_sequence(turncard, crib_hand): c = hand.Hand(crib_hand, is_crib=True, turncard=turncard) return c.compute_score()
def endHand(self): theWinner = None maxWin = {} for p in self.players: maxWin[p.id] = p.pot if self.numInHand == 1: for p in self.players: if p.isInHand: winningIDs = [p.id] elif self.numInHand > 1: #NEED TO ADD REVEAL CODE HERE assert len(self.communityCards) == 5 hands = [] for p in self.players: if p.isInHand: hands.append( hand.Hand(p.pocket + self.communityCards, ID=p.id)) winningIDs = hand.winner(hands) else: assert False displayText = "" handName = "" for ID in winningIDs: p = self.getPlayerByID(ID) if len(displayText) == 0: displayText += p.name #If the winner revealed their hand include some text to show who won if p.hasRevealed: handName = " with " + hand.Hand( p.pocket + self.communityCards).handName() else: handName = "." token = " has won" else: displayText += ", " + p.name token = " have tied" displayText += token + " this hand" + handName splitPots = [] while len(winningIDs) > 0: #First, we need to create split pots for winners who only partially contributed lowestPotContribution = -10 for p in self.players: if (p.id in winningIDs) and (p.pot < lowestPotContribution or lowestPotContribution == -10): lowestPotContribution = p.pot #Make a new split pot potAmount = 0 for p in self.players: deduction = min(lowestPotContribution, p.pot) p.pot -= deduction potAmount += deduction splitIDs = winningIDs[:] splitPots.append((potAmount, splitIDs)) #Remove all players who are no longer inHand from the winningIDs for p in self.players: if p.id in winningIDs and p.pot <= 0: winningIDs.remove(p.id) #Any remaining money should return back to the original owner for p in self.players: p.bank += p.pot p.pot = 0 #Now we need to distribute the splitPots (or single pot if there was no all-in plays) for splitPot in splitPots: amount, ids = splitPot fraction = int(amount / len(ids)) remainder = amount % len(ids) for ID in ids: p = self.getPlayerByID(ID) p.bank += fraction if remainder > 0: p.bank += remainder remainder -= 1 #Remove bankrupt players from the game for p in self.players: if p.bank < 0: #Something went wrong and the player has negative money assert False elif p.bank == 0: self.removeFromGame(p) self.passToPlayers({ state.State.CONTINUE_ONLY: True, state.State.CONTINUE_TEXT: displayText }) #Increment the dealer p = self.getPlayerByID(self.currentDealer) p.isDealer = False while True: self.currentDealer = (self.currentDealer + 1) % self.numPlayers p = self.getPlayerByID(self.currentDealer) assert p != None if p.isInGame == True: break p.isDealer = True
def peg_logic(hand_playing=None, stack=None, count=None, turncard=None): h = hand.Hand(list_of_cards=hand_playing, turncard=turncard) return h.peg_selection(stack, count)
def reset_hands(lst_of_players): for player_obj in lst_of_players: player_obj.hand_of_cards = hand.Hand() return True
def peg_sequence(self): verbose.pegging() verbose.continue_prompt() #temporary copy to restore player.cards to original state after peg_sequence() is complete hand1 = self.player_one.cards.copy() hand2 = self.player_two.cards.copy() if self.player_one.is_dealer: is_p1_turn = False else: is_p1_turn = False while self.game_not_over and (self.player_one.cards or self.player_two.cards): self.peg_count = 0 stack = hand.Hand([]) while (self.game_not_over and self.peg_count < 31) and (self.player_one.can_peg(self.peg_count) or self.player_two.can_peg(self.peg_count)): if is_p1_turn and self.player_one.can_peg(self.peg_count): selected = self.player_one.peg_one(stack.hand, self.peg_count, self.turncard) self.player_one.cards.remove(selected) stack.hand.append(selected) self.peg_count += selected.value verbose.peg_one(self.player_one, selected, self.peg_count) peg_points = stack.determine_peg_points(self.peg_count) if peg_points > 0: self.player_one.score += peg_points verbose.peg_points(self.player_one, peg_points) if self.player_one.score <= 121: verbose.post_score(self.player_one, self.player_two) self.update_board() is_p1_turn = False p1_played_last = True if not self.game_not_over: break if self.player_two.can_peg(self.peg_count): selected = self.player_two.peg_one(stack.hand, self.peg_count, self.turncard) self.player_two.cards.remove(selected) stack.hand.append(selected) self.peg_count += selected.value verbose.peg_one(self.player_two, selected, self.peg_count) peg_points = stack.determine_peg_points(self.peg_count) if peg_points > 0: self.player_two.score += peg_points verbose.peg_points(self.player_two, peg_points) if self.player_two.score <= 121: verbose.post_score(self.player_one, self.player_two) self.update_board() if not self.game_not_over: break p1_played_last = False is_p1_turn = True elif self.player_one.can_peg(self.peg_count): is_p1_turn = True if self.peg_count < 31: if p1_played_last: verbose.peg_go(self.player_one) self.player_one.score += 1 verbose.post_score(self.player_one, self.player_two) self.update_board() else: verbose.peg_go(self.player_two) self.player_two.score += 1 verbose.post_score(self.player_one, self.player_two) self.update_board() if not self.game_not_over: break self.player_one.cards = hand1 self.player_two.cards = hand2 self.board.display_board()
""" Implement a Deck of Cards, which can be used to fill Hands of Cards """ import card import deck import hand # creating card card1 = card.Card("Spades", '2') # init deck deck1 = deck.Deck() print(deck1.remaining()) # init hand hand1 = hand.Hand() hand1.addCard(card1) hand1.sortByValue() hand1.addCard(deck1.deal()) print(hand1)
#!/usr/bin/env python3 """ Main applikation window for the blackjack game. """ import deck import hand # Create X number of Hands (one for each player) based on previous input. playingPlayers = list() # Create 1 deck. ourDeck = deck.Deck() # Shuffle deck. ourDeck.shuffle() for i in range(3): playingPlayers.append(hand.Hand()) # Give each player 2 starting cards. playingPlayers[i].takeCard(ourDeck) playingPlayers[i].takeCard(ourDeck) # Save players that have stayed: stayedPlayers = list() # ---------------- Gameloop ---------------- # Create a loop that goes from player to player. for i, player in enumerate(playingPlayers): playing = True # Ask if the player wants to play. playerChoice = input("Do you want to stay? yes/no y/n\n-->")
def __init__(self): #Each player has its own hand instance to get the score and the categories used. self.hand = hand.Hand() self.categoriesUsed = []
import hand import player import pot #import game_init deck = deck.Deck() print(deck.show_deck()) print(deck.nth_card(23)) print(deck.nth_card(23).show_card(), deck.nth_card(23).figure(), deck.nth_card(23).color(), deck.nth_card(23).value()) print(deck.draw_by_number(1).show_card()) print(deck.show_deck()) print(deck.draw_by_name('AS').show_card()) print(deck.show_deck()) print(board.Board(deck.make_board()).show_board()) print(hand.Hand(deck.make_hand()).show_hand()) print(len(deck.show_deck())) print(deck.show_deck()) print(deck.nth_card(66).show_card()) board = board.Board(deck.make_board()) print(board.show_board()) print(deck.show_deck()) print(board.flop()) print(board.flop1()) print(board.flop2()) print(board.flop3()) print(board.turn()) print(board.river())
def make_hand(self, a_card): if self.name == 'Dealer': a_bet = 0 else: a_bet = self.get_bet() self.hands.append(hand.Hand(a_bet, a_card))