Add Custom EventEmitters & fuzzy.TeamSwitchEvent

This is intended to fix #17

Author: markus-wa

demoinfocs_test.go

@@ -17,13 +17,15 @@ import (
 	dem "github.com/markus-wa/demoinfocs-golang"
 	common "github.com/markus-wa/demoinfocs-golang/common"
 	events "github.com/markus-wa/demoinfocs-golang/events"
+	fuzzy "github.com/markus-wa/demoinfocs-golang/fuzzy"
 	msg "github.com/markus-wa/demoinfocs-golang/msg"
 )
 
 const csDemosPath = "test/cs-demos"
 const demSetPath = csDemosPath + "/set"
 const defaultDemPath = csDemosPath + "/default.dem"
 const unexpectedEndOfDemoPath = csDemosPath + "/unexpected_end_of_demo.dem"
+const valveMatchmakingDemoPath = csDemosPath + "/valve_matchmaking.dem"
 
 func init() {
 	if _, err := os.Stat(defaultDemPath); err != nil {
@@ -166,6 +168,54 @@ func TestUnexpectedEndOfDemo(t *testing.T) {
 	}
 }
 
+func TestValveMatchmakingFuzzyEmitters(t *testing.T) {
+	f, err := os.Open(valveMatchmakingDemoPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer f.Close()
+
+	cfg := dem.DefaultParserConfig
+	cfg.AdditionalEventEmitters = []dem.EventEmitter{new(fuzzy.ValveMatchmakingTeamSwitchEmitter)}
+
+	p := dem.NewParserWithConfig(f, cfg)
+	_, err = p.ParseHeader()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	teamSwitchDone := false
+	tScoreBeforeSwap, ctScoreBeforeSwap := -1, -1
+	p.RegisterEventHandler(func(ev events.RoundEndedEvent) {
+		switch ev.Winner {
+		case common.TeamTerrorists:
+			tScoreBeforeSwap = p.GameState().TState().Score() + 1
+
+		case common.TeamCounterTerrorists:
+			ctScoreBeforeSwap = p.GameState().CTState().Score() + 1
+		}
+	})
+
+	p.RegisterEventHandler(func(fuzzy.TeamSwitchEvent) {
+		teamSwitchDone = true
+		if tScoreBeforeSwap != p.GameState().CTState().Score() {
+			t.Error("T-Score before swap != CT-Score after swap")
+		}
+		if ctScoreBeforeSwap != p.GameState().TState().Score() {
+			t.Error("CT-Score before swap != T-Score after swap")
+		}
+	})
+
+	err = p.ParseToEnd()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if !teamSwitchDone {
+		t.Fatal("TeamSwitchEvent not received")
+	}
+}
+
 func TestCancelParseToEnd(t *testing.T) {
 	f, err := os.Open(defaultDemPath)
 	if err != nil {

fuzzy/team_switch.go

@@ -0,0 +1,72 @@
+package fuzzy
+
+import (
+	dem "github.com/markus-wa/demoinfocs-golang"
+	common "github.com/markus-wa/demoinfocs-golang/common"
+	events "github.com/markus-wa/demoinfocs-golang/events"
+	dp "github.com/markus-wa/godispatch"
+)
+
+// TeamSwitchEvent signals that the teams have switched.
+// See also: ValveMatchmakingTeamSwitchEmitter
+type TeamSwitchEvent struct{}
+
+// ValveMatchmakingTeamSwitchEmitter emits a TeamSwitchEvent for Valve MM demos.
+// Sadly this WON'T work for Major games as it currently doesn't account for overtime.
+// This is a beta feature and may be changed or replaced without notice.
+// See also: github.com/markus-wa/demoinfocs-golang/ParserConfig.AdditionalEventEmitters
+type ValveMatchmakingTeamSwitchEmitter struct {
+	parser              *dem.Parser
+	dispatch            func(interface{})
+	currentHandlerID    dp.HandlerIdentifier
+	tScoreBeforeSwitch  int
+	ctScoreBeforeSwitch int
+}
+
+// Register registers the emitter on the parser. It should only be used by the parser.
+func (em *ValveMatchmakingTeamSwitchEmitter) Register(parser *dem.Parser, dispatch func(interface{})) {
+	em.parser = parser
+	em.dispatch = dispatch
+
+	em.currentHandlerID = parser.RegisterEventHandler(em.handleLastRoundHalf)
+}
+
+// Get to the last round of the first half
+func (em *ValveMatchmakingTeamSwitchEmitter) handleLastRoundHalf(events.LastRoundHalfEvent) {
+	em.parser.UnregisterEventHandler(em.currentHandlerID)
+	em.currentHandlerID = em.parser.RegisterEventHandler(em.handleRoundEnded)
+}
+
+// Get scores before switch
+func (em *ValveMatchmakingTeamSwitchEmitter) handleRoundEnded(ev events.RoundEndedEvent) {
+	em.tScoreBeforeSwitch = em.parser.GameState().TState().Score()
+	em.ctScoreBeforeSwitch = em.parser.GameState().CTState().Score()
+
+	// Score hasn't been updated yet because CS:GO demos are weird
+	switch ev.Winner {
+	case common.TeamTerrorists:
+		em.tScoreBeforeSwitch++
+	case common.TeamCounterTerrorists:
+		em.ctScoreBeforeSwitch++
+	}
+
+	em.parser.UnregisterEventHandler(em.currentHandlerID)
+	em.currentHandlerID = em.parser.RegisterEventHandler(em.handleRoundStarted)
+}
+
+// Find first round of second half
+func (em *ValveMatchmakingTeamSwitchEmitter) handleRoundStarted(events.RoundStartedEvent) {
+	em.parser.UnregisterEventHandler(em.currentHandlerID)
+	em.currentHandlerID = em.parser.RegisterEventHandler(em.handleTickDone)
+}
+
+// Wait for score to update - this isn't (necessarily?) the case after RoundStartedEvent
+func (em *ValveMatchmakingTeamSwitchEmitter) handleTickDone(events.TickDoneEvent) {
+	tScoreOk := em.parser.GameState().TState().Score() == em.ctScoreBeforeSwitch
+	ctScoreOk := em.parser.GameState().CTState().Score() == em.tScoreBeforeSwitch
+	if tScoreOk && ctScoreOk {
+		em.dispatch(TeamSwitchEvent{})
+
+		em.parser.UnregisterEventHandler(em.currentHandlerID)
+	}
+}

parser.go

@@ -166,6 +166,18 @@ type ParserConfig struct {
 	// Check out demopacket.go to see which net-messages are already being parsed by default.
 	// This is a beta feature and may be changed or replaced without notice.
 	AdditionalNetMessageCreators map[int]NetMessageCreator
+	// AdditionalEventEmitters contains additional event emitters - either from the fuzzy package or custom ones.
+	// This is mainly used to add logic specifically for one type of demo (e.g. Matchmaking, FaceIt etc.).
+	// This is a beta feature and may be changed or replaced without notice.
+	// See also: package fuzzy for existing emitters with fuzzy-logic that depends on the demo-type.
+	AdditionalEventEmitters []EventEmitter
+}
+
+// EventEmitter is the interface to define additional event-emitters.
+// The emitters may fire additional events by calling the eventDispatcher function received during registration of the emitter.
+// See also: package fuzzy for existing emitters with fuzzy-logic that depends on the demo-type.
+type EventEmitter interface {
+	Register(parser *Parser, eventDispatcher func(event interface{}))
 }
 
 // DefaultParserConfig is the default Parser configuration used by NewParser().
@@ -207,6 +219,10 @@ func NewParserWithConfig(demostream io.Reader, config ParserConfig) *Parser {
 
 	p.additionalNetMessageCreators = config.AdditionalNetMessageCreators
 
+	for _, emitter := range config.AdditionalEventEmitters {
+		emitter.Register(&p, p.eventDispatcher.Dispatch)
+	}
+
 	return &p
 }