How to Create a Coin Flip Simulator in Batch Script

One of the simplest yet most practical introductions to randomness in batch scripting is building a coin flip simulator. Because a coin flip naturally represents a binary outcome (Heads or Tails) it maps perfectly to how computers handle values like 0 and 1, making it an ideal starting point for understanding pseudo-random behavior in scripts.

This guide will walk you through how to generate a random number using system variables, constrain it into a two-outcome result, and use conditional logic to display the outcome in the console. Along the way, you'll also learn how to wrap the logic in a loop to create a simple interactive program, giving you a solid foundation for adding randomness to your future batch scripts.

The Principle of Binary Randomness

Every native command prompt environment possesses the dynamic variable %RANDOM%. Whenever this variable is requested, CMD responds with a random number falling between 0 and 32767.

To transform this gigantic range of integers into a simple coin flip, you must utilize the Modulo operator (%%). Modulo divides a number by a specified value and returns strictly the remainder. Because dividing any whole number by 2 leaves a remainder of exclusively either 0 or 1, modulo arithmetic creates the perfect binary switch for Heads and Tails.

Generating the 0 and 1

@echo off
setlocal enabledelayedexpansion

:: Extract a random integer
set "raw_number=!RANDOM!"

:: Apply Modulo 2 to strip the number down to only a 0 or 1
set /a "flip_result=raw_number %% 2"

echo Result integer generated: !flip_result!
pause

info

By incorporating setlocal enabledelayedexpansion, you ensure variables referenced with ! marks are evaluated at execution time rather than at parse time. This distinction becomes critical inside for loops and ( ) blocks: %RANDOM% with standard %-expansion would be resolved once when the block is first read, producing the same number on every iteration, while !RANDOM! with delayed expansion produces a fresh value each time the line executes.

Mapping the Result to Text Output

Outputting 0 or 1 isn't very intuitive for an end-user seeking a coin flip game. The script needs an embedded dictionary to translate the numeric outcome into an English string. Because there are exclusively two states, a single if/else block completely handles the entire logic mapping.

@echo off
setlocal enabledelayedexpansion

set /a "flip=!RANDOM! %% 2"

:: Compare the integer and assign the string
if !flip! equ 0 (
    set "OUTCOME=HEADS"
) else (
    set "OUTCOME=TAILS"
)

echo The coin landed on: !OUTCOME!
pause

Adding Interactive User Choices

A complete game simulator should allow the user to effectively "call the flip in the air." By expanding our script to prompt the user for a choice of 'Heads' or 'Tails' before the evaluation map outputs the translated answer string, we simulate a standard gambling mechanic.

The Wrong Way: Evaluating User Input Without Sanitization

When soliciting text from a user within a batch terminal, developers frequently forget that users don't strictly type precisely formatted strings. If your comparison checks exclusively look for HEADS, but the user types heads, the script unconditionally registers a loss entirely.

Wrong Code Example:

@echo off
set /p CALL="Call Heads or Tails? "

:: If the user types 'heads' or 'HEADs', this equation evaluates False.
if "%CALL%"=="HEADS" (
    set user_call=0
) else (
    set user_call=1
)

What Happens: Command Prompt variables are case-sensitive during evaluations. Because heads does not string-match HEADS, the script instantly drops to the else block, forcefully locking the user's bet to Tails every single time despite their actual intent.

The Correct Way: Implement Case-Insensitive Checking

To safely accommodate user input variations within a Batch terminal, the developer must employ the /i switch alongside the comparison operator. This instructs CMD to completely ignore character casing.

Correct Code Example:

@echo off
setlocal enabledelayedexpansion

:GET_BET
set "CALL="
set /p "CALL=Call Heads (H) or Tails (T)? "

:: The /I switch ignores casing
if /i "!CALL!"=="H" (
    set "choice_int=0"
    set "choice_str=HEADS"
    goto EXECUTE_FLIP
)
if /i "!CALL!"=="HEADS" (
    set "choice_int=0"
    set "choice_str=HEADS"
    goto EXECUTE_FLIP
)

if /i "!CALL!"=="T" (
    set "choice_int=1"
    set "choice_str=TAILS"
    goto EXECUTE_FLIP
)
if /i "!CALL!"=="TAILS" (
    set "choice_int=1"
    set "choice_str=TAILS"
    goto EXECUTE_FLIP
)

:: User typed an invalid string. Loop back to prevent failure.
echo Invalid bet. Try again.
goto GET_BET

:EXECUTE_FLIP

What Happens: Because there exists a strict loop validation map checking multiple variations with /i "!CALL!"=="H", the execution bounds prevent anything besides a recognized intention from advancing out of the prompt phase.

Building the Loop and Stat Tracker

The final step for a polished Command Prompt simulator involves looping the process repeatedly while establishing a win/loss tracking variable layout outside the loop. These counters provide persistent session statistics seamlessly.

@echo off
setlocal enabledelayedexpansion
title Coin Flip Simulator
mode con cols=50 lines=20
color 0E

:: Initialize Session Statistics
set "WINS=0"
set "LOSS=0"
set "FLIPS=0"

:MAINMENU
cls
echo =======================================
echo          VIRTUAL COIN FLIPPER
echo =======================================
echo Session Flips: !FLIPS!
echo Total Wins:    !WINS!
echo Total Losses:  !LOSS!
echo =======================================
echo.

set "BET="
set /p "BET=Call [H]eads or [T]ails (Type 'Q' to quit): "

if /i "!BET!"=="q" goto STAT_BOARD

:: Validate Choice
if /i "!BET!"=="h" (
    set "H_CHOICE=0"
    set "H_NAME=HEADS"
) else if /i "!BET!"=="t" (
    set "H_CHOICE=1"
    set "H_NAME=TAILS"
) else (
    REM Invalid input - restart menu
    goto MAINMENU
)

echo.
echo F L I P P I N G...
timeout /t 1 >nul

:: Generate Random Output [0 or 1]
set /a "outcome=!RANDOM! %% 2"

:: Map Ints to Strings
if !outcome! equ 0 (
    set "O_NAME=HEADS"
) else (
    set "O_NAME=TAILS"
)

echo.
echo    *** The coin landed on: !O_NAME! ***
echo.
timeout /t 1 >nul

:: Evaluate Win Condition using numeric comparison
set /a "FLIPS+=1"

if !outcome! equ !H_CHOICE! (
    echo    +=========================+
    echo    ^|  WIN^^! You called it^^!   ^|
    echo    +=========================+
    set /a "WINS+=1"
    color 0A
) else (
    echo    -=========================-
    echo    ^|  LOSS - Better luck...  ^|
    echo    -=========================-
    set /a "LOSS+=1"
    color 0C
)

ping 127.0.0.1 -n 3 >nul
color 0E
goto MAINMENU

:STAT_BOARD
cls
echo =======================================
echo           THANKS FOR PLAYING
echo =======================================
echo Final Flips:  !FLIPS!
echo Final Wins:   !WINS!
echo Final Losses: !LOSS!
echo =======================================
pause

Conclusion

Constructing a Coin Flip Simulator thoroughly illustrates the power of Windows Batch Scripting specifically manipulating the native pseudo-random seed to accomplish Boolean data generation securely. By implementing strict case-insensitive input comparisons to eliminate operator failure, tracking integer permutations outside continuous loops, and applying simplistic mathematical % restrictions, you drastically strengthen your fundamental logical abilities far beyond elementary command line executions.

The Principle of Binary Randomness​

Generating the 0 and 1​

Mapping the Result to Text Output​

Adding Interactive User Choices​

The Wrong Way: Evaluating User Input Without Sanitization​

The Correct Way: Implement Case-Insensitive Checking​

Building the Loop and Stat Tracker​

Conclusion​

Table of Contents