Tukukkk

You were all so helpful with my Tc Tac Toe games in C. I was encouraged to put it up on GitHub and two very helpful users refactored it in ways that really taught me a thing or two. While I have switched focus to Python in anticipation of the upcoming 7DRL I was so happy about the way my C projects were reviewed that this has become one of my favorite forums. So now I want your help with something else:

Over the last week or so I've created a Blackjack game with Python 3.5.3. The logic was easy to do, especially with Python, but making a clean curses interface was more challenging. What I wound up doing was creating a blackjack game without curses to get the logic straight and then implementing curses in the form of a draw_screen() function that turned out to be a real monster. It is messy and repetitive compared to the rest of the code, and the function wound up being well over 100 lines long. In addition to that I'm still struggling to do things in the most "Pythonic" way, and even the behind-the-screen logic may not be implemented in a way that is ideal.

What I want help from you guys with is to help me refactor the draw_screen() function into something more manageable. Should I split it up into multiple functions? How best to do that? I would also appreciate any and all feedback regarding how I could make the non-curses logic of the game more "Pythonic."

I intend to make a Roguelike for the 7DRL event this year and I intend to do it with Python 3.5.3 and the curses library. It'll be harder than what I usually do but I'm looking forward to it. By helping me hammer out my fundamentals here you will help me to be better prepared for making a small Roguelike in the near future.

Note: the GREEN_TEXT and RED_TEXT color pair definitions were originally
going to be used for the player's funds and for busting prompts, respectively. I haven't removed them because I intend to add that functionality myself very soon, if not today.

Here is the code itself:

"""

Project: Simple 21/Blackjack

File: twenty-one-curses.py

Date: 24 JAN 2019

Author: sgibber2018

Description: A simple implementation of 21/Blackjack using the terminal and python.

             Uses the curses library for character cell graphics. 

"""



import random

import curses



# init curses

stdscr = curses.initscr()

curses.cbreak()

curses.noecho()

curses.curs_set(False)

curses.start_color()



# init curses colors

curses.init_color(curses.COLOR_RED, 900, 0, 0)

curses.init_color(curses.COLOR_BLACK, 0, 0, 0)

curses.init_color(curses.COLOR_GREEN, 0, 900, 0)

curses.init_color(curses.COLOR_WHITE, 1000, 1000, 1000)

colors_dict = {"RED_CARD":1,

               "BLACK_CARD":2,

               "GREEN_TEXT":3,

               "RED_TEXT":4}

curses.init_pair(colors_dict.get("RED_CARD"), curses.COLOR_RED, curses.COLOR_WHITE)

curses.init_pair(colors_dict.get("BLACK_CARD"), curses.COLOR_BLACK, curses.COLOR_WHITE)

curses.init_pair(colors_dict.get("GREEN_TEXT"), curses.COLOR_GREEN, curses.COLOR_BLACK)

curses.init_pair(colors_dict.get("RED_TEXT"), curses.COLOR_RED, curses.COLOR_BLACK)





class Card:

    def __init__(self, suit, value):

        self.suit = suit

        self.value = value





def generate_deck():

    """

    Generate a list of Card objects to be used as a deck

    and return it

    """

    deck = 

    card_suits = ["D", "H", "S", "C"]

    card_nums_range = range(2, 11)

    card_faces = ["J", "Q", "K", "A"]

    for suits in range(len(card_suits)):

        for card_nums in card_nums_range:

            deck.append(Card(card_suits[suits], str(card_nums)))

        for card in range(len(card_faces)):

            deck.append(Card(card_suits[suits], card_faces[card]))

    random.shuffle(deck)

    return deck



def draw(hand, num_to_draw, deck):

    """

    takes a hand list and a number and draws that number

    of cards from the deck and places them in the 

    desired hand

    """

    for num_cards in range(num_to_draw):

        card = deck[-1]

        hand.append(card)

        deck.remove(card)



def count_hand(hand):

    """    

    Evaluates a hand and returns the value

    of its cards

    """

    card_values = {"2": 2, "3": 3, "4": 4, "5": 5,

                   "6": 6, "7": 7, "8":8, "9": 9,

                   "10":10, "J":10, "Q":10, "K":10}

    hand_sum = 0

    hand_suits = 

    for cards in hand:

        hand_suits.append(cards.value)

    if "A" in hand_suits:

        num_aces = 0

        for card_value in hand_suits:

            if card_value == "A":

                num_aces += 1

        for card in hand:

            if card.value != "A":

                hand_sum += card_values.get(card.value)

        if num_aces == 1:

            if hand_sum + 11 > 21:

                hand_sum += 1

            elif hand_sum + 11 <= 21:

                hand_sum += 11

        elif num_aces == 2:

            if hand_sum + 12 > 21:

                hand_sum += 2

            elif hand_sum + 12 <= 21:

                hand_sum += 12

        elif num_aces == 3:

            if hand_sum + 13 > 21:

                hand_sum += 3

            elif hand_sum + 13 <= 21:

                hand_sum += 13

        elif num_aces == 4:

            if hand_sum + 14 > 21:

                hand_sum += 4

            elif hand_sum + 14 <= 21:

                hand_sum += 14

    elif "A" not in hand_suits:

        for card in hand:

            hand_sum += card_values.get(card.value)

    return hand_sum



def player_hits(player_hand, stdscr):

    """

    Asks if player wants to hit

    """

    # get dimensions

    wsize = stdscr.getmaxyx()

    prompt_line = 16

    # lay out the strings

    prompt = "(H)it or (S)tay"

    prompt_hit = "Player has chosen to hit!"

    prompt_stay = "Player has chosen to stay!"

    prompt_wrong = "Invalid input! Try again..."

    # center the prompts

    prompt_x = wsize[1] // 2 - len(prompt) // 2

    prompt_hit_x = wsize[1] // 2 - len(prompt_hit) // 2

    prompt_stay_x = wsize[1] // 2 - len(prompt_stay) // 2

    prompt_wrong_x = wsize[1] // 2 - len(prompt_wrong) // 2

    # clear the entire prompt line

    clear_str = ""

    for char_cell in range(wsize[1]):

        clear_str += " "

    stdscr.addstr(prompt_line, 0, clear_str)

    # display the prompt

    stdscr.addstr(prompt_line, prompt_x, prompt)

    # get the input

    uinput = stdscr.getch()

    if uinput == 104 or uinput == 72:

        # print("Player has chosen to hit!")

        stdscr.addstr(prompt_line, 0, clear_str)

        stdscr.addstr(prompt_line, prompt_hit_x, prompt_hit)

        stdscr.getch()

        return True

    elif uinput == 83 or uinput == 115:

        # print("Player has chosen to stay!")

        stdscr.addstr(prompt_line, 0, clear_str)

        stdscr.addstr(prompt_line, prompt_stay_x, prompt_stay)

        stdscr.getch()

        return False

    else:

        # print("Invalid input! Try again...")

        stdscr.addstr(prompt_line, 0, clear_str)

        stdscr.addstr(prompt_line, prompt_wrong_x, prompt_wrong)

        stdscr.getch()

        player_hits(player_hand)



def prompt(string, stdscr):

    """

    Takes a string, clears the prompt line, and places the

    string on the prompt line

    """

    wsize = stdscr.getmaxyx()

    prompt_line = 16

    prompt_clear = ""

    for char_cell in range(wsize[1]):

        prompt_clear += " "

    stdscr.addstr(prompt_line, 0, prompt_clear)

    centered_x = wsize[1] // 2 - len(string) // 2

    stdscr.addstr(prompt_line, centered_x, string)

    stdscr.getch()



def is_busted(hand):

    """

    Checks a hand and if it is busted, returns True

    """

    card_values = {"2": 2, "3": 3, "4": 4, "5": 5,

                   "6": 6, "7": 7, "8":8, "9": 9,

                   "10":10, "J":10, "Q":10, "K":10}

    hand_sum = 0

    hand_suits = 

    for cards in hand:

        hand_suits.append(cards.value)

    if "A" in hand_suits:

        num_aces = 0

        for card_value in hand_suits:

            if card_value == "A":

                num_aces += 1

        for card in hand:

            if card.value != "A":

                hand_sum += card_values.get(card.value)

        if num_aces == 1:

            if hand_sum + 11 > 21:

                hand_sum += 1

            elif hand_sum + 11 <= 21:

                hand_sum += 11

        elif num_aces == 2:

            if hand_sum + 12 > 21:

                hand_sum += 2

            elif hand_sum + 12 <= 21:

                hand_sum += 12

        elif num_aces == 3:

            if hand_sum + 13 > 21:

                hand_sum += 3

            elif hand_sum + 13 <= 21:

                hand_sum += 13

        elif num_aces == 4:

            if hand_sum + 14 > 21:

                hand_sum += 4

            elif hand_sum + 14 <= 21:

                hand_sum += 14

    elif "A" not in hand_suits:

        for card in hand:

            hand_sum += card_values.get(card.value)

    if hand_sum > 21:

        return True

    else:

        return False





def game_not_over(player_funds, turn_num):

    """

    Checks to see if the game is over.

    Returns True if game not over.

    Prints game over if game is over, then returns False

    """

    if player_funds <= 0:

        prompt("Player loses in " + str(turn_num) + " turns!", stdscr)

        return False

    elif player_funds > 0:

        return True



def compare_hands(dealer_hand, player_hand):

    """

    Checks to see which hand is the winner

    returns "dealer" or "player" as a result

    In case of tie, returns "dealer"

    """

    player_score = count_hand(player_hand)

    dealer_score = count_hand(dealer_hand)

    if player_score > dealer_score:

        return "player"

    elif dealer_score >= player_score:

        return "dealer"



def dealer_hits(dealer_hand):

    """

    Counts the dealer hand and returns true

    if under 17

    """

    count = count_hand(dealer_hand)

    if count < 17:

        prompt("Dealer hits!", stdscr)

        return True

    else: 

        prompt("Dealer Stays!", stdscr)

        return False



def draw_screen(stdscr, dealer_hand, player_hand, turn_num, player_funds, dealer_flipped=False):

    """

    Draws the entire game status on to the screen

    including a visual representation of the cards in play.

    Will be centered in final version.

    """

    # clear screen

    stdscr.clear()

    # get dimensions

    wsize = stdscr.getmaxyx()

    display_height = 17

    display_width = 36

    # get the strings

    funds_str = str("Player Funds: " + str(player_funds))

    turn_str = str("Turn Number: " + str(turn_num))

    player_score_str = str("Player: " + str(count_hand(player_hand)))

    # dealer score string depends on whether dealer_flipped is flagged

    if dealer_flipped:

        dealer_score_str = str("Dealer: " + str(count_hand(dealer_hand)))

    if not dealer_flipped:

        flipped_dealer_hand = 

        for card in range(len(dealer_hand)):

            if card != 0:

                flipped_dealer_hand.append(dealer_hand[card])

        dealer_score_str = str("Dealer Visible: " + str(count_hand(flipped_dealer_hand)))

    # place the strings in their appropriate places

    dealer_str_coords = (0, 1)

    player_str_coords = (8, 1)

    funds_str_coords = (15, 1)

    turn_str_coords = (15, 20)

    stdscr.addstr(dealer_str_coords[0], dealer_str_coords[1], dealer_score_str)

    stdscr.addstr(player_str_coords[0], player_str_coords[1], player_score_str)

    stdscr.addstr(funds_str_coords[0], funds_str_coords[1], funds_str)

    stdscr.addstr(turn_str_coords[0], turn_str_coords[1], turn_str)

    # place the cards:

    # create lists of tuples with the x and y coords or each symbol on each card

    # List of lists of tuples: 

    #   Outer list = hand.

    #   Inner list = card

    #   Sets = (top-left suit, central value, bottom-right suit)

    # called with something like sym = dealer_hand_coords[0][0] for top-left symbol of first card in hand

    # first tuple doubles as a top-left coordinate for the blank card rects

    dealer_hand_coords = [[(2, 1), (4, 2), (6, 3)],

                          [(2, 5), (4, 6), (6, 7)],

                          [(2, 9), (4, 10), (6, 11)],

                          [(2, 13), (4, 14), (6, 15)],

                          [(2, 17), (4, 18), (6, 19)],

                          [(2, 21), (4, 22), (6, 23)],

                          [(2, 25), (4, 26), (6, 27)],

                          [(2, 29), (4, 30), (6, 31)],

                          [(2, 33), (4, 34), (6, 35)]]



    player_hand_coords = [[(9, 1), (11, 2), (13, 3)],

                          [(9, 5), (11, 6), (13, 7)],

                          [(9, 9), (11, 10), (13, 11)],

                          [(9, 13), (11, 14), (13, 15)],

                          [(9, 17), (11, 18), (13, 19)],

                          [(9, 21), (11, 22), (13, 23)],

                          [(9, 25), (11, 26), (13, 27)],

                          [(9, 29), (11, 30), (13, 31)],

                          [(9, 33), (11, 34), (13, 35)]]



    # NOTE: Re-Factor this into some more DRY-compliant code

    # NOTE: Re-Factor into multiple smaller functions that are easier for others

    #       to follow along with!

    # player hand

    for card in range(len(player_hand)):

        # for each card in the hand

        value = player_hand[card].value

        suit = player_hand[card].suit

        if suit == "H" or suit == "D":

            color = colors_dict.get("RED_CARD")

        elif suit == "C" or suit == "S":

            color = colors_dict.get("BLACK_CARD")



        # place the blank card rect

        card_height = 5

        card_width = 3

        for cell_y in range(player_hand_coords[card][0][0], player_hand_coords[card][0][0] + card_height):

            for cell_x in range(player_hand_coords[card][0][1], player_hand_coords[card][0][1] + card_width):

                stdscr.addstr(cell_y, cell_x, " ", curses.color_pair(color))



        # place the symbols

        # place two suit symbols and a value symbol

        stdscr.addstr(player_hand_coords[card][0][0], player_hand_coords[card][0][1], suit, curses.color_pair(color))

        stdscr.addstr(player_hand_coords[card][1][0], player_hand_coords[card][1][1], value, curses.color_pair(color))

        stdscr.addstr(player_hand_coords[card][2][0], player_hand_coords[card][2][1], suit, curses.color_pair(color))



    # dealer hand

    if dealer_flipped:

        for card in range(len(dealer_hand)):

            # for each card in the hand

            value = dealer_hand[card].value

            suit = dealer_hand[card].suit

            if suit == "H" or suit == "D":

                color = colors_dict.get("RED_CARD")

            elif suit == "C" or suit == "S":

                color = colors_dict.get("BLACK_CARD")



            # place the blank card rect

            card_height = 5

            card_width = 3

            for cell_y in range(dealer_hand_coords[card][0][0], dealer_hand_coords[card][0][0] + card_height):

                for cell_x in range(dealer_hand_coords[card][0][1], dealer_hand_coords[card][0][1] + card_width):

                    stdscr.addstr(cell_y, cell_x, " ", curses.color_pair(color))



            # place the symbols

            # place two suit symbols and a value symbol

            stdscr.addstr(dealer_hand_coords[card][0][0], dealer_hand_coords[card][0][1], suit, curses.color_pair(color))

            stdscr.addstr(dealer_hand_coords[card][1][0], dealer_hand_coords[card][1][1], value, curses.color_pair(color))

            stdscr.addstr(dealer_hand_coords[card][2][0], dealer_hand_coords[card][2][1], suit, curses.color_pair(color))



    if not dealer_flipped:

        for card in range(len(dealer_hand)):

            # for each card in the hand

            value = dealer_hand[card].value

            suit = dealer_hand[card].suit

            if suit == "H" or suit == "D":

                color = colors_dict.get("RED_CARD")

            elif suit == "C" or suit == "S":

                color = colors_dict.get("BLACK_CARD")



            # place the blank card rect

            card_height = 5

            card_width = 3

            for cell_y in range(dealer_hand_coords[card][0][0], dealer_hand_coords[card][0][0] + card_height):

                for cell_x in range(dealer_hand_coords[card][0][1], dealer_hand_coords[card][0][1] + card_width):

                    stdscr.addstr(cell_y, cell_x, " ", curses.color_pair(color))



            # place the symbols

            # place two suit symbols and a value symbol

            if card != 0:

                stdscr.addstr(dealer_hand_coords[card][0][0], dealer_hand_coords[card][0][1], suit, curses.color_pair(color))

                stdscr.addstr(dealer_hand_coords[card][1][0], dealer_hand_coords[card][1][1], value, curses.color_pair(color))

                stdscr.addstr(dealer_hand_coords[card][2][0], dealer_hand_coords[card][2][1], suit, curses.color_pair(color))

    stdscr.refresh()



def main(stdscr):

    try:

        # bet amount

        bet = 100

        # starting funds

        player_funds = 1000

        turn_num = 1

        while game_not_over(player_funds, turn_num):

            # while the player has funds left to bet

            # generate a new deck

            deck = generate_deck()

            dealer_hand = 

            player_hand = 

            # draw two cards for each player

            draw(dealer_hand, 2, deck)

            draw(player_hand, 2, deck)

            # take the player's bet

            player_funds -= bet

            winner = None

            player_hitting = True

            while player_hitting:

                # while the player is deciding to hit or stay:

                # draw the screen with curses

                draw_screen(stdscr, dealer_hand, player_hand, turn_num, player_funds)

                if player_hits(player_hand, stdscr):

                    # if the player chooses to hit:

                    # draw a card

                    draw(player_hand, 1, deck) 

                    if is_busted(player_hand):

                        # If the player busts:

                        # draw the screen again

                        draw_screen(stdscr, dealer_hand, player_hand, turn_num, player_funds)

                        # prompt that the player has busted

                        prompt("Player Busted!", stdscr)

                        player_hitting = False

                        winner = "dealer"

                else:

                    # end the loop if the player chooses to stay

                    player_hitting = False

            if not is_busted(player_hand):

                # If the player has stayed and the player has not busted:

                dealer_hitting = True

                while dealer_hitting:

                    # while the dealer is choosing to hit or stay:

                    # draw the screen with curses

                    draw_screen(stdscr, dealer_hand, player_hand, turn_num, player_funds, dealer_flipped=True)

                    if dealer_hits(dealer_hand):

                        # If the dealer chooses to hit:

                        # dealer draws a card

                        draw(dealer_hand, 1, deck)

                        if is_busted(dealer_hand):

                            # If the dealer busts:

                            # draw the screen with curses

                            draw_screen(stdscr, dealer_hand, player_hand, turn_num, player_funds, dealer_flipped=True)

                            # prompt that the dealer has busted

                            prompt("Dealer Busted!", stdscr)

                            dealer_hitting = False

                            winner = "player"

                            # reward the player with double their bet

                            player_funds += bet * 2

                    else:

                        # if the dealer busts, break the loop

                        dealer_hitting = False

            if not is_busted(dealer_hand):

                if not is_busted(player_hand):

                    # If neither player has busted and both have stayed:

                    # draw the screen with curses

                    draw_screen(stdscr, dealer_hand, player_hand, turn_num, player_funds, dealer_flipped=True)

                    # get the winning hand

                    winner = compare_hands(dealer_hand, player_hand)

                    # prompt the winner

                    prompt(str(winner + " Wins!"), stdscr)

                    if winner == "player":

                        # if the player wins, reward them with double their bet

                        player_funds += bet * 2

            # increase turn num

            turn_num += 1

    finally:

        # end curses window on error or exit

        curses.endwin()





if __name__ == "__main__":

main(stdscr)

And here is a link to the GitHub page, for those who want to contribute more directly.

As ever, anyone who finds this useful is more than welcome to do whatever they want with it. I worked hard on it, but it was just a practice project. If it helps someone else, by all means go for it.

• I are not implementing standard (aka Las Vegas) rules. According to the standard rules, a player's hand of an Ace and a honeur forms a blackjack, and must be disclosed immediately. I am not even talking about the split and insurance rules.




• You don't give the player an opportunity to wrap up, collect her fortune and go home. The game continues until she is stripped off completely.



• 
  

  I am afraid there are more monsters than you are aware of. To begin with, I don't see a clean MVC separation. A litmus test is to evaluate efforts required to port this code from curses to, say, Tk.

  
  
  

  Besides, draw_screen has no business to count hands' values, or to be concerned with the dealers' open card. This information shall be computed by the model, and passed to view in an appropriate form.

  
  


• 
  

  count_hand is suspiciously similar to is_busted. I expect

  
  
  

  def is_busted(....):
  
      return count_hand(....) > 21
  
  

  
  


• 
  

  count_hand is also overcomplicated. Consider

  
  
  

  def count_hand(hand):
  
      aces = 0
  
      hand_sum = 0
  
      for card in hand:
  
          if card.is_ace():
  
              aces += 1 # Initially count all aces as 1
  
          hand_sum += card.value
  
      # Now try to assign come aces an extra 10 points
  
      while aces > 0 and hand_sum <= 11:
  
          aces -= 1
  
          hand_sum += 10
  
      return hand_sum
  
  

  
  
  

  Notice how having card itself an instance of the class helps.