leon/knifer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Implement Team display in perround overview

Browse Source 
Now tracks the scores of the teams and displays them on the homepage.
Also now displays the team numbers next to the overview of rounds won to know which team won which round
This commit is contained in:
Lol3rrr
2024-10-15 22:02:19 +02:00
parent a2be4c2167
commit 5cb9094f76
11 changed files with 263 additions and 253 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
backend/src/analysis.rs
View File

@@ -102,33 +102,3 @@ pub struct AnalysisInput {
pub demoid: String,
pub path: PathBuf,
}
#[derive(Debug)]
pub struct BaseInfo {
pub map: String,
pub players: Vec<(BasePlayerInfo, BasePlayerStats)>,
pub teams: Vec<(u32, BaseTeamInfo)>
}
#[derive(Debug)]
pub struct BaseTeamInfo {
pub score: usize,
pub name: String,
}
#[derive(Debug)]
pub struct BasePlayerInfo {
pub name: String,
pub steam_id: String,
pub team: i32,
pub color: i32,
pub ingame_id: i32,
}
#[derive(Debug)]
pub struct BasePlayerStats {
pub kills: usize,
pub deaths: usize,
pub damage: usize,
pub assists: usize,
}

81
backend/src/analysis/base.rs
View File

@@ -1,5 +1,35 @@
use super::*;
#[derive(Debug)]
struct BaseInfo {
pub map: String,
pub players: Vec<(BasePlayerInfo, BasePlayerStats)>,
pub teams: std::collections::HashMap<i32, BaseTeamInfo>,
}
#[derive(Debug)]
struct BaseTeamInfo {
pub start_side: String,
pub end_score: usize,
}
#[derive(Debug)]
struct BasePlayerInfo {
pub name: String,
pub steam_id: String,
pub team: i32,
pub color: i32,
pub ingame_id: i32,
}
#[derive(Debug)]
struct BasePlayerStats {
pub kills: usize,
pub deaths: usize,
pub damage: usize,
pub assists: usize,
}
pub struct BaseAnalysis {}
impl BaseAnalysis {
@@ -36,6 +66,12 @@ impl Analysis for BaseAnalysis {
let base_result = BaseInfo {
map: result.map,
teams: result.teams.into_iter().map(|(numb, team)| {
(numb, BaseTeamInfo {
end_score: team.end_score,
start_side: team.start_side,
})
}).collect(),
players: result
.players
.into_iter()
@@ -57,12 +93,6 @@ impl Analysis for BaseAnalysis {
)
})
.collect(),
teams: result.teams.into_iter().map(|(numb, val)| {
(numb, BaseTeamInfo {
name: val.name,
score: val.score,
})
}).collect(),
};
let (player_info, player_stats): (Vec<_>, Vec<_>) = base_result
@@ -89,20 +119,20 @@ impl Analysis for BaseAnalysis {
})
.unzip();
let teams = base_result.teams.into_iter().map(|(numb, team)| {
crate::models::DemoTeam {
demo_id: input.demoid.clone(),
team: numb as i16,
end_score: team.end_score as i16,
start_name: team.start_side,
}
}).collect::<Vec<_>>();
let demo_info = crate::models::DemoInfo {
demo_id: input.demoid.clone(),
map: base_result.map,
};
let demo_teams: Vec<crate::models::DemoTeam> = base_result.teams.into_iter().map(|(numb, info)| {
crate::models::DemoTeam {
demo_id: input.demoid.clone(),
team: numb as i16,
end_score: info.score as i16,
start_name: info.name,
}
}).collect();
Ok(Box::new(move |connection| {
let store_demo_info_query =
diesel::dsl::insert_into(crate::schema::demo_info::dsl::demo_info)
@@ -143,19 +173,26 @@ impl Analysis for BaseAnalysis {
)),
));
let store_demo_teams = diesel::dsl::insert_into(crate::schema::demo_teams::dsl::demo_teams)
.values(demo_teams).on_conflict((crate::schema::demo_teams::dsl::demo_id, crate::schema::demo_teams::dsl::team))
.do_update()
.set((
crate::schema::demo_teams::dsl::start_name.eq(diesel::upsert::excluded(crate::schema::demo_teams::dsl::start_name)),
crate::schema::demo_teams::dsl::end_score.eq(diesel::upsert::excluded(crate::schema::demo_teams::dsl::end_score)),
let store_teams = diesel::dsl::insert_into(crate::schema::demo_teams::dsl::demo_teams)
.values(teams)
.on_conflict((
crate::schema::demo_teams::dsl::demo_id,
crate::schema::demo_teams::dsl::team,
))
.do_update().set((
crate::schema::demo_teams::dsl::start_name.eq(diesel::upsert::excluded(
crate::schema::demo_teams::dsl::start_name,
)),
crate::schema::demo_teams::dsl::end_score.eq(diesel::upsert::excluded(
crate::schema::demo_teams::dsl::end_score,
)),
));
Box::pin(async move {
store_demo_info_query.execute(connection).await?;
store_demo_players_query.execute(connection).await?;
store_demo_player_stats_query.execute(connection).await?;
store_demo_teams.execute(connection).await?;
store_teams.execute(connection).await?;
Ok(())
})

35
backend/src/api/demos.rs
View File

@@ -264,18 +264,11 @@ async fn scoreboard(
return Err(axum::http::StatusCode::INTERNAL_SERVER_ERROR);
}
let team1_number: i16 = response.last().map(|(p, _)| p.team).unwrap();
let mut team1 = Vec::new();
let mut team2 = Vec::new();
let mut teams = std::collections::BTreeMap::new();
for (player, stats) in response {
let team_vec = if player.team == team1_number {
&mut team1
} else {
&mut team2
};
let team = teams.entry(player.team as u32).or_insert(Vec::new());
team_vec.push(common::demo_analysis::ScoreBoardPlayer {
team.push(common::demo_analysis::ScoreBoardPlayer {
name: player.name,
kills: stats.kills as usize,
deaths: stats.deaths as usize,
@@ -285,8 +278,7 @@ async fn scoreboard(
}
Ok(axum::Json(common::demo_analysis::ScoreBoard {
team1,
team2,
teams: teams.into_iter().collect::<Vec<_>>()
}))
}
@@ -373,17 +365,20 @@ async fn heatmap(
async fn perround(
session: UserSession,
Path(demo_id): Path<String>,
) -> Result<axum::response::Json<Vec<common::demo_analysis::DemoRound>>, axum::http::StatusCode> {
) -> Result<axum::response::Json<common::demo_analysis::PerRoundResult>, axum::http::StatusCode> {
let rounds_query = crate::schema::demo_round::dsl::demo_round
.filter(crate::schema::demo_round::dsl::demo_id.eq(demo_id.clone()));
let round_players_query = crate::schema::demo_players::dsl::demo_players
.filter(crate::schema::demo_players::dsl::demo_id.eq(demo_id));
.filter(crate::schema::demo_players::dsl::demo_id.eq(demo_id.clone()));
let demo_teams = crate::schema::demo_teams::dsl::demo_teams
.filter(crate::schema::demo_teams::dsl::demo_id.eq(demo_id));
let mut db_con = crate::db_connection().await;
let raw_rounds: Vec<crate::models::DemoRound> = rounds_query.load(&mut db_con).await.unwrap();
let players: Vec<crate::models::DemoPlayer> =
round_players_query.load(&mut db_con).await.unwrap();
let raw_teams: Vec<crate::models::DemoTeam> = demo_teams.load(&mut db_con).await.unwrap();
let mut result = Vec::with_capacity(raw_rounds.len());
for raw_round in raw_rounds.into_iter() {
@@ -450,7 +445,17 @@ async fn perround(
result.push(common::demo_analysis::DemoRound { reason, events });
}
Ok(axum::Json(result))
let teams = raw_teams.into_iter().map(|dteam| {
common::demo_analysis::PerRoundTeam {
name: dteam.start_name,
number: dteam.team as u32,
}
}).collect();
Ok(axum::Json(common::demo_analysis::PerRoundResult {
rounds: result,
teams,
}))
}
// The corresponding values for each map can be found using the Source2 Viewer and opening the

20
backend/src/models.rs
View File

@@ -42,6 +42,16 @@ pub struct DemoInfo {
pub map: String,
}
#[derive(Queryable, Selectable, Insertable, Debug)]
#[diesel(table_name = crate::schema::demo_teams)]
#[diesel(check_for_backend(diesel::pg::Pg))]
pub struct DemoTeam {
pub demo_id: String,
pub team: i16,
pub end_score: i16,
pub start_name: String,
}
#[derive(Queryable, Selectable, Insertable, Debug)]
#[diesel(table_name = crate::schema::demo_players)]
#[diesel(check_for_backend(diesel::pg::Pg))]
@@ -65,16 +75,6 @@ pub struct DemoPlayerStats {
pub assists: i16,
}
#[derive(Queryable, Selectable, Insertable, Debug)]
#[diesel(table_name = crate::schema::demo_teams)]
#[diesel(check_for_backend(diesel::pg::Pg))]
pub struct DemoTeam {
pub demo_id: String,
pub team: i16,
pub end_score: i16,
pub start_name: String,
}
#[derive(Queryable, Selectable, Insertable, Debug)]
#[diesel(table_name = crate::schema::processing_status)]
#[diesel(check_for_backend(diesel::pg::Pg))]