CS2 POV demo support

Author: markus-wa

pkg/demoinfocs/datatables.go

@@ -1003,7 +1003,18 @@ func (p *parser) nadeProjectileDestroyed(proj *common.GrenadeProjectile) {
 
 func (p *parser) bindWeaponS2(entity st.Entity) {
 	entityID := entity.ID()
-	itemIndex := entity.PropertyValueMust("m_iItemDefinitionIndex").S2UInt64()
+	itemIndexVal := entity.PropertyValueMust("m_iItemDefinitionIndex")
+
+	if itemIndexVal.Any == nil {
+		p.eventDispatcher.Dispatch(events.ParserWarn{
+			Type:    events.WarnTypeMissingItemDefinitionIndex,
+			Message: "missing m_iItemDefinitionIndex property in weapon entity",
+		})
+
+		return
+	}
+
+	itemIndex := itemIndexVal.S2UInt64()
 	wepType := common.EquipmentIndexMapping[itemIndex]
 
 	if wepType == common.EqUnknown {

pkg/demoinfocs/demoinfocs_test.go

@@ -38,6 +38,7 @@ const (
 	retakeDemPath           = csDemosPath + "/retake_unknwon_bombsite_index.dem"
 	unexpectedEndOfDemoPath = csDemosPath + "/unexpected_end_of_demo.dem"
 	s2DemPath               = demSetPathS2 + "/s2.dem"
+	s2POVDemPath            = demSetPathS2 + "/pov.dem"
 )
 
 var concurrentDemos = flag.Int("concurrentdemos", 2, "The `number` of current demos")
@@ -231,6 +232,26 @@ func TestS2(t *testing.T) {
 	assertions.NoError(err, "error occurred in ParseToEnd()")
 }
 
+func TestS2POV(t *testing.T) {
+	t.Parallel()
+
+	if testing.Short() {
+		t.Skip("skipping test due to -short flag")
+	}
+
+	f, err := os.Open(s2POVDemPath)
+	assertions := assert.New(t)
+	assertions.NoError(err, "error opening demo %q", s2POVDemPath)
+
+	defer mustClose(t, f)
+
+	p := demoinfocs.NewParser(f)
+
+	t.Log("Parsing to end")
+	err = p.ParseToEnd()
+	assertions.NoError(err, "error occurred in ParseToEnd()")
+}
+
 func TestEncryptedNetMessages(t *testing.T) {
 	t.Parallel()
 
@@ -524,6 +545,10 @@ func testDemoSet(t *testing.T, path string) {
 						t.Log("expected known issue with team swaps occurred:", warn.Message)
 						return
 
+					case events.WarnTypeMissingItemDefinitionIndex:
+						t.Log("expected known issue with missing item definition index occurred:", warn.Message)
+						return
+
 					case events.WarnTypeGameEventBeforeDescriptors:
 						if strings.Contains(name, "POV-orbit-skytten-vs-cloud9-gfinity15sm1-nuke.dem") {
 							t.Log("expected known issue for POV demos occurred:", warn.Message)

pkg/demoinfocs/events/events.go

@@ -581,6 +581,7 @@ const (
 	WarnTypeCantReadEncryptedNetMessage
 
 	WarnTypeUnknownEquipmentIndex
+	WarnTypeMissingItemDefinitionIndex
 )
 
 // ParserWarn signals that a non-fatal problem occurred during parsing.

pkg/demoinfocs/game_events.go

@@ -240,6 +240,7 @@ func newGameEventHandler(parser *parser, ignoreBombsiteIndexNotFound bool) gameE
 		"item_remove":                     geh.itemRemove,                        // Dropped?
 		"jointeam_failed":                 nil,                                   // Dunno, only in locally recorded (POV) demos
 		"other_death":                     geh.otherDeath,                        // Other deaths, like chickens.
+		"player_activate":                 nil,                                   // CS2 POV demos
 		"player_blind":                    delay(geh.playerBlind),                // Player got blinded by a flash. Delayed because Player.FlashDuration hasn't been updated yet
 		"player_changename":               nil,                                   // Name change
 		"player_connect":                  geh.playerConnect,                     // Bot connected or player reconnected, players normally come in via string tables & data tables

pkg/demoinfocs/sendtables2/entity.go

@@ -519,16 +519,16 @@ func (p *Parser) OnPacketEntities(m *msgs2.CSVCMsg_PacketEntities) error {
 					_panicf("unable to find new class %d", classID)
 				}
 
-				baseline := p.classBaselines[classID]
-				if baseline == nil {
-					_panicf("unable to find new baseline %d", classID)
-				}
-
 				e = newEntity(index, serial, class)
 				p.entities[index] = e
 
-				e.readFields(newReader(baseline), &paths)
-				paths = paths[:0]
+				baseline := p.classBaselines[classID]
+
+				if baseline != nil {
+					// POV demos are missing some baselines?
+					e.readFields(newReader(baseline), &paths)
+					paths = paths[:0]
+				}
 
 				e.readFields(r, &paths)
 				paths = paths[:0]

pkg/demoinfocs/stringtables.go

@@ -303,6 +303,10 @@ func parseStringTable(
 	flags int32,
 	variantBitCount bool) (items []*stringTableItem) {
 	items = make([]*stringTableItem, 0)
+	// Some tables have no data
+	if len(buf) == 0 {
+		return items
+	}
 
 	// Create a reader for the buffer
 	r := bit.NewSmallBitReader(bytes.NewReader(buf))
@@ -312,14 +316,9 @@ func parseStringTable(
 	index := int32(-1)
 	keys := make([]string, 0, stringtableKeyHistorySize+1)
 
-	// Some tables have no data
-	if len(buf) == 0 {
-		return items
-	}
-
 	// Loop through entries in the data structure
 	//
-	// Each entry is a tuple consisting of {index, key, value}
+	// Each entry is a tuple consisting of {index, missing m_iItemDefinitionIndex property key, value}
 	//
 	// Index can either be incremented from the previous position or
 	// overwritten with a given entry.
@@ -373,46 +372,49 @@ func parseStringTable(
 			if len(keys) > stringtableKeyHistorySize {
 				keys = keys[1:]
 			}
-		}
 
-		// Some entries have a value.
-		hasValue := r.ReadBit()
-		if hasValue {
-			bitSize := uint(0)
-			isCompressed := false
-			if userDataFixed {
-				bitSize = uint(userDataSize)
-			} else {
-				if (flags & 0x1) != 0 {
-					isCompressed = r.ReadBit()
-				}
+			// Some entries have a value.
+			hasValue := r.ReadBit()
+			if hasValue {
+				bitSize := uint(0)
+				isCompressed := false
 
-				if variantBitCount {
-					bitSize = r.ReadUBitInt() * 8
+				if userDataFixed {
+					bitSize = uint(userDataSize)
 				} else {
-					bitSize = r.ReadInt(17) * 8
+					if (flags & 0x1) != 0 {
+						isCompressed = r.ReadBit()
+					}
+
+					if variantBitCount {
+						bitSize = r.ReadUBitInt() * 8
+					} else {
+						bitSize = r.ReadInt(17) * 8
+					}
 				}
-			}
-			value = r.ReadBits(int(bitSize))
 
-			if isCompressed {
-				tmp, err := snappy.Decode(nil, value)
-				if err != nil {
-					panic(fmt.Sprintf("unable to decode snappy compressed stringtable item (%s, %d, %s): %s", name, index, key, err))
+				value = r.ReadBits(int(bitSize))
+
+				if isCompressed {
+					tmp, err := snappy.Decode(nil, value)
+					if err != nil {
+						panic(fmt.Sprintf("unable to decode snappy compressed stringtable item (%s, %d, %s): %s", name, index, key, err))
+					}
+
+					value = tmp
 				}
-				value = tmp
 			}
-		}
 
-		items = append(items, &stringTableItem{index, key, value})
+			items = append(items, &stringTableItem{index, key, value})
+		}
 	}
 
 	return items
 }
 
 var instanceBaselineKeyRegex = regexp.MustCompile(`^\d+:\d+$`)
 
-func (p *parser) processStringTableS2(tab createStringTable, br *bit.BitReader) {
+func (p *parser) processStringTableS2(tab createStringTable) {
 	items := parseStringTable(tab.StringData, tab.GetNumEntries(), tab.GetName(), tab.GetUserDataFixedSize(), tab.GetUserDataSize(), tab.GetFlags(), tab.GetUsingVarintBitcounts())
 
 	for _, item := range items {
@@ -452,23 +454,23 @@ func (p *parser) processStringTable(tab createStringTable) {
 		tab.StringData = b
 	}
 
-	br := bit.NewSmallBitReader(bytes.NewReader(tab.StringData))
-
 	if tab.isS2 {
-		p.processStringTableS2(tab, br)
+		p.processStringTableS2(tab)
 	} else {
+		br := bit.NewSmallBitReader(bytes.NewReader(tab.StringData))
+
 		if br.ReadBit() {
 			panic("unknown stringtable format")
 		}
 
 		p.processStringTableS1(tab, br)
+
+		p.poolBitReader(br)
 	}
 
 	if tab.GetName() == stNameModelPreCache {
 		p.processModelPreCacheUpdate()
 	}
-
-	p.poolBitReader(br)
 }
 
 func parsePlayerInfo(reader io.Reader) common.PlayerInfo {