repository·master·Indexed 22 days ago
https://github.com/markus-wa/demoinfocs-golangA high-performance Go library for parsing and analyzing Counter-Strike 2 and CS:GO demo files. It enables developers to extract game events, track game state, and access low-level network messages. Features include support for parsing live CSTV+ broadcasts, custom handlers for unhandled entity data and property updates, and a fake package for mocking the parser in unit tests.
The demoinfocs-golang repository provides several example implementations demonstrating different ways to interact with CS2 demo data. These range from high-level data visualization to low-level protocol handling.
Note: Example code is intended for demonstration purposes and may use simplified error handling. It should not be used in production systems without implementing robust error management.
The library provides several high-level capabilities for demo analysis:
events package.sendtables.You can process entity data that is not explicitly defined in the parser by registering custom handlers. This is achieved by setting up two types of handlers:
server-classes to intercept when a new entity of a specific class is created.entities to intercept updates to their properties.This approach allows you to extract information from unhandled entity-data without modifying the core parser logic.
The following patterns are demonstrated across the repository's examples:
Parser.ServerClasses().fake package to write unit tests for your code.The print-events example outputs a stream of parsed game information. The format includes:
Map: de_cache).[Side]PlayerName <Weapon (Modifier)> [Side]VictimName.[T] indicates Terrorist.[CT] indicates Counter-Terrorist.(HS) indicates a Headshot.(WB) indicates a Wallbang.Chat - [Side]PlayerName says: message.Round finished: winnerSide=SIDE ; score=X:Y.Map: de_cache
[T]xms*ASUS ♥ /F/ <AK-47 (HS)> [CT]crisby
Chat - [T]to1nou * Seagate says: hf
Round finished: winnerSide=CT ; score=1:0You can parse live Counter-Strike 2 (CS2) broadcasts using the CSTV+ (Live Broadcast Parsing) functionality. This involves running a local Node.js server to handle the broadcast stream, starting a dedicated CS2 server with specific parameters, and then using the Go parser to consume the broadcast URL.
broadcasts.go tool with the generated broadcast URL to see real-time parsed data (kills, chat, round results, etc.).# 1. Start the Node.js stream handler
node cstv.js
# 2. Start the dedicated CS2 server
cs2 -dedicated -port 27016 +sv_setsteamaccount 0F81C7E09971B48600F6642E21183EEC +game_type 0 +game_mode 1 +sv_hibernate_when_empty 0 +map de_overpass
# 3. In the CS2 console, configure the broadcast
tv_delay 0; tv_broadcast_url "http://localhost:8080"; tv_broadcast 1
# 4. Run the Go parser with the tokenized URL
go run broadcasts.go -url "http://localhost:8080/<token>"To automate checks like interface updates, building, and testing during your workflow, you can install optional pre-commit and pre-push hooks using the provided script.
scripts/git-hooks/link-git-hooks.shIf you need to re-generate the protobuf code within the msg package, ensure you have protoc-gen-go installed. Then, run the go generate command targeting the msg package. Note: On Windows, run this from CMD rather than Bash.
go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
go generate ./msgTo use the demoinfocs-golang library in a WebAssembly environment, you cannot use the standard library build process. Instead, you must use a specialized build process and repository designed for WASM integration.
For a complete implementation and build instructions, refer to the dedicated WASM example repository.
https://github.com/markus-wa/demoinfocs-wasmTo use the library for parsing legacy CS:GO demos, use the following command to fetch the v3 package:
go get -u github.com/markus-wa/demoinfocs-golang/v3/pkg/demoinfocsgo get -u github.com/markus-wa/demoinfocs-golang/v3/pkg/demoinfocsTo write unit tests for applications using demoinfocs-golang, you can use the fake package to mock the demoinfocs.Parser interface and other components. This allows you to simulate specific event sequences and parser behaviors (like errors) without needing a real demo file.
fake.NewParser().parser.MockEvents(...args) to schedule events. The arguments are passed to the mock's internal event map. The index in the slice determines the frame at which the events are emitted (e.g., parser.MockEvents(event1) for frame 0, parser.MockEvents(event2, event3) for frame 1)..On("MethodName").Return(value) pattern to define what the mock should return when specific parser methods are called (e.g., ParseToEnd).import (
"errors"
"testing"
assert "github.com/stretchr/testify/assert"
common "github.com/markus-wa/demoinfocs-golang/v5/pkg/demoinfocs/common"
events "github.com/markus-wa/demoinfocs-golang/v5/pkg/demoinfocs/events"
fake "github.com/markus-wa/demoinfocs-golang/v5/pkg/demoinfocs/fake"
)
func TestCollectKills(t *testing.T) {
parser := fake.NewParser()
kill1 := kill(common.EqAK47)
kill2 := kill(common.EqScout)
kill3 := kill(common.EqAUG)
// Mocking events at specific frames
parser.MockEvents(kill1) // Frame 0
parser.MockEvents(kill2, kill3) // Frame 1
// Mocking method return values
parser.On("ParseToEnd").Return(nil)
actual, err := collectKills(parser)
assert.Nil(t, err)
expected := []events.Kill{kill1, kill2, kill3}
assert.Equal(t, expected, actual)
}
func kill(wep common.EquipmentElement) events.Kill {
eq := common.NewEquipment(wep)
return events.Kill{
Killer: new(common.Player),
Weapon: &eq,
Victim: new(common.Player),
}
}