demoinfocs-golang - A CS:GO Demo Parser

Is a Go library for super fast parsing and analysing of Counter Strike: Global Offensive (CS:GO) demos (aka replays). It is based on Valve's demoinfogo and SatsHelix's demoinfo.

Discussions / Chat

You can use gitter to ask questions and discuss ideas about this project.

Requirements

This library is intended to be used with go 1.11 or higher as it is built using Go modules.

It's recommended to use modules for consumers as well if possible. If you are unfamiliar with Go modules there's a list of recommended resources in the wiki.

Go Get

go get -u github.com/markus-wa/demoinfocs-golang

Example

This is a simple example on how to handle game events using this library. It prints all kills in a given demo (killer, weapon, victim, was it a wallbang/headshot?) by registering a handler for events.Kill.

Check out the godoc of the events package for some information about the other available events and their purpose.

package main

import (
	"fmt"
	"os"

	dem "github.com/markus-wa/demoinfocs-golang"
	events "github.com/markus-wa/demoinfocs-golang/events"
)

func main() {
	f, err := os.Open("/path/to/demo.dem")
	if err != nil {
		panic(err)
	}
	defer f.Close()

	p := dem.NewParser(f)

	// Register handler on kill events
	p.RegisterEventHandler(func(e events.Kill) {
		var hs string
		if e.IsHeadshot {
			hs = " (HS)"
		}
		var wallBang string
		if e.PenetratedObjects > 0 {
			wallBang = " (WB)"
		}
		fmt.Printf("%s <%v%s%s> %s\n", e.Killer, e.Weapon, hs, wallBang, e.Victim)
	})

	// Parse to end
	err = p.ParseToEnd()
	if err != nil {
		panic(err)
	}
}

Sample output

Running the code above will print something like this:

xms <AK-47 (HS)> crisby
tiziaN <USP-S (HS)> Ex6TenZ
tiziaN <USP-S> mistou
tiziaN <USP-S (HS)> ALEX
xms <Glock-18 (HS)> tiziaN
...
keev <AWP (HS) (WB)> to1nou
...

More examples

Check out the examples folder for more examples, like how to generate heatmaps like this one:

Features

Game events (kills, shots, round starts/ends, footsteps etc.) - docs / example
Tracking of game-state (players, teams, grenades, ConVars etc.) - docs
Grenade projectiles / trajectories - docs / example
Access to entities, server-classes & data-tables - docs / example
Access to all net-messages - docs / example
Chat & console messages ¹ - docs / example
POV demo support ²
Easy debugging via build-flags
Built with performance & concurrency in mind

Only for some demos; in MM demos the chat is encrypted for example.
Only partially supported (as good as other parsers), some POV demos seem to be inherently broken

Performance / Benchmarks

Two of the top priorities of this parser are performance and concurrency.

Here are some benchmark results from a system with an Intel i7 6700k CPU and a SSD disk running Windows 10 and a demo with 85'000 frames.

Overview

Benchmark	Description	Average Duration	Speed
`BenchmarkConcurrent`	Read and parse 8 demos concurrently	2.06 s (per 8 demos)	~330'000 ticks / s
`BenchmarkDemoInfoCs`	Read demo from drive and parse	0.89 s	~95'000 ticks / s
`BenchmarkInMemory`	Read demo from memory and parse	0.88 s	~96'000 ticks / s

That's almost 1.5 hours of gameplay per second when parsing in parallel (recorded at 64 ticks per second) - or 25 minues per second when only parsing a single demo at a time.

Raw output

$ go test -run _NONE_ -bench . -benchtime 30s -benchmem -concurrentdemos 8
goos: windows
goarch: amd64
pkg: github.com/markus-wa/demoinfocs-golang
BenchmarkDemoInfoCs-8             50     894500010 ns/op    257610127 B/op    914355 allocs/op
BenchmarkInMemory-8               50     876279984 ns/op    257457271 B/op    914143 allocs/op
BenchmarkConcurrent-8             20    2058303680 ns/op    2059386582 B/op  7313145 allocs/op
--- BENCH: BenchmarkConcurrent-8
    demoinfocs_test.go:315: Running concurrency benchmark with 8 demos
    demoinfocs_test.go:315: Running concurrency benchmark with 8 demos
PASS
ok      github.com/markus-wa/demoinfocs-golang  134.244s

Versioning

We use SemVer for versioning. For the versions available, see the tags on this repository. There is one caveat however: Beta features - which are marked as such via comments and in release notes - may change in minor releases.

Projects using demoinfocs-golang

noesis.gg - A suite of explorative tools to help you analyze and improve your CS:GO performance
esportal.se - An alternative Matchmaking service that aims to provide a friendly environment free from trolls and misbehaving individuals
cs-demo-minifier - Converts demos to JSON, MessagePack and more
csgo_spray_pattern_plotter - A tool to extract and plot spray patterns from CS:GO replays
CS:GO Player Skill Prediction - Machine learning master thesis by @quancore about predicting player performance
csgoverview - A 2D demo replay tool for CS:GO

If your project is using this library feel free to submit a PR or send a message in Gitter to be included in the list.

Development

Git hooks

To install some (optional, but quite handy) pre-commit and pre-push hooks, you can run the following script.

bin/git-hooks/link-git-hooks.sh

`pre-commit`:

check if interfaces have been updated
build the code
run unit tests

`pre-push`:

run regression tests

Testing

Unit tests

For any new features, Test Driven Development should be practiced where possible. However, due to some design flaws in some parts of the code it's currently not always practical to do so.

Running unit tests:

bin/unit-tests.sh
# or (identical)
go test -short ./...

Regression tests

For the full regression suite you will need to download the test demo-set.

Prerequisites:

Git LFS must be installed
7z must be in your PATH environment variable (p7zip or p7zip-full package on most Linux distros)

Downloading demos + running regression tests:

bin/regression-tests.sh

Updating the `default.golden` file

The file test/default.golden file contains a serialized output of all expected game events in test/cs-demos/default.dem.

If there is a change to game events (new fields etc.) it is necessary to update this file so the regression tests pass. To update it you can run the following command:

go test -run TestDemoInfoCs -update

Please don't update the .golden file if you are not sure it's required. Maybe the failing CI is just pointing out a regression.

Debugging

You can use the build tag debugdemoinfocs (i.e. go test -tags debugdemoinfocs -v) to print out debugging information - such as game events or unhandled demo-messages - during the parsing process.
Side-note: The tag isn't called debug to avoid naming conflicts with other libs (and underscores in tags don't work, apparently).

To change the default debugging behavior, Go's ldflags parameter can be used. Example for additionally printing out all server-classes with their properties: -ldflags '-X github.com/markus-wa/demoinfocs-golang.debugServerClasses=YES'

Check out debug_on.go for any other settings that can be changed.

Generating interfaces

We generate interfaces such as IGameState from structs to make it easier to keep docs in synch over structs and interfaces. For this we use @vburenin's ifacemaker tool.

You can download the latest version here. After adding it to your PATH you can use bin/generate-interfaces.sh to update interfaces.

Generating protobuf code

Should you need to re-generate the protobuf generated code in the msg package, you will need the following tools:

The latest protobuf generator (protoc) from your package manager or https://github.com/google/protobuf/releases
And protoc-gen-gogofaster from gogoprotobuf to generate code for go.
```
  go get -u github.com/gogo/protobuf/protoc-gen-gogofaster
```

Make sure both are inside your PATH variable.

After installing these use go generate ./msg to generate the protobuf code. If you're on Windows you'll need to run go generate from CMD, not Bash.

Acknowledgements

Thanks to @JetBrains for sponsoring a license of their awesome GoLand IDE for this project - go check it out!

And a very special thanks goes out to all the ⭐️contributors⭐️, be it in the form of PRs, issues or anything else.

License

This project is licensed under the MIT license.

xavier-rodet/demoinfocs-golang