mirror of
https://github.com/cwinfo/matterbridge.git
synced 2024-09-20 19:32:31 +00:00
2544 lines
55 KiB
Go
2544 lines
55 KiB
Go
// 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
|
|
}
|