This code implements a partially functional version of the game...

August 31, 2025 at 11:59 AM

import random
from words import word_to_num

last = 0
out = ''
end = False

class Player:
  def __init__(self, name, difficulty, turn):
    self.name = name
    self.difficulty = difficulty
    self.moves = 0
    self.turn = turn
  
  def play(self):
    global last
    if random.random() > (1 / self.difficulty):
      nextFour = last % 4
      if nextFour > 0:
        self.moves = nextFour   
    else:
      self.moves = random.randint(1, 3)
        
    print(f'\n{self.name} said:')
    for self.i in range(int(self.moves)):
        
      last += 1
      print(last, end='... ')

print('\nWelcome to Twenty One! The aim of the game is to say 1, 2, or 3 consecutive numbers after the previous person. But, Dont say 21!\n')
name = input('What is your name?: ')

p1 = Player('Emily', 5, 1)
p2 = Player('Bob', 9, 2)


while not end:  
  while last != 21:   ##Loops turns until someone says 21
    ## PLAYER CODE 
    while True:
      amount = input('How many numbers would you like to go forward?: ')
      if amount.isdigit():
        break
      elif amount in word_to_num:   
        amount = word_to_num[str(amount.upper())] 
        break
      else:
        print('Please enter a valid amount, 1,2, or 3')
        continue

    print(f'\n{name} said:')
    for i in range(int(amount)):
      last += 1
        
      print(last, end='... ') 
        
    ## COMPUTER CODE

    p1.play()
    p2.play()

]

This code implements a partially functional version of the game "Twenty One." Here's an explanation of what this code does:

Overview of the Game

"Twenty One" is a turn-based game in which players (or a player and a computer) take turns counting up by saying 1, 2, or 3 consecutive numbers. The goal is to avoid being the one to say 21. The player who has no choice but to say "21" loses.

Code Description

Imports and Initialization:
- import random: Used to generate random numbers for the computer player's decisions.
- from words import word_to_num: This implies there is a separate words.py module, which contains a mapping (word_to_num) that converts numbers written in words (like "ONE", "TWO", "THREE") into their numeric equivalents (1, 2, 3). Without this file, the code will fail to run.
- Variables last, out, and end are initialized:
  - last keeps track of the current number in the game.
  - out appears unused.
  - end is a flag to stop the game loop if needed (it is not used properly, as explained later).
Player Class:
- Represents a player or computer in the game. Each player has:
  - name: Their name.
  - difficulty: A number representing the difficulty level. Higher numbers make the computer more strategic.
  - moves: How many numbers the player says in their turn.
  - turn: Unused in the code, likely meant to track whose turn it is.
- play():
  - Decides how many numbers the computer player will say.
  - If a random chance (random.random()) is greater than 1/self.difficulty, the computer plays strategically by calculating how many numbers would leave a remainder of 0 when divided by 4 (to avoid losing in subsequent turns).
  - Otherwise, it chooses randomly between 1, 2, or 3.
  - The numbers the computer "says" are printed and added to the last value.
Game Introduction and Player Input:
- Welcomes the player to the game and explains the rules.
- Prompts the player to enter their name.
- Sets up two computer players (p1 and p2) with different difficulty values (Emily has a difficulty of 5, Bob has a difficulty of 9).
Game Loop:
- The game continues while the last number is not 21.
- Player's Turn:
  - Prompts the player to choose how many numbers (1, 2, or 3) they wish to say.
  - If the player's input isn't a valid digit but is a valid word (like "ONE"), it converts it into a number using word_to_num.
  - Updates the last value and prints the sequence of numbers the player says.
- Computer's Turn:
  - Both computer players (p1 and p2) take their turns using the play() method.
Game End:
- The game ends when last == 21, but there’s no specific code to handle what happens after someone says "21" (for example, announcing the loser). Also, the end variable is unused.

Issues with the Code:

Incomplete Handling of Game End: The game loop doesn’t handle what happens when a player or computer says 21. The program should announce the loser and stop.
Unused Variables: Variables like out and the turn attribute in the Player class are unused.
Dependency on Missing Module: The word_to_num dictionary or module (words.py) is not included in the code snippet. Without it, processing inputs like "ONE", "TWO", etc., will fail.
Multiple Computers Overshadow Each Other: Both p1 and p2 take turns after every player action, which isn't explained well in the game rules.

What the Code Does in Its Current State:

Asks a player to participate in a game counting to 21.
Alternates between a human player and two computer players taking turns to "say" 1, 2, or 3 numbers.
Continues the game loop, printing numbers, until the current count (last) reaches 21. After that, the program ends, but without declaring the winner or loser.

Generate your own explanations

Download our vscode extension

Read other generated explanations

Built by @thebuilderjr