events: add TeamState where applicable

Author: markus-wa

common/common.go

@@ -117,6 +117,9 @@ type TeamState struct {
 	//
 	// Watch out, in some demos this is upper-case and in some lower-case.
 	Flag string
+
+	// Terrorist TeamState for CTs, CT TeamState for Terrorists
+	Opponent *TeamState
 }
 
 // Team returns the team for which the TeamState contains data.

events/events.go

@@ -61,9 +61,11 @@ const (
 // Attention: TeamState.Score() won't be up to date yet after this.
 // Add +1 to the winner's score as a workaround.
 type RoundEnd struct {
-	Message string
-	Reason  RoundEndReason
-	Winner  common.Team
+	Message     string
+	Reason      RoundEndReason
+	Winner      common.Team
+	WinnerState *common.TeamState // TeamState of the winner. May be nil if it's a draw (Winner == TeamSpectators)
+	LoserState  *common.TeamState // TeamState of the loser. May be nil if it's a draw (Winner == TeamSpectators)
 }
 
 // RoundEndOfficial signals that the round has 'officially' ended.
@@ -107,11 +109,20 @@ type Footstep struct {
 
 // PlayerTeamChange occurs when a player swaps teams.
 type PlayerTeamChange struct {
-	Player  *common.Player
+	Player *common.Player
+
 	NewTeam common.Team
+	// TeamState of the old team.
+	// May be nil if player changed from spectators/unassigned (OldTeam == TeamSpectators || OldTeam == TeamUnassigned).
+	NewTeamState *common.TeamState
+
 	OldTeam common.Team
-	Silent  bool
-	IsBot   bool
+	// TeamState of the old team.
+	// May be nil if player changed from spectators/unassigned (OldTeam == TeamSpectators || OldTeam == TeamUnassigned).
+	OldTeamState *common.TeamState
+
+	Silent bool
+	IsBot  bool
 }
 
 // PlayerJump signals that a player has jumped.

game_events.go

@@ -59,19 +59,19 @@ func (p *Parser) handleGameEvent(ge *msg.CSVCMsg_GameEvent) {
 	case "round_end": // Round ended and the winner was announced
 		data = mapGameEventData(d, ge)
 
-		t := common.TeamSpectators
-
-		switch data["winner"].GetValByte() {
-		case int32(p.gameState.tState.ID):
-			t = common.TeamTerrorists
-		case int32(p.gameState.ctState.ID):
-			t = common.TeamCounterTerrorists
+		winner := common.Team(data["winner"].ValByte)
+		winnerState := p.gameState.Team(winner)
+		var loserState *common.TeamState
+		if winnerState != nil {
+			loserState = winnerState.Opponent
 		}
 
 		p.eventDispatcher.Dispatch(events.RoundEnd{
-			Message: data["message"].GetValString(),
-			Reason:  events.RoundEndReason(data["reason"].GetValByte()),
-			Winner:  t,
+			Message:     data["message"].GetValString(),
+			Reason:      events.RoundEndReason(data["reason"].GetValByte()),
+			Winner:      winner,
+			WinnerState: winnerState,
+			LoserState:  loserState,
 		})
 
 	case "round_officially_ended": // The event after which you get teleported to the spawn (=> You can still walk around between round_end and this event)
@@ -270,12 +270,15 @@ func (p *Parser) handleGameEvent(ge *msg.CSVCMsg_GameEvent) {
 			if player.Team != newTeam {
 				player.Team = newTeam
 
+				oldTeam := common.Team(data["oldteam"].GetValByte())
 				p.eventDispatcher.Dispatch(events.PlayerTeamChange{
-					Player:  player,
-					IsBot:   data["isbot"].GetValBool(),
-					Silent:  data["silent"].GetValBool(),
-					NewTeam: newTeam,
-					OldTeam: common.Team(data["oldteam"].GetValByte()),
+					Player:       player,
+					IsBot:        data["isbot"].GetValBool(),
+					Silent:       data["silent"].GetValBool(),
+					NewTeam:      newTeam,
+					NewTeamState: p.gameState.Team(newTeam),
+					OldTeam:      oldTeam,
+					OldTeamState: p.gameState.Team(oldTeam),
 				})
 			} else {
 				p.eventDispatcher.Dispatch(events.ParserWarn{

game_state.go

@@ -41,6 +41,19 @@ func (gs GameState) IngameTick() int {
 	return gs.ingameTick
 }
 
+// Team returns the TeamState corresponding to team.
+// Returns nil if team != TeamTerrorists && team != TeamCounterTerrorists.
+//
+// Make sure to handle swapping sides properly if you keep the reference.
+func (gs *GameState) Team(team common.Team) *common.TeamState {
+	if team == common.TeamTerrorists {
+		return &gs.tState
+	} else if team == common.TeamCounterTerrorists {
+		return &gs.ctState
+	}
+	return nil
+}
+
 // TeamCounterTerrorists returns the TeamState of the CT team.
 //
 // Make sure to handle swapping sides properly if you keep the reference.
@@ -103,8 +116,8 @@ func (gs GameState) IsMatchStarted() bool {
 	return gs.isMatchStarted
 }
 
-func newGameState() GameState {
-	return GameState{
+func newGameState() *GameState {
+	gs := &GameState{
 		playersByEntityID:  make(map[int]*common.Player),
 		playersByUserID:    make(map[int]*common.Player),
 		grenadeProjectiles: make(map[int]*common.GrenadeProjectile),
@@ -113,6 +126,11 @@ func newGameState() GameState {
 		tState:             common.NewTeamState(common.TeamTerrorists),
 		ctState:            common.NewTeamState(common.TeamCounterTerrorists),
 	}
+
+	gs.tState.Opponent = &gs.ctState
+	gs.ctState.Opponent = &gs.tState
+
+	return gs
 }
 
 // Participants provides helper functions on top of the currently connected players.

game_state_interface.go

@@ -14,6 +14,11 @@ type IGameState interface {
 	//
 	// Watch out, I've seen this return wonky negative numbers at the start of demos.
 	IngameTick() int
+	// Team returns the TeamState corresponding to team.
+	// Returns nil if team != TeamTerrorists && team != TeamCounterTerrorists.
+	//
+	// Make sure to handle swapping sides properly if you keep the reference.
+	Team(team common.Team) *common.TeamState
 	// TeamCounterTerrorists returns the TeamState of the CT team.
 	//
 	// Make sure to handle swapping sides properly if you keep the reference.

game_state_test.go

@@ -8,9 +8,23 @@ import (
 	"github.com/markus-wa/demoinfocs-golang/common"
 )
 
-func TestNewGameState(t *testing.T) {
+func TestNewGameState_TeamState_Team(t *testing.T) {
 	gs := newGameState()
 
 	assert.Equal(t, common.TeamTerrorists, gs.tState.Team())
 	assert.Equal(t, common.TeamCounterTerrorists, gs.ctState.Team())
 }
+
+func TestNewGameState_TeamState_Pointers(t *testing.T) {
+	gs := newGameState()
+
+	assert.True(t, gs.TeamCounterTerrorists() == &gs.ctState)
+	assert.True(t, gs.TeamTerrorists() == &gs.tState)
+}
+
+func TestNewGameState_TeamState_Opponent(t *testing.T) {
+	gs := newGameState()
+
+	assert.True(t, &gs.ctState == gs.tState.Opponent)
+	assert.True(t, &gs.tState == gs.ctState.Opponent)
+}

parser.go

@@ -232,7 +232,7 @@ func NewParserWithConfig(demostream io.Reader, config ParserConfig) *Parser {
 	p.rawPlayers = make(map[int]*playerInfo)
 	p.triggers = make(map[int]*boundingBoxInformation)
 	p.cancelChan = make(chan struct{}, 1)
-	p.gameState = newGameState()
+	p.gameState = *newGameState()
 	p.grenadeModelIndices = make(map[int]common.EquipmentElement)
 
 	// Attach proto msg handlers