Merge branch 'develop' into 'vaep'

# Conflicts:
#   R/read_rcl.R

R/detect_foul.R

+detect_foul <- function(path) {
+  rcl <- path |> readr::read_lines()
+
+  foul_actions <- c()
+
+  count <- 1
+
+  for (i in rcl) {
+    str <- stringr::str_extract(i, "foul_\\w+_(l|r)")
+    if (!is.na(str)) {
+      foul_actions <- c(foul_actions, rcl[count - 1])
+    }
+    count <- count + 1
+  }
+
+  foul_actions <- foul_actions |>
+    tibble::as_tibble() |>
+    dplyr::mutate(
+      step = value |> stringr::str_extract("\\d+") |> as.numeric(),
+      agent = value |> stringr::str_extract("\\w+_([0-9]{1,2}|Coach)"),
+      team = agent |> stringr::str_remove("_([0-9]{1,2}|Coach)"),
+      unum = agent |> stringr::str_extract("([0-9]{1,2}|Coach)$"),
+      commands = value |>
+        stringr::str_extract("\\(.+\\)$") |>
+        purrr::map(~ .x |>
+          stringr::str_split("\\(|\\)", simplify = TRUE) |>
+          stringr::str_trim() |>
+          purrr::discard(~ .x == "")),
+    ) |>
+    tidyr::unnest(commands) |>
+    dplyr::mutate(
+      commands = commands |> stringr::str_split("\\ ", n = 2),
+      command  = commands |> purrr::map_chr(1),
+      args     = commands |> purrr::map(~ .x[-1]),
+    ) |>
+    dplyr::select(
+      step,
+      team,
+      unum,
+      command,
+      args,
+      # line = value,
+    ) |>
+    dplyr::filter(command == "tackle")
+
+  return(foul_actions)
+}

R/make_data.R

+get_player <- function(rcg, name) {
+    output <- rcg |>
+        dplyr::inner_join(name, by = "side") |>
+        dplyr::filter(is.na(stime)) |>
+        dplyr::select(
+            step,
+            team = name,
+            side,
+            unum,
+            px = x,
+            py = y,
+            pvx = vx,
+            pvy = vy,
+            body,
+            neck,
+        )
+
+    return(output)
+}
+
+get_action <- function(rcl, ball, players) {
+    output <- rcl |>
+        dplyr::filter(command == "kick" | command == "tackle") |>
+        dplyr::mutate(
+            x = args |> stringr::str_extract("[0-9\\-\\.]+"),
+            l1 = args |> stringr::str_remove(x),
+            y = l1 |> stringr::str_extract("[0-9\\-\\.]+"),
+            unum = as.numeric(unum)
+        ) |>
+        dplyr::select(
+            step,
+            team,
+            unum,
+            command,
+            ax = x,
+            ay = y,
+        ) |>
+        dplyr::inner_join(ball, by = "step") %>%
+        dplyr::inner_join(players, by = c("step", "team", "unum")) %>%
+        dplyr::mutate(after_team = lead(team)) %>%
+        dplyr::mutate(a_sameteam = (after_team == team)) %>%
+        dplyr::mutate(tackle_scc = (command == "tackle" & a_sameteam)) %>%
+        dplyr::mutate(a_tackle_scc = lead(tackle_scc)) %>%
+        dplyr::select(-c(after_team, a_sameteam))
+
+    return(output)
+}
+
+get_tackle <- function(action) {
+    output <- action %>%
+        dplyr::filter(command == "tackle") %>%
+        dplyr::select(-c(a_tackle_scc, ax, ay))
+    return(output)
+}
+
+
+
+get_kick_log <- function(action) {
+  output <- action %>%
+    dplyr::filter(command == "kick") %>%
+    dplyr::mutate(before_team = lag(team)) %>%
+    dplyr::mutate(before_unum = lag(unum)) %>%
+    dplyr::mutate(after_team = lead(team)) %>%
+    dplyr::mutate(after_unum = lead(unum)) %>%
+    dplyr::mutate(b_sameteam = (before_team == team)) %>%
+    dplyr::mutate(b_sameunum = (before_unum == unum)) %>%
+    dplyr::mutate(a_sameteam = (after_team == team)) %>%
+    dplyr::mutate(a_sameunum = (after_unum == unum))
+  
+  output$b_sameteam[1] <- TRUE
+  output$b_sameunum[1] <- FALSE
+  
+  output <- output %>%
+    dplyr::mutate(dribble = (a_sameteam & a_sameunum)) %>%
+    dplyr::mutate(pass = (a_sameteam & !a_sameunum)) %>%
+    group_by(grc = cumsum(!dribble)) %>%
+    mutate(touch = row_number()) %>%
+    ungroup() %>%
+    select(-c(tackle_scc, grc, before_team, before_unum, b_sameteam, b_sameunum, after_team, after_unum, a_sameteam, a_sameunum))
+  return(output)
+}
+
+get_kick <- function(action) {
+    output <- action %>%
+        dplyr::filter(command == "kick") %>%
+        dplyr::mutate(after_team = lead(team)) %>%
+        dplyr::mutate(after_unum = lead(unum)) %>%
+        dplyr::mutate(a_sameteam = (after_team == team)) %>%
+        dplyr::mutate(a_sameunum = (after_unum == unum)) %>%
+        select(-c(command, pvx, pvy, body, neck)) %>% 
+        dplyr::mutate(next_ball_x = lead(ball_x)) %>%
+        dplyr::mutate(next_ball_y = lead(ball_y))
+
+
+    return(output)
+}
+
+get_action_Allplayer <- function(players,action){
+  action <- action  %>% 
+    dplyr::select(step,action_team=team,ball_x,ball_y,pass,dribble)
+  output <- players  %>% 
+    dplyr::inner_join(action,by = "step")
+  return(output)
+}
+
+get_pass_Allplayer <- function(players,pass){
+    pass <- pass  %>% 
+        dplyr::select(step,ax,ay,pass_team=team,ball_x,ball_y,ball_vx,ball_vy,pass_scc)
+    output <- players  %>% 
+        dplyr::inner_join(pass,by = "step")
+    return(output)
+}
+
+get_dribble_Allplayer <- function(players,dribble){
+    dribble <- dribble  %>% 
+        dplyr::select(step,dribble_team=team,ball_x,ball_y,dribble_scc)
+    output <- players  %>% 
+        dplyr::inner_join(dribble,by = "step")
+    return(output)
+}
+
+get_pass <- function(kick) {
+    output <- kick %>%
+        dplyr::mutate(pass_scc = (a_sameteam & !a_sameunum)) %>%
+        dplyr::mutate(pass = ((a_sameteam & !a_sameunum) | (!a_tackle_scc & !a_sameteam))) %>%
+        dplyr::filter(pass) %>%
+        distinct(step,.keep_all=TRUE) %>%
+        select(-c(a_tackle_scc,tackle_scc, pass, a_sameteam, a_sameunum, after_team, after_unum))
+
+    return(output)
+}
+
+
+
+
+get_dribble <- function(kick) {
+    output <- kick %>%
+        dplyr::mutate(dribble = ((!a_sameteam & a_tackle_scc) | (a_sameteam & a_sameunum))) %>%
+        dplyr::mutate(dribble_scc = (a_sameteam & a_sameunum)) %>%
+        group_by(grc = cumsum(!dribble)) %>%
+        mutate(touch = row_number()) %>%
+        ungroup() %>%
+        dplyr::filter(dribble) %>%
+        select(-c(a_tackle_scc,tackle_scc, dribble, a_sameteam, a_sameunum, after_team, after_unum, dribble, grc))
+
+    return(output)
+}
+
+read_referee <- function(path_rcl) {
+    referee <- path_rcl |>
+        readr::read_lines() |>
+        tibble::as_tibble() |>
+        dplyr::mutate(
+            step = value |> stringr::str_extract("\\d+"),
+            command = value |>
+                stringr::str_extract("referee [a-zA-Z0-9_]*") |>
+                stringr::str_remove("referee "),
+            step = as.numeric(step),
+        ) |>
+        dplyr::select(
+            step,
+            command,
+        ) %>%
+        tidyr::drop_na()
+
+
+    return(referee)
+}
+
+read_goal <- function(referee, name) {
+    goal <- referee |>
+        dplyr::filter(stringr::str_detect(command, "goal_[rl]_[0-9]+")) |>
+        dplyr::mutate(
+            side = command |>
+                stringr::str_remove("goal_") |>
+                stringr::str_extract("[rl]"),
+            score = command |>
+                stringr::str_remove("goal_[rl]_") |>
+                stringr::str_extract("[0-9]+"),
+        ) |>
+        dplyr::inner_join(name, by = "side") |>
+        dplyr::select(
+            step,
+            side,
+            name,
+            score,
+        ) %>%
+        tidyr::drop_na()
+
+    return(goal)
+}
+
+before_goal <- function(kick_log, goal_step, goal_team) {
+    playlist <- kick_log %>%
+        dplyr::arrange(desc(step)) %>%
+        dplyr::filter(
+            step > goal_step - 100,
+            step < goal_step,
+            team == goal_team,
+        )
+}
+
+get_goal_playlist <- function(kick_log, goal) {
+    if (length(goal$step) < 1) {
+        return(NA)
+    }
+    i <- 1
+    output <- before_goal(kick_log, goal$step[i], goal$name[i])
+    i <- i + 1
+    while (i <= length(goal$step)) {
+        # print(i)
+        i_list <- before_goal(kick_log, goal$step[i], goal$name[i])
+        output <- output |> bind_rows(i_list)
+        i <- i + 1
+    }
+    # for(i in goal$step){
+    #   i_list <- before_goal(kick_log,goal$step[i],goal$name[i])
+    #   output <- output |> bind_rows(i_list)
+    #   print(i)
+    # }
+    return(output)
+}
+
+convert_by_step <- function(rcg, rcl) {
+    output <- dplyr::inner_join(rcg, rcl, by = "step")
+    return(output)
+}
+
+get_dribble_point <- function(log_data) {
+    output <- log_data %>% filter(dribble == TRUE, pass == FALSE)
+    return(output)
+}
+
+get_pass_point <- function(log_data) {
+    output <- log_data %>% filter(pass == TRUE)
+    return(output)
+}
+
+get_tackle_point <- function(log_data) {
+    output <- log_data %>% filter(tackle == TRUE)
+    return(output)
+}
+
+get_rcl <- function(path_rcl) {
+    output <- path_rcl |> read_rcl()
+    return(output)
+}
+
+get_name <- function(path_rcg) {
+    team_name <- path_rcg |>
+        stringr::str_extract("[a-zA-Z0-9_-]*.rcg") |>
+        stringr::str_remove("[0-9]*-") |>
+        stringr::str_remove(".rcl")
+    l_team <- team_name |>
+        stringr::str_extract("[a-zA-Z0-9_]*-vs-") |>
+        stringr::str_remove("_[0-9]*-vs-")
+    r_team <- path_rcg |>
+        stringr::str_extract("[a-zA-Z0-9_]*.rcg") |>
+        stringr::str_remove("_[0-9]*.rcg")
+    name_table <- tibble::tribble(
+        ~side, ~name,
+        "l", l_team,
+        "r", r_team,
+    )
+
+    return(name_table)
+}
+
+replase_rcg_to_rcl <- function(path_rcg) {
+    output <- path_rcg |> stringr::str_replace(pattern = ".rcg", replacement = ".rcl")
+}
+replase_rcl_to_rcg <- function(path_rcl) {
+    output <- path_rcl |> stringr::str_replace(pattern = ".rcl", replacement = ".rcg")
+}
+
+
+kick_dist <- function(rcg) {
+    ball_path <- rcg |>
+        dplyr::group_nest(step, ball_x, ball_y) |>
+        dplyr::mutate(
+            move_dist_x = ball_x - dplyr::lag(ball_x),
+            move_dist_y = ball_y - dplyr::lag(ball_y),
+            move_dist = sqrt(move_dist_x^2 + move_dist_y^2),
+            move_dist = dplyr::if_else(is.na(move_dist), 0, move_dist)
+        ) |>
+        dplyr::filter(move_dist != 0 & move_dist < 40)
+}
+
+select_name <- function(data,name){
+    output <- data  %>% 
+        dplyr::filter(team %in% name)
+    return(output)
+}
+
+get_AttackLine <- function(data){
+    output <- data  %>%
+        dplyr::group_by(step) %>% 
+        filter(px == max(px)) %>% 
+        dplyr::select(
+          step,
+          pass_team,
+          pass_scc,
+          AL=px
+          )
+    return(output)
+}
+
+get_DefendLine <- function(data){
+    output <- data  %>%
+        dplyr::group_by(step) %>% 
+        filter(px == min(px)) %>% 
+        dplyr::select(step,DL=px)
+    return(output)
+}
+
+get_MedianLine <- function(data){
+    output <- data  %>%
+        dplyr::group_by(step) %>% 
+        dplyr::summarize(ML=median(px)) %>% 
+        dplyr::select(step,ML)
+    return(output)
+}
+
+get_DynamicPressureLine <- function(data){
+    data <- data  %>% 
+        filter(unum != 1)
+    ad <- get_AttackLine(data)
+    dd <- get_DefendLine(data)
+    md <- get_MedianLine(data)
+    output <- dplyr::inner_join(ad,dd,by = "step") %>% 
+              dplyr::inner_join(md,by = "step") %>%
+              distinct(step,.keep_all=TRUE)
+    return(output)
+}
\ No newline at end of file

R/make_graphics.R

+DEFAULT_MAX_PLAYER <- 11
+DEFAULT_PITCH_LENGTH <- 105.0
+DEFAULT_PITCH_WIDTH <- 70.0
+DEFAULT_PITCH_MARGIN <- 5.0
+DEFAULT_CENTER_CIRCLE_R <- 9.15
+DEFAULT_PENALTY_AREA_LENGTH <- 16.5
+DEFAULT_PENALTY_AREA_WIDTH <- 40.32
+DEFAULT_PENALTY_CIRCLE_R <- 9.15
+DEFAULT_PENALTY_SPOT_DIST <- 11.0
+DEFAULT_GOAL_AREA_LENGTH <- 5.5
+DEFAULT_GOAL_AREA_WIDTH <- 18.32
+DEFAULT_GOAL_DEPTH <- 2.44
+# DEFAULT_CORNER_ARC_R <- 1.0
+half_p_l <- DEFAULT_PITCH_LENGTH/2
+half_p_w <- DEFAULT_PITCH_WIDTH/2
+penalty_x <- half_p_l - DEFAULT_PENALTY_AREA_LENGTH
+penalty_y <- DEFAULT_PENALTY_AREA_WIDTH/2
+goal_x <- half_p_l - DEFAULT_GOAL_AREA_LENGTH
+goal_y <- DEFAULT_GOAL_AREA_WIDTH/2
+
+
+
+make_field <- function(input_graph){
+    p <- input_graph +
+    
+    geom_hline(yintercept = 0, linetype = "solid")+
+    geom_vline(xintercept = 0, linetype = "solid")+
+    geom_linerange(aes(x=half_p_l, y=NULL, ymin=-half_p_w, ymax=half_p_w))+
+    geom_linerange(aes(x=-half_p_l, y=NULL, ymin=-half_p_w, ymax=half_p_w))+
+    geom_linerange(aes(x=NULL, y=half_p_w, xmin=-half_p_l, xmax=half_p_l))+
+    geom_linerange(aes(x=NULL, y=-half_p_w, xmin=-half_p_l, xmax=half_p_l))+
+
+    geom_point(size=0.1) +
+    geom_linerange(aes(x=penalty_x, y=NULL, ymin=-penalty_y, ymax=penalty_y))+
+    geom_linerange(aes(x=-penalty_x, y=NULL, ymin=-penalty_y, ymax=penalty_y))+
+    geom_linerange(aes(x=NULL, y=penalty_y, xmin=penalty_x, xmax=half_p_l))+
+    geom_linerange(aes(x=NULL, y=-penalty_y, xmin=penalty_x, xmax=half_p_l))+
+    geom_linerange(aes(x=NULL, y=penalty_y, xmax=-penalty_x, xmin=-half_p_l))+
+    geom_linerange(aes(x=NULL, y=-penalty_y, xmax=-penalty_x, xmin=-half_p_l))+
+
+    geom_linerange(aes(x=goal_x, y=NULL, ymin=-goal_y, ymax=goal_y))+
+    geom_linerange(aes(x=-goal_x, y=NULL, ymin=-goal_y, ymax=goal_y))+
+    geom_linerange(aes(x=NULL, y=goal_y, xmax=goal_x, xmin=half_p_l))+
+    geom_linerange(aes(x=NULL, y=-goal_y, xmax=goal_x, xmin=half_p_l))+
+    geom_linerange(aes(x=NULL, y=goal_y, xmin=-goal_x, xmax=-half_p_l))+
+    geom_linerange(aes(x=NULL, y=-goal_y, xmin=-goal_x, xmax=-half_p_l))+
+
+    ggforce::geom_circle(aes(x0 = 0, y0 = 0, r = DEFAULT_CENTER_CIRCLE_R),inherit.aes = FALSE)
+    return(p)
+}
+
+make_heatmap <- function(p_data){
+    p <- ggplot(data = p_data, aes(x = x, y = y )) +
+    ggplot2::coord_fixed(xlim=c(-half_p_l,half_p_l),ylim =c(-half_p_w,half_p_w))+ 
+    theme(text = element_text(size = 24)) +
+    geom_density_2d_filled(alpha = 0.7) +
+    labs(x = "x軸", y = "y軸",fill = "プレー割合") + 
+    theme_minimal(base_size = 6)
+
+    p <- p |> make_field()
+
+    return(p)
+}
+make_heatmap_ball <- function(p_data){
+    p <- ggplot(data = p_data, aes(x = ball_x, y = ball_y )) +
+    ggplot2::coord_fixed(xlim=c(-half_p_l,half_p_l),ylim =c(-half_p_w,half_p_w))+ 
+    theme(text = element_text(size = 24)) +
+    geom_density_2d_filled(alpha = 0.7) +
+    labs(x = "x軸", y = "y軸",fill = "プレー割合") + 
+    theme_minimal(base_size = 6)
+
+    p <- p |> make_field()
+
+    return(p)
+}
+make_kick_point <- function(p_data,input_graph){
+    p <- input_graph +
+    geom_point(data = p_data,colour = "red",size = 0.5,aes(x = as.numeric(ball_x), y = as.numeric(ball_y)))
+
+    return(p)
+}
+
+make_pass_point <- function(p_data,input_graph){
+    p <- input_graph +
+    geom_point(data = p_data,colour = "bule",size = 0.5,aes(x = as.numeric(ball_x), y = as.numeric(ball_y)))
+
+    return(p)
+}
+
+make_dribble_point <- function(p_data,input_graph){
+    p <- input_graph +
+    geom_point(data = p_data,colour = "green",size = 0.5,aes(x = as.numeric(ball_x), y = as.numeric(ball_y)))
+
+    return(p)
+}
+
+make_tackle_point <- function(p_data,input_graph){
+    p <- input_graph +
+    geom_point(data = p_data,colour = "",size = 0.5,aes(x = as.numeric(ball_x), y = as.numeric(ball_y)))
+
+    return(p)
+}
+
+make_ball_area <- function(rcg){
+    ball_path <- rcg |>
+        dplyr::group_nest(step, ball_x, ball_y) |>
+        dplyr::mutate(move_dist_x = ball_x - dplyr::lag(ball_x),
+                        move_dist_y = ball_y - dplyr::lag(ball_y),
+                        move_dist   = sqrt(move_dist_x^2 + move_dist_y^2),
+                        move_dist   = dplyr::if_else(is.na(move_dist), 0, move_dist)
+        ) |>
+        dplyr::filter(move_dist != 0 & move_dist < 40)
+
+    output <- ball_path |>
+        plotly::plot_ly(showlegend = FALSE) |>
+        plotly::add_markers(
+            data       = ball_path,
+            x          = ~ball_x,
+            y          = ~ball_y,
+            z          = ~move_dist,
+            marker     = list(color        = ~move_dist,
+                            size         = 3,
+                            colorscale   = "Viridis",
+                            opacity      = 0.8,
+                            showscale  = FALSE)
+        ) |>
+        plotly::add_paths(
+            data       = ball_path |>
+            dplyr::select(step, ball_x, ball_y, move_dist) |>
+            dplyr::mutate(base = 0) |>
+            tidyr::pivot_longer(c(move_dist, base)) |>
+            dplyr::group_by(step),
+            x          = ~ball_x,
+            y          = ~ball_y,
+            z          = ~value,
+            color      = ~value
+        ) |>
+        plotly::hide_colorbar() |>
+        plotly::layout(
+            scene = list(
+                xaxis  = list(title = "ボールのX座標"),
+                yaxis  = list(title = "ボールのY座標"),
+                zaxis  = list(title = "ボールの飛距離"),
+                camera = list(eye    = list(x = 0.8, y = -1.8, z =  0.8),
+                                center = list(x = 0.0, y =  0.0, z = -0.2))
+            )
+        )
+
+}
\ No newline at end of file

R/make_soccer_map.R

+make_soccer_map_pp <- function(rcg) {
+    soocer_field = c(6000,104,68)
+    names(soocer_field) = c("time","length","width")
+    soccer_map <- array(0, dim = c(6000,13,104,68))
+
+    for(i in seq_along(rcg)){
+        # SP - (x,y) location	1 on attacking players’ location (x,y)
+        px <- round(rcg$x[i])+soocer_field["length"]/2
+        py <- round(rcg$y[i])+soocer_field["width"]/2
+        bx <- round(rcg$ball_x[i])+soocer_field["length"]/2
+        by <- round(rcg$ball_y[i])+soocer_field["width"]/2
+        step <- rcg$step[i]
+        if(rcg$side[i]=="l"){
+            soccer_map[step,1,px,py] = rcg$unum[i]
+            soccer_map[step,3,px,py] = rcg$vx[i]
+            soccer_map[step,4,px,py] = rcg$vy[i]
+        }else if (rcg$side[i]=="r"){
+            soccer_map[step,2,px,py] = rcg$unum[i]
+            soccer_map[step,5,px,py] = rcg$vx[i]
+            soccer_map[step,6,px,py] = rcg$vy[i]
+        }
+        soccer_map[step,7,px,py] = atan(py/(soocer_field["length"]/2 - px))
+        dist_p_b = sqrt((bx-px)^2+(by-py)^2)
+        dist_p_g = sqrt(((soocer_field["length"]/2)-px)^2+(py)^2)
+
+        soccer_map[step,8,px,py] = (py-by) / dist_p_b
+        soccer_map[step,9,px,py] = (px-bx) / dist_p_b
+        soccer_map[step,10,px,py] = py / dist_p_g
+        soccer_map[step,11,px,py] = px / dist_p_g
+        soccer_map[step,12,px,py] = dist_p_b
+        soccer_map[step,13,px,py] = dist_p_g
+    }
+    return(soccer_map)
+}
+
+make_soccer_map_ps <- function(rcg) {
+    soocer_field = c(6000,104,68)
+    names(soocer_field) = c("time","length","width")
+    soccer_map <- array(0, dim = c(6000,13,104,68))
+
+    for(i in seq_along(rcg)){
+        # SP - (x,y) location	1 on attacking players’ location (x,y)
+        px <- round(rcg$x[i])+soocer_field["length"]/2
+        py <- round(rcg$y[i])+soocer_field["width"]/2
+        bx <- round(rcg$ball_x[i])+soocer_field["length"]/2
+        by <- round(rcg$ball_y[i])+soocer_field["width"]/2
+        step <- rcg$step[i]
+        if(rcg$side[i]=="l"){
+            soccer_map[step,1,px,py] = rcg$unum[i]
+            soccer_map[step,3,px,py] = rcg$vx[i]
+            soccer_map[step,4,px,py] = rcg$vy[i]
+        }else if (rcg$side[i]=="r"){
+            soccer_map[step,2,px,py] = rcg$unum[i]
+            soccer_map[step,5,px,py] = rcg$vx[i]
+            soccer_map[step,6,px,py] = rcg$vy[i]
+        }
+        soccer_map[step,7,px,py] = atan(py/(soocer_field["length"]/2 - px))
+        dist_p_b = sqrt((bx-px)^2+(by-py)^2)
+        dist_p_g = sqrt(((soocer_field["length"]/2)-px)^2+(py)^2)
+
+        soccer_map[step,8,px,py] = (py-by) / dist_p_b
+        soccer_map[step,9,px,py] = (px-bx) / dist_p_b
+        soccer_map[step,10,px,py] = py / dist_p_g
+        soccer_map[step,11,px,py] = px / dist_p_g
+        soccer_map[step,12,px,py] = dist_p_b
+        soccer_map[step,13,px,py] = dist_p_g
+    }
+    return(soccer_map)
+}
+
+make_soccer_map_pe <- function(rcg) {
+    soocer_field = c(6000,104,68)
+    names(soocer_field) = c("time","length","width")
+    soccer_map <- array(0, dim = c(6000,13,104,68))
+
+    for(i in seq_along(rcg)){
+        # SP - (x,y) location	1 on attacking players’ location (x,y)
+        px <- round(rcg$x[i])+soocer_field["length"]/2
+        py <- round(rcg$y[i])+soocer_field["width"]/2
+        bx <- round(rcg$ball_x[i])+soocer_field["length"]/2
+        by <- round(rcg$ball_y[i])+soocer_field["width"]/2
+        step <- rcg$step[i]
+        if(rcg$side[i]=="l"){
+            soccer_map[step,1,px,py] = rcg$unum[i]
+            soccer_map[step,3,px,py] = rcg$vx[i]
+            soccer_map[step,4,px,py] = rcg$vy[i]
+        }else if (rcg$side[i]=="r"){
+            soccer_map[step,2,px,py] = rcg$unum[i]
+            soccer_map[step,5,px,py] = rcg$vx[i]
+            soccer_map[step,6,px,py] = rcg$vy[i]
+        }
+        soccer_map[step,7,px,py] = atan(py/(soocer_field["length"]/2 - px))
+        dist_p_b = sqrt((bx-px)^2+(by-py)^2)
+        dist_p_g = sqrt(((soocer_field["length"]/2)-px)^2+(py)^2)
+
+        soccer_map[step,8,px,py] = (py-by) / dist_p_b
+        soccer_map[step,9,px,py] = (px-bx) / dist_p_b
+        soccer_map[step,10,px,py] = py / dist_p_g
+        soccer_map[step,11,px,py] = px / dist_p_g
+        soccer_map[step,12,px,py] = dist_p_b
+        soccer_map[step,13,px,py] = dist_p_g
+    }
+    return(soccer_map)
+}
\ No newline at end of file

R/read_old_rcg.R

+read_old_rcg_ball <- function(path_rcg){
+    ball_log <- path_rcg |>
+    readr::read_lines() |>
+    tibble::as_tibble() |>
+    dplyr::mutate(
+        step = value |> stringr::str_extract("\\(show ([0-9]*)*")
+                    |> stringr::str_remove("\\(show "),
+        ball = value |> stringr::str_extract("\\(\\(b\\)( [0-9\\-\\.]*)*\\)")
+            |> stringr::str_remove("\\(\\(b\\) ")
+            |> stringr::str_remove("\\)"),
+        ball_x = ball |> stringr::str_extract("[0-9\\-\\.]+"),
+        ball_y = ball |> stringr::str_remove(ball_x)
+            |> stringr::str_extract("[0-9\\-\\.]+"),
+        ball_vx = ball  |> stringr::str_remove(ball_x)
+            |> stringr::str_remove(ball_y)
+            |> stringr::str_extract("[0-9\\-\\.]+"),
+        ball_vy = ball  |> stringr::str_remove(ball_x)
+            |> stringr::str_remove(ball_y)
+            |> stringr::str_remove(ball_vx)
+            |> stringr::str_extract("[0-9\\-\\.]+"),
+        step = as.numeric(step),
+        # ball,
+        ball_x = as.numeric(ball_x),
+        ball_y = as.numeric(ball_y),
+        ball_vx = as.numeric(ball_vx),
+        ball_vy = as.numeric(ball_vy),
+    )|>
+    dplyr::select(
+        step,
+        # ball,
+        ball_x,
+        ball_y,
+        ball_vx,
+        ball_vy,
+    ) %>% tidyr::drop_na()
+    return(ball_log)
+}
+
+read_old_rcg_player <- function(path_rcg){
+    player_log <- path_rcg |>
+    readr::read_lines() |>
+    tibble::as_tibble() |>
+    dplyr::mutate(
+        step = value |> stringr::str_extract("\\(show ([0-9]*)*")
+                    |> stringr::str_remove("\\(show "),
+        players = value |> stringr::str_extract_all("\\(\\([lr] [0-9]*\\) [0-9]* [0-9x]* ([0-9\\-\\.]* )*\\(v h [0-9\\-\\.]*\\) \\(s( [0-9\\-\\.]*)*\\)( \\(f [rl] [0-9\\-\\.]*\\))* \\(c( [0-9\\-\\.]*)*\\)\\)")
+    ) |>
+    tidyr::unnest(players) |>
+    dplyr::mutate(
+        player = players |> stringr::str_extract("\\([rl] [0-9]+\\)"),
+        side = player |> stringr::str_extract("[rl]"),
+        unum = player |> stringr::str_extract("[0-9]+"),
+        params = players |> stringr::str_remove("\\([rl] [0-9]+\\)"),
+
+        type = params|> stringr::str_extract("[0-9\\-\\.x]+"),
+        l1 = params |> stringr::str_remove(type),
+
+        state = l1 |> stringr::str_extract("[0-9\\-\\.x]+"),
+        l2 = l1 |> stringr::str_remove(state),
+
+        x = l2 |> stringr::str_extract("[0-9\\-\\.]+"),
+        l3 = l2 |> stringr::str_remove(x),
+
+        y = l3 |> stringr::str_extract("[0-9\\-\\.]+"),
+        l4 = l3 |> stringr::str_remove(y),
+
+        vx = l4 |> stringr::str_extract("[0-9\\-\\.]+"),
+        l5 = l4 |> stringr::str_remove(vx),
+
+        vy = l5 |> stringr::str_extract("[0-9\\-\\.]+"),
+        l6 = l5 |> stringr::str_remove(vy),
+
+        body = l6 |> stringr::str_extract("[0-9\\-\\.]+"),
+        l7 = l6 |> stringr::str_remove(body),
+
+        neck = l7 |> stringr::str_extract("[0-9\\-\\.]+"),
+        l8 = l7 |> stringr::str_remove(neck),
+
+        step = as.numeric(step),
+        # players,
+        # player,
+        side,
+        unum = unum,
+        # params,
+        # type,
+        # state,
+        x = as.numeric(x),
+        y = as.numeric(y),
+        vx = as.numeric(vx),
+        vy = as.numeric(vy),
+        body = as.numeric(body),
+        neck = as.numeric(neck),
+    ) |>
+    dplyr::select(
+        step,
+        # players,
+        # player,
+        side,
+        unum,
+        # params,
+        # type,
+        # state,
+        x,
+        y,
+        vx,
+        vy,
+        body,
+        neck,
+    ) %>% tidyr::drop_na()
+    return(player_log)
+}
\ No newline at end of file

R/read_rcg.R

@@ -10,7 +10,7 @@ read_rcg <- function(path) {
     jsonlite::parse_json(simplifyVector = TRUE, flatten = TRUE) |>
     tibble::as_tibble() |>
     dplyr::filter(type == "show") |>
-    dplyr::select(time, players, ball.x, ball.y, ball.vx, ball.vy) |>
+    dplyr::select(time,stime,players, ball.x, ball.y, ball.vx, ball.vy) |>
     tidyr::unnest(players) |>
     dplyr::select(time:capacity, ball.x:ball.vy) |>
     dplyr::rename(step = time) |>
@@ -18,3 +18,11 @@ read_rcg <- function(path) {
   
   return(rcg)
 }
+
+get_ball <- function(rcg) {
+  ball <- rcg |>
+    dplyr::select(step, ball_x, ball_y, ball_vx, ball_vy) |>
+    dplyr::distinct(step,.keep_all = TRUE)
+  
+  return(ball)
+}
\ No newline at end of file

R/read_rcl.R

@@ -9,7 +9,7 @@ read_rcl <- function(path) {
   readr::read_lines() |>
   tibble::as_tibble() |>
   dplyr::mutate(
-      step     = value |> stringr::str_extract("\\d+"),
+    step     = value |> stringr::str_extract("\\d+") |> as.numeric(),
     agent    = value |> stringr::str_extract("\\w+_([0-9]{1,2}|Coach)(?!\\))"),
     team     = agent |> stringr::str_remove("_([0-9]{1,2}|Coach)"),
     unum     = agent |> stringr::str_extract("([0-9]{1,2}|Coach)$"),
@@ -32,7 +32,7 @@ read_rcl <- function(path) {
     unum,
     command,
     args,
-#      line = value,
+    # line = value,
   )
   
   return(rcl)