Update app.R

app.R

@@ -2316,6 +2316,7 @@ create_advanced_pitcher_summary <- function(data, player_name) {
   list(stats = summary_stats, colors = colors)
 }
 
+
 create_advanced_pitch_characteristics <- function(data, player_name) {
   data <- normalize_columns(data)
   
@@ -2329,7 +2330,6 @@ create_advanced_pitch_characteristics <- function(data, player_name) {
   } else "Right"
   
   if (!is.null(stuffplus_model) && nrow(pitcher_data) > 0) {
-
     # If reference data exists, use the league-standardization path
     if (!is.null(reference_data_for_stuff)) {
       combined <- dplyr::bind_rows(
@@ -2338,11 +2338,8 @@ create_advanced_pitch_characteristics <- function(data, player_name) {
         reference_data_for_stuff$sbc
       )
       pitcher_data <- standardize_stuffplus_to_league(pitcher_data, combined)
-
     } else {
-      # Reference data not available → fall back to local standardization using the model
       message("WARNING: No reference data available. Using local standardization.")
-
       pitcher_data$raw_stuff <- tryCatch({
         predict(stuffplus_model, pitcher_data, type = "numeric")$.pred
       }, error = function(e) {
@@ -2357,63 +2354,80 @@ create_advanced_pitch_characteristics <- function(data, player_name) {
         q <- quantile(finite_raw, probs = c(0.01, 0.99), na.rm = TRUE)
         lo <- q[1]; hi <- q[2]
         pitcher_data$raw_stuff_winz <- pmin(pmax(pitcher_data$raw_stuff, lo), hi)
-
         raw_mean <- mean(pitcher_data$raw_stuff_winz, na.rm = TRUE)
         raw_sd   <- sd(pitcher_data$raw_stuff_winz, na.rm = TRUE)
         if (!is.finite(raw_sd) || raw_sd == 0) raw_sd <- 1e-8
-
         pitcher_data$stuff_plus <- ((pitcher_data$raw_stuff_winz - raw_mean) / raw_sd) * 10 + 100
       }
     }
-
   } else {
-    # Either no model or no pitcher data
     if (is.null(stuffplus_model)) message("Stuff+ model not loaded")
     if (nrow(pitcher_data) == 0)  message("No pitcher data for Stuff+ prediction")
-
     pitcher_data$raw_stuff  <- NA_real_
     pitcher_data$stuff_plus <- NA_real_
   }
   
+  # Handle case where pitcher_data is empty after filtering
+  if (nrow(pitcher_data) == 0) {
+    empty_df <- data.frame(
+      Pitch = character(0), Count = integer(0), `Usage%` = numeric(0),
+      `Avg Velo` = numeric(0), `Max Velo` = numeric(0), `Avg Spin` = numeric(0),
+      `Avg IVB` = numeric(0), `Avg HB` = numeric(0), `VAA` = numeric(0),
+      `HAA` = numeric(0), `hRel` = numeric(0), `vRel` = numeric(0),
+      `Ext` = numeric(0), `Strike%` = numeric(0), `Whiff%` = numeric(0),
+      `Zone%` = numeric(0), `Stuff+` = numeric(0),
+      check.names = FALSE, stringsAsFactors = FALSE
+    )
+    return(list(stats = empty_df, colors = matrix("#FFFFFF", nrow = 0, ncol = 17)))
+  }
   
   pitch_stats <- pitcher_data %>%
     dplyr::group_by(Pitch = TaggedPitchType) %>%
     dplyr::summarise(
       Count      = dplyr::n(),
-      `Usage%`   = 100 * dplyr::n() / nrow(pitcher_data),
-      `Avg Velo` = round(mean(RelSpeed,          na.rm = TRUE), 1),
-      `Max Velo` = round(max(RelSpeed,           na.rm = TRUE), 1),
-      `Avg Spin` = round(mean(SpinRate,          na.rm = TRUE), 0),
-      `Avg IVB`  = round(mean(InducedVertBreak,  na.rm = TRUE), 1),
-      `Avg HB`   = round(mean(HorzBreak,         na.rm = TRUE), 1),
-      `VAA`      = round(mean(VertApprAngle,     na.rm = TRUE), 1),
-      `HAA`      = round(mean(HorzApprAngle,     na.rm = TRUE), 1),
-      `hRel`     = round(mean(RelSide,           na.rm = TRUE), 1),
-      `vRel`     = round(mean(RelHeight,         na.rm = TRUE), 1),
-      `Ext`      = round(mean(Extension,         na.rm = TRUE), 2),
-      `Strike%`  = 100 * sum(!PitchCall %in% c("BallCalled","BallinDirt","BallIntentional")) / dplyr::n(),
+      `Usage%`   = round(100 * dplyr::n() / nrow(pitcher_data), 1),
+      `Avg Velo` = round(mean(RelSpeed, na.rm = TRUE), 1),
+      `Max Velo` = round(max(RelSpeed, na.rm = TRUE), 1),
+      `Avg Spin` = round(mean(SpinRate, na.rm = TRUE), 0),
+      `Avg IVB`  = round(mean(InducedVertBreak, na.rm = TRUE), 1),
+      `Avg HB`   = round(mean(HorzBreak, na.rm = TRUE), 1),
+      `VAA`      = round(mean(VertApprAngle, na.rm = TRUE), 1),
+      `HAA`      = round(mean(HorzApprAngle, na.rm = TRUE), 1),
+      `hRel`     = round(mean(RelSide, na.rm = TRUE), 1),
+      `vRel`     = round(mean(RelHeight, na.rm = TRUE), 1),
+      `Ext`      = round(mean(Extension, na.rm = TRUE), 2),
+      `Strike%`  = round(100 * sum(!PitchCall %in% c("BallCalled","BallinDirt","BallIntentional")) / dplyr::n(), 1),
       `Whiff%`   = ifelse(sum(SwingIndicator, na.rm = TRUE) > 0,
-                          100 * sum(WhiffIndicator, na.rm = TRUE) / sum(SwingIndicator, na.rm = TRUE), 0),
-      `Zone%`    = 100 * sum(StrikeZoneIndicator, na.rm = TRUE) / dplyr::n(),
+                          round(100 * sum(WhiffIndicator, na.rm = TRUE) / sum(SwingIndicator, na.rm = TRUE), 1), 0),
+      `Zone%`    = round(100 * sum(StrikeZoneIndicator, na.rm = TRUE) / dplyr::n(), 1),
       `Stuff+`   = round(mean(stuff_plus, na.rm = TRUE), 1),
       .groups = "drop"
     ) %>%
     dplyr::arrange(dplyr::desc(`Usage%`))
   
-  # IMPORTANT: Remove duplicate columns FIRST, before creating color matrix
+  # CRITICAL: Remove duplicate columns FIRST before creating color matrix
   dup_mask <- duplicated(names(pitch_stats))
   if (any(dup_mask)) {
     message("Removing ", sum(dup_mask), " duplicate columns from pitch_stats")
     pitch_stats <- pitch_stats[, !dup_mask, drop = FALSE]
   }
   
-  # NOW create the color matrix with the FINAL dimensions
-  num_cols <- ncol(pitch_stats)
+  # NOW get final dimensions and create color matrix
   num_rows <- nrow(pitch_stats)
+  num_cols <- ncol(pitch_stats)
   color_matrix <- matrix("#FFFFFF", nrow = max(1, num_rows), ncol = max(1, num_cols))
   
-  # Define col_idx AFTER deduplication so indices are correct
-  col_idx <- function(nm) match(nm, names(pitch_stats))
+  if (num_rows == 0) {
+    return(list(stats = pitch_stats, colors = color_matrix))
+  }
+  
+  # Get column indices AFTER deduplication
+  col_idx <- function(nm) {
+    idx <- match(nm, names(pitch_stats))
+    if (is.na(idx)) return(NA_integer_)
+    idx
+  }
+  
   c_avg_velo <- col_idx("Avg Velo")
   c_max_velo <- col_idx("Max Velo")
   c_spin     <- col_idx("Avg Spin")
@@ -2423,6 +2437,11 @@ create_advanced_pitch_characteristics <- function(data, player_name) {
   c_stuff    <- col_idx("Stuff+")
   c_ext      <- col_idx("Ext")
   
+  # Helper to safely check index validity
+  valid_idx <- function(idx) {
+    !is.na(idx) && is.numeric(idx) && length(idx) == 1 && idx >= 1 && idx <= num_cols
+  }
+  
   for (i in seq_len(num_rows)) {
     pt <- pitch_stats$Pitch[i]
     
@@ -2447,27 +2466,27 @@ create_advanced_pitch_characteristics <- function(data, player_name) {
         vb_r <- sec_ref$velo_r %||% NA_real_
         velo_bench <- if (identical(pitcher_hand, "Left")) vb_l else vb_r
       }
-      if (!is.na(velo_bench) && has_col_index(c_avg_velo) && c_avg_velo <= num_cols)
+      if (!is.na(velo_bench) && valid_idx(c_avg_velo))
         color_matrix[i, c_avg_velo] <- get_gradient_color(pitch_stats$`Avg Velo`[i], velo_bench, "higher_better", 0.05)
-      if (!is.na(velo_bench) && has_col_index(c_max_velo) && c_max_velo <= num_cols)
+      if (!is.na(velo_bench) && valid_idx(c_max_velo))
         color_matrix[i, c_max_velo] <- get_gradient_color(pitch_stats$`Max Velo`[i], velo_bench, "higher_better", 0.05)
     }
     
-    if (!is.null(sec_ref) && has_col_index(c_spin) && c_spin <= num_cols && !is.null(sec_ref$spin))
-      color_matrix[i, c_spin]  <- get_gradient_color(pitch_stats$`Avg Spin`[i],  sec_ref$spin,   "higher_better", 0.20)
-    if (!is.null(sec_ref) && has_col_index(c_strk) && c_strk <= num_cols && !is.null(sec_ref$strike))
-      color_matrix[i, c_strk]  <- get_gradient_color(pitch_stats$`Strike%`[i],  sec_ref$strike, "higher_better", 0.15)
-    if (!is.null(sec_ref) && has_col_index(c_whiff) && c_whiff <= num_cols && !is.null(sec_ref$whiff))
-      color_matrix[i, c_whiff] <- get_gradient_color(pitch_stats$`Whiff%`[i],   sec_ref$whiff,  "higher_better", 0.30)
-    if (!is.null(sec_ref) && has_col_index(c_zone) && c_zone <= num_cols && !is.null(sec_ref$zone))
-      color_matrix[i, c_zone]  <- get_gradient_color(pitch_stats$`Zone%`[i],    sec_ref$zone,   "higher_better", 0.20)
+    if (!is.null(sec_ref) && valid_idx(c_spin) && !is.null(sec_ref$spin))
+      color_matrix[i, c_spin]  <- get_gradient_color(pitch_stats$`Avg Spin`[i], sec_ref$spin, "higher_better", 0.20)
+    if (!is.null(sec_ref) && valid_idx(c_strk) && !is.null(sec_ref$strike))
+      color_matrix[i, c_strk]  <- get_gradient_color(pitch_stats$`Strike%`[i], sec_ref$strike, "higher_better", 0.15)
+    if (!is.null(sec_ref) && valid_idx(c_whiff) && !is.null(sec_ref$whiff))
+      color_matrix[i, c_whiff] <- get_gradient_color(pitch_stats$`Whiff%`[i], sec_ref$whiff, "higher_better", 0.30)
+    if (!is.null(sec_ref) && valid_idx(c_zone) && !is.null(sec_ref$zone))
+      color_matrix[i, c_zone]  <- get_gradient_color(pitch_stats$`Zone%`[i], sec_ref$zone, "higher_better", 0.20)
     
-    if (has_col_index(c_stuff) && c_stuff <= num_cols) {
+    if (valid_idx(c_stuff)) {
       val <- pitch_stats$`Stuff+`[i]
       if (is.finite(val)) color_matrix[i, c_stuff] <- get_gradient_color(val, 100, "higher_better", 0.20)
     }
     
-    if (has_col_index(c_ext) && c_ext <= num_cols) {
+    if (valid_idx(c_ext)) {
       ext_bench <- sec_extension_benchmark(pt)
       if (is.finite(ext_bench)) {
         color_matrix[i, c_ext] <- get_gradient_color(pitch_stats$`Ext`[i], ext_bench, "higher_better", 0.08)
@@ -2477,7 +2496,6 @@ create_advanced_pitch_characteristics <- function(data, player_name) {
   
   list(stats = pitch_stats, colors = color_matrix)
 }
-
              
 create_movement_plot <- create_pitcher_movement_plot
 
@@ -2732,31 +2750,63 @@ create_advanced_pitcher_pdf <- function(game_df, pitcher_name, output_file) {
   
   .text_on_fill <- function(hex) {
     if (is.na(hex) || !nzchar(hex)) return("black")
-    rgb <- grDevices::col2rgb(hex) / 255
-    L <- 0.2126*rgb[1] + 0.7152*rgb[2] + 0.0722*rgb[3]
-    ifelse(L < 0.5, "white", "black")
+    tryCatch({
+      rgb <- grDevices::col2rgb(hex) / 255
+      L <- 0.2126*rgb[1] + 0.7152*rgb[2] + 0.0722*rgb[3]
+      ifelse(L < 0.5, "white", "black")
+    }, error = function(e) "black")
+  }
+  
+  # Safe cell accessor - handles missing columns gracefully
+  get_cell_value <- function(df, colname, row_idx) {
+    if (is.null(df) || !is.data.frame(df)) return(NA)
+    if (is.null(colname) || !nzchar(colname)) return(NA)
+    if (!(colname %in% names(df))) return(NA)
+    if (row_idx < 1 || row_idx > nrow(df)) return(NA)
+    tryCatch(df[[colname]][row_idx], error = function(e) NA)
   }
   
   pitcher_df <- dplyr::filter(game_df, Pitcher == pitcher_name)
   if (nrow(pitcher_df) == 0) {
     pdf(output_file, width = 11, height = 14)
     grid::grid.newpage()
-    grid::grid.text("No data available for this pitcher",
+    grid::grid.text(paste("No data available for", pitcher_name),
                     gp = grid::gpar(fontsize = 16, fontface = "bold"))
     dev.off()
     return(output_file)
   }
   
-  summary_result <- create_advanced_pitcher_summary(pitcher_df, pitcher_name)
+  game_day <- tryCatch(parse_game_day(pitcher_df), error = function(e) Sys.Date())
+  
+  # Get summary stats with error handling
+  summary_result <- tryCatch(
+    create_advanced_pitcher_summary(pitcher_df, pitcher_name),
+    error = function(e) {
+      message("Error in summary: ", e$message)
+      list(stats = data.frame(IP=0, R=0, BF=0, K=0, BB=0, H=0, check.names=FALSE), 
+           colors = rep("#FFFFFF", 6))
+    }
+  )
   summary_stats  <- summary_result$stats
   summary_colors <- summary_result$colors
   
-  pitch_result        <- create_advanced_pitch_characteristics(pitcher_df, pitcher_name)
-  pitch_char          <- pitch_result$stats
+  # Get pitch characteristics with error handling
+  pitch_result <- tryCatch(
+    create_advanced_pitch_characteristics(pitcher_df, pitcher_name),
+    error = function(e) {
+      message("Error in pitch characteristics: ", e$message)
+      list(
+        stats = data.frame(Pitch = "-", Count = 0, `Usage%` = NA_real_, check.names = FALSE),
+        colors = matrix("#FFFFFF", nrow = 1, ncol = 3)
+      )
+    }
+  )
+  pitch_char <- pitch_result$stats
   pitch_colors_matrix <- pitch_result$colors
   
-  if (nrow(pitch_char) == 0) {
-    pitch_char <- tibble::tibble(
+  # Handle empty or NULL pitch_char
+  if (is.null(pitch_char) || nrow(pitch_char) == 0) {
+    pitch_char <- data.frame(
       Pitch = "-", Count = 0, `Usage%` = NA_real_,
       `Avg Velo` = NA_real_, `Max Velo` = NA_real_,
       `Avg Spin` = NA_real_, 
@@ -2765,58 +2815,92 @@ create_advanced_pitcher_pdf <- function(game_df, pitcher_name, output_file) {
       `hRel`     = NA_real_, `vRel`     = NA_real_, `Ext` = NA_real_,
       `Strike%`  = NA_real_, `Whiff%`   = NA_real_,
       `Zone%`    = NA_real_, 
-      `Stuff+`   = NA_real_
+      `Stuff+`   = NA_real_,
+      check.names = FALSE
     )
+    pitch_colors_matrix <- matrix("#FFFFFF", nrow = 1, ncol = ncol(pitch_char))
   }
   
+  # Limit rows to max 9
   max_rows_to_show <- min(nrow(pitch_char), 9)
   if (nrow(pitch_char) > max_rows_to_show) {
-    pitch_char <- pitch_char %>% dplyr::slice(1:max_rows_to_show)
+    pitch_char <- pitch_char[1:max_rows_to_show, , drop = FALSE]
   }
-  pitch_colors_matrix <- sync_color_matrix_to_df(pitch_colors_matrix, pitch_char, fill = "#FFFFFF")
   
-  movement_plot <- create_movement_plot(pitcher_df, pitcher_name, pitch_colors)
-  velo_plot     <- create_velocity_distribution_plot(pitcher_df, pitcher_name, pitch_colors)
-  location_lhb  <- create_location_by_result_plot(pitcher_df, pitcher_name, "Left",  pitch_colors)
-  location_rhb  <- create_location_by_result_plot(pitcher_df, pitcher_name, "Right", pitch_colors)
-  count_plot    <- create_count_usage_plot(pitcher_df, pitcher_name, pitch_colors)
+  # Get final dimensions
+  num_rows <- nrow(pitch_char)
+  num_cols <- ncol(pitch_char)
   
+  # CRITICAL: Rebuild color matrix to EXACTLY match pitch_char dimensions
+  new_color_matrix <- matrix("#FFFFFF", nrow = num_rows, ncol = num_cols)
+  if (!is.null(pitch_colors_matrix) && is.matrix(pitch_colors_matrix)) {
+    rows_to_copy <- min(nrow(pitch_colors_matrix), num_rows)
+    cols_to_copy <- min(ncol(pitch_colors_matrix), num_cols)
+    if (rows_to_copy > 0 && cols_to_copy > 0) {
+      new_color_matrix[1:rows_to_copy, 1:cols_to_copy] <- 
+        pitch_colors_matrix[1:rows_to_copy, 1:cols_to_copy]
+    }
+  }
+  pitch_colors_matrix <- new_color_matrix
+  
+  # Create plots with error handling
+  movement_plot <- tryCatch(
+    create_movement_plot(pitcher_df, pitcher_name, pitch_colors),
+    error = function(e) ggplot2::ggplot() + ggplot2::theme_void() + ggplot2::ggtitle("Movement Plot Error")
+  )
+  velo_plot <- tryCatch(
+    create_velocity_distribution_plot(pitcher_df, pitcher_name, pitch_colors),
+    error = function(e) ggplot2::ggplot() + ggplot2::theme_void() + ggplot2::ggtitle("Velocity Plot Error")
+  )
+  location_lhb <- tryCatch(
+    create_location_by_result_plot(pitcher_df, pitcher_name, "Left", pitch_colors),
+    error = function(e) ggplot2::ggplot() + ggplot2::theme_void() + ggplot2::ggtitle("LHB Location Error")
+  )
+  location_rhb <- tryCatch(
+    create_location_by_result_plot(pitcher_df, pitcher_name, "Right", pitch_colors),
+    error = function(e) ggplot2::ggplot() + ggplot2::theme_void() + ggplot2::ggtitle("RHB Location Error")
+  )
+  count_plot <- tryCatch(
+    create_count_usage_plot(pitcher_df, pitcher_name, pitch_colors),
+    error = function(e) ggplot2::ggplot() + ggplot2::theme_void() + ggplot2::ggtitle("Count Usage Error")
+  )
+  
+  # Start PDF
   pdf(output_file, width = 11, height = 14)
   on.exit(try(dev.off(), silent = TRUE), add = TRUE)
   grid::grid.newpage()
   
-  header_y_top   <- 0.98
-  
+  # Layout calculations
+  header_y_top    <- 0.98
   charts_y_top    <- 0.85
   charts_height   <- 0.30
   charts_y_bottom <- charts_y_top - charts_height
-  
-  count_y_top    <- charts_y_bottom - 0.02
-  count_height   <- 0.18
-  count_y_bottom <- count_y_top - count_height
-  
-  base_loc_top <- 0.30
-  table_margin <- 0.03
-  min_row_h    <- 0.0125
-  max_row_h    <- 0.0180
+  count_y_top     <- charts_y_bottom - 0.02
+  count_height    <- 0.18
+  count_y_bottom  <- count_y_top - count_height
+  base_loc_top    <- 0.30
+  table_margin    <- 0.03
+  min_row_h       <- 0.0125
+  max_row_h       <- 0.0180
   
   y_top_char_orig <- count_y_bottom - 0.011
-  rows_including_header <- nrow(pitch_char) + 1
+  rows_including_header <- num_rows + 1
   available_for_table_orig <- y_top_char_orig - (base_loc_top + table_margin)
-  row_h_char <- min(max_row_h, max(min_row_h, available_for_table_orig / rows_including_header))
+  row_h_char <- min(max_row_h, max(min_row_h, available_for_table_orig / max(1, rows_including_header)))
   y_loc_top <- y_top_char_orig - rows_including_header * row_h_char - (table_margin * 0.5)
   
   table_lower_offset <- 0.025
   y_top_char <- y_top_char_orig - table_lower_offset
-  
   available_for_table <- y_top_char - (base_loc_top + table_margin)
-  row_h_char <- min(max_row_h, max(min_row_h, available_for_table / rows_including_header))
+  row_h_char <- min(max_row_h, max(min_row_h, available_for_table / max(1, rows_including_header)))
   
+  # Header
   grid::pushViewport(grid::viewport(x = 0.5, y = header_y_top, width = 1, height = 0.04, just = c("center","top")))
   grid::grid.text(paste(pitcher_name, "- Advanced Pitcher Report"),
                   gp = grid::gpar(fontface = "bold", cex = 1.8, col = "#006F71"))
   grid::popViewport()
   
+  # Summary section
   grid::grid.text("Summary", x = 0.5, y = 0.94,
                   gp = grid::gpar(fontface = "bold", cex = 1.1, col = "#006F71"))
   
@@ -2844,29 +2928,44 @@ create_advanced_pitcher_pdf <- function(game_df, pitcher_name, output_file) {
                     gp = grid::gpar(cex = 0.62))
   }
   
+  # Movement plot
   grid::pushViewport(grid::viewport(x = 0.25, y = charts_y_top, width = 0.45, height = charts_height, just = c("center","top")))
-  print(movement_plot, newpage = FALSE)
+  tryCatch(print(movement_plot, newpage = FALSE), error = function(e) NULL)
   grid::popViewport()
   
+  # Velocity plot
   grid::pushViewport(grid::viewport(x = 0.75, y = charts_y_top, width = 0.45, height = charts_height, just = c("center","top")))
-  print(velo_plot, newpage = FALSE)
+  tryCatch(print(velo_plot, newpage = FALSE), error = function(e) NULL)
   grid::popViewport()
   
+  # Count plot
   grid::pushViewport(grid::viewport(x = 0.5, y = count_y_top, width = 0.92, height = count_height, just = c("center","top")))
-  print(count_plot, newpage = FALSE)
+  tryCatch(print(count_plot, newpage = FALSE), error = function(e) NULL)
   grid::popViewport()
   
+  # Pitch Characteristics table
   grid::grid.text("Pitch Characteristics", x = 0.5, y = y_top_char + 0.015,
                   gp = grid::gpar(fontface = "bold", cex = 1.1, col = "#006F71"))
   
   char_headers  <- names(pitch_char)
   num_char_cols <- length(char_headers)
   
-  char_widths   <- c(0.10, rep((1 - 0.10 - 0.06) / max(1, (num_char_cols - 1)), max(0, num_char_cols - 1)))
-  x_start_char  <- 0.5 - sum(char_widths)/2
-  x_pos_char    <- c(x_start_char, x_start_char + cumsum(char_widths[-length(char_widths)]))
+  # Calculate column widths safely
+  if (num_char_cols > 1) {
+    char_widths <- c(0.10, rep((1 - 0.10 - 0.06) / (num_char_cols - 1), num_char_cols - 1))
+  } else {
+    char_widths <- c(0.10)
+  }
+  
+  x_start_char <- 0.5 - sum(char_widths)/2
+  x_pos_char   <- c(x_start_char)
+  if (length(char_widths) > 1) {
+    x_pos_char <- c(x_start_char, x_start_char + cumsum(char_widths[-length(char_widths)]))
+  }
   
+  # Draw header row
   for (i in seq_along(char_headers)) {
+    if (i > length(x_pos_char) || i > length(char_widths)) break
     grid::grid.rect(x = x_pos_char[i], y = y_top_char, width = char_widths[i]*0.985, height = row_h_char,
                     just = c("left","top"), gp = grid::gpar(fill = "#006F71", col = "black", lwd = 0.5))
     grid::grid.text(char_headers[i],
@@ -2874,34 +2973,38 @@ create_advanced_pitcher_pdf <- function(game_df, pitcher_name, output_file) {
                     gp = grid::gpar(col = "white", cex = 0.50, fontface = "bold"))
   }
   
-  get_cell_scalar <- function(df, colname, r) {
-    if (!nzchar(colname) || is.null(df) || !is.data.frame(df)) return(NA)
-    if (!(colname %in% names(df))) return(NA)
-    col <- df[[colname]]
-    if (length(col) < r || r < 1) return(NA)
-    col[r]
-  }
-  
+  # Find Pitch column index
   i_col_pitch  <- match("Pitch", char_headers)
   has_pitchcol <- !is.na(i_col_pitch) && i_col_pitch >= 1
   
-  for (r in seq_len(nrow(pitch_char))) {
+  # Draw data rows
+  for (r in seq_len(num_rows)) {
     y_row <- y_top_char - r * row_h_char
-    pitch_name <- if (has_pitchcol) as.character(get_cell_scalar(pitch_char, "Pitch", r)) else NA_character_
+    pitch_name <- if (has_pitchcol) as.character(get_cell_value(pitch_char, "Pitch", r)) else NA_character_
     
     for (i in seq_along(char_headers)) {
+      if (i > length(x_pos_char) || i > length(char_widths)) break
+      if (i > num_cols) break
+      
       colname <- char_headers[i]
       
-      bg <- safe_color_at(pitch_colors_matrix, r, i, default = "#FFFFFF")
+      # Get background color safely - check bounds explicitly
+      bg <- "#FFFFFF"
+      if (r >= 1 && r <= nrow(pitch_colors_matrix) && i >= 1 && i <= ncol(pitch_colors_matrix)) {
+        bg <- pitch_colors_matrix[r, i]
+        if (is.na(bg) || !nzchar(bg)) bg <- "#FFFFFF"
+      }
       
-      if (has_pitchcol && identical(colname, "Pitch") && !is.na(pitch_name) && !is.null(pitch_colors[[pitch_name]])) {
+      # Override for Pitch column with pitch type color
+      if (has_pitchcol && identical(colname, "Pitch") && !is.na(pitch_name) && pitch_name %in% names(pitch_colors)) {
         bg <- pitch_colors[[pitch_name]]
       }
       
       grid::grid.rect(x = x_pos_char[i], y = y_row, width = char_widths[i]*0.985, height = row_h_char,
                       just = c("left","top"), gp = grid::gpar(fill = bg, col = "grey80", lwd = 0.3))
       
-      val <- get_cell_scalar(pitch_char, colname, r)
+      # Get value safely
+      val <- get_cell_value(pitch_char, colname, r)
       
       display_val <- if (is.numeric(val)) {
         if (is.na(val) || is.nan(val) || is.infinite(val)) "-" else sprintf("%.1f", val)
@@ -2919,14 +3022,16 @@ create_advanced_pitcher_pdf <- function(game_df, pitcher_name, output_file) {
     }
   }
   
+  # Location plots
   grid::pushViewport(grid::viewport(x = 0.25, y = y_loc_top, width = 0.45, height = 0.24, just = c("center","top")))
-  print(location_lhb, newpage = FALSE)
+  tryCatch(print(location_lhb, newpage = FALSE), error = function(e) NULL)
   grid::popViewport()
   
   grid::pushViewport(grid::viewport(x = 0.75, y = y_loc_top, width = 0.45, height = 0.24, just = c("center","top")))
-  print(location_rhb, newpage = FALSE)
+  tryCatch(print(location_rhb, newpage = FALSE), error = function(e) NULL)
   grid::popViewport()
   
+  # Footer
   grid::grid.text("Red: Below SEC Avg, White: Near SEC Avg, Green: Above SEC Avg | Stuff+ predicts pitch effectiveness; 100 is average, 10 = one SD",
                   x = 0.5, y = 0.04, gp = grid::gpar(cex = 0.82, col = "grey40", fontface = "italic"))
   grid::grid.text("Data: TrackMan | Report Generated: Coastal Carolina Baseball",
@@ -2935,6 +3040,7 @@ create_advanced_pitcher_pdf <- function(game_df, pitcher_name, output_file) {
   invisible(output_file)
 }
 
+           
 # =====================================================================
 # ===========================    UI    ================================
 # =====================================================================