summaryrefslogtreecommitdiffstats
path: root/vendor/github.com/Philipp15b/go-steam/protocol/steamlang/messages.go
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/github.com/Philipp15b/go-steam/protocol/steamlang/messages.go')
-rw-r--r--vendor/github.com/Philipp15b/go-steam/protocol/steamlang/messages.go2543
1 files changed, 2543 insertions, 0 deletions
diff --git a/vendor/github.com/Philipp15b/go-steam/protocol/steamlang/messages.go b/vendor/github.com/Philipp15b/go-steam/protocol/steamlang/messages.go
new file mode 100644
index 00000000..fa5028d8
--- /dev/null
+++ b/vendor/github.com/Philipp15b/go-steam/protocol/steamlang/messages.go
@@ -0,0 +1,2543 @@
+// Generated code
+// DO NOT EDIT
+
+package steamlang
+
+import (
+ "encoding/binary"
+ . "github.com/Philipp15b/go-steam/protocol/protobuf"
+ "github.com/Philipp15b/go-steam/rwu"
+ "github.com/Philipp15b/go-steam/steamid"
+ "github.com/golang/protobuf/proto"
+ "io"
+)
+
+const UdpHeader_MAGIC uint32 = 0x31305356
+
+type UdpHeader struct {
+ Magic uint32
+ PayloadSize uint16
+ PacketType EUdpPacketType
+ Flags uint8
+ SourceConnID uint32
+ DestConnID uint32
+ SeqThis uint32
+ SeqAck uint32
+ PacketsInMsg uint32
+ MsgStartSeq uint32
+ MsgSize uint32
+}
+
+func NewUdpHeader() *UdpHeader {
+ return &UdpHeader{
+ Magic: UdpHeader_MAGIC,
+ PacketType: EUdpPacketType_Invalid,
+ SourceConnID: 512,
+ }
+}
+
+func (d *UdpHeader) Serialize(w io.Writer) error {
+ var err error
+ err = binary.Write(w, binary.LittleEndian, d.Magic)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.PayloadSize)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.PacketType)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.Flags)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.SourceConnID)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.DestConnID)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.SeqThis)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.SeqAck)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.PacketsInMsg)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.MsgStartSeq)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.MsgSize)
+ return err
+}
+
+func (d *UdpHeader) Deserialize(r io.Reader) error {
+ var err error
+ d.Magic, err = rwu.ReadUint32(r)
+ if err != nil {
+ return err
+ }
+ d.PayloadSize, err = rwu.ReadUint16(r)
+ if err != nil {
+ return err
+ }
+ t0, err := rwu.ReadUint8(r)
+ if err != nil {
+ return err
+ }
+ d.PacketType = EUdpPacketType(t0)
+ d.Flags, err = rwu.ReadUint8(r)
+ if err != nil {
+ return err
+ }
+ d.SourceConnID, err = rwu.ReadUint32(r)
+ if err != nil {
+ return err
+ }
+ d.DestConnID, err = rwu.ReadUint32(r)
+ if err != nil {
+ return err
+ }
+ d.SeqThis, err = rwu.ReadUint32(r)
+ if err != nil {
+ return err
+ }
+ d.SeqAck, err = rwu.ReadUint32(r)
+ if err != nil {
+ return err
+ }
+ d.PacketsInMsg, err = rwu.ReadUint32(r)
+ if err != nil {
+ return err
+ }
+ d.MsgStartSeq, err = rwu.ReadUint32(r)
+ if err != nil {
+ return err
+ }
+ d.MsgSize, err = rwu.ReadUint32(r)
+ return err
+}
+
+const ChallengeData_CHALLENGE_MASK uint32 = 0xA426DF2B
+
+type ChallengeData struct {
+ ChallengeValue uint32
+ ServerLoad uint32
+}
+
+func NewChallengeData() *ChallengeData {
+ return &ChallengeData{}
+}
+
+func (d *ChallengeData) Serialize(w io.Writer) error {
+ var err error
+ err = binary.Write(w, binary.LittleEndian, d.ChallengeValue)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.ServerLoad)
+ return err
+}
+
+func (d *ChallengeData) Deserialize(r io.Reader) error {
+ var err error
+ d.ChallengeValue, err = rwu.ReadUint32(r)
+ if err != nil {
+ return err
+ }
+ d.ServerLoad, err = rwu.ReadUint32(r)
+ return err
+}
+
+const ConnectData_CHALLENGE_MASK uint32 = ChallengeData_CHALLENGE_MASK
+
+type ConnectData struct {
+ ChallengeValue uint32
+}
+
+func NewConnectData() *ConnectData {
+ return &ConnectData{}
+}
+
+func (d *ConnectData) Serialize(w io.Writer) error {
+ var err error
+ err = binary.Write(w, binary.LittleEndian, d.ChallengeValue)
+ return err
+}
+
+func (d *ConnectData) Deserialize(r io.Reader) error {
+ var err error
+ d.ChallengeValue, err = rwu.ReadUint32(r)
+ return err
+}
+
+type Accept struct {
+}
+
+func NewAccept() *Accept {
+ return &Accept{}
+}
+
+func (d *Accept) Serialize(w io.Writer) error {
+ var err error
+ return err
+}
+
+func (d *Accept) Deserialize(r io.Reader) error {
+ var err error
+ return err
+}
+
+type Datagram struct {
+}
+
+func NewDatagram() *Datagram {
+ return &Datagram{}
+}
+
+func (d *Datagram) Serialize(w io.Writer) error {
+ var err error
+ return err
+}
+
+func (d *Datagram) Deserialize(r io.Reader) error {
+ var err error
+ return err
+}
+
+type Disconnect struct {
+}
+
+func NewDisconnect() *Disconnect {
+ return &Disconnect{}
+}
+
+func (d *Disconnect) Serialize(w io.Writer) error {
+ var err error
+ return err
+}
+
+func (d *Disconnect) Deserialize(r io.Reader) error {
+ var err error
+ return err
+}
+
+type MsgHdr struct {
+ Msg EMsg
+ TargetJobID uint64
+ SourceJobID uint64
+}
+
+func NewMsgHdr() *MsgHdr {
+ return &MsgHdr{
+ Msg: EMsg_Invalid,
+ TargetJobID: ^uint64(0),
+ SourceJobID: ^uint64(0),
+ }
+}
+
+func (d *MsgHdr) Serialize(w io.Writer) error {
+ var err error
+ err = binary.Write(w, binary.LittleEndian, d.Msg)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.TargetJobID)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.SourceJobID)
+ return err
+}
+
+func (d *MsgHdr) Deserialize(r io.Reader) error {
+ var err error
+ t0, err := rwu.ReadInt32(r)
+ if err != nil {
+ return err
+ }
+ d.Msg = EMsg(t0)
+ d.TargetJobID, err = rwu.ReadUint64(r)
+ if err != nil {
+ return err
+ }
+ d.SourceJobID, err = rwu.ReadUint64(r)
+ return err
+}
+
+type ExtendedClientMsgHdr struct {
+ Msg EMsg
+ HeaderSize uint8
+ HeaderVersion uint16
+ TargetJobID uint64
+ SourceJobID uint64
+ HeaderCanary uint8
+ SteamID steamid.SteamId
+ SessionID int32
+}
+
+func NewExtendedClientMsgHdr() *ExtendedClientMsgHdr {
+ return &ExtendedClientMsgHdr{
+ Msg: EMsg_Invalid,
+ HeaderSize: 36,
+ HeaderVersion: 2,
+ TargetJobID: ^uint64(0),
+ SourceJobID: ^uint64(0),
+ HeaderCanary: 239,
+ }
+}
+
+func (d *ExtendedClientMsgHdr) Serialize(w io.Writer) error {
+ var err error
+ err = binary.Write(w, binary.LittleEndian, d.Msg)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.HeaderSize)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.HeaderVersion)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.TargetJobID)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.SourceJobID)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.HeaderCanary)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.SteamID)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.SessionID)
+ return err
+}
+
+func (d *ExtendedClientMsgHdr) Deserialize(r io.Reader) error {
+ var err error
+ t0, err := rwu.ReadInt32(r)
+ if err != nil {
+ return err
+ }
+ d.Msg = EMsg(t0)
+ d.HeaderSize, err = rwu.ReadUint8(r)
+ if err != nil {
+ return err
+ }
+ d.HeaderVersion, err = rwu.ReadUint16(r)
+ if err != nil {
+ return err
+ }
+ d.TargetJobID, err = rwu.ReadUint64(r)
+ if err != nil {
+ return err
+ }
+ d.SourceJobID, err = rwu.ReadUint64(r)
+ if err != nil {
+ return err
+ }
+ d.HeaderCanary, err = rwu.ReadUint8(r)
+ if err != nil {
+ return err
+ }
+ t1, err := rwu.ReadUint64(r)
+ if err != nil {
+ return err
+ }
+ d.SteamID = steamid.SteamId(t1)
+ d.SessionID, err = rwu.ReadInt32(r)
+ return err
+}
+
+type MsgHdrProtoBuf struct {
+ Msg EMsg
+ HeaderLength int32
+ Proto *CMsgProtoBufHeader
+}
+
+func NewMsgHdrProtoBuf() *MsgHdrProtoBuf {
+ return &MsgHdrProtoBuf{
+ Msg: EMsg_Invalid,
+ Proto: new(CMsgProtoBufHeader),
+ }
+}
+
+func (d *MsgHdrProtoBuf) Serialize(w io.Writer) error {
+ var err error
+ buf0, err := proto.Marshal(d.Proto)
+ if err != nil {
+ return err
+ }
+ d.HeaderLength = int32(len(buf0))
+ err = binary.Write(w, binary.LittleEndian, EMsg(uint32(d.Msg)|ProtoMask))
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.HeaderLength)
+ if err != nil {
+ return err
+ }
+ _, err = w.Write(buf0)
+ return err
+}
+
+func (d *MsgHdrProtoBuf) Deserialize(r io.Reader) error {
+ var err error
+ t0, err := rwu.ReadInt32(r)
+ if err != nil {
+ return err
+ }
+ d.Msg = EMsg(uint32(t0) & EMsgMask)
+ d.HeaderLength, err = rwu.ReadInt32(r)
+ if err != nil {
+ return err
+ }
+ buf1 := make([]byte, d.HeaderLength, d.HeaderLength)
+ _, err = io.ReadFull(r, buf1)
+ if err != nil {
+ return err
+ }
+ err = proto.Unmarshal(buf1, d.Proto)
+ return err
+}
+
+type MsgGCHdrProtoBuf struct {
+ Msg uint32
+ HeaderLength int32
+ Proto *CMsgProtoBufHeader
+}
+
+func NewMsgGCHdrProtoBuf() *MsgGCHdrProtoBuf {
+ return &MsgGCHdrProtoBuf{
+ Msg: 0,
+ Proto: new(CMsgProtoBufHeader),
+ }
+}
+
+func (d *MsgGCHdrProtoBuf) Serialize(w io.Writer) error {
+ var err error
+ buf0, err := proto.Marshal(d.Proto)
+ if err != nil {
+ return err
+ }
+ d.HeaderLength = int32(len(buf0))
+ err = binary.Write(w, binary.LittleEndian, EMsg(uint32(d.Msg)|ProtoMask))
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.HeaderLength)
+ if err != nil {
+ return err
+ }
+ _, err = w.Write(buf0)
+ return err
+}
+
+func (d *MsgGCHdrProtoBuf) Deserialize(r io.Reader) error {
+ var err error
+ t0, err := rwu.ReadUint32(r)
+ if err != nil {
+ return err
+ }
+ d.Msg = uint32(t0) & EMsgMask
+ d.HeaderLength, err = rwu.ReadInt32(r)
+ if err != nil {
+ return err
+ }
+ buf1 := make([]byte, d.HeaderLength, d.HeaderLength)
+ _, err = io.ReadFull(r, buf1)
+ if err != nil {
+ return err
+ }
+ err = proto.Unmarshal(buf1, d.Proto)
+ return err
+}
+
+type MsgGCHdr struct {
+ HeaderVersion uint16
+ TargetJobID uint64
+ SourceJobID uint64
+}
+
+func NewMsgGCHdr() *MsgGCHdr {
+ return &MsgGCHdr{
+ HeaderVersion: 1,
+ TargetJobID: ^uint64(0),
+ SourceJobID: ^uint64(0),
+ }
+}
+
+func (d *MsgGCHdr) Serialize(w io.Writer) error {
+ var err error
+ err = binary.Write(w, binary.LittleEndian, d.HeaderVersion)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.TargetJobID)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.SourceJobID)
+ return err
+}
+
+func (d *MsgGCHdr) Deserialize(r io.Reader) error {
+ var err error
+ d.HeaderVersion, err = rwu.ReadUint16(r)
+ if err != nil {
+ return err
+ }
+ d.TargetJobID, err = rwu.ReadUint64(r)
+ if err != nil {
+ return err
+ }
+ d.SourceJobID, err = rwu.ReadUint64(r)
+ return err
+}
+
+type MsgClientJustStrings struct {
+}
+
+func NewMsgClientJustStrings() *MsgClientJustStrings {
+ return &MsgClientJustStrings{}
+}
+
+func (d *MsgClientJustStrings) GetEMsg() EMsg {
+ return EMsg_Invalid
+}
+
+func (d *MsgClientJustStrings) Serialize(w io.Writer) error {
+ var err error
+ return err
+}
+
+func (d *MsgClientJustStrings) Deserialize(r io.Reader) error {
+ var err error
+ return err
+}
+
+type MsgClientGenericResponse struct {
+ Result EResult
+}
+
+func NewMsgClientGenericResponse() *MsgClientGenericResponse {
+ return &MsgClientGenericResponse{}
+}
+
+func (d *MsgClientGenericResponse) GetEMsg() EMsg {
+ return EMsg_Invalid
+}
+
+func (d *MsgClientGenericResponse) Serialize(w io.Writer) error {
+ var err error
+ err = binary.Write(w, binary.LittleEndian, d.Result)
+ return err
+}
+
+func (d *MsgClientGenericResponse) Deserialize(r io.Reader) error {
+ var err error
+ t0, err := rwu.ReadInt32(r)
+ d.Result = EResult(t0)
+ return err
+}
+
+const MsgChannelEncryptRequest_PROTOCOL_VERSION uint32 = 1
+
+type MsgChannelEncryptRequest struct {
+ ProtocolVersion uint32
+ Universe EUniverse
+}
+
+func NewMsgChannelEncryptRequest() *MsgChannelEncryptRequest {
+ return &MsgChannelEncryptRequest{
+ ProtocolVersion: MsgChannelEncryptRequest_PROTOCOL_VERSION,
+ Universe: EUniverse_Invalid,
+ }
+}
+
+func (d *MsgChannelEncryptRequest) GetEMsg() EMsg {
+ return EMsg_ChannelEncryptRequest
+}
+
+func (d *MsgChannelEncryptRequest) Serialize(w io.Writer) error {
+ var err error
+ err = binary.Write(w, binary.LittleEndian, d.ProtocolVersion)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.Universe)
+ return err
+}
+
+func (d *MsgChannelEncryptRequest) Deserialize(r io.Reader) error {
+ var err error
+ d.ProtocolVersion, err = rwu.ReadUint32(r)
+ if err != nil {
+ return err
+ }
+ t0, err := rwu.ReadInt32(r)
+ d.Universe = EUniverse(t0)
+ return err
+}
+
+type MsgChannelEncryptResponse struct {
+ ProtocolVersion uint32
+ KeySize uint32
+}
+
+func NewMsgChannelEncryptResponse() *MsgChannelEncryptResponse {
+ return &MsgChannelEncryptResponse{
+ ProtocolVersion: MsgChannelEncryptRequest_PROTOCOL_VERSION,
+ KeySize: 128,
+ }
+}
+
+func (d *MsgChannelEncryptResponse) GetEMsg() EMsg {
+ return EMsg_ChannelEncryptResponse
+}
+
+func (d *MsgChannelEncryptResponse) Serialize(w io.Writer) error {
+ var err error
+ err = binary.Write(w, binary.LittleEndian, d.ProtocolVersion)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.KeySize)
+ return err
+}
+
+func (d *MsgChannelEncryptResponse) Deserialize(r io.Reader) error {
+ var err error
+ d.ProtocolVersion, err = rwu.ReadUint32(r)
+ if err != nil {
+ return err
+ }
+ d.KeySize, err = rwu.ReadUint32(r)
+ return err
+}
+
+type MsgChannelEncryptResult struct {
+ Result EResult
+}
+
+func NewMsgChannelEncryptResult() *MsgChannelEncryptResult {
+ return &MsgChannelEncryptResult{
+ Result: EResult_Invalid,
+ }
+}
+
+func (d *MsgChannelEncryptResult) GetEMsg() EMsg {
+ return EMsg_ChannelEncryptResult
+}
+
+func (d *MsgChannelEncryptResult) Serialize(w io.Writer) error {
+ var err error
+ err = binary.Write(w, binary.LittleEndian, d.Result)
+ return err
+}
+
+func (d *MsgChannelEncryptResult) Deserialize(r io.Reader) error {
+ var err error
+ t0, err := rwu.ReadInt32(r)
+ d.Result = EResult(t0)
+ return err
+}
+
+type MsgClientNewLoginKey struct {
+ UniqueID uint32
+ LoginKey []uint8
+}
+
+func NewMsgClientNewLoginKey() *MsgClientNewLoginKey {
+ return &MsgClientNewLoginKey{
+ LoginKey: make([]uint8, 20, 20),
+ }
+}
+
+func (d *MsgClientNewLoginKey) GetEMsg() EMsg {
+ return EMsg_ClientNewLoginKey
+}
+
+func (d *MsgClientNewLoginKey) Serialize(w io.Writer) error {
+ var err error
+ err = binary.Write(w, binary.LittleEndian, d.UniqueID)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.LoginKey)
+ return err
+}
+
+func (d *MsgClientNewLoginKey) Deserialize(r io.Reader) error {
+ var err error
+ d.UniqueID, err = rwu.ReadUint32(r)
+ if err != nil {
+ return err
+ }
+ err = binary.Read(r, binary.LittleEndian, d.LoginKey)
+ return err
+}
+
+type MsgClientNewLoginKeyAccepted struct {
+ UniqueID uint32
+}
+
+func NewMsgClientNewLoginKeyAccepted() *MsgClientNewLoginKeyAccepted {
+ return &MsgClientNewLoginKeyAccepted{}
+}
+
+func (d *MsgClientNewLoginKeyAccepted) GetEMsg() EMsg {
+ return EMsg_ClientNewLoginKeyAccepted
+}
+
+func (d *MsgClientNewLoginKeyAccepted) Serialize(w io.Writer) error {
+ var err error
+ err = binary.Write(w, binary.LittleEndian, d.UniqueID)
+ return err
+}
+
+func (d *MsgClientNewLoginKeyAccepted) Deserialize(r io.Reader) error {
+ var err error
+ d.UniqueID, err = rwu.ReadUint32(r)
+ return err
+}
+
+const (
+ MsgClientLogon_ObfuscationMask uint32 = 0xBAADF00D
+ MsgClientLogon_CurrentProtocol uint32 = 65579
+ MsgClientLogon_ProtocolVerMajorMask uint32 = 0xFFFF0000
+ MsgClientLogon_ProtocolVerMinorMask uint32 = 0xFFFF
+ MsgClientLogon_ProtocolVerMinorMinGameServers uint16 = 4
+ MsgClientLogon_ProtocolVerMinorMinForSupportingEMsgMulti uint16 = 12
+ MsgClientLogon_ProtocolVerMinorMinForSupportingEMsgClientEncryptPct uint16 = 14
+ MsgClientLogon_ProtocolVerMinorMinForExtendedMsgHdr uint16 = 17
+ MsgClientLogon_ProtocolVerMinorMinForCellId uint16 = 18
+ MsgClientLogon_ProtocolVerMinorMinForSessionIDLast uint16 = 19
+ MsgClientLogon_ProtocolVerMinorMinForServerAvailablityMsgs uint16 = 24
+ MsgClientLogon_ProtocolVerMinorMinClients uint16 = 25
+ MsgClientLogon_ProtocolVerMinorMinForOSType uint16 = 26
+ MsgClientLogon_ProtocolVerMinorMinForCegApplyPESig uint16 = 27
+ MsgClientLogon_ProtocolVerMinorMinForMarketingMessages2 uint16 = 27
+ MsgClientLogon_ProtocolVerMinorMinForAnyProtoBufMessages uint16 = 28
+ MsgClientLogon_ProtocolVerMinorMinForProtoBufLoggedOffMessage uint16 = 28
+ MsgClientLogon_ProtocolVerMinorMinForProtoBufMultiMessages uint16 = 28
+ MsgClientLogon_ProtocolVerMinorMinForSendingProtocolToUFS uint16 = 30
+ MsgClientLogon_ProtocolVerMinorMinForMachineAuth uint16 = 33
+ MsgClientLogon_ProtocolVerMinorMinForSessionIDLastAnon uint16 = 36
+ MsgClientLogon_ProtocolVerMinorMinForEnhancedAppList uint16 = 40
+ MsgClientLogon_ProtocolVerMinorMinForGzipMultiMessages uint16 = 43
+)
+
+type MsgClientLogon struct {
+}
+
+func NewMsgClientLogon() *MsgClientLogon {
+ return &MsgClientLogon{}
+}
+
+func (d *MsgClientLogon) GetEMsg() EMsg {
+ return EMsg_ClientLogon
+}
+
+func (d *MsgClientLogon) Serialize(w io.Writer) error {
+ var err error
+ return err
+}
+
+func (d *MsgClientLogon) Deserialize(r io.Reader) error {
+ var err error
+ return err
+}
+
+type MsgClientVACBanStatus struct {
+ NumBans uint32
+}
+
+func NewMsgClientVACBanStatus() *MsgClientVACBanStatus {
+ return &MsgClientVACBanStatus{}
+}
+
+func (d *MsgClientVACBanStatus) GetEMsg() EMsg {
+ return EMsg_ClientVACBanStatus
+}
+
+func (d *MsgClientVACBanStatus) Serialize(w io.Writer) error {
+ var err error
+ err = binary.Write(w, binary.LittleEndian, d.NumBans)
+ return err
+}
+
+func (d *MsgClientVACBanStatus) Deserialize(r io.Reader) error {
+ var err error
+ d.NumBans, err = rwu.ReadUint32(r)
+ return err
+}
+
+type MsgClientAppUsageEvent struct {
+ AppUsageEvent EAppUsageEvent
+ GameID uint64
+ Offline uint16
+}
+
+func NewMsgClientAppUsageEvent() *MsgClientAppUsageEvent {
+ return &MsgClientAppUsageEvent{}
+}
+
+func (d *MsgClientAppUsageEvent) GetEMsg() EMsg {
+ return EMsg_ClientAppUsageEvent
+}
+
+func (d *MsgClientAppUsageEvent) Serialize(w io.Writer) error {
+ var err error
+ err = binary.Write(w, binary.LittleEndian, d.AppUsageEvent)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.GameID)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.Offline)
+ return err
+}
+
+func (d *MsgClientAppUsageEvent) Deserialize(r io.Reader) error {
+ var err error
+ t0, err := rwu.ReadInt32(r)
+ if err != nil {
+ return err
+ }
+ d.AppUsageEvent = EAppUsageEvent(t0)
+ d.GameID, err = rwu.ReadUint64(r)
+ if err != nil {
+ return err
+ }
+ d.Offline, err = rwu.ReadUint16(r)
+ return err
+}
+
+type MsgClientEmailAddrInfo struct {
+ PasswordStrength uint32
+ FlagsAccountSecurityPolicy uint32
+ Validated bool
+}
+
+func NewMsgClientEmailAddrInfo() *MsgClientEmailAddrInfo {
+ return &MsgClientEmailAddrInfo{}
+}
+
+func (d *MsgClientEmailAddrInfo) GetEMsg() EMsg {
+ return EMsg_ClientEmailAddrInfo
+}
+
+func (d *MsgClientEmailAddrInfo) Serialize(w io.Writer) error {
+ var err error
+ err = binary.Write(w, binary.LittleEndian, d.PasswordStrength)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.FlagsAccountSecurityPolicy)
+ if err != nil {
+ return err
+ }
+ err = rwu.WriteBool(w, d.Validated)
+ return err
+}
+
+func (d *MsgClientEmailAddrInfo) Deserialize(r io.Reader) error {
+ var err error
+ d.PasswordStrength, err = rwu.ReadUint32(r)
+ if err != nil {
+ return err
+ }
+ d.FlagsAccountSecurityPolicy, err = rwu.ReadUint32(r)
+ if err != nil {
+ return err
+ }
+ d.Validated, err = rwu.ReadBool(r)
+ return err
+}
+
+type MsgClientUpdateGuestPassesList struct {
+ Result EResult
+ CountGuestPassesToGive int32
+ CountGuestPassesToRedeem int32
+}
+
+func NewMsgClientUpdateGuestPassesList() *MsgClientUpdateGuestPassesList {
+ return &MsgClientUpdateGuestPassesList{}
+}
+
+func (d *MsgClientUpdateGuestPassesList) GetEMsg() EMsg {
+ return EMsg_ClientUpdateGuestPassesList
+}
+
+func (d *MsgClientUpdateGuestPassesList) Serialize(w io.Writer) error {
+ var err error
+ err = binary.Write(w, binary.LittleEndian, d.Result)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.CountGuestPassesToGive)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.CountGuestPassesToRedeem)
+ return err
+}
+
+func (d *MsgClientUpdateGuestPassesList) Deserialize(r io.Reader) error {
+ var err error
+ t0, err := rwu.ReadInt32(r)
+ if err != nil {
+ return err
+ }
+ d.Result = EResult(t0)
+ d.CountGuestPassesToGive, err = rwu.ReadInt32(r)
+ if err != nil {
+ return err
+ }
+ d.CountGuestPassesToRedeem, err = rwu.ReadInt32(r)
+ return err
+}
+
+type MsgClientRequestedClientStats struct {
+ CountStats int32
+}
+
+func NewMsgClientRequestedClientStats() *MsgClientRequestedClientStats {
+ return &MsgClientRequestedClientStats{}
+}
+
+func (d *MsgClientRequestedClientStats) GetEMsg() EMsg {
+ return EMsg_ClientRequestedClientStats
+}
+
+func (d *MsgClientRequestedClientStats) Serialize(w io.Writer) error {
+ var err error
+ err = binary.Write(w, binary.LittleEndian, d.CountStats)
+ return err
+}
+
+func (d *MsgClientRequestedClientStats) Deserialize(r io.Reader) error {
+ var err error
+ d.CountStats, err = rwu.ReadInt32(r)
+ return err
+}
+
+type MsgClientP2PIntroducerMessage struct {
+ SteamID steamid.SteamId
+ RoutingType EIntroducerRouting
+ Data []uint8
+ DataLen uint32
+}
+
+func NewMsgClientP2PIntroducerMessage() *MsgClientP2PIntroducerMessage {
+ return &MsgClientP2PIntroducerMessage{
+ Data: make([]uint8, 1450, 1450),
+ }
+}
+
+func (d *MsgClientP2PIntroducerMessage) GetEMsg() EMsg {
+ return EMsg_ClientP2PIntroducerMessage
+}
+
+func (d *MsgClientP2PIntroducerMessage) Serialize(w io.Writer) error {
+ var err error
+ err = binary.Write(w, binary.LittleEndian, d.SteamID)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.RoutingType)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.Data)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.DataLen)
+ return err
+}
+
+func (d *MsgClientP2PIntroducerMessage) Deserialize(r io.Reader) error {
+ var err error
+ t0, err := rwu.ReadUint64(r)
+ if err != nil {
+ return err
+ }
+ d.SteamID = steamid.SteamId(t0)
+ t1, err := rwu.ReadInt32(r)
+ if err != nil {
+ return err
+ }
+ d.RoutingType = EIntroducerRouting(t1)
+ err = binary.Read(r, binary.LittleEndian, d.Data)
+ if err != nil {
+ return err
+ }
+ d.DataLen, err = rwu.ReadUint32(r)
+ return err
+}
+
+type MsgClientOGSBeginSession struct {
+ AccountType uint8
+ AccountId steamid.SteamId
+ AppId uint32
+ TimeStarted uint32
+}
+
+func NewMsgClientOGSBeginSession() *MsgClientOGSBeginSession {
+ return &MsgClientOGSBeginSession{}
+}
+
+func (d *MsgClientOGSBeginSession) GetEMsg() EMsg {
+ return EMsg_ClientOGSBeginSession
+}
+
+func (d *MsgClientOGSBeginSession) Serialize(w io.Writer) error {
+ var err error
+ err = binary.Write(w, binary.LittleEndian, d.AccountType)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.AccountId)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.AppId)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.TimeStarted)
+ return err
+}
+
+func (d *MsgClientOGSBeginSession) Deserialize(r io.Reader) error {
+ var err error
+ d.AccountType, err = rwu.ReadUint8(r)
+ if err != nil {
+ return err
+ }
+ t0, err := rwu.ReadUint64(r)
+ if err != nil {
+ return err
+ }
+ d.AccountId = steamid.SteamId(t0)
+ d.AppId, err = rwu.ReadUint32(r)
+ if err != nil {
+ return err
+ }
+ d.TimeStarted, err = rwu.ReadUint32(r)
+ return err
+}
+
+type MsgClientOGSBeginSessionResponse struct {
+ Result EResult
+ CollectingAny bool
+ CollectingDetails bool
+ SessionId uint64
+}
+
+func NewMsgClientOGSBeginSessionResponse() *MsgClientOGSBeginSessionResponse {
+ return &MsgClientOGSBeginSessionResponse{}
+}
+
+func (d *MsgClientOGSBeginSessionResponse) GetEMsg() EMsg {
+ return EMsg_ClientOGSBeginSessionResponse
+}
+
+func (d *MsgClientOGSBeginSessionResponse) Serialize(w io.Writer) error {
+ var err error
+ err = binary.Write(w, binary.LittleEndian, d.Result)
+ if err != nil {
+ return err
+ }
+ err = rwu.WriteBool(w, d.CollectingAny)
+ if err != nil {
+ return err
+ }
+ err = rwu.WriteBool(w, d.CollectingDetails)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.SessionId)
+ return err
+}
+
+func (d *MsgClientOGSBeginSessionResponse) Deserialize(r io.Reader) error {
+ var err error
+ t0, err := rwu.ReadInt32(r)
+ if err != nil {
+ return err
+ }
+ d.Result = EResult(t0)
+ d.CollectingAny, err = rwu.ReadBool(r)
+ if err != nil {
+ return err
+ }
+ d.CollectingDetails, err = rwu.ReadBool(r)
+ if err != nil {
+ return err
+ }
+ d.SessionId, err = rwu.ReadUint64(r)
+ return err
+}
+
+type MsgClientOGSEndSession struct {
+ SessionId uint64
+ TimeEnded uint32
+ ReasonCode int32
+ CountAttributes int32
+}
+
+func NewMsgClientOGSEndSession() *MsgClientOGSEndSession {
+ return &MsgClientOGSEndSession{}
+}
+
+func (d *MsgClientOGSEndSession) GetEMsg() EMsg {
+ return EMsg_ClientOGSEndSession
+}
+
+func (d *MsgClientOGSEndSession) Serialize(w io.Writer) error {
+ var err error
+ err = binary.Write(w, binary.LittleEndian, d.SessionId)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.TimeEnded)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.ReasonCode)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.CountAttributes)
+ return err
+}
+
+func (d *MsgClientOGSEndSession) Deserialize(r io.Reader) error {
+ var err error
+ d.SessionId, err = rwu.ReadUint64(r)
+ if err != nil {
+ return err
+ }
+ d.TimeEnded, err = rwu.ReadUint32(r)
+ if err != nil {
+ return err
+ }
+ d.ReasonCode, err = rwu.ReadInt32(r)
+ if err != nil {
+ return err
+ }
+ d.CountAttributes, err = rwu.ReadInt32(r)
+ return err
+}
+
+type MsgClientOGSEndSessionResponse struct {
+ Result EResult
+}
+
+func NewMsgClientOGSEndSessionResponse() *MsgClientOGSEndSessionResponse {
+ return &MsgClientOGSEndSessionResponse{}
+}
+
+func (d *MsgClientOGSEndSessionResponse) GetEMsg() EMsg {
+ return EMsg_ClientOGSEndSessionResponse
+}
+
+func (d *MsgClientOGSEndSessionResponse) Serialize(w io.Writer) error {
+ var err error
+ err = binary.Write(w, binary.LittleEndian, d.Result)
+ return err
+}
+
+func (d *MsgClientOGSEndSessionResponse) Deserialize(r io.Reader) error {
+ var err error
+ t0, err := rwu.ReadInt32(r)
+ d.Result = EResult(t0)
+ return err
+}
+
+type MsgClientOGSWriteRow struct {
+ SessionId uint64
+ CountAttributes int32
+}
+
+func NewMsgClientOGSWriteRow() *MsgClientOGSWriteRow {
+ return &MsgClientOGSWriteRow{}
+}
+
+func (d *MsgClientOGSWriteRow) GetEMsg() EMsg {
+ return EMsg_ClientOGSWriteRow
+}
+
+func (d *MsgClientOGSWriteRow) Serialize(w io.Writer) error {
+ var err error
+ err = binary.Write(w, binary.LittleEndian, d.SessionId)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.CountAttributes)
+ return err
+}
+
+func (d *MsgClientOGSWriteRow) Deserialize(r io.Reader) error {
+ var err error
+ d.SessionId, err = rwu.ReadUint64(r)
+ if err != nil {
+ return err
+ }
+ d.CountAttributes, err = rwu.ReadInt32(r)
+ return err
+}
+
+type MsgClientGetFriendsWhoPlayGame struct {
+ GameId uint64
+}
+
+func NewMsgClientGetFriendsWhoPlayGame() *MsgClientGetFriendsWhoPlayGame {
+ return &MsgClientGetFriendsWhoPlayGame{}
+}
+
+func (d *MsgClientGetFriendsWhoPlayGame) GetEMsg() EMsg {
+ return EMsg_ClientGetFriendsWhoPlayGame
+}
+
+func (d *MsgClientGetFriendsWhoPlayGame) Serialize(w io.Writer) error {
+ var err error
+ err = binary.Write(w, binary.LittleEndian, d.GameId)
+ return err
+}
+
+func (d *MsgClientGetFriendsWhoPlayGame) Deserialize(r io.Reader) error {
+ var err error
+ d.GameId, err = rwu.ReadUint64(r)
+ return err
+}
+
+type MsgClientGetFriendsWhoPlayGameResponse struct {
+ Result EResult
+ GameId uint64
+ CountFriends uint32
+}
+
+func NewMsgClientGetFriendsWhoPlayGameResponse() *MsgClientGetFriendsWhoPlayGameResponse {
+ return &MsgClientGetFriendsWhoPlayGameResponse{}
+}
+
+func (d *MsgClientGetFriendsWhoPlayGameResponse) GetEMsg() EMsg {
+ return EMsg_ClientGetFriendsWhoPlayGameResponse
+}
+
+func (d *MsgClientGetFriendsWhoPlayGameResponse) Serialize(w io.Writer) error {
+ var err error
+ err = binary.Write(w, binary.LittleEndian, d.Result)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.GameId)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.CountFriends)
+ return err
+}
+
+func (d *MsgClientGetFriendsWhoPlayGameResponse) Deserialize(r io.Reader) error {
+ var err error
+ t0, err := rwu.ReadInt32(r)
+ if err != nil {
+ return err
+ }
+ d.Result = EResult(t0)
+ d.GameId, err = rwu.ReadUint64(r)
+ if err != nil {
+ return err
+ }
+ d.CountFriends, err = rwu.ReadUint32(r)
+ return err
+}
+
+type MsgGSPerformHardwareSurvey struct {
+ Flags uint32
+}
+
+func NewMsgGSPerformHardwareSurvey() *MsgGSPerformHardwareSurvey {
+ return &MsgGSPerformHardwareSurvey{}
+}
+
+func (d *MsgGSPerformHardwareSurvey) GetEMsg() EMsg {
+ return EMsg_GSPerformHardwareSurvey
+}
+
+func (d *MsgGSPerformHardwareSurvey) Serialize(w io.Writer) error {
+ var err error
+ err = binary.Write(w, binary.LittleEndian, d.Flags)
+ return err
+}
+
+func (d *MsgGSPerformHardwareSurvey) Deserialize(r io.Reader) error {
+ var err error
+ d.Flags, err = rwu.ReadUint32(r)
+ return err
+}
+
+type MsgGSGetPlayStatsResponse struct {
+ Result EResult
+ Rank int32
+ LifetimeConnects uint32
+ LifetimeMinutesPlayed uint32
+}
+
+func NewMsgGSGetPlayStatsResponse() *MsgGSGetPlayStatsResponse {
+ return &MsgGSGetPlayStatsResponse{}
+}
+
+func (d *MsgGSGetPlayStatsResponse) GetEMsg() EMsg {
+ return EMsg_GSGetPlayStatsResponse
+}
+
+func (d *MsgGSGetPlayStatsResponse) Serialize(w io.Writer) error {
+ var err error
+ err = binary.Write(w, binary.LittleEndian, d.Result)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.Rank)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.LifetimeConnects)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.LifetimeMinutesPlayed)
+ return err
+}
+
+func (d *MsgGSGetPlayStatsResponse) Deserialize(r io.Reader) error {
+ var err error
+ t0, err := rwu.ReadInt32(r)
+ if err != nil {
+ return err
+ }
+ d.Result = EResult(t0)
+ d.Rank, err = rwu.ReadInt32(r)
+ if err != nil {
+ return err
+ }
+ d.LifetimeConnects, err = rwu.ReadUint32(r)
+ if err != nil {
+ return err
+ }
+ d.LifetimeMinutesPlayed, err = rwu.ReadUint32(r)
+ return err
+}
+
+type MsgGSGetReputationResponse struct {
+ Result EResult
+ ReputationScore uint32
+ Banned bool
+ BannedIp uint32
+ BannedPort uint16
+ BannedGameId uint64
+ TimeBanExpires uint32
+}
+
+func NewMsgGSGetReputationResponse() *MsgGSGetReputationResponse {
+ return &MsgGSGetReputationResponse{}
+}
+
+func (d *MsgGSGetReputationResponse) GetEMsg() EMsg {
+ return EMsg_GSGetReputationResponse
+}
+
+func (d *MsgGSGetReputationResponse) Serialize(w io.Writer) error {
+ var err error
+ err = binary.Write(w, binary.LittleEndian, d.Result)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.ReputationScore)
+ if err != nil {
+ return err
+ }
+ err = rwu.WriteBool(w, d.Banned)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.BannedIp)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.BannedPort)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.BannedGameId)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.TimeBanExpires)
+ return err
+}
+
+func (d *MsgGSGetReputationResponse) Deserialize(r io.Reader) error {
+ var err error
+ t0, err := rwu.ReadInt32(r)
+ if err != nil {
+ return err
+ }
+ d.Result = EResult(t0)
+ d.ReputationScore, err = rwu.ReadUint32(r)
+ if err != nil {
+ return err
+ }
+ d.Banned, err = rwu.ReadBool(r)
+ if err != nil {
+ return err
+ }
+ d.BannedIp, err = rwu.ReadUint32(r)
+ if err != nil {
+ return err
+ }
+ d.BannedPort, err = rwu.ReadUint16(r)
+ if err != nil {
+ return err
+ }
+ d.BannedGameId, err = rwu.ReadUint64(r)
+ if err != nil {
+ return err
+ }
+ d.TimeBanExpires, err = rwu.ReadUint32(r)
+ return err
+}
+
+type MsgGSDeny struct {
+ SteamId steamid.SteamId
+ DenyReason EDenyReason
+}
+
+func NewMsgGSDeny() *MsgGSDeny {
+ return &MsgGSDeny{}
+}
+
+func (d *MsgGSDeny) GetEMsg() EMsg {
+ return EMsg_GSDeny
+}
+
+func (d *MsgGSDeny) Serialize(w io.Writer) error {
+ var err error
+ err = binary.Write(w, binary.LittleEndian, d.SteamId)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.DenyReason)
+ return err
+}
+
+func (d *MsgGSDeny) Deserialize(r io.Reader) error {
+ var err error
+ t0, err := rwu.ReadUint64(r)
+ if err != nil {
+ return err
+ }
+ d.SteamId = steamid.SteamId(t0)
+ t1, err := rwu.ReadInt32(r)
+ d.DenyReason = EDenyReason(t1)
+ return err
+}
+
+type MsgGSApprove struct {
+ SteamId steamid.SteamId
+}
+
+func NewMsgGSApprove() *MsgGSApprove {
+ return &MsgGSApprove{}
+}
+
+func (d *MsgGSApprove) GetEMsg() EMsg {
+ return EMsg_GSApprove
+}
+
+func (d *MsgGSApprove) Serialize(w io.Writer) error {
+ var err error
+ err = binary.Write(w, binary.LittleEndian, d.SteamId)
+ return err
+}
+
+func (d *MsgGSApprove) Deserialize(r io.Reader) error {
+ var err error
+ t0, err := rwu.ReadUint64(r)
+ if err != nil {
+ return err
+ }
+ d.SteamId = steamid.SteamId(t0)
+ return err
+}
+
+type MsgGSKick struct {
+ SteamId steamid.SteamId
+ DenyReason EDenyReason
+ WaitTilMapChange int32
+}
+
+func NewMsgGSKick() *MsgGSKick {
+ return &MsgGSKick{}
+}
+
+func (d *MsgGSKick) GetEMsg() EMsg {
+ return EMsg_GSKick
+}
+
+func (d *MsgGSKick) Serialize(w io.Writer) error {
+ var err error
+ err = binary.Write(w, binary.LittleEndian, d.SteamId)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.DenyReason)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.WaitTilMapChange)
+ return err
+}
+
+func (d *MsgGSKick) Deserialize(r io.Reader) error {
+ var err error
+ t0, err := rwu.ReadUint64(r)
+ if err != nil {
+ return err
+ }
+ d.SteamId = steamid.SteamId(t0)
+ t1, err := rwu.ReadInt32(r)
+ if err != nil {
+ return err
+ }
+ d.DenyReason = EDenyReason(t1)
+ d.WaitTilMapChange, err = rwu.ReadInt32(r)
+ return err
+}
+
+type MsgGSGetUserGroupStatus struct {
+ SteamIdUser steamid.SteamId
+ SteamIdGroup steamid.SteamId
+}
+
+func NewMsgGSGetUserGroupStatus() *MsgGSGetUserGroupStatus {
+ return &MsgGSGetUserGroupStatus{}
+}
+
+func (d *MsgGSGetUserGroupStatus) GetEMsg() EMsg {
+ return EMsg_GSGetUserGroupStatus
+}
+
+func (d *MsgGSGetUserGroupStatus) Serialize(w io.Writer) error {
+ var err error
+ err = binary.Write(w, binary.LittleEndian, d.SteamIdUser)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.SteamIdGroup)
+ return err
+}
+
+func (d *MsgGSGetUserGroupStatus) Deserialize(r io.Reader) error {
+ var err error
+ t0, err := rwu.ReadUint64(r)
+ if err != nil {
+ return err
+ }
+ d.SteamIdUser = steamid.SteamId(t0)
+ t1, err := rwu.ReadUint64(r)
+ if err != nil {
+ return err
+ }
+ d.SteamIdGroup = steamid.SteamId(t1)
+ return err
+}
+
+type MsgGSGetUserGroupStatusResponse struct {
+ SteamIdUser steamid.SteamId
+ SteamIdGroup steamid.SteamId
+ ClanRelationship EClanRelationship
+ ClanRank EClanRank
+}
+
+func NewMsgGSGetUserGroupStatusResponse() *MsgGSGetUserGroupStatusResponse {
+ return &MsgGSGetUserGroupStatusResponse{}
+}
+
+func (d *MsgGSGetUserGroupStatusResponse) GetEMsg() EMsg {
+ return EMsg_GSGetUserGroupStatusResponse
+}
+
+func (d *MsgGSGetUserGroupStatusResponse) Serialize(w io.Writer) error {
+ var err error
+ err = binary.Write(w, binary.LittleEndian, d.SteamIdUser)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.SteamIdGroup)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.ClanRelationship)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.ClanRank)
+ return err
+}
+
+func (d *MsgGSGetUserGroupStatusResponse) Deserialize(r io.Reader) error {
+ var err error
+ t0, err := rwu.ReadUint64(r)
+ if err != nil {
+ return err
+ }
+ d.SteamIdUser = steamid.SteamId(t0)
+ t1, err := rwu.ReadUint64(r)
+ if err != nil {
+ return err
+ }
+ d.SteamIdGroup = steamid.SteamId(t1)
+ t2, err := rwu.ReadInt32(r)
+ if err != nil {
+ return err
+ }
+ d.ClanRelationship = EClanRelationship(t2)
+ t3, err := rwu.ReadInt32(r)
+ d.ClanRank = EClanRank(t3)
+ return err
+}
+
+type MsgClientJoinChat struct {
+ SteamIdChat steamid.SteamId
+ IsVoiceSpeaker bool
+}
+
+func NewMsgClientJoinChat() *MsgClientJoinChat {
+ return &MsgClientJoinChat{}
+}
+
+func (d *MsgClientJoinChat) GetEMsg() EMsg {
+ return EMsg_ClientJoinChat
+}
+
+func (d *MsgClientJoinChat) Serialize(w io.Writer) error {
+ var err error
+ err = binary.Write(w, binary.LittleEndian, d.SteamIdChat)
+ if err != nil {
+ return err
+ }
+ err = rwu.WriteBool(w, d.IsVoiceSpeaker)
+ return err
+}
+
+func (d *MsgClientJoinChat) Deserialize(r io.Reader) error {
+ var err error
+ t0, err := rwu.ReadUint64(r)
+ if err != nil {
+ return err
+ }
+ d.SteamIdChat = steamid.SteamId(t0)
+ d.IsVoiceSpeaker, err = rwu.ReadBool(r)
+ return err
+}
+
+type MsgClientChatEnter struct {
+ SteamIdChat steamid.SteamId
+ SteamIdFriend steamid.SteamId
+ ChatRoomType EChatRoomType
+ SteamIdOwner steamid.SteamId
+ SteamIdClan steamid.SteamId
+ ChatFlags uint8
+ EnterResponse EChatRoomEnterResponse
+ NumMembers int32
+}
+
+func NewMsgClientChatEnter() *MsgClientChatEnter {
+ return &MsgClientChatEnter{}
+}
+
+func (d *MsgClientChatEnter) GetEMsg() EMsg {
+ return EMsg_ClientChatEnter
+}
+
+func (d *MsgClientChatEnter) Serialize(w io.Writer) error {
+ var err error
+ err = binary.Write(w, binary.LittleEndian, d.SteamIdChat)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.SteamIdFriend)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.ChatRoomType)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.SteamIdOwner)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.SteamIdClan)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.ChatFlags)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.EnterResponse)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.NumMembers)
+ return err
+}
+
+func (d *MsgClientChatEnter) Deserialize(r io.Reader) error {
+ var err error
+ t0, err := rwu.ReadUint64(r)
+ if err != nil {
+ return err
+ }
+ d.SteamIdChat = steamid.SteamId(t0)
+ t1, err := rwu.ReadUint64(r)
+ if err != nil {
+ return err
+ }
+ d.SteamIdFriend = steamid.SteamId(t1)
+ t2, err := rwu.ReadInt32(r)
+ if err != nil {
+ return err
+ }
+ d.ChatRoomType = EChatRoomType(t2)
+ t3, err := rwu.ReadUint64(r)
+ if err != nil {
+ return err
+ }
+ d.SteamIdOwner = steamid.SteamId(t3)
+ t4, err := rwu.ReadUint64(r)
+ if err != nil {
+ return err
+ }
+ d.SteamIdClan = steamid.SteamId(t4)
+ d.ChatFlags, err = rwu.ReadUint8(r)
+ if err != nil {
+ return err
+ }
+ t5, err := rwu.ReadInt32(r)
+ if err != nil {
+ return err
+ }
+ d.EnterResponse = EChatRoomEnterResponse(t5)
+ d.NumMembers, err = rwu.ReadInt32(r)
+ return err
+}
+
+type MsgClientChatMsg struct {
+ SteamIdChatter steamid.SteamId
+ SteamIdChatRoom steamid.SteamId
+ ChatMsgType EChatEntryType
+}
+
+func NewMsgClientChatMsg() *MsgClientChatMsg {
+ return &MsgClientChatMsg{}
+}
+
+func (d *MsgClientChatMsg) GetEMsg() EMsg {
+ return EMsg_ClientChatMsg
+}
+
+func (d *MsgClientChatMsg) Serialize(w io.Writer) error {
+ var err error
+ err = binary.Write(w, binary.LittleEndian, d.SteamIdChatter)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.SteamIdChatRoom)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.ChatMsgType)
+ return err
+}
+
+func (d *MsgClientChatMsg) Deserialize(r io.Reader) error {
+ var err error
+ t0, err := rwu.ReadUint64(r)
+ if err != nil {
+ return err
+ }
+ d.SteamIdChatter = steamid.SteamId(t0)
+ t1, err := rwu.ReadUint64(r)
+ if err != nil {
+ return err
+ }
+ d.SteamIdChatRoom = steamid.SteamId(t1)
+ t2, err := rwu.ReadInt32(r)
+ d.ChatMsgType = EChatEntryType(t2)
+ return err
+}
+
+type MsgClientChatMemberInfo struct {
+ SteamIdChat steamid.SteamId
+ Type EChatInfoType
+}
+
+func NewMsgClientChatMemberInfo() *MsgClientChatMemberInfo {
+ return &MsgClientChatMemberInfo{}
+}
+
+func (d *MsgClientChatMemberInfo) GetEMsg() EMsg {
+ return EMsg_ClientChatMemberInfo
+}
+
+func (d *MsgClientChatMemberInfo) Serialize(w io.Writer) error {
+ var err error
+ err = binary.Write(w, binary.LittleEndian, d.SteamIdChat)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.Type)
+ return err
+}
+
+func (d *MsgClientChatMemberInfo) Deserialize(r io.Reader) error {
+ var err error
+ t0, err := rwu.ReadUint64(r)
+ if err != nil {
+ return err
+ }
+ d.SteamIdChat = steamid.SteamId(t0)
+ t1, err := rwu.ReadInt32(r)
+ d.Type = EChatInfoType(t1)
+ return err
+}
+
+type MsgClientChatAction struct {
+ SteamIdChat steamid.SteamId
+ SteamIdUserToActOn steamid.SteamId
+ ChatAction EChatAction
+}
+
+func NewMsgClientChatAction() *MsgClientChatAction {
+ return &MsgClientChatAction{}
+}
+
+func (d *MsgClientChatAction) GetEMsg() EMsg {
+ return EMsg_ClientChatAction
+}
+
+func (d *MsgClientChatAction) Serialize(w io.Writer) error {
+ var err error
+ err = binary.Write(w, binary.LittleEndian, d.SteamIdChat)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.SteamIdUserToActOn)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.ChatAction)
+ return err
+}
+
+func (d *MsgClientChatAction) Deserialize(r io.Reader) error {
+ var err error
+ t0, err := rwu.ReadUint64(r)
+ if err != nil {
+ return err
+ }
+ d.SteamIdChat = steamid.SteamId(t0)
+ t1, err := rwu.ReadUint64(r)
+ if err != nil {
+ return err
+ }
+ d.SteamIdUserToActOn = steamid.SteamId(t1)
+ t2, err := rwu.ReadInt32(r)
+ d.ChatAction = EChatAction(t2)
+ return err
+}
+
+type MsgClientChatActionResult struct {
+ SteamIdChat steamid.SteamId
+ SteamIdUserActedOn steamid.SteamId
+ ChatAction EChatAction
+ ActionResult EChatActionResult
+}
+
+func NewMsgClientChatActionResult() *MsgClientChatActionResult {
+ return &MsgClientChatActionResult{}
+}
+
+func (d *MsgClientChatActionResult) GetEMsg() EMsg {
+ return EMsg_ClientChatActionResult
+}
+
+func (d *MsgClientChatActionResult) Serialize(w io.Writer) error {
+ var err error
+ err = binary.Write(w, binary.LittleEndian, d.SteamIdChat)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.SteamIdUserActedOn)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.ChatAction)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.ActionResult)
+ return err
+}
+
+func (d *MsgClientChatActionResult) Deserialize(r io.Reader) error {
+ var err error
+ t0, err := rwu.ReadUint64(r)
+ if err != nil {
+ return err
+ }
+ d.SteamIdChat = steamid.SteamId(t0)
+ t1, err := rwu.ReadUint64(r)
+ if err != nil {
+ return err
+ }
+ d.SteamIdUserActedOn = steamid.SteamId(t1)
+ t2, err := rwu.ReadInt32(r)
+ if err != nil {
+ return err
+ }
+ d.ChatAction = EChatAction(t2)
+ t3, err := rwu.ReadInt32(r)
+ d.ActionResult = EChatActionResult(t3)
+ return err
+}
+
+type MsgClientChatRoomInfo struct {
+ SteamIdChat steamid.SteamId
+ Type EChatInfoType
+}
+
+func NewMsgClientChatRoomInfo() *MsgClientChatRoomInfo {
+ return &MsgClientChatRoomInfo{}
+}
+
+func (d *MsgClientChatRoomInfo) GetEMsg() EMsg {
+ return EMsg_ClientChatRoomInfo
+}
+
+func (d *MsgClientChatRoomInfo) Serialize(w io.Writer) error {
+ var err error
+ err = binary.Write(w, binary.LittleEndian, d.SteamIdChat)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.Type)
+ return err
+}
+
+func (d *MsgClientChatRoomInfo) Deserialize(r io.Reader) error {
+ var err error
+ t0, err := rwu.ReadUint64(r)
+ if err != nil {
+ return err
+ }
+ d.SteamIdChat = steamid.SteamId(t0)
+ t1, err := rwu.ReadInt32(r)
+ d.Type = EChatInfoType(t1)
+ return err
+}
+
+type MsgClientGetNumberOfCurrentPlayers struct {
+ GameID uint64
+}
+
+func NewMsgClientGetNumberOfCurrentPlayers() *MsgClientGetNumberOfCurrentPlayers {
+ return &MsgClientGetNumberOfCurrentPlayers{}
+}
+
+func (d *MsgClientGetNumberOfCurrentPlayers) GetEMsg() EMsg {
+ return EMsg_ClientGetNumberOfCurrentPlayers
+}
+
+func (d *MsgClientGetNumberOfCurrentPlayers) Serialize(w io.Writer) error {
+ var err error
+ err = binary.Write(w, binary.LittleEndian, d.GameID)
+ return err
+}
+
+func (d *MsgClientGetNumberOfCurrentPlayers) Deserialize(r io.Reader) error {
+ var err error
+ d.GameID, err = rwu.ReadUint64(r)
+ return err
+}
+
+type MsgClientGetNumberOfCurrentPlayersResponse struct {
+ Result EResult
+ NumPlayers uint32
+}
+
+func NewMsgClientGetNumberOfCurrentPlayersResponse() *MsgClientGetNumberOfCurrentPlayersResponse {
+ return &MsgClientGetNumberOfCurrentPlayersResponse{}
+}
+
+func (d *MsgClientGetNumberOfCurrentPlayersResponse) GetEMsg() EMsg {
+ return EMsg_ClientGetNumberOfCurrentPlayersResponse
+}
+
+func (d *MsgClientGetNumberOfCurrentPlayersResponse) Serialize(w io.Writer) error {
+ var err error
+ err = binary.Write(w, binary.LittleEndian, d.Result)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.NumPlayers)
+ return err
+}
+
+func (d *MsgClientGetNumberOfCurrentPlayersResponse) Deserialize(r io.Reader) error {
+ var err error
+ t0, err := rwu.ReadInt32(r)
+ if err != nil {
+ return err
+ }
+ d.Result = EResult(t0)
+ d.NumPlayers, err = rwu.ReadUint32(r)
+ return err
+}
+
+type MsgClientSetIgnoreFriend struct {
+ MySteamId steamid.SteamId
+ SteamIdFriend steamid.SteamId
+ Ignore uint8
+}
+
+func NewMsgClientSetIgnoreFriend() *MsgClientSetIgnoreFriend {
+ return &MsgClientSetIgnoreFriend{}
+}
+
+func (d *MsgClientSetIgnoreFriend) GetEMsg() EMsg {
+ return EMsg_ClientSetIgnoreFriend
+}
+
+func (d *MsgClientSetIgnoreFriend) Serialize(w io.Writer) error {
+ var err error
+ err = binary.Write(w, binary.LittleEndian, d.MySteamId)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.SteamIdFriend)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.Ignore)
+ return err
+}
+
+func (d *MsgClientSetIgnoreFriend) Deserialize(r io.Reader) error {
+ var err error
+ t0, err := rwu.ReadUint64(r)
+ if err != nil {
+ return err
+ }
+ d.MySteamId = steamid.SteamId(t0)
+ t1, err := rwu.ReadUint64(r)
+ if err != nil {
+ return err
+ }
+ d.SteamIdFriend = steamid.SteamId(t1)
+ d.Ignore, err = rwu.ReadUint8(r)
+ return err
+}
+
+type MsgClientSetIgnoreFriendResponse struct {
+ Unknown uint64
+ Result EResult
+}
+
+func NewMsgClientSetIgnoreFriendResponse() *MsgClientSetIgnoreFriendResponse {
+ return &MsgClientSetIgnoreFriendResponse{}
+}
+
+func (d *MsgClientSetIgnoreFriendResponse) GetEMsg() EMsg {
+ return EMsg_ClientSetIgnoreFriendResponse
+}
+
+func (d *MsgClientSetIgnoreFriendResponse) Serialize(w io.Writer) error {
+ var err error
+ err = binary.Write(w, binary.LittleEndian, d.Unknown)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.Result)
+ return err
+}
+
+func (d *MsgClientSetIgnoreFriendResponse) Deserialize(r io.Reader) error {
+ var err error
+ d.Unknown, err = rwu.ReadUint64(r)
+ if err != nil {
+ return err
+ }
+ t0, err := rwu.ReadInt32(r)
+ d.Result = EResult(t0)
+ return err
+}
+
+type MsgClientLoggedOff struct {
+ Result EResult
+ SecMinReconnectHint int32
+ SecMaxReconnectHint int32
+}
+
+func NewMsgClientLoggedOff() *MsgClientLoggedOff {
+ return &MsgClientLoggedOff{}
+}
+
+func (d *MsgClientLoggedOff) GetEMsg() EMsg {
+ return EMsg_ClientLoggedOff
+}
+
+func (d *MsgClientLoggedOff) Serialize(w io.Writer) error {
+ var err error
+ err = binary.Write(w, binary.LittleEndian, d.Result)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.SecMinReconnectHint)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.SecMaxReconnectHint)
+ return err
+}
+
+func (d *MsgClientLoggedOff) Deserialize(r io.Reader) error {
+ var err error
+ t0, err := rwu.ReadInt32(r)
+ if err != nil {
+ return err
+ }
+ d.Result = EResult(t0)
+ d.SecMinReconnectHint, err = rwu.ReadInt32(r)
+ if err != nil {
+ return err
+ }
+ d.SecMaxReconnectHint, err = rwu.ReadInt32(r)
+ return err
+}
+
+type MsgClientLogOnResponse struct {
+ Result EResult
+ OutOfGameHeartbeatRateSec int32
+ InGameHeartbeatRateSec int32
+ ClientSuppliedSteamId steamid.SteamId
+ IpPublic uint32
+ ServerRealTime uint32
+}
+
+func NewMsgClientLogOnResponse() *MsgClientLogOnResponse {
+ return &MsgClientLogOnResponse{}
+}
+
+func (d *MsgClientLogOnResponse) GetEMsg() EMsg {
+ return EMsg_ClientLogOnResponse
+}
+
+func (d *MsgClientLogOnResponse) Serialize(w io.Writer) error {
+ var err error
+ err = binary.Write(w, binary.LittleEndian, d.Result)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.OutOfGameHeartbeatRateSec)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.InGameHeartbeatRateSec)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.ClientSuppliedSteamId)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.IpPublic)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.ServerRealTime)
+ return err
+}
+
+func (d *MsgClientLogOnResponse) Deserialize(r io.Reader) error {
+ var err error
+ t0, err := rwu.ReadInt32(r)
+ if err != nil {
+ return err
+ }
+ d.Result = EResult(t0)
+ d.OutOfGameHeartbeatRateSec, err = rwu.ReadInt32(r)
+ if err != nil {
+ return err
+ }
+ d.InGameHeartbeatRateSec, err = rwu.ReadInt32(r)
+ if err != nil {
+ return err
+ }
+ t1, err := rwu.ReadUint64(r)
+ if err != nil {
+ return err
+ }
+ d.ClientSuppliedSteamId = steamid.SteamId(t1)
+ d.IpPublic, err = rwu.ReadUint32(r)
+ if err != nil {
+ return err
+ }
+ d.ServerRealTime, err = rwu.ReadUint32(r)
+ return err
+}
+
+type MsgClientSendGuestPass struct {
+ GiftId uint64
+ GiftType uint8
+ AccountId uint32
+}
+
+func NewMsgClientSendGuestPass() *MsgClientSendGuestPass {
+ return &MsgClientSendGuestPass{}
+}
+
+func (d *MsgClientSendGuestPass) GetEMsg() EMsg {
+ return EMsg_ClientSendGuestPass
+}
+
+func (d *MsgClientSendGuestPass) Serialize(w io.Writer) error {
+ var err error
+ err = binary.Write(w, binary.LittleEndian, d.GiftId)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.GiftType)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.AccountId)
+ return err
+}
+
+func (d *MsgClientSendGuestPass) Deserialize(r io.Reader) error {
+ var err error
+ d.GiftId, err = rwu.ReadUint64(r)
+ if err != nil {
+ return err
+ }
+ d.GiftType, err = rwu.ReadUint8(r)
+ if err != nil {
+ return err
+ }
+ d.AccountId, err = rwu.ReadUint32(r)
+ return err
+}
+
+type MsgClientSendGuestPassResponse struct {
+ Result EResult
+}
+
+func NewMsgClientSendGuestPassResponse() *MsgClientSendGuestPassResponse {
+ return &MsgClientSendGuestPassResponse{}
+}
+
+func (d *MsgClientSendGuestPassResponse) GetEMsg() EMsg {
+ return EMsg_ClientSendGuestPassResponse
+}
+
+func (d *MsgClientSendGuestPassResponse) Serialize(w io.Writer) error {
+ var err error
+ err = binary.Write(w, binary.LittleEndian, d.Result)
+ return err
+}
+
+func (d *MsgClientSendGuestPassResponse) Deserialize(r io.Reader) error {
+ var err error
+ t0, err := rwu.ReadInt32(r)
+ d.Result = EResult(t0)
+ return err
+}
+
+type MsgClientServerUnavailable struct {
+ JobidSent uint64
+ EMsgSent uint32
+ EServerTypeUnavailable EServerType
+}
+
+func NewMsgClientServerUnavailable() *MsgClientServerUnavailable {
+ return &MsgClientServerUnavailable{}
+}
+
+func (d *MsgClientServerUnavailable) GetEMsg() EMsg {
+ return EMsg_ClientServerUnavailable
+}
+
+func (d *MsgClientServerUnavailable) Serialize(w io.Writer) error {
+ var err error
+ err = binary.Write(w, binary.LittleEndian, d.JobidSent)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.EMsgSent)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.EServerTypeUnavailable)
+ return err
+}
+
+func (d *MsgClientServerUnavailable) Deserialize(r io.Reader) error {
+ var err error
+ d.JobidSent, err = rwu.ReadUint64(r)
+ if err != nil {
+ return err
+ }
+ d.EMsgSent, err = rwu.ReadUint32(r)
+ if err != nil {
+ return err
+ }
+ t0, err := rwu.ReadInt32(r)
+ d.EServerTypeUnavailable = EServerType(t0)
+ return err
+}
+
+type MsgClientCreateChat struct {
+ ChatRoomType EChatRoomType
+ GameId uint64
+ SteamIdClan steamid.SteamId
+ PermissionOfficer EChatPermission
+ PermissionMember EChatPermission
+ PermissionAll EChatPermission
+ MembersMax uint32
+ ChatFlags uint8
+ SteamIdFriendChat steamid.SteamId
+ SteamIdInvited steamid.SteamId
+}
+
+func NewMsgClientCreateChat() *MsgClientCreateChat {
+ return &MsgClientCreateChat{}
+}
+
+func (d *MsgClientCreateChat) GetEMsg() EMsg {
+ return EMsg_ClientCreateChat
+}
+
+func (d *MsgClientCreateChat) Serialize(w io.Writer) error {
+ var err error
+ err = binary.Write(w, binary.LittleEndian, d.ChatRoomType)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.GameId)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.SteamIdClan)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.PermissionOfficer)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.PermissionMember)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.PermissionAll)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.MembersMax)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.ChatFlags)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.SteamIdFriendChat)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.SteamIdInvited)
+ return err
+}
+
+func (d *MsgClientCreateChat) Deserialize(r io.Reader) error {
+ var err error
+ t0, err := rwu.ReadInt32(r)
+ if err != nil {
+ return err
+ }
+ d.ChatRoomType = EChatRoomType(t0)
+ d.GameId, err = rwu.ReadUint64(r)
+ if err != nil {
+ return err
+ }
+ t1, err := rwu.ReadUint64(r)
+ if err != nil {
+ return err
+ }
+ d.SteamIdClan = steamid.SteamId(t1)
+ t2, err := rwu.ReadInt32(r)
+ if err != nil {
+ return err
+ }
+ d.PermissionOfficer = EChatPermission(t2)
+ t3, err := rwu.ReadInt32(r)
+ if err != nil {
+ return err
+ }
+ d.PermissionMember = EChatPermission(t3)
+ t4, err := rwu.ReadInt32(r)
+ if err != nil {
+ return err
+ }
+ d.PermissionAll = EChatPermission(t4)
+ d.MembersMax, err = rwu.ReadUint32(r)
+ if err != nil {
+ return err
+ }
+ d.ChatFlags, err = rwu.ReadUint8(r)
+ if err != nil {
+ return err
+ }
+ t5, err := rwu.ReadUint64(r)
+ if err != nil {
+ return err
+ }
+ d.SteamIdFriendChat = steamid.SteamId(t5)
+ t6, err := rwu.ReadUint64(r)
+ if err != nil {
+ return err
+ }
+ d.SteamIdInvited = steamid.SteamId(t6)
+ return err
+}
+
+type MsgClientCreateChatResponse struct {
+ Result EResult
+ SteamIdChat steamid.SteamId
+ ChatRoomType EChatRoomType
+ SteamIdFriendChat steamid.SteamId
+}
+
+func NewMsgClientCreateChatResponse() *MsgClientCreateChatResponse {
+ return &MsgClientCreateChatResponse{}
+}
+
+func (d *MsgClientCreateChatResponse) GetEMsg() EMsg {
+ return EMsg_ClientCreateChatResponse
+}
+
+func (d *MsgClientCreateChatResponse) Serialize(w io.Writer) error {
+ var err error
+ err = binary.Write(w, binary.LittleEndian, d.Result)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.SteamIdChat)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.ChatRoomType)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.SteamIdFriendChat)
+ return err
+}
+
+func (d *MsgClientCreateChatResponse) Deserialize(r io.Reader) error {
+ var err error
+ t0, err := rwu.ReadInt32(r)
+ if err != nil {
+ return err
+ }
+ d.Result = EResult(t0)
+ t1, err := rwu.ReadUint64(r)
+ if err != nil {
+ return err
+ }
+ d.SteamIdChat = steamid.SteamId(t1)
+ t2, err := rwu.ReadInt32(r)
+ if err != nil {
+ return err
+ }
+ d.ChatRoomType = EChatRoomType(t2)
+ t3, err := rwu.ReadUint64(r)
+ if err != nil {
+ return err
+ }
+ d.SteamIdFriendChat = steamid.SteamId(t3)
+ return err
+}
+
+type MsgClientMarketingMessageUpdate2 struct {
+ MarketingMessageUpdateTime uint32
+ Count uint32
+}
+
+func NewMsgClientMarketingMessageUpdate2() *MsgClientMarketingMessageUpdate2 {
+ return &MsgClientMarketingMessageUpdate2{}
+}
+
+func (d *MsgClientMarketingMessageUpdate2) GetEMsg() EMsg {
+ return EMsg_ClientMarketingMessageUpdate2
+}
+
+func (d *MsgClientMarketingMessageUpdate2) Serialize(w io.Writer) error {
+ var err error
+ err = binary.Write(w, binary.LittleEndian, d.MarketingMessageUpdateTime)
+ if err != nil {
+ return err
+ }
+ err = binary.Write(w, binary.LittleEndian, d.Count)
+ return err
+}
+
+func (d *MsgClientMarketingMessageUpdate2) Deserialize(r io.Reader) error {
+ var err error
+ d.MarketingMessageUpdateTime, err = rwu.ReadUint32(r)
+ if err != nil {
+ return err
+ }
+ d.Count, err = rwu.ReadUint32(r)
+ return err
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-01 19:40:36 +0000