CHIPLESS

Analysis

11 min read

Project Overview

There are plenty of people that have a pack of cards, but very few have a set of Poker chips. For those that still wish to play Poker, without having to buy a set of Poker chips, I propose an Android app, called Chipless, to manage the bets with a virtual currency, while you still play with physical cards. The app will allow you to configure game settings like the starting chips, small and big blind bets and add up to 10 players to the table, including a dealer and each with a name value. Then you will be able to begin the game, where it will progress like a standard Texas Holdem Poker game, allowing players to make bets using the app and select the winner at the end based on who has the winning hand.

Description of the Problem

Many poker enthusiasts enjoy playing the game but often don’t carry around poker chips with them, as many poker chip sets are not very portable, but without them they are unable to manage their bets effectively. While packs of cards are more commonplace to own and are certainly more portable, not only this but purchasing poker chips might seem unnecessary or inconvenient, particularly for casual players. This limits the accessibility of poker, especially for those who may not play frequently enough to justify buying chips. A solution is needed to allow players to enjoy the game without needing physical chips, enabling them to focus on the core experience of playing poker with minimal setup. Which is another issue with poker’s portability is the long setup time, but the chips are the main contributor to this long setup time. Without them and instead using a digital set of poker chips, the setup time drastically decreases. As of currently, there also isn’t many similar apps that offer this function and that is part of what I wish to solve, there is not many high quality options and I wish to provide exactly that, a high quality option for those that wish to play without chips but still not all required to download an app and also play with physical cards.

Stakeholders

The primary stakeholders in this project include:

  • Casual Poker Players: People who play poker infrequently and do not wish to invest in poker chips. *Including friends of mine who I used one of my specific research examples with, to act as digital chips but we noticed flaws in the design that I now wish to address.
  • Poker Enthusiasts: Individuals who play poker regularly but want a streamlined way to manage bets.
  • Android Users: People familiar with and who prefer using Android devices for entertainment.
  • Game Hosts: Individuals who frequently organise poker nights and want a simplified system for managing bets.
  • Advertisers and In-App Purchase Providers: If monetisation is integrated, these parties will benefit from user engagement.

Specific Stakeholder: Adam, a casual Poker player

Interview ( w/Adam )

todo

Computational Methods

Abstraction

The user interface (UI) abstracts the complex rules and interactions of poker into simple, easy-to-use controls for setting bets, managing players, and progressing the game. The app abstracts away the need for physical chips by using a virtual currency system, allowing players to focus on gameplay.

Decomposition

The problem is broken down into the following key components:

  • UI Design: Implementing a clean interface with controls for bets and game progression.
  • Game Logic: Coding Texas Hold’em rules, including betting rounds, turn management, and win conditions.
  • Data Handling: Managing player data, bet amounts, and game state in real-time.
  • Database Integration: For saving table information for later use. ( The current stage, who’s turn it is, player names, current bet amounts, etc. )

Thinking Ahead

Inputs

  • Navigation Button Press Processing
  • Depending on which button is pressed, navigate to a specific screen Outputs
  • Display the new screen

Create Table Screen

Inputs

  • Player names
  • Starting chip count
  • Small blind amount
  • Big blind amount
  • Number of players
  • Player locations on the table
  • Dealer Selection Processing
  • Validate the number of players, the length of player names, no duplicate player names, the characters used in player names aren’t invalid, small blind is less than big blind, etc.
  • Store player names, positions, chip balance and roles, along with the default player status in player objects
  • Store player objects in a list
  • Store table configuration to table object
  • Depending on who the dealer is, assign other player roles ( Big Blind, Small Blind ) Outputs
  • Display player names, dealer role
  • Error indication for validation checks

Game Table Screen

Inputs

  • Action made ( Fold, Check, Call, Raise )
  • Bet amount
  • Undo previous action ( Using a stack data structure ) Processing
  • On pre-flop round, remove small and big blind accordingly
  • Determine which player’s turn it is ( skipping those who have folded or are sat out, moving clockwise from last player )
  • Determine the current bet to match
  • Validate bet amounts to ensure they don’t exceed a player’s balance
  • Deduct bets from player balances
  • Add bets to the pot total
  • When needed, create a side pots with a list of players that are included in that pot
  • Update player statuses ( reset bet statuses each round, maintain FOLDED until end of round and SAT_OUT status indefinitely )
  • Keep a track of the previous action and upon undo button press, revert the action
  • Save current state to database, overwriting the previous save
  • When player’s balance is 0 after making a bet, give ALL_IN status
  • On raise, grant all other participating players PARTIAL_MATCH status and raising player RAISED status Outputs
  • Display players: names, dealer role, chip counts, current bet amount, indicate player statuses ( met the bet, raised the bet, partially met the bet, folded, sat out )
  • Display whose turn it is
  • Display pot total
  • Display side pot totals
  • Error indication for validation checks
  • Show confirmation of player actions
  • Save data to database

Match Summary

Inputs

  • Winner selection ( manual multi-select, based on hands )
  • Confirm sinner selection
  • Select players to sit out
  • Add any new players to empty seats
  • Chip balance for each new player
  • Proceed to next match Processing
  • When a winner is selected, enable confirm button
  • Split pot between winners
  • Reset pot total
  • Update player statuses ( sit out selected players, move dealer status to next player, default status for other players )
  • Create new player objects
  • Add new player objects to player list
  • Validate whether there is sufficient active players to start Outputs
  • Display players for winner selection
  • Display table with current players and empty seats
  • Grey out start button if conditions not met

Saved Tables Screen

Inputs

  • Game table to load Processing
  • Access database and retrieve the specified game table data and player data
  • Assign game table data to a table class object
  • Assign player data to individual player class objects
  • Move to Game Table Screen after loading data
  • OPTIONAL: Verify database integrity Outputs
  • Confirmation or error indication

Logical Thinking

Decision-making within the app occurs at several key stages, such as tracking betting rounds, and adjusting chip counts. Conditional logic and comparison algorithms will ensure accuracy in game progression.

Research

Research for this project will involve:

  • Poker Game Rules: Understanding the nuances of Texas Hold’em Poker to ensure the app’s logic adheres to official rules.

  • UI/UX Design Best Practices: Studying successful mobile applications to ensure an intuitive and user-friendly experience. *When beginning to draft the UI, I have done research into optimal UI/UX design practices and implemented them, including text spacing, text formatting including size, element positioning to prioritise certain aspects, etc.

  • Existing Poker Apps: Analysing other poker apps for features, user interfaces, and areas of improvement.

  • Digital Poker Chips: This is an android app that provides a similar function: manages bets with customisable starting chips, small and big blind bets, players, blind structure for a more tournament style poker session and even allows saving of tables for later, all while using physical cards. This has been my primary inspiration when designing the UI of Chipless and I plan to implement many, if not all features provided by this app. *“As of currently, there also isn’t many similar apps that offer this function and that is part of what I wish to solve, there is not many high quality options and I wish to provide exactly that, a high quality option for those that wish to play without chips but still not all required to download an app and also play with physical cards.” (Description of the Problem, provided above)

Features of the Proposed Solution

The proposed Android app, Chipless, will include the following features:

  • Game Configuration Options: Users can set up game parameters such as starting chips, small and big blinds, and the number of players (up to 10).
  • Virtual Betting System: Players place bets using virtual currency managed by the app, eliminating the need for physical poker chips.
  • Game Progression: The app will manage the progression of a Texas Hold’em Poker game, including betting rounds and the showdown.
  • Player Management: Users can add players to the table, assign them roles ( e.g., dealer ), and record their names.
  • Bet Tracking: The app will handle all bet calculations, ensuring accuracy and reducing human error.
  • Win Determination: Players will select the winner at the end of the game based on who has the best poker hand.

Hardware & Software Requirements

Hardware

  • Android smartphone or tablet with a minimum of 2GB RAM and Android 8.0 or higher.
  • Device with touchscreen capabilities.

Software

  • Development Environment: IntelliJ IDEA for building and testing the app.
  • Programming Languages: Kotlin for Backend and Frontend Android development. Using the Jetpack Compose Library for Native Android UI
  • Version Control: Git for source code management.

Success Criteria

The success of this project will be determined by the following criteria:

  • Ensure all buttons go to the correct screen respectively

Create Table Screen

  • Ensure player names are correctly stored and displayed.
  • Ensure the correct starting chip count is assigned to each player.
  • Validate that the small blind is less than the big blind.
  • Validate the number of players is within the allowed range (e.g., 2 to 10 players).
  • Ensure duplicate player names are not allowed.
  • Display an error message if any player name contains invalid characters.
  • Ensure player roles (e.g., dealer, small blind, big blind) are correctly assigned.
  • Display all player names and the dealer’s role on the screen.
  • Show an error message if any validation fails (e.g., missing player name or incorrect blind values).
  • Ensure the table configuration is stored correctly in the table object.

Game Table Screen

  • Ensure the small and big blinds are deducted automatically at the start of each hand.
  • Ensure the game proceeds to the correct player’s turn, skipping folded players.
  • Ensure bet amounts do not exceed a player’s chip balance.
  • Ensure the correct bet is deducted from each player’s chip balance.
  • Correctly add bets to the pot total.
  • Display accurate player statuses (e.g., folded, met the bet, raised, etc.).
  • Show whose turn it is clearly on the screen.
  • Ensure the undo function correctly reverts the previous action.
  • Display the updated chip counts for all players.
  • Display the current pot total after each betting round.
  • Validate and display errors for invalid bets (e.g., betting more chips than available).
  • Ensure the game state is saved to the database after every significant action.

Match Summary

  • Enable the confirm button only after a winner is selected.
  • Ensure the pot is split correctly if multiple winners are selected.
  • Reset the pot total after winners are confirmed.
  • Update player statuses correctly for the next round (e.g., sit out selected players, move the dealer role).
  • Ensure new players can be added to the table and their chip balances are assigned correctly.
  • Grey out the start button if the number of active players is insufficient to start a match.
  • Validate that there are no errors when adding new players to empty seats.
  • Display the correct players for winner selection and match summary.

Saved Tables Screen

  • Ensure the correct game table is retrieved from the database.
  • Verify that all player data (e.g., names, chip counts, roles) is accurately loaded.
  • Ensure the table configuration is correctly loaded into the game screen.
  • Move to the Game Table Screen after successful loading of the table.
  • Display an error message if there is an issue loading the game table from the database.