315 lines
8.0 KiB
Go
315 lines
8.0 KiB
Go
package main
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"math"
|
|
"os"
|
|
"time"
|
|
|
|
demoinfocs "github.com/markus-wa/demoinfocs-golang/v4/pkg/demoinfocs"
|
|
"github.com/markus-wa/demoinfocs-golang/v4/pkg/demoinfocs/common"
|
|
"github.com/markus-wa/demoinfocs-golang/v4/pkg/demoinfocs/events"
|
|
msg "github.com/markus-wa/demoinfocs-golang/v4/pkg/demoinfocs/msgs2"
|
|
)
|
|
|
|
type PlayerStats struct {
|
|
Name string `json:"name"`
|
|
SteamID string `json:"steamId"`
|
|
Kills int `json:"kills"`
|
|
Deaths int `json:"deaths"`
|
|
Assists int `json:"assists"`
|
|
FlashAssists int `json:"flashAssists"`
|
|
MVPs int `json:"mvps"`
|
|
MVPReason1 int `json:"mvpEliminations"`
|
|
MVPReason2 int `json:"mvpDefuse"`
|
|
MVPReason3 int `json:"mvpPlant"`
|
|
KnifeKills int `json:"knifeKills"`
|
|
ZeusKills int `json:"zeusKills"`
|
|
WallbangKills int `json:"wallbangKills"`
|
|
SmokeKills int `json:"smokeKills"`
|
|
Headshots int `json:"headshots"`
|
|
NoScopes int `json:"noScopes"`
|
|
BlindKills int `json:"blindKills"`
|
|
RankOld int `json:"rankOld,omitempty"`
|
|
RankNew int `json:"rankNew,omitempty"`
|
|
RankChange int `json:"rankChange,omitempty"`
|
|
WinCount int `json:"winCount,omitempty"`
|
|
}
|
|
|
|
type RoundResult struct {
|
|
Round int `json:"round"`
|
|
Winner string `json:"winner"`
|
|
WinReason string `json:"winReason"`
|
|
}
|
|
|
|
type DemoMeta struct {
|
|
MatchID uint64 `json:"matchId"`
|
|
Map string `json:"map"`
|
|
Players []PlayerStats `json:"players"`
|
|
Duration float64 `json:"duration"`
|
|
TickRate float64 `json:"tickRate"`
|
|
ScoreCT int `json:"scoreCT"`
|
|
ScoreT int `json:"scoreT"`
|
|
TeamCT string `json:"teamCT"`
|
|
TeamT string `json:"teamT"`
|
|
WinnerTeam string `json:"winnerTeam"`
|
|
RoundCount int `json:"roundCount"`
|
|
RoundHistory []RoundResult `json:"roundHistory"`
|
|
DemoDate string `json:"demoDate"`
|
|
}
|
|
|
|
func sanitizeFloat(value float64) float64 {
|
|
if math.IsNaN(value) || math.IsInf(value, 0) {
|
|
return 0
|
|
}
|
|
return value
|
|
}
|
|
|
|
func getDemoTimestamp(path string) string {
|
|
info, err := os.Stat(path)
|
|
if err != nil {
|
|
return ""
|
|
}
|
|
return info.ModTime().UTC().Format("2006-01-02T15:04:05Z")
|
|
}
|
|
|
|
func reasonToString(reason events.RoundEndReason) string {
|
|
switch reason {
|
|
case events.RoundEndReasonTargetBombed:
|
|
return "Bomb"
|
|
case events.RoundEndReasonTerroristsStopped:
|
|
return "T eliminated"
|
|
case events.RoundEndReasonCTStoppedEscape:
|
|
return "CT stopped escape"
|
|
case events.RoundEndReasonTerroristsEscaped:
|
|
return "T escaped"
|
|
case events.RoundEndReasonHostagesRescued:
|
|
return "Hostages rescued"
|
|
case events.RoundEndReasonCTWin:
|
|
return "CT win"
|
|
case events.RoundEndReasonTerroristsWin:
|
|
return "T win"
|
|
case events.RoundEndReasonDraw:
|
|
return "Draw"
|
|
case events.RoundEndReasonHostagesNotRescued:
|
|
return "Hostages not rescued"
|
|
case events.RoundEndReasonTerroristsNotEscaped:
|
|
return "T not escaped"
|
|
case events.RoundEndReasonBombDefused:
|
|
return "Bomb defused"
|
|
default:
|
|
return "Unknown"
|
|
}
|
|
}
|
|
|
|
func main() {
|
|
if len(os.Args) < 2 {
|
|
fmt.Println("❌ Demo-Datei fehlt")
|
|
os.Exit(1)
|
|
}
|
|
|
|
filePath := os.Args[1]
|
|
f, err := os.Open(filePath)
|
|
if err != nil {
|
|
fmt.Printf("❌ Datei konnte nicht geöffnet werden: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
defer f.Close()
|
|
|
|
p := demoinfocs.NewParser(f)
|
|
|
|
var mapName string
|
|
var matchId uint64
|
|
var scoreCT, scoreT, roundCount int
|
|
var roundHistory []RoundResult
|
|
|
|
if len(os.Args) >= 3 {
|
|
inputId := os.Args[2]
|
|
_, err := fmt.Sscanf(inputId, "%d", &matchId)
|
|
if err != nil {
|
|
fmt.Printf("⚠️ Ungültige matchId-Argument: %v\n", err)
|
|
matchId = 0
|
|
}
|
|
}
|
|
|
|
p.RegisterNetMessageHandler(func(msg *msg.CSVCMsg_ServerInfo) {
|
|
if msg != nil && msg.GetMapName() != "" {
|
|
mapName = msg.GetMapName()
|
|
}
|
|
})
|
|
|
|
header, err := p.ParseHeader()
|
|
if err != nil {
|
|
fmt.Printf("❌ Header konnte nicht gelesen werden: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
playerStats := make(map[uint64]*PlayerStats)
|
|
|
|
getOrCreate := func(sid uint64, name string) *PlayerStats {
|
|
stat := playerStats[sid]
|
|
if stat == nil {
|
|
stat = &PlayerStats{
|
|
Name: name,
|
|
SteamID: fmt.Sprintf("%d", sid),
|
|
}
|
|
playerStats[sid] = stat
|
|
}
|
|
return stat
|
|
}
|
|
|
|
p.RegisterEventHandler(func(e events.Kill) {
|
|
if e.Killer != nil && e.Killer.SteamID64 != e.Victim.SteamID64 {
|
|
stat := getOrCreate(e.Killer.SteamID64, e.Killer.Name)
|
|
stat.Kills++
|
|
if e.IsHeadshot {
|
|
stat.Headshots++
|
|
}
|
|
if e.NoScope {
|
|
stat.NoScopes++
|
|
}
|
|
if e.AttackerBlind {
|
|
stat.BlindKills++
|
|
}
|
|
if e.ThroughSmoke {
|
|
stat.SmokeKills++
|
|
}
|
|
if e.IsWallBang() {
|
|
stat.WallbangKills++
|
|
}
|
|
if e.Weapon != nil {
|
|
switch e.Weapon.Type {
|
|
case common.EqKnife:
|
|
stat.KnifeKills++
|
|
case common.EqZeus:
|
|
stat.ZeusKills++
|
|
}
|
|
}
|
|
}
|
|
if e.Victim != nil {
|
|
stat := getOrCreate(e.Victim.SteamID64, e.Victim.Name)
|
|
stat.Deaths++
|
|
}
|
|
if e.Assister != nil {
|
|
stat := getOrCreate(e.Assister.SteamID64, e.Assister.Name)
|
|
stat.Assists++
|
|
}
|
|
})
|
|
|
|
p.RegisterEventHandler(func(e events.PlayerFlashed) {
|
|
if e.Attacker != nil && e.Attacker.SteamID64 != e.Player.SteamID64 {
|
|
stat := getOrCreate(e.Attacker.SteamID64, e.Attacker.Name)
|
|
stat.FlashAssists++
|
|
}
|
|
})
|
|
|
|
p.RegisterEventHandler(func(e events.RoundMVPAnnouncement) {
|
|
if e.Player != nil {
|
|
stat := getOrCreate(e.Player.SteamID64, e.Player.Name)
|
|
stat.MVPs++
|
|
switch e.Reason {
|
|
case events.MVPReasonMostEliminations:
|
|
stat.MVPReason1++
|
|
case events.MVPReasonBombDefused:
|
|
stat.MVPReason2++
|
|
case events.MVPReasonBombPlanted:
|
|
stat.MVPReason3++
|
|
}
|
|
}
|
|
})
|
|
|
|
p.RegisterEventHandler(func(e events.RoundEnd) {
|
|
scoreCT = p.GameState().TeamCounterTerrorists().Score()
|
|
scoreT = p.GameState().TeamTerrorists().Score()
|
|
roundCount++
|
|
|
|
var winner string
|
|
switch e.Winner {
|
|
case common.TeamTerrorists:
|
|
winner = "T"
|
|
case common.TeamCounterTerrorists:
|
|
winner = "CT"
|
|
default:
|
|
winner = "Unknown"
|
|
}
|
|
|
|
roundHistory = append(roundHistory, RoundResult{
|
|
Round: roundCount,
|
|
Winner: winner,
|
|
WinReason: reasonToString(e.Reason),
|
|
})
|
|
})
|
|
|
|
p.RegisterEventHandler(func(e events.RankUpdate) {
|
|
if e.Player != nil {
|
|
stat := getOrCreate(e.Player.SteamID64, e.Player.Name)
|
|
stat.RankOld = e.RankOld
|
|
stat.RankNew = e.RankNew
|
|
stat.RankChange = int(e.RankChange)
|
|
stat.WinCount = e.WinCount
|
|
}
|
|
})
|
|
|
|
err = p.ParseToEnd()
|
|
if err != nil {
|
|
fmt.Printf("❌ Fehler beim Parsen: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
teamCT := p.GameState().TeamCounterTerrorists().ClanName()
|
|
teamT := p.GameState().TeamTerrorists().ClanName()
|
|
scoreCT = p.GameState().TeamCounterTerrorists().Score()
|
|
scoreT = p.GameState().TeamTerrorists().Score()
|
|
|
|
winnerTeam := "Draw"
|
|
if scoreCT > scoreT {
|
|
winnerTeam = teamCT
|
|
} else if scoreT > scoreCT {
|
|
winnerTeam = teamT
|
|
}
|
|
|
|
demoDate := getDemoTimestamp(filePath)
|
|
if demoDate == "" {
|
|
demoDate = time.Now().UTC().Format("2006-01-02T15:04:05Z")
|
|
}
|
|
|
|
duration := sanitizeFloat(header.PlaybackTime.Seconds())
|
|
tickRate := 0.0
|
|
if duration > 0 {
|
|
tickRate = sanitizeFloat(float64(header.PlaybackTicks) / duration)
|
|
}
|
|
|
|
if mapName == "" {
|
|
mapName = header.MapName
|
|
}
|
|
|
|
result := DemoMeta{
|
|
MatchID: matchId,
|
|
Map: mapName,
|
|
Duration: duration,
|
|
TickRate: tickRate,
|
|
ScoreCT: scoreCT,
|
|
ScoreT: scoreT,
|
|
TeamCT: teamCT,
|
|
TeamT: teamT,
|
|
WinnerTeam: winnerTeam,
|
|
RoundCount: roundCount,
|
|
RoundHistory: roundHistory,
|
|
DemoDate: demoDate,
|
|
}
|
|
|
|
for _, stat := range playerStats {
|
|
result.Players = append(result.Players, *stat)
|
|
}
|
|
|
|
jsonData, err := json.Marshal(result)
|
|
if err != nil {
|
|
fmt.Printf("❌ Fehler beim JSON-Export: %v\n", err)
|
|
fmt.Printf("⛔ Dump vor Fehler: %+v\n", result)
|
|
os.Exit(1)
|
|
}
|
|
|
|
fmt.Println(string(jsonData))
|
|
}
|