group_stage.qmd

---
title: "Group Stage Play"
author: "Zach Culp"
format: html
editor: visual
---

## Group Stage

### Simulate Game

```{r}
simulate_match <- function(team1, team2, strength1, strength2) {
  if(is.na(team1) && is.na(team2)){
    return(NA)
  }
  if (is.na(team1)) {
    return(team2)
  } else if (is.na(team2)) {
    return(team1)
  } else {
    p <- exp(strength1 - strength2) / (1 + exp(strength1 - strength2))
    return(ifelse(runif(1) < p, team1, team2))  # Randomize outcome
  }
}
```

### Simulate Each Group

```{r}
simulate_group_stage_tournament <- function(num_teams, distribution, group_length = 4, ties = TRUE, rounds = 1, third_place = T, theta_hat = NULL) {
  
  if (num_teams <= 3) {
    stop("Number of Teams must be greater than 3.")
  }
  
  if (num_teams %% group_length != 0) {
    stop("Number of teams must be divisible by group length.")
  }
  
  teams <- paste(num_teams:1)
  
  # Create team strengths based on distribution
  if (distribution == "Normal"){
    strengths <- sapply(num_teams, function(n) { qnorm(1:n/(n+1)) })
    team_strengths <- data.frame(
      true_rank = as.numeric(teams),
      theta = strengths,
      rank_hat = rep(NA, length(teams)),
      game_wins = rep(0, length(teams)),
      game_losses = rep(0, length(teams))
    )
    df <- arrange(team_strengths, true_rank)
  }
  else if (distribution == "Same"){
    strengths <- sapply(num_teams, function(n) {rep(0, n)})
    team_strengths <- data.frame(
      true_rank = as.numeric(teams),
      theta = strengths,
      rank_hat = rep(NA, length(teams)),
      game_wins = rep(0, length(teams)),
      game_losses = rep(0, length(teams))
    )
    df <- arrange(team_strengths, true_rank)
  }
  else if (distribution == "Uniform"){
    strengths <- sapply(num_teams, function(n) { qunif(1:n/(n+1), 0, sqrt(12)) })
    team_strengths <- data.frame(
      true_rank = as.numeric(teams),
      theta = strengths,
      game_wins = rep(0, length(teams)),
      game_losses = rep(0, length(teams)),
      rank_hat = rep(NA, length(teams))
    )
    df <- arrange(team_strengths, true_rank)
  } 
  else if (distribution == "Exponential"){
      strengths <- sapply(num_teams, function(n) { qexp(1:n/(n+1)) })
      unif_strength <- data.frame(
        true_rank = as.numeric(teams),
        theta = c(strengths, rep(NA, length(teams) - num_teams)),
        game_wins = rep(0,length(teams)),
        game_losses = rep(0,length(teams)),
        rank_hat = rep(NA,length(teams))
      )
      df <- arrange(unif_strength, true_rank)
  }    
  else if (distribution == "Manual") {
    strengths <- theta_hat
    manual_strengths <- data.frame(
      theta = strengths,  # Also renamed to match other distributions
      rank_hat = rep(NA, length(strengths)),
      game_wins = rep(0, length(strengths)),
      game_losses = rep(0, length(strengths))
    )
    df <- manual_strengths %>% 
      arrange(desc(theta)) %>%
      mutate(true_rank = row_number()) %>%
      arrange(true_rank)
  }
  else {
    stop("Distribution not found: Enter Manual to input your own strengths")
  }
  
  num_groups <- num_teams / group_length
  
  # Create balanced groups using snake draft seeding
  # Sort teams by strength (best to worst)
  df <- df %>% arrange(desc(theta))
  
  # Assign groups using snake draft method
  df$groups <- NA
  for (i in 1:nrow(df)) {
    group_round <- ceiling(i / num_groups)
    if (group_round %% 2 == 1) {
      # Forward direction for odd rounds
      group_id <- ((i - 1) %% num_groups) + 1
    } else {
      # Reverse direction for even rounds
      group_id <- num_groups - ((i - 1) %% num_groups)
    }
    df$groups[i] <- group_id
  }
  
  # Reset game stats for group play
  df$game_wins <- 0
  df$game_losses <- 0
  df$rank_hat <- NA
  
  all_group_results <- list()
  
  # Simulate each group
  for (g in 1:num_groups) {
    group_teams <- df[df$groups == g, ]
    n_group_teams <- nrow(group_teams)
    
    # Play round robin within the group
    for (r in 1:rounds) {
      for (i in 1:(n_group_teams - 1)) {
        for (j in (i + 1):n_group_teams) {
          team1 <- group_teams$true_rank[i]
          team2 <- group_teams$true_rank[j]
          
          strength1 <- group_teams$theta[i]
          strength2 <- group_teams$theta[j]
          
          match_winner <- simulate_match(team1, team2, strength1, strength2)
          
          # Update wins and losses
          if (match_winner == team1) {
            df$game_wins[df$true_rank == team1] <- df$game_wins[df$true_rank == team1] + 1
            df$game_losses[df$true_rank == team2] <- df$game_losses[df$true_rank == team2] + 1
          } else {
            df$game_wins[df$true_rank == team2] <- df$game_wins[df$true_rank == team2] + 1
            df$game_losses[df$true_rank == team1] <- df$game_losses[df$true_rank == team1] + 1
          }
        }
      }
    }
    
    # Rank teams within each group
    group_df <- df[df$groups == g, ]

    group_df$group_rank <- rank(-group_df$game_wins, ties.method = "random")


    all_group_results[[g]] <- group_df
  }

  # Combine all group results
  final_df <- do.call(rbind, all_group_results)

  # Calculate overall tournament ranking
  # First by group rank, then by total wins, then by true rank as tiebreaker
  final_df <- final_df %>%
    arrange(group_rank, desc(game_wins), true_rank)
  
  final_df <- final_df %>%
    mutate(distribution = distribution) %>%
    arrange(true_rank) %>%
    mutate(rank_hat = ifelse(group_rank <= 2, group_rank, num_groups*group_rank)) %>%
    select(true_rank, theta, game_wins, game_losses, groups, group_rank, rank_hat, distribution)
  
  #print(final_df)
  

  # Get top finishers from each group (group_rank <= 1.5 covers both rank 1 and tied 1.5)
  group_winners <- final_df %>%
    group_by(groups) %>%
    filter(group_rank == min(group_rank)) %>%  # Get best finisher(s)
    slice(1) %>%  # If still tied, take first one
    ungroup() %>%
    arrange(groups)
  
  # Get second place finishers (next best after winners)
  group_seconds <- final_df %>%
    group_by(groups) %>%
    arrange(group_rank, true_rank) %>%  # Sort by rank, then true_rank as tiebreaker
    slice(2) %>%  # Take second team
    ungroup() %>%
    arrange(groups)
  
  n_groups <- length(unique(final_df$groups))
  matchup_vector <- c()
  
  # Build the alternating order
  for (i in seq(1, n_groups, by = 2)) {
    g1 <- group_winners$groups[i]
    g2 <- group_winners$groups[i + 1]
    
    winner_g1 <- group_winners$true_rank[group_winners$groups == g1]
    second_g2 <- group_seconds$true_rank[group_seconds$groups == g2]
    
    winner_g2 <- group_winners$true_rank[group_winners$groups == g2]
    second_g1 <- group_seconds$true_rank[group_seconds$groups == g1]
    
    # append in alternating order
    matchup_vector <- c(matchup_vector, winner_g1, second_g2, winner_g2, second_g1)
  }
  matchup_vector
  
  knockout_results <- simulate_knockout(df = final_df, matchup_vector = matchup_vector, series = 1, third_place = third_place)
  
  knockout_results <- knockout_results %>%
    filter(!is.na(rank_hat))
  final_df <- final_df %>%
    filter(rank_hat > num_groups)
  
  combined_df <- bind_rows(
  final_df %>% filter(rank_hat >= num_groups),   # group-stage only teams
  knockout_results %>% filter(!is.na(rank_hat))  # knockout-stage teams
) %>% arrange(true_rank)
  if (ties == F){
    final_df <- final_df %>%
      mutate(rank_hat = rank(rank_hat, ties.method = "random"))
  } else{
    final_df <- final_df %>%
      mutate(rank_hat = rank(rank_hat, ties.method = "average"))
  }

  
  return(combined_df)
}

simulate_group_stage_tournament(16, "Exponential")

```

## Simulate Knockout Round

```{r}
simulate_knockout <- function(df, matchup_vector, series = 1, third_place = TRUE) {
  
  teams <- matchup_vector
  permuted_df <- df
  permuted_df$rank_hat <- NA
  
  round_number <- ceiling(log2(length(teams)))
  losers_semis <- c()
  
  while (length(teams) > 1) {
    
    #cat("\n--- New Round ---\n")
    next_round <- c()
    
    for (j in seq(1, length(teams), by = 2)) {
      team1 <- teams[j]
      team2 <- teams[j+1]
      
      #cat(sprintf("Matchup: Team1 = %s | Team2 = %s\n", team1, team2))
      
      strength1 <- permuted_df$theta[which(permuted_df$true_rank == team1)]
      strength2 <- permuted_df$theta[which(permuted_df$true_rank == team2)]
      
      #cat(sprintf("Strengths: %.2f vs %.2f\n", strength1, strength2))
      
      wins_team1 <- 0
      wins_team2 <- 0
      losses_team1 <- 0
      losses_team2 <- 0
      
      for (game in 1:series) {
        match_winner <- simulate_match(team1, team2, strength1, strength2)
        #cat(sprintf("Game %d Winner: %s\n", game, match_winner))
        
        if (match_winner == team1) {
          wins_team1 <- wins_team1 + 1
          losses_team2 <- losses_team2 + 1
        } else {
          wins_team2 <- wins_team2 + 1
          losses_team1 <- losses_team1 + 1
        }
        if (wins_team1 > series / 2 || wins_team2 > series / 2) break
      }
      
      # update df
      permuted_df <- permuted_df %>%
        mutate(game_wins = ifelse(true_rank == team1, game_wins + wins_team1, game_wins)) %>%
        mutate(game_wins = ifelse(true_rank == team2, game_wins + wins_team2, game_wins)) %>%
        mutate(game_losses = ifelse(true_rank == team1, game_losses + losses_team1, game_losses)) %>%
        mutate(game_losses = ifelse(true_rank == team2, game_losses + losses_team2, game_losses))
      
      # winner moves to next round
      series_winner <- ifelse(wins_team1 > wins_team2, team1, team2)
      #cat(sprintf("Series Winner: %s\n", series_winner))
      next_round <- c(next_round, series_winner)
      
      # assign ranks
      if (round_number > 2) {  # early rounds
        loser <- ifelse(series_winner == team1, team2, team1)
        permuted_df$rank_hat[permuted_df$true_rank == loser] <- 2^round_number
      } else if (round_number == 2) {  # semifinals
        loser <- ifelse(series_winner == team1, team2, team1)
        permuted_df$rank_hat[permuted_df$true_rank == loser] <- 4
        losers_semis <- c(losers_semis, loser)
      } else if (round_number == 1) {  # finals
        winner <- series_winner
        loser <- ifelse(series_winner == team1, team2, team1)
        permuted_df$rank_hat[permuted_df$true_rank == winner] <- 1
        permuted_df$rank_hat[permuted_df$true_rank == loser] <- 2
      }
      
    }
    
    teams <- next_round
    round_number <- round_number - 1
  }
  
  # third place match
  if (third_place & length(losers_semis) == 2) {
    team1 <- losers_semis[1]
    team2 <- losers_semis[2]
    strength1 <- permuted_df$theta[permuted_df$true_rank == team1]
    strength2 <- permuted_df$theta[permuted_df$true_rank == team2]
    
    #cat(sprintf("\nThird Place Match: %s vs %s | Strengths: %.2f vs %.2f\n", team1, team2, strength1, strength2))
    
    wins_team1 <- 0
    wins_team2 <- 0
    
    for (game in 1:series) {
      match_winner <- simulate_match(team1, team2, strength1, strength2)
      #cat(sprintf("Game %d Winner: %s\n", game, match_winner))
      
      
      if (match_winner == team1) wins_team1 <- wins_team1 + 1 else wins_team2 <- wins_team2 + 1
      if (wins_team1 > series / 2 || wins_team2 > series / 2) break
    }
    
    if (wins_team1 > wins_team2) {
      permuted_df$rank_hat[permuted_df$true_rank == team1] <- 3
      permuted_df$rank_hat[permuted_df$true_rank == team2] <- 4
    } else {
      permuted_df$rank_hat[permuted_df$true_rank == team2] <- 3
      permuted_df$rank_hat[permuted_df$true_rank == team1] <- 4
    }
  }
  
  permuted_df <- permuted_df %>% arrange(true_rank)
  return(permuted_df)
}

```