Flipping Coins Until Some Event Happens

Imagine I have 3 coins .

• Coin 1: Probability of Heads = 0.5, Reward Heads = +1, Reward Tails = -1
• Coin 2: Probability of Heads = 0.8, Reward Heads = 0.2, Reward Tails = -0.1
• Coin 3 Probability of Heads = 0.3 Reward Heads = + 3, Reward Tails = -5

Now, imagine a game where two players (player 1 always starts the game and both players start with reward = 0) take turns flipping random coins while tallying their score (player 1 always starts) : the first player to reach reward = + 10 wins.

My Question: I want to simulate 5 games that contain the turn-by-turn details of both players until a winner is reached.

First, I defined the coin information:

# Define coin properties
coin1 <- list(prob = 0.5, reward_heads = 1, reward_tails = -1)
coin2 <- list(prob = 0.8, reward_heads = 0.2, reward_tails = -0.1)
coin3 <- list(prob = 0.3, reward_heads = 3, reward_tails = -5)

Next, I defined a function to flip a coin

# Define function to flip a coin 
flip_coin <- function(coin) {
  if (runif(1) < coin$prob) {
    return(coin$reward_heads)
  } else {
    return(coin$reward_tails)
  }
}

Then, I defined the initial data frame to store the game results:

game_log <- data.frame(turn_no = numeric(), 
                       current_player_turn = character(), 
                       coin_chosen = character(),
                       player_1_current_score = numeric(), 
                       player_2_current_score = numeric(),
                       stringsAsFactors = FALSE)
player_names <- c("player 1", "player 2")
current_player <- player_names[1]
# Set up initial scores and game state
player_scores <- c(0, 0)
game_state <- list(current_player = 1, game_log = game_log)

Finally, I tried to write a function to simulate a single game - this would involve steps such as: creating a WHILE LOOP until cumulative score of any player is > 10, select a random coin at each turn, flipping the selected coin, updating scores and alternating between players

play_game <- function() {
game_no = n
  # Play the game until a player reaches a score of +10
  while (max(player_scores) < 10) {
    # Choose a coin at random
    coin_choice <- sample(c("coin1", "coin2", "coin3"), 1)
    
    # Flip the chosen coin
    coin_result <- flip_coin(get(coin_choice))
    
    # Update the current player's score
    player_scores[current_player] <- player_scores[current_player] + coin_result
    
    # Log the current turn's information
    turn_info <- data.frame(turn_no = nrow(game_log) + 1,
                            current_player_turn = current_player,
                            coin_chosen = coin_choice, game_no = n,
                            player_1_current_score = player_scores[1],
                            player_2_current_score = player_scores[2])
    game_log <- rbind(game_log, turn_info)
    
    # Switch to the other player's turn
    current_player <- ifelse(current_player == 1, 2, 1)
  }
  
  # Return the game log
  return(game_log)
}

But I get an error:

Error in while (max(player_scores) < 10) { : 
  missing value where TRUE/FALSE needed

Had this worked, I would have then replicated 5 games like this:

n_iterations <- 5
result <- lapply(1:n_iterations, play_game, n = n_rows)
result <- do.call(rbind, result)

Can someone please show me how to do this?

Thanks!

The main problem I see is:

# You are trying to index via strings of playernames instead of integers:
player_names <- c("player 1", "player 2")
current_player <- player_names[1]
...
player_scores[current_player] <- player_scores[current_player] + coin_result

This leads to player_scores looking like this:

              player 1 
   0        0       NA 

I'm sure this is not intended, since any NA within a vector will make max() (or any of the simple statisics function) fail.

You can fix this by using the which()-function

n=1 # 1:10 tested
play_game <- function() {
  game_no = n
  
  current_player <- which(player_names==current_player) # integer instead of string
  # or simply initialise current player before the start of the while loop with: current_player <- 1 
  
  player_scores <- c(0, 0)
  
  # Play the game until a player reaches a score of +10
  while (max(player_scores) < 10) {...}

Careful though as, at least in my tests, the values get negative really fast and there will never be a positive outcome, leading to an endless loop.
I changed some things to play till -10:

# Define coin properties
coin1 <- list(prob = 0.5, reward_heads = 1, reward_tails = -1)
coin2 <- list(prob = 0.8, reward_heads = 0.2, reward_tails = -0.1)
coin3 <- list(prob = 0.3, reward_heads = 3, reward_tails = -5)

# Define function to flip a coin 
flip_coin <- function(coin) {
  if (runif(1) < coin$prob) {
    return(coin$reward_heads)
  } else {
    return(coin$reward_tails)
  }
}

play_game <- function(n=NULL) { # added "n" as input
  
  # init
  player_names <- c("player 1", "player 2")
  
  game_log <- data.frame(turn_no = numeric(), 
                         current_player_turn = character(), 
                         coin_chosen = character(),
                         player_1_current_score = numeric(), 
                         player_2_current_score = numeric(),
                         stringsAsFactors = FALSE)
  
  # Set up initial scores and game state
  game_state <- list(current_player = 1, game_log = game_log)
  
  game_no = n
  
  current_player <- 1 # which(player_names==current_player)

  player_scores <- c(0, 0)
  
  # Play the game until a player reaches a score of -10 // careful here!!
  while (min(player_scores) > -10) {    # while (max(player_scores[1]) < 10 | max(player_scores[2]) < 10) {
    
    # Choose a coin at random
    coin_choice <- sample(c("coin1", "coin2", "coin3"), 1)
    
    # Flip the chosen coin
    coin_result <- flip_coin(get(coin_choice))
    
    # Update the current player's score
    player_scores[current_player] <- player_scores[current_player] + coin_result
    
    # Log the current turn's information
    turn_info <- data.frame(turn_no = nrow(game_log) + 1,
                            current_player_turn = player_names[current_player],
                            coin_chosen = coin_choice, game_no = n,
                            player_1_current_score = player_scores[1],
                            player_2_current_score = player_scores[2])
    
    game_log <- rbind(game_log, turn_info)
    
    # Switch to the other player's turn
    current_player <- ifelse(current_player == 1, 2, 1)
  }
  
  # Return the game log
  return(game_log)
}

lapply(1:5, \(x) play_game(x))

First result:

[[1]]
   turn_no current_player_turn coin_chosen game_no player_1_current_score player_2_current_score
1        1            player 1       coin1       1                    1.0                    0.0
2        2            player 2       coin1       1                    1.0                    1.0
3        3            player 1       coin2       1                    0.9                    1.0
4        4            player 2       coin1       1                    0.9                    2.0
5        5            player 1       coin2       1                    1.1                    2.0
6        6            player 2       coin2       1                    1.1                    2.2
7        7            player 1       coin2       1                    1.3                    2.2
8        8            player 2       coin2       1                    1.3                    2.4
9        9            player 1       coin1       1                    2.3                    2.4
10      10            player 2       coin3       1                    2.3                   -2.6
11      11            player 1       coin3       1                   -2.7                   -2.6
12      12            player 2       coin2       1                   -2.7                   -2.4
13      13            player 1       coin3       1                   -7.7                   -2.4
14      14            player 2       coin2       1                   -7.7                   -2.2
15      15            player 1       coin2       1                   -7.5                   -2.2
16      16            player 2       coin3       1                   -7.5                   -7.2
17      17            player 1       coin2       1                   -7.3                   -7.2
18      18            player 2       coin1       1                   -7.3                   -6.2
19      19            player 1       coin3       1                   -4.3                   -6.2
20      20            player 2       coin3       1                   -4.3                  -11.2