Implementing Teen Patti Using Circular Linked List in Python

Teen Patti, often referred to as Indian Poker, is a popular card game loved by many across the globe, particularly in India. It’s a game of skill, strategy, and a bit of luck where players try to outsmart each other to win the pot. The game involves betting and is typically played with a standard 52-card deck. In this blog post, we will explore how to implement a simple version of Teen Patti using a circular linked list in Python, maximizing efficiency and showcasing some fundamental concepts of data structures.

Why Use a Circular Linked List?

Circular linked lists are a special type of linked list where all nodes are connected in a circle, and there is no null at the end of the list. This characteristic provides several advantages for our Teen Patti implementation:

• Continuous Play: In Teen Patti, once a round of betting is completed, the game continues seamlessly to the next player—ideal for a circular structure.
• Dynamic Size: The number of players can vary during the game, allowing us to easily add and remove players without having to restructure the entire list.
• Resource Efficiency: Using a circular linked list means we do not need to worry about the performance hits of shifting elements as in arrays.

Setting Up the Environment

To follow along with this project, you will need:

• Basic knowledge of Python
• Python installed (preferably version 3.x)
• A text editor or IDE for coding

Once you have everything set up, we can get started by creating our circular linked list structure.

Defining the Node and Circular Linked List Classes

Let’s begin by defining a Node class to represent each player and a CircularLinkedList class to manage the game:

class Node:
    def __init__(self, player_name):
        self.player_name = player_name
        self.next = None
        
class CircularLinkedList:
    def __init__(self):
        self.head = None
    
    def append(self, player_name):
        new_node = Node(player_name)
        if not self.head:
            self.head = new_node
            new_node.next = new_node
        else:
            current = self.head
            while current.next != self.head:
                current = current.next
            current.next = new_node
            new_node.next = self.head
            
    def display(self):
        players = []
        if self.head:
            current = self.head
            while True:
                players.append(current.player_name)
                current = current.next
                if current == self.head:
                    break
        return players

    

Adding Players

Next, we need to add functionality to enable players to join the game. We will leverage the append method we just defined:

def add_players(circular_linked_list, player_names):
    for name in player_names:
        circular_linked_list.append(name)

    

Now, let’s initialize our circular linked list and add some players:

player_list = CircularLinkedList()
add_players(player_list, ["Alice", "Bob", "Charlie", "David"])
print("Players in the game: " + ', '.join(player_list.display()))

    

Implementing Game Mechanics

With the initial setup complete, we can focus on the core mechanics of Teen Patti. We can create a method to handle the betting rounds, player turns, and displaying current pots.

class TeenPattiGame:
    def __init__(self):
        self.players = CircularLinkedList()
        self.pot = 0
        
    def place_bet(self, player_name, amount):
        self.pot += amount
        print(f"{player_name} placed a bet of {amount}. Total pot: {self.pot}")

    def next_turn(self, current_player):
        players_display = self.players.display()
        current_index = players_display.index(current_player)
        next_player = players_display[(current_index + 1) % len(players_display)]
        print(f"Next turn: {next_player}")
        return next_player

    

Bringing It Together

Finally, we can simulate a game by introducing players, handling their bets, and moving turns:

# Create a new game
game = TeenPattiGame()

# Add players
add_players(game.players, ["Alice", "Bob", "Charlie", "David"])

# Simulate some betting rounds
current_player = game.players.head.player_name
game.place_bet(current_player, 10)  # Alice bets
current_player = game.next_turn(current_player)

game.place_bet(current_player, 20)  # Bob bets
current_player = game.next_turn(current_player)

game.place_bet(current_player, 15)  # Charlie bets
current_player = game.next_turn(current_player)

game.place_bet(current_player, 5)  # David bets
current_player = game.next_turn(current_player)

# Display the final pot
print(f"Final pot amount: {game.pot}")

    

Enhancing the Game

This basic structure opens a door to many enhancements. A few ideas include:

• Adding card distribution mechanics for players.
• Implementing various betting strategies (minimum, maximum bets).
• Creating a visual representation of the game using a GUI library like Tkinter.
• Integrating AI opponents for a solo play experience.

Each enhancement will not only make the game more entertaining but will also serve as a fantastic opportunity to hone your programming skills further.

Conclusion to the Journey of Learning

In this blog post, we have walked through the fundamentals of creating a simple version of Teen Patti using a circular linked list in Python. We covered setting up the data structure required, managing player turns, and pot management—all essential elements that capture the essence of this thrilling card game. While this implementation remains basic, it serves as a stepping stone towards creating more complex and feature-rich versions of Teen Patti. So keep coding, keep exploring, and enjoy the fascinating world of programming!

India’s Favourite Card Game Lives On in Teen Patti Master