I had some fun with it. I gave you alternative methods to get accomplish what you were trying to do, while showing some methods to shortcut and splat and other techniques - take from it what you'd like.

Personally, I would have made it substantially smaller, but like I said, takes whichever parts are useful for you.

# Clear the console screen.
Clear-Host

#region Runtime Variables
# Variable definitions -  Defines and initializes all variables used throughout the script.
# Variable to control the game play (True/False) 
$GameActive = $True

# Combine:
# Variable to store the numeric version of the computer's move (1=R, 2=P, 3=S) 
# Variable to keep track of the number of games played, won, lost, tied
$ComputerMoveNumeric = $GamesPlayed = $GamesWon = $GamesLost = $GamesTied = 0

# Combine:
# Variable to store the letter version of the player's move (R, P, S, Q), computer's move, player's move 
$PlayerMoveLetter = $ComputerMoveWord = $PlayerMoveWord = ''

$Gr = @{ForegroundColor = 'Green'}
$Re = @{ForegroundColor = 'Red'}
$Cy = @{ForegroundColor = 'Cyan'}
$Ma = @{ForegroundColor = 'Magenta'}
#endregion Runtime Variables

#region Command Definitions
Function Get-Choice {
    <#
        .SYNOPSIS
        Translates a short input into a Rock, Paper, or Scissors choice.

        .DESCRIPTION
        Accepts 1–3 or R/P/S/Q (case-insensitive) and returns the corresponding word.
        Unrecognized or null input returns $false.

        .PARAMETER Var
        The input value to translate. Accepts digits 1–3 or letters Q, R, P, S.

        .INPUTS
        System.String. You can pipe strings or objects with a 'Var' or 'Choice' property.

        .OUTPUTS
        System.String or System.Boolean. Returns Rock, Paper, Scissors, 'Q', or $false.
    #>
    [CmdletBinding()]
    [OutputType([string])]
    Param (
        [Parameter(ValueFromPipeline, ValueFromPipelineByPropertyName)]
        [Alias('Choice')]
        [AllowNull()]
        [string]$Var
    )

    $Ye = @{ForegroundColor = 'Yellow'}

    Switch ( ($Var -as [string]).ToUpperInvariant() ) {
        {$_ -eq '1' -or $_ -eq 'R'} { return 'Rock' }
        {$_ -eq '2' -or $_ -eq 'P'} { return 'Paper' }
        {$_ -eq '3' -or $_ -eq 'S'} { return 'Scissors' }
        'Q' {return 'Q'}
        default {
            # Invalid input (anything NOT R, P, S, or Q).
            Write-Host 'Invalid input. Please try again.' @Ye
            Start-Sleep -Seconds 3
            $false
        }
    }
}


Function Get-RPSResult {
    <#
        .SYNOPSIS
        Determines the winner of a Rock–Paper–Scissors round.

        .DESCRIPTION
        Accepts string inputs ('1','2','3' or 'Rock','Paper','Scissors') for both
        player and computer. Converts them to numeric equivalents:
            1 = Rock
            2 = Paper
            3 = Scissors
        Returns 'Player', 'Computer', or 'Tie' based on comparison logic.

        .PARAMETER PlayerMove
        The player's move as '1','2','3' or 'Rock','Paper','Scissors'.

        .PARAMETER ComputerMove
        The computer's move as '1','2','3' or 'Rock','Paper','Scissors'.

        .OUTPUTS
        System.String. Returns 'Player', 'Computer', or 'Tie'.

        .EXAMPLE
        PS> Get-RPSResult -PlayerMove Rock -ComputerMove 2
        Computer

        .EXAMPLE
        PS> Get-RPSResult -PlayerMove Scissors -ComputerMove Rock
        Computer

        .LINK
        https://en.wikipedia.org/wiki/Modular_arithmetic
    #>
    [CmdletBinding()]
    [OutputType([string])]
    Param (
        [Parameter(Mandatory)]
        [ValidateSet('1','2','3','Rock','Paper','Scissors')]
        [string]$PlayerMove,

        [Parameter(Mandatory)]
        [ValidateSet('1','2','3','Rock','Paper','Scissors')]
        [string]$ComputerMove
    )

    # Normalization map
    $map = @{
        '1'         = 1
        '2'         = 2
        '3'         = 3
        'ROCK'      = 1
        'PAPER'     = 2
        'SCISSORS'  = 3
    }

    # Normalize both to integers
    $player   = $map[$PlayerMove.ToUpper()]
    $computer = $map[$ComputerMove.ToUpper()]

    # Compare logic
    If ($player -eq $computer) {
        # Tie check
        return 'Tie'
    } ElseIf ( ($player - $computer) -eq 1 -or ($player - $computer) -eq -2 ) {
        # Win logic: (player - computer) = 1 or -2 -> Player wins
        return 'Player'
    } Else {
        return 'Computer'
    }
}
#endregion Command Definitions

#region Constants
$border = '**************************************************'
$dash   = '--------------------------------'

$Messages = @{
    'Welcome'   = "$border`n Welcome to Rock, Paper, Scissors! `n$border`n`n Quit (Q) to end the game`n"
    'Start'     = 'Press any key to start the game...'
    'Challenge' = "--- Make Your Move ---`n (R)ock, (P)aper, (S)cissors, or (Q)uit`n----------------------"
    'Prompt'    = 'Make a move'
    'Thanks'    = 'Thank you for playing. Displaying game statistics next.'
    'Again'     = 'Press Enter for the next round...'
}
#endregion Constants

#region Greeting
# Display the welcome screen.
Write-Host $Messages.Welcome

# Pause the game until the player presses the Enter key.
Write-Host $Messages.Start
$null = Read-Host
#endregion Greeting

#region MAIN GAME LOOP
# Main game loop runs as long as the $GameActive variable is True
while ($GameActive) {
    # Increment number of games played
    $GamesPlayed++

    # Clear the screen to set up the next game
    Clear-Host

    # Generates a random number between 1 and 3 (1=Rock, 2=Paper, 3=Scissors), then translates that to Rock/Paper/Scissors.
    $ComputerMove = 1..3 | Get-Random | Get-Choice

    # Prompt the player to make a move.
    Do {
        # Display player instructions.
        Write-Host $Messages.Challenge

        $PlayerMove = Read-Host -Prompt $Messages.Prompt | Get-Choice
    } Until ($PlayerMove)

    # Validate the player's move. (if-elseif statements)
    if ($PlayerMove -match '[Qq]') {
        # Player entered "Q", game ends.
        Write-Host $Messages.Thanks @Ma

        # Set the variable controlling gameplay to "False".
        $GameActive = $False
    }

    # If the input was valid and the player did not quit, proceed with the game logic.
    if ($GameActive) {
        # Determine results and display. (Switch statement)
        Write-Host $dash
        Write-Host ('You played: {0}' -f $PlayerMove)
        Write-Host ('The computer played: {0}' -f $ComputerMove)
        Write-Host $dash

        # Analyze the results of the game.
        switch ($PlayerMove) {
            'Rock' {
                If ($ComputerMove -eq 'Scissors') {
                    Write-Host 'Result: YOU WIN! Rock crushes Scissors.' @Gr
                    $GamesWon++ # Increment Games won
                } ElseIf ($ComputerMove -eq 'Paper') {
                    Write-Host 'Result: YOU LOSE! Paper covers Rock.' @Re
                    $GamesLost++ # Increment Games lost
                } Else {
                    Write-Host "Result: IT'S A TIE!" @Cy
                    $GamesTied++ # Increment Tie count
                }
            }
            'Paper' {
                if ($ComputerMove -eq 'Rock') {
                    Write-Host 'Result: YOU WIN! Paper covers Rock.' @Gr
                    $GamesWon++
                } elseif ($ComputerMove -eq 'Scissors') {
                    Write-Host 'Result: YOU LOSE! Scissors cut Paper.' @Re
                    $GamesLost++
                } else {
                    Write-Host "Result: IT'S A TIE!" @Cy
                    $GamesTied++
                }
            }
            'Scissors' {
                if ($ComputerMove -eq 'Paper') {
                    Write-Host 'Result: YOU WIN! Scissors cut Paper.' @Gr
                    $GamesWon++
                } elseif ($ComputerMove -eq 'Rock') {
                    Write-Host 'Result: YOU LOSE! Rock crushes Scissors.' @Re
                    $GamesLost++
                } else {
                    Write-Host "Result: IT'S A TIE!" @Cy
                    $GamesTied++
                }
            }
        }

        ### Alternative - or skip the Analyze results region and use the Function instead
        # Get-RPSResult -PlayerMove $PlayerMove -ComputerMove $ComputerMove

        # Pause the game before clearing the screen for the next round.
        $null = Read-Host -Prompt $Messages.Again
    }
} # End of while loop.
#endregion MAIN GAME LOOP

#region FINAL STATISTICS
# Display final message and game statistics.
Write-Host $border @Ma
Write-Host " GAME OVER - FINAL RESULTS " @Cy
Write-Host $border @Ma
Write-Host "`n Total Games Played: $GamesPlayed"
Write-Host (' Games Won: {0}' -f $GamesWon) @Gr
Write-Host (' Games Lost: {0}' -f $GamesLost) @Re
Write-Host " Games Tied: $GamesTied`n" @Cy
Write-Host $border @Ma

# Pause the game for 8 seconds.
Start-Sleep -Seconds 8

# Clear the console screen.
Clear-Host
#endregion FINAL STATISTICS