demoinfocs

README

demoinfocs-golang

Is a CS:GO demo parser written in Go based on Valve's demoinfogo and SatsHelix's demoinfo.

Discussions / Chat

Use gitter to ask questions and discuss ideas about this project.
There are also some other rooms available around the topic of CS:GO demos.

Go Get

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

Example

This is a simple example on how to use the library. After each round (on every RoundEndedEvent) it prints out which team won.

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

import (
	"fmt"
	"log"
	"os"

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

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

	p := dem.NewParser(f, dem.WarnToStdErr)

	// Parse header
	h, err := p.ParseHeader()
	if err != nil {
		t.Fatal(err)
	}
	fmt.Println("Map:", h.MapName)

	// Register handler on round end to figure out who won
	p.RegisterEventHandler(func(e events.RoundEndedEvent) {
		gs := p.GameState()
		switch e.Winner {
		case common.TeamTerrorists:
			// Winner's score + 1 because it hasn't actually been updated yet
			fmt.Printf("Round finished: winnerSide=T  ; score=%d:%d\n", gs.TState().Score()+1, gs.CTState().Score())
		case common.TeamCounterTerrorists:
			fmt.Printf("Round finished: winnerSide=CT ; score=%d:%d\n", gs.CTState().Score()+1, gs.TState().Score())
		default:
			// Probably match medic or something similar
			fmt.Println("Round finished: No winner (tie)")
		}
	})

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

Development

Running tests

To run tests Git LFS is required.

git submodule init
git submodule update
pushd test/cs-demos && git lfs pull && popd
go test

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 paramter can be used. Example for additionally printing out the ingame-tick-numbers: -ldflags '-X github.com/markus-wa/demoinfocs-golang.debugIngameTicks=YES'

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

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.

Documentation

Overview

Package demoinfocs provides a demo parser for the game Counter-Strike: Global Offensive. It is based on the official demoinfogo tool by Valve as well as Stats Helix's demoinfo. A good entry point to using the library is the Parser type. Demo events are documented in the events package.

Index

• Variables
• func WarnToStdErr(warning string)
• type GameState
  • func (gs *GameState) CTState() *TeamState
  • func (gs GameState) IngameTick() int
  • func (gs GameState) Participants() []*common.Player
  • func (gs GameState) PlayingParticipants() []*common.Player
  • func (gs *GameState) TState() *TeamState
• type Parser
  • func NewParser(demostream io.Reader, warnHandler WarnHandler) *Parser
  • func NewParserWithBufferSize(demostream io.Reader, msgQueueBufferSize int, warnHandler WarnHandler) *Parser
  • func (p *Parser) Cancel()
  • func (p *Parser) CurrentFrame() int
  • func (p *Parser) CurrentTime() float32
  • func (p *Parser) GameState() *GameState
  • func (p *Parser) Header() common.DemoHeader
  • func (p *Parser) ParseHeader() (common.DemoHeader, error)
  • func (p *Parser) ParseNextFrame() (b bool, err error)
  • func (p *Parser) ParseToEnd() (err error)
  • func (p *Parser) Progress() float32
  • func (p *Parser) RegisterEventHandler(handler interface{}) dp.HandlerIdentifier
  • func (p *Parser) SendTableParser() *st.SendTableParser
  • func (p *Parser) UnregisterEventHandler(identifier dp.HandlerIdentifier)
• type TeamState
  • func (ts TeamState) ClanName() string
  • func (ts TeamState) Flag() string
  • func (ts TeamState) ID() int
  • func (ts TeamState) Score() int
• type WarnHandler

Variables

var (
	// ErrCancelled signals that parsing was cancelled via Parser.Cancel()
	ErrCancelled error = errors.New("Parsing was cancelled before it finished (ErrCancelled)")

	// ErrUnexpectedEndOfDemo signals that the demo is incomplete / corrupt -
	// these demos may still be useful, check the how far the parser got.
	ErrUnexpectedEndOfDemo error = errors.New("Demo stream ended unexpectedly (ErrUnexpectedEndOfDemo)")
)

Parsing errors

Functions

func WarnToStdErr

func WarnToStdErr(warning string)

WarnToStdErr is a WarnHandler that prints all warnings to standard error output.

Types

type GameState

type GameState struct {
	// contains filtered or unexported fields
}

GameState contains all game-state relevant information.

func (*GameState) CTState

func (gs *GameState) CTState() *TeamState

CTState returns the TeamState of the CT team. Make sure you handle swapping sides properly if you keep the reference.

func (GameState) IngameTick

func (gs GameState) IngameTick() int

IngameTick returns the latest actual tick number of the server during the game. Watch out, I've seen this return wonky negative numbers at the start of demos.

func (GameState) Participants

func (gs GameState) Participants() []*common.Player

Participants returns all connected players. This includes spectators.

func (GameState) PlayingParticipants

func (gs GameState) PlayingParticipants() []*common.Player

PlayingParticipants returns all players that aren't spectating or unassigned.

func (*GameState) TState

func (gs *GameState) TState() *TeamState

TState returns the TeamState of the T team. Make sure you handle swapping sides properly if you keep the reference.

type Parser

type Parser struct {
	// contains filtered or unexported fields
}

Parser can parse a CS:GO demo. Creating a Parser is done via NewParser(). To start off use Parser.ParseHeader() to parse the demo header. After parsing the header Parser.ParseNextFrame() and Parser.ParseToEnd() can be used to parse the demo. Use Parser.RegisterEventHandler() to receive notifications about events.

func NewParser

func NewParser(demostream io.Reader, warnHandler WarnHandler) *Parser

NewParser creates a new Parser on the basis of an io.Reader - like os.File or bytes.Reader - that reads demo data. Any warnings that don't stop the Parser from doing it's job will be passed to the warnHandler if it's not nil.

func NewParserWithBufferSize

func NewParserWithBufferSize(demostream io.Reader, msgQueueBufferSize int, warnHandler WarnHandler) *Parser

NewParserWithBufferSize returns a new Parser with a custom msgQueue buffer size. For large demos, fast i/o and slow CPUs higher numbers are suggested and vice versa. The buffer size can easily be in the hundred-thousands to low millions for the best performance. A negative value will make the Parser automatically decide the buffer size during ParseHeader() based on the number of ticks in the demo (nubmer of ticks = buffer size). See also: NewParser()

func (*Parser) Cancel

func (p *Parser) Cancel()

Cancel aborts ParseToEnd(). All information that was already read up to this point will still be used (and new events may still be sent).

func (*Parser) CurrentFrame

func (p *Parser) CurrentFrame() int

CurrentFrame return the number of the current frame, aka. 'demo-tick' (Since demos often have a different tick-rate than the game). Starts with frame 0, should go up to DemoHeader.PlaybackFrames but might not be the case (usually it's just close to it).

func (*Parser) CurrentTime

func (p *Parser) CurrentTime() float32

CurrentTime returns the ingame time in seconds since the start of the demo.

func (*Parser) GameState

func (p *Parser) GameState() *GameState

GameState returns the current game-state

func (*Parser) Header

func (p *Parser) Header() common.DemoHeader

Header returns the DemoHeader which contains the demo's metadata.

func (*Parser) ParseHeader

func (p *Parser) ParseHeader() (common.DemoHeader, error)

ParseHeader attempts to parse the header of the demo. Returns error if the filestamp (first 8 bytes) doesn't match HL2DEMO.

func (*Parser) ParseNextFrame

func (p *Parser) ParseNextFrame() (b bool, err error)

ParseNextFrame attempts to parse the next frame / demo-tick (not ingame tick). Returns true unless the demo command 'stop' or an error was encountered. May return ErrUnexpectedEndOfDemo for incomplete / corrupt demos. Panics if header hasn't been parsed yet - see Parser.ParseHeader().

func (*Parser) ParseToEnd

func (p *Parser) ParseToEnd() (err error)

ParseToEnd attempts to parse the demo until the end. Aborts and returns ErrCancelled if Cancel() is called before the end. May return ErrUnexpectedEndOfDemo for incomplete / corrupt demos. May panic if the demo is corrupt in some way.

func (*Parser) Progress

func (p *Parser) Progress() float32

Progress returns the parsing progress from 0 to 1. Where 0 means nothing has been parsed yet and 1 means the demo has been parsed to the end. Might not actually be reliable since it's just based on the reported tick count of the header.

func (*Parser) RegisterEventHandler

func (p *Parser) RegisterEventHandler(handler interface{}) dp.HandlerIdentifier

RegisterEventHandler registers a handler for game events. Must be of type func(<EventType>) where EventType is the kind of event that is handled. To catch all events func(interface{}) can be used. Parameter handler has to be of type interface{} because lolnogenerics. Returns a identifier with which the handler can be removed via UnregisterEventHandler()

func (*Parser) SendTableParser

func (p *Parser) SendTableParser() *st.SendTableParser

SendTableParser returns the sendtable parser. This is a beta feature and may be changed or replaced without notice.

func (*Parser) UnregisterEventHandler

func (p *Parser) UnregisterEventHandler(identifier dp.HandlerIdentifier)

UnregisterEventHandler removes a handler via identifier. The identifier is returned at registration by RegisterEventHandler()

type TeamState

type TeamState struct {
	// contains filtered or unexported fields
}

TeamState contains a team's ID, score, clan name & country flag.

func (TeamState) ClanName

func (ts TeamState) ClanName() string

ClanName returns the team's clan name.

func (TeamState) Flag

func (ts TeamState) Flag() string

Flag returns the team's country flag. Watch out, in some demos this is upper-case and in some lower-case.

func (TeamState) ID

func (ts TeamState) ID() int

ID returns the team-ID. This stays the same even after switching sides.

func (TeamState) Score

func (ts TeamState) Score() int

Score returns the team's number of rounds won.

type WarnHandler

type WarnHandler func(string)

WarnHandler is a function that handles warnings of a Parser.