parsing: move code from demopacket.go to parsing.go

Author: markus-wa

demopacket.go

@@ -5,12 +5,13 @@ import (
 	"sync"
 	"time"
 
-	r3 "github.com/golang/geo/r3"
+	"github.com/gogo/protobuf/proto"
+	"github.com/golang/geo/r3"
 	dp "github.com/markus-wa/godispatch"
 
 	bit "github.com/markus-wa/demoinfocs-golang/bitread"
-	common "github.com/markus-wa/demoinfocs-golang/common"
-	msg "github.com/markus-wa/demoinfocs-golang/msg"
+	"github.com/markus-wa/demoinfocs-golang/common"
+	"github.com/markus-wa/demoinfocs-golang/msg"
 	st "github.com/markus-wa/demoinfocs-golang/sendtables"
 )
 
@@ -73,6 +74,11 @@ type Parser struct {
 	delayedEvents        []interface{}                                   // Contains events that need to be dispatched at the end of a tick (e.g. flash events because FlashDuration isn't updated before that)
 }
 
+// NetMessageCreator creates additional net-messages to be dispatched to net-message handlers.
+//
+// See also: ParserConfig.AdditionalNetMessageCreators & Parser.RegisterNetMessageHandler()
+type NetMessageCreator func() proto.Message
+
 type bombsite struct {
 	index  int
 	center r3.Vector
@@ -210,7 +216,7 @@ type ParserConfig struct {
 	// AdditionalNetMessageCreators maps net-message-IDs to creators (instantiators).
 	// The creators should return a new instance of the correct protobuf-message type (from the msg package).
 	// Interesting net-message-IDs can easily be discovered with the build-tag 'debugdemoinfocs'; when looking for 'UnhandledMessage'.
-	// Check out demopacket.go to see which net-messages are already being parsed by default.
+	// Check out parsing.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
 }

parser.go

@@ -4,10 +4,14 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"sync"
 	"time"
 
-	common "github.com/markus-wa/demoinfocs-golang/common"
-	events "github.com/markus-wa/demoinfocs-golang/events"
+	"github.com/gogo/protobuf/proto"
+
+	"github.com/markus-wa/demoinfocs-golang/common"
+	"github.com/markus-wa/demoinfocs-golang/events"
+	"github.com/markus-wa/demoinfocs-golang/msg"
 )
 
 const maxOsPath = 260
@@ -240,6 +244,97 @@ func (p *Parser) parseFrame() bool {
 	return true
 }
 
+var byteSlicePool = sync.Pool{
+	New: func() interface{} {
+		s := make([]byte, 0, 256)
+		return &s
+	},
+}
+
+func (p *Parser) parsePacket() {
+	// Booooring
+	// 152 bytes CommandInfo, 4 bytes SeqNrIn, 4 bytes SeqNrOut
+	// See at the bottom of the file what the CommandInfo would contain if you are interested.
+	p.bitReader.Skip((152 + 4 + 4) << 3)
+
+	// Here we go
+	p.bitReader.BeginChunk(p.bitReader.ReadSignedInt(32) << 3)
+	for !p.bitReader.ChunkFinished() {
+		cmd := int(p.bitReader.ReadVarInt32())
+		size := int(p.bitReader.ReadVarInt32())
+
+		p.bitReader.BeginChunk(size << 3)
+		var m proto.Message
+		switch cmd {
+		case int(msg.SVC_Messages_svc_PacketEntities):
+			// We could pool CSVCMsg_PacketEntities as they take up A LOT of the allocations
+			// but unless we're on a system that's doing a lot of concurrent parsing there isn't really a point
+			// as handling packets is a lot slower than creating them and we can't pool until they are handled.
+			m = new(msg.CSVCMsg_PacketEntities)
+
+		case int(msg.SVC_Messages_svc_GameEventList):
+			m = new(msg.CSVCMsg_GameEventList)
+
+		case int(msg.SVC_Messages_svc_GameEvent):
+			m = new(msg.CSVCMsg_GameEvent)
+
+		case int(msg.SVC_Messages_svc_CreateStringTable):
+			m = new(msg.CSVCMsg_CreateStringTable)
+
+		case int(msg.SVC_Messages_svc_UpdateStringTable):
+			m = new(msg.CSVCMsg_UpdateStringTable)
+
+		case int(msg.SVC_Messages_svc_UserMessage):
+			m = new(msg.CSVCMsg_UserMessage)
+
+		default:
+			var name string
+			if cmd < 8 || cmd >= 100 {
+				name = msg.NET_Messages_name[int32(cmd)]
+			} else {
+				name = msg.SVC_Messages_name[int32(cmd)]
+			}
+
+			if isDebug {
+				debugUnhandledMessage(cmd, name)
+			}
+
+			if name != "" {
+				// Handle additional net-messages as defined by the user
+				creator := p.additionalNetMessageCreators[cmd]
+				if creator != nil {
+					m = creator()
+					break
+				}
+			} else {
+				// Send a warning if the command is unknown
+				// This might mean our proto files are out of date
+				p.eventDispatcher.Dispatch(events.ParserWarn{Message: fmt.Sprintf("Unknown message command %q", cmd)})
+			}
+
+			// On to the next one
+			p.bitReader.EndChunk()
+			continue
+		}
+
+		b := byteSlicePool.Get().(*[]byte)
+		p.bitReader.ReadBytesInto(b, size)
+
+		if proto.Unmarshal(*b, m) != nil {
+			// TODO: Don't crash here, happens with demos that work in gotv
+			panic(fmt.Sprintf("Failed to unmarshal cmd %d", cmd))
+		}
+		p.msgQueue <- m
+
+		// Reset length to 0 and pool
+		*b = (*b)[:0]
+		byteSlicePool.Put(b)
+
+		p.bitReader.EndChunk()
+	}
+	p.bitReader.EndChunk()
+}
+
 type frameParsedTokenType struct{}
 
 var frameParsedToken = new(frameParsedTokenType)
@@ -255,3 +350,52 @@ func (p *Parser) handleFrameParsed(*frameParsedTokenType) {
 	p.currentFrame++
 	p.eventDispatcher.Dispatch(events.TickDone{})
 }
+
+/*
+Format of 'CommandInfos' - I honestly have no clue what they are good for.
+This data is skipped in Parser.parsePacket().
+If you find a use for this please let me know!
+
+Here is all i know:
+
+CommandInfo [152 bytes]
+- [2]Split
+
+Split [76 bytes]
+- flags [4 bytes]
+- viewOrigin [12 bytes]
+- viewAngles [12 bytes]
+- localViewAngles [12 bytes]
+- viewOrigin2 [12 bytes]
+- viewAngles2 [12 bytes]
+- localViewAngles2 [12 bytes]
+
+Origin [12 bytes]
+- X [4 bytes]
+- Y [4 bytes]
+- Z [4 bytes]
+
+Angle [12 bytes]
+- X [4 bytes]
+- Y [4 bytes]
+- Z [4 bytes]
+
+They are parsed in the following order:
+split1.flags
+split1.viewOrigin.x
+split1.viewOrigin.y
+split1.viewOrigin.z
+split1.viewAngles.x
+split1.viewAngles.y
+split1.viewAngles.z
+split1.localViewAngles.x
+split1.localViewAngles.y
+split1.localViewAngles.z
+split1.viewOrigin2...
+split1.viewAngles2...
+split1.localViewAngles2...
+split2.flags
+...
+
+Or just check this file's history for an example on how to parse them
+*/