1// Generated code 2// DO NOT EDIT 3 4package steamlang 5 6import ( 7 "encoding/binary" 8 . "github.com/Philipp15b/go-steam/protocol/protobuf" 9 "github.com/Philipp15b/go-steam/rwu" 10 "github.com/Philipp15b/go-steam/steamid" 11 "github.com/golang/protobuf/proto" 12 "io" 13) 14 15const UdpHeader_MAGIC uint32 = 0x31305356 16 17type UdpHeader struct { 18 Magic uint32 19 PayloadSize uint16 20 PacketType EUdpPacketType 21 Flags uint8 22 SourceConnID uint32 23 DestConnID uint32 24 SeqThis uint32 25 SeqAck uint32 26 PacketsInMsg uint32 27 MsgStartSeq uint32 28 MsgSize uint32 29} 30 31func NewUdpHeader() *UdpHeader { 32 return &UdpHeader{ 33 Magic: UdpHeader_MAGIC, 34 PacketType: EUdpPacketType_Invalid, 35 SourceConnID: 512, 36 } 37} 38 39func (d *UdpHeader) Serialize(w io.Writer) error { 40 var err error 41 err = binary.Write(w, binary.LittleEndian, d.Magic) 42 if err != nil { 43 return err 44 } 45 err = binary.Write(w, binary.LittleEndian, d.PayloadSize) 46 if err != nil { 47 return err 48 } 49 err = binary.Write(w, binary.LittleEndian, d.PacketType) 50 if err != nil { 51 return err 52 } 53 err = binary.Write(w, binary.LittleEndian, d.Flags) 54 if err != nil { 55 return err 56 } 57 err = binary.Write(w, binary.LittleEndian, d.SourceConnID) 58 if err != nil { 59 return err 60 } 61 err = binary.Write(w, binary.LittleEndian, d.DestConnID) 62 if err != nil { 63 return err 64 } 65 err = binary.Write(w, binary.LittleEndian, d.SeqThis) 66 if err != nil { 67 return err 68 } 69 err = binary.Write(w, binary.LittleEndian, d.SeqAck) 70 if err != nil { 71 return err 72 } 73 err = binary.Write(w, binary.LittleEndian, d.PacketsInMsg) 74 if err != nil { 75 return err 76 } 77 err = binary.Write(w, binary.LittleEndian, d.MsgStartSeq) 78 if err != nil { 79 return err 80 } 81 err = binary.Write(w, binary.LittleEndian, d.MsgSize) 82 return err 83} 84 85func (d *UdpHeader) Deserialize(r io.Reader) error { 86 var err error 87 d.Magic, err = rwu.ReadUint32(r) 88 if err != nil { 89 return err 90 } 91 d.PayloadSize, err = rwu.ReadUint16(r) 92 if err != nil { 93 return err 94 } 95 t0, err := rwu.ReadUint8(r) 96 if err != nil { 97 return err 98 } 99 d.PacketType = EUdpPacketType(t0) 100 d.Flags, err = rwu.ReadUint8(r) 101 if err != nil { 102 return err 103 } 104 d.SourceConnID, err = rwu.ReadUint32(r) 105 if err != nil { 106 return err 107 } 108 d.DestConnID, err = rwu.ReadUint32(r) 109 if err != nil { 110 return err 111 } 112 d.SeqThis, err = rwu.ReadUint32(r) 113 if err != nil { 114 return err 115 } 116 d.SeqAck, err = rwu.ReadUint32(r) 117 if err != nil { 118 return err 119 } 120 d.PacketsInMsg, err = rwu.ReadUint32(r) 121 if err != nil { 122 return err 123 } 124 d.MsgStartSeq, err = rwu.ReadUint32(r) 125 if err != nil { 126 return err 127 } 128 d.MsgSize, err = rwu.ReadUint32(r) 129 return err 130} 131 132const ChallengeData_CHALLENGE_MASK uint32 = 0xA426DF2B 133 134type ChallengeData struct { 135 ChallengeValue uint32 136 ServerLoad uint32 137} 138 139func NewChallengeData() *ChallengeData { 140 return &ChallengeData{} 141} 142 143func (d *ChallengeData) Serialize(w io.Writer) error { 144 var err error 145 err = binary.Write(w, binary.LittleEndian, d.ChallengeValue) 146 if err != nil { 147 return err 148 } 149 err = binary.Write(w, binary.LittleEndian, d.ServerLoad) 150 return err 151} 152 153func (d *ChallengeData) Deserialize(r io.Reader) error { 154 var err error 155 d.ChallengeValue, err = rwu.ReadUint32(r) 156 if err != nil { 157 return err 158 } 159 d.ServerLoad, err = rwu.ReadUint32(r) 160 return err 161} 162 163const ConnectData_CHALLENGE_MASK uint32 = ChallengeData_CHALLENGE_MASK 164 165type ConnectData struct { 166 ChallengeValue uint32 167} 168 169func NewConnectData() *ConnectData { 170 return &ConnectData{} 171} 172 173func (d *ConnectData) Serialize(w io.Writer) error { 174 var err error 175 err = binary.Write(w, binary.LittleEndian, d.ChallengeValue) 176 return err 177} 178 179func (d *ConnectData) Deserialize(r io.Reader) error { 180 var err error 181 d.ChallengeValue, err = rwu.ReadUint32(r) 182 return err 183} 184 185type Accept struct { 186} 187 188func NewAccept() *Accept { 189 return &Accept{} 190} 191 192func (d *Accept) Serialize(w io.Writer) error { 193 var err error 194 return err 195} 196 197func (d *Accept) Deserialize(r io.Reader) error { 198 var err error 199 return err 200} 201 202type Datagram struct { 203} 204 205func NewDatagram() *Datagram { 206 return &Datagram{} 207} 208 209func (d *Datagram) Serialize(w io.Writer) error { 210 var err error 211 return err 212} 213 214func (d *Datagram) Deserialize(r io.Reader) error { 215 var err error 216 return err 217} 218 219type Disconnect struct { 220} 221 222func NewDisconnect() *Disconnect { 223 return &Disconnect{} 224} 225 226func (d *Disconnect) Serialize(w io.Writer) error { 227 var err error 228 return err 229} 230 231func (d *Disconnect) Deserialize(r io.Reader) error { 232 var err error 233 return err 234} 235 236type MsgHdr struct { 237 Msg EMsg 238 TargetJobID uint64 239 SourceJobID uint64 240} 241 242func NewMsgHdr() *MsgHdr { 243 return &MsgHdr{ 244 Msg: EMsg_Invalid, 245 TargetJobID: ^uint64(0), 246 SourceJobID: ^uint64(0), 247 } 248} 249 250func (d *MsgHdr) Serialize(w io.Writer) error { 251 var err error 252 err = binary.Write(w, binary.LittleEndian, d.Msg) 253 if err != nil { 254 return err 255 } 256 err = binary.Write(w, binary.LittleEndian, d.TargetJobID) 257 if err != nil { 258 return err 259 } 260 err = binary.Write(w, binary.LittleEndian, d.SourceJobID) 261 return err 262} 263 264func (d *MsgHdr) Deserialize(r io.Reader) error { 265 var err error 266 t0, err := rwu.ReadInt32(r) 267 if err != nil { 268 return err 269 } 270 d.Msg = EMsg(t0) 271 d.TargetJobID, err = rwu.ReadUint64(r) 272 if err != nil { 273 return err 274 } 275 d.SourceJobID, err = rwu.ReadUint64(r) 276 return err 277} 278 279type ExtendedClientMsgHdr struct { 280 Msg EMsg 281 HeaderSize uint8 282 HeaderVersion uint16 283 TargetJobID uint64 284 SourceJobID uint64 285 HeaderCanary uint8 286 SteamID steamid.SteamId 287 SessionID int32 288} 289 290func NewExtendedClientMsgHdr() *ExtendedClientMsgHdr { 291 return &ExtendedClientMsgHdr{ 292 Msg: EMsg_Invalid, 293 HeaderSize: 36, 294 HeaderVersion: 2, 295 TargetJobID: ^uint64(0), 296 SourceJobID: ^uint64(0), 297 HeaderCanary: 239, 298 } 299} 300 301func (d *ExtendedClientMsgHdr) Serialize(w io.Writer) error { 302 var err error 303 err = binary.Write(w, binary.LittleEndian, d.Msg) 304 if err != nil { 305 return err 306 } 307 err = binary.Write(w, binary.LittleEndian, d.HeaderSize) 308 if err != nil { 309 return err 310 } 311 err = binary.Write(w, binary.LittleEndian, d.HeaderVersion) 312 if err != nil { 313 return err 314 } 315 err = binary.Write(w, binary.LittleEndian, d.TargetJobID) 316 if err != nil { 317 return err 318 } 319 err = binary.Write(w, binary.LittleEndian, d.SourceJobID) 320 if err != nil { 321 return err 322 } 323 err = binary.Write(w, binary.LittleEndian, d.HeaderCanary) 324 if err != nil { 325 return err 326 } 327 err = binary.Write(w, binary.LittleEndian, d.SteamID) 328 if err != nil { 329 return err 330 } 331 err = binary.Write(w, binary.LittleEndian, d.SessionID) 332 return err 333} 334 335func (d *ExtendedClientMsgHdr) Deserialize(r io.Reader) error { 336 var err error 337 t0, err := rwu.ReadInt32(r) 338 if err != nil { 339 return err 340 } 341 d.Msg = EMsg(t0) 342 d.HeaderSize, err = rwu.ReadUint8(r) 343 if err != nil { 344 return err 345 } 346 d.HeaderVersion, err = rwu.ReadUint16(r) 347 if err != nil { 348 return err 349 } 350 d.TargetJobID, err = rwu.ReadUint64(r) 351 if err != nil { 352 return err 353 } 354 d.SourceJobID, err = rwu.ReadUint64(r) 355 if err != nil { 356 return err 357 } 358 d.HeaderCanary, err = rwu.ReadUint8(r) 359 if err != nil { 360 return err 361 } 362 t1, err := rwu.ReadUint64(r) 363 if err != nil { 364 return err 365 } 366 d.SteamID = steamid.SteamId(t1) 367 d.SessionID, err = rwu.ReadInt32(r) 368 return err 369} 370 371type MsgHdrProtoBuf struct { 372 Msg EMsg 373 HeaderLength int32 374 Proto *CMsgProtoBufHeader 375} 376 377func NewMsgHdrProtoBuf() *MsgHdrProtoBuf { 378 return &MsgHdrProtoBuf{ 379 Msg: EMsg_Invalid, 380 Proto: new(CMsgProtoBufHeader), 381 } 382} 383 384func (d *MsgHdrProtoBuf) Serialize(w io.Writer) error { 385 var err error 386 buf0, err := proto.Marshal(d.Proto) 387 if err != nil { 388 return err 389 } 390 d.HeaderLength = int32(len(buf0)) 391 err = binary.Write(w, binary.LittleEndian, EMsg(uint32(d.Msg)|ProtoMask)) 392 if err != nil { 393 return err 394 } 395 err = binary.Write(w, binary.LittleEndian, d.HeaderLength) 396 if err != nil { 397 return err 398 } 399 _, err = w.Write(buf0) 400 return err 401} 402 403func (d *MsgHdrProtoBuf) Deserialize(r io.Reader) error { 404 var err error 405 t0, err := rwu.ReadInt32(r) 406 if err != nil { 407 return err 408 } 409 d.Msg = EMsg(uint32(t0) & EMsgMask) 410 d.HeaderLength, err = rwu.ReadInt32(r) 411 if err != nil { 412 return err 413 } 414 buf1 := make([]byte, d.HeaderLength, d.HeaderLength) 415 _, err = io.ReadFull(r, buf1) 416 if err != nil { 417 return err 418 } 419 err = proto.Unmarshal(buf1, d.Proto) 420 return err 421} 422 423type MsgGCHdrProtoBuf struct { 424 Msg uint32 425 HeaderLength int32 426 Proto *CMsgProtoBufHeader 427} 428 429func NewMsgGCHdrProtoBuf() *MsgGCHdrProtoBuf { 430 return &MsgGCHdrProtoBuf{ 431 Msg: 0, 432 Proto: new(CMsgProtoBufHeader), 433 } 434} 435 436func (d *MsgGCHdrProtoBuf) Serialize(w io.Writer) error { 437 var err error 438 buf0, err := proto.Marshal(d.Proto) 439 if err != nil { 440 return err 441 } 442 d.HeaderLength = int32(len(buf0)) 443 err = binary.Write(w, binary.LittleEndian, EMsg(uint32(d.Msg)|ProtoMask)) 444 if err != nil { 445 return err 446 } 447 err = binary.Write(w, binary.LittleEndian, d.HeaderLength) 448 if err != nil { 449 return err 450 } 451 _, err = w.Write(buf0) 452 return err 453} 454 455func (d *MsgGCHdrProtoBuf) Deserialize(r io.Reader) error { 456 var err error 457 t0, err := rwu.ReadUint32(r) 458 if err != nil { 459 return err 460 } 461 d.Msg = uint32(t0) & EMsgMask 462 d.HeaderLength, err = rwu.ReadInt32(r) 463 if err != nil { 464 return err 465 } 466 buf1 := make([]byte, d.HeaderLength, d.HeaderLength) 467 _, err = io.ReadFull(r, buf1) 468 if err != nil { 469 return err 470 } 471 err = proto.Unmarshal(buf1, d.Proto) 472 return err 473} 474 475type MsgGCHdr struct { 476 HeaderVersion uint16 477 TargetJobID uint64 478 SourceJobID uint64 479} 480 481func NewMsgGCHdr() *MsgGCHdr { 482 return &MsgGCHdr{ 483 HeaderVersion: 1, 484 TargetJobID: ^uint64(0), 485 SourceJobID: ^uint64(0), 486 } 487} 488 489func (d *MsgGCHdr) Serialize(w io.Writer) error { 490 var err error 491 err = binary.Write(w, binary.LittleEndian, d.HeaderVersion) 492 if err != nil { 493 return err 494 } 495 err = binary.Write(w, binary.LittleEndian, d.TargetJobID) 496 if err != nil { 497 return err 498 } 499 err = binary.Write(w, binary.LittleEndian, d.SourceJobID) 500 return err 501} 502 503func (d *MsgGCHdr) Deserialize(r io.Reader) error { 504 var err error 505 d.HeaderVersion, err = rwu.ReadUint16(r) 506 if err != nil { 507 return err 508 } 509 d.TargetJobID, err = rwu.ReadUint64(r) 510 if err != nil { 511 return err 512 } 513 d.SourceJobID, err = rwu.ReadUint64(r) 514 return err 515} 516 517type MsgClientJustStrings struct { 518} 519 520func NewMsgClientJustStrings() *MsgClientJustStrings { 521 return &MsgClientJustStrings{} 522} 523 524func (d *MsgClientJustStrings) GetEMsg() EMsg { 525 return EMsg_Invalid 526} 527 528func (d *MsgClientJustStrings) Serialize(w io.Writer) error { 529 var err error 530 return err 531} 532 533func (d *MsgClientJustStrings) Deserialize(r io.Reader) error { 534 var err error 535 return err 536} 537 538type MsgClientGenericResponse struct { 539 Result EResult 540} 541 542func NewMsgClientGenericResponse() *MsgClientGenericResponse { 543 return &MsgClientGenericResponse{} 544} 545 546func (d *MsgClientGenericResponse) GetEMsg() EMsg { 547 return EMsg_Invalid 548} 549 550func (d *MsgClientGenericResponse) Serialize(w io.Writer) error { 551 var err error 552 err = binary.Write(w, binary.LittleEndian, d.Result) 553 return err 554} 555 556func (d *MsgClientGenericResponse) Deserialize(r io.Reader) error { 557 var err error 558 t0, err := rwu.ReadInt32(r) 559 d.Result = EResult(t0) 560 return err 561} 562 563const MsgChannelEncryptRequest_PROTOCOL_VERSION uint32 = 1 564 565type MsgChannelEncryptRequest struct { 566 ProtocolVersion uint32 567 Universe EUniverse 568} 569 570func NewMsgChannelEncryptRequest() *MsgChannelEncryptRequest { 571 return &MsgChannelEncryptRequest{ 572 ProtocolVersion: MsgChannelEncryptRequest_PROTOCOL_VERSION, 573 Universe: EUniverse_Invalid, 574 } 575} 576 577func (d *MsgChannelEncryptRequest) GetEMsg() EMsg { 578 return EMsg_ChannelEncryptRequest 579} 580 581func (d *MsgChannelEncryptRequest) Serialize(w io.Writer) error { 582 var err error 583 err = binary.Write(w, binary.LittleEndian, d.ProtocolVersion) 584 if err != nil { 585 return err 586 } 587 err = binary.Write(w, binary.LittleEndian, d.Universe) 588 return err 589} 590 591func (d *MsgChannelEncryptRequest) Deserialize(r io.Reader) error { 592 var err error 593 d.ProtocolVersion, err = rwu.ReadUint32(r) 594 if err != nil { 595 return err 596 } 597 t0, err := rwu.ReadInt32(r) 598 d.Universe = EUniverse(t0) 599 return err 600} 601 602type MsgChannelEncryptResponse struct { 603 ProtocolVersion uint32 604 KeySize uint32 605} 606 607func NewMsgChannelEncryptResponse() *MsgChannelEncryptResponse { 608 return &MsgChannelEncryptResponse{ 609 ProtocolVersion: MsgChannelEncryptRequest_PROTOCOL_VERSION, 610 KeySize: 128, 611 } 612} 613 614func (d *MsgChannelEncryptResponse) GetEMsg() EMsg { 615 return EMsg_ChannelEncryptResponse 616} 617 618func (d *MsgChannelEncryptResponse) Serialize(w io.Writer) error { 619 var err error 620 err = binary.Write(w, binary.LittleEndian, d.ProtocolVersion) 621 if err != nil { 622 return err 623 } 624 err = binary.Write(w, binary.LittleEndian, d.KeySize) 625 return err 626} 627 628func (d *MsgChannelEncryptResponse) Deserialize(r io.Reader) error { 629 var err error 630 d.ProtocolVersion, err = rwu.ReadUint32(r) 631 if err != nil { 632 return err 633 } 634 d.KeySize, err = rwu.ReadUint32(r) 635 return err 636} 637 638type MsgChannelEncryptResult struct { 639 Result EResult 640} 641 642func NewMsgChannelEncryptResult() *MsgChannelEncryptResult { 643 return &MsgChannelEncryptResult{ 644 Result: EResult_Invalid, 645 } 646} 647 648func (d *MsgChannelEncryptResult) GetEMsg() EMsg { 649 return EMsg_ChannelEncryptResult 650} 651 652func (d *MsgChannelEncryptResult) Serialize(w io.Writer) error { 653 var err error 654 err = binary.Write(w, binary.LittleEndian, d.Result) 655 return err 656} 657 658func (d *MsgChannelEncryptResult) Deserialize(r io.Reader) error { 659 var err error 660 t0, err := rwu.ReadInt32(r) 661 d.Result = EResult(t0) 662 return err 663} 664 665type MsgClientNewLoginKey struct { 666 UniqueID uint32 667 LoginKey []uint8 668} 669 670func NewMsgClientNewLoginKey() *MsgClientNewLoginKey { 671 return &MsgClientNewLoginKey{ 672 LoginKey: make([]uint8, 20, 20), 673 } 674} 675 676func (d *MsgClientNewLoginKey) GetEMsg() EMsg { 677 return EMsg_ClientNewLoginKey 678} 679 680func (d *MsgClientNewLoginKey) Serialize(w io.Writer) error { 681 var err error 682 err = binary.Write(w, binary.LittleEndian, d.UniqueID) 683 if err != nil { 684 return err 685 } 686 err = binary.Write(w, binary.LittleEndian, d.LoginKey) 687 return err 688} 689 690func (d *MsgClientNewLoginKey) Deserialize(r io.Reader) error { 691 var err error 692 d.UniqueID, err = rwu.ReadUint32(r) 693 if err != nil { 694 return err 695 } 696 err = binary.Read(r, binary.LittleEndian, d.LoginKey) 697 return err 698} 699 700type MsgClientNewLoginKeyAccepted struct { 701 UniqueID uint32 702} 703 704func NewMsgClientNewLoginKeyAccepted() *MsgClientNewLoginKeyAccepted { 705 return &MsgClientNewLoginKeyAccepted{} 706} 707 708func (d *MsgClientNewLoginKeyAccepted) GetEMsg() EMsg { 709 return EMsg_ClientNewLoginKeyAccepted 710} 711 712func (d *MsgClientNewLoginKeyAccepted) Serialize(w io.Writer) error { 713 var err error 714 err = binary.Write(w, binary.LittleEndian, d.UniqueID) 715 return err 716} 717 718func (d *MsgClientNewLoginKeyAccepted) Deserialize(r io.Reader) error { 719 var err error 720 d.UniqueID, err = rwu.ReadUint32(r) 721 return err 722} 723 724const ( 725 MsgClientLogon_ObfuscationMask uint32 = 0xBAADF00D 726 MsgClientLogon_CurrentProtocol uint32 = 65580 727 MsgClientLogon_ProtocolVerMajorMask uint32 = 0xFFFF0000 728 MsgClientLogon_ProtocolVerMinorMask uint32 = 0xFFFF 729 MsgClientLogon_ProtocolVerMinorMinGameServers uint16 = 4 730 MsgClientLogon_ProtocolVerMinorMinForSupportingEMsgMulti uint16 = 12 731 MsgClientLogon_ProtocolVerMinorMinForSupportingEMsgClientEncryptPct uint16 = 14 732 MsgClientLogon_ProtocolVerMinorMinForExtendedMsgHdr uint16 = 17 733 MsgClientLogon_ProtocolVerMinorMinForCellId uint16 = 18 734 MsgClientLogon_ProtocolVerMinorMinForSessionIDLast uint16 = 19 735 MsgClientLogon_ProtocolVerMinorMinForServerAvailablityMsgs uint16 = 24 736 MsgClientLogon_ProtocolVerMinorMinClients uint16 = 25 737 MsgClientLogon_ProtocolVerMinorMinForOSType uint16 = 26 738 MsgClientLogon_ProtocolVerMinorMinForCegApplyPESig uint16 = 27 739 MsgClientLogon_ProtocolVerMinorMinForMarketingMessages2 uint16 = 27 740 MsgClientLogon_ProtocolVerMinorMinForAnyProtoBufMessages uint16 = 28 741 MsgClientLogon_ProtocolVerMinorMinForProtoBufLoggedOffMessage uint16 = 28 742 MsgClientLogon_ProtocolVerMinorMinForProtoBufMultiMessages uint16 = 28 743 MsgClientLogon_ProtocolVerMinorMinForSendingProtocolToUFS uint16 = 30 744 MsgClientLogon_ProtocolVerMinorMinForMachineAuth uint16 = 33 745 MsgClientLogon_ProtocolVerMinorMinForSessionIDLastAnon uint16 = 36 746 MsgClientLogon_ProtocolVerMinorMinForEnhancedAppList uint16 = 40 747 MsgClientLogon_ProtocolVerMinorMinForSteamGuardNotificationUI uint16 = 41 748 MsgClientLogon_ProtocolVerMinorMinForProtoBufServiceModuleCalls uint16 = 42 749 MsgClientLogon_ProtocolVerMinorMinForGzipMultiMessages uint16 = 43 750 MsgClientLogon_ProtocolVerMinorMinForNewVoiceCallAuthorize uint16 = 44 751 MsgClientLogon_ProtocolVerMinorMinForClientInstanceIDs uint16 = 44 752) 753 754type MsgClientLogon struct { 755} 756 757func NewMsgClientLogon() *MsgClientLogon { 758 return &MsgClientLogon{} 759} 760 761func (d *MsgClientLogon) GetEMsg() EMsg { 762 return EMsg_ClientLogon 763} 764 765func (d *MsgClientLogon) Serialize(w io.Writer) error { 766 var err error 767 return err 768} 769 770func (d *MsgClientLogon) Deserialize(r io.Reader) error { 771 var err error 772 return err 773} 774 775type MsgClientVACBanStatus struct { 776 NumBans uint32 777} 778 779func NewMsgClientVACBanStatus() *MsgClientVACBanStatus { 780 return &MsgClientVACBanStatus{} 781} 782 783func (d *MsgClientVACBanStatus) GetEMsg() EMsg { 784 return EMsg_ClientVACBanStatus 785} 786 787func (d *MsgClientVACBanStatus) Serialize(w io.Writer) error { 788 var err error 789 err = binary.Write(w, binary.LittleEndian, d.NumBans) 790 return err 791} 792 793func (d *MsgClientVACBanStatus) Deserialize(r io.Reader) error { 794 var err error 795 d.NumBans, err = rwu.ReadUint32(r) 796 return err 797} 798 799type MsgClientAppUsageEvent struct { 800 AppUsageEvent EAppUsageEvent 801 GameID uint64 802 Offline uint16 803} 804 805func NewMsgClientAppUsageEvent() *MsgClientAppUsageEvent { 806 return &MsgClientAppUsageEvent{} 807} 808 809func (d *MsgClientAppUsageEvent) GetEMsg() EMsg { 810 return EMsg_ClientAppUsageEvent 811} 812 813func (d *MsgClientAppUsageEvent) Serialize(w io.Writer) error { 814 var err error 815 err = binary.Write(w, binary.LittleEndian, d.AppUsageEvent) 816 if err != nil { 817 return err 818 } 819 err = binary.Write(w, binary.LittleEndian, d.GameID) 820 if err != nil { 821 return err 822 } 823 err = binary.Write(w, binary.LittleEndian, d.Offline) 824 return err 825} 826 827func (d *MsgClientAppUsageEvent) Deserialize(r io.Reader) error { 828 var err error 829 t0, err := rwu.ReadInt32(r) 830 if err != nil { 831 return err 832 } 833 d.AppUsageEvent = EAppUsageEvent(t0) 834 d.GameID, err = rwu.ReadUint64(r) 835 if err != nil { 836 return err 837 } 838 d.Offline, err = rwu.ReadUint16(r) 839 return err 840} 841 842type MsgClientEmailAddrInfo struct { 843 PasswordStrength uint32 844 FlagsAccountSecurityPolicy uint32 845 Validated bool 846} 847 848func NewMsgClientEmailAddrInfo() *MsgClientEmailAddrInfo { 849 return &MsgClientEmailAddrInfo{} 850} 851 852func (d *MsgClientEmailAddrInfo) GetEMsg() EMsg { 853 return EMsg_ClientEmailAddrInfo 854} 855 856func (d *MsgClientEmailAddrInfo) Serialize(w io.Writer) error { 857 var err error 858 err = binary.Write(w, binary.LittleEndian, d.PasswordStrength) 859 if err != nil { 860 return err 861 } 862 err = binary.Write(w, binary.LittleEndian, d.FlagsAccountSecurityPolicy) 863 if err != nil { 864 return err 865 } 866 err = rwu.WriteBool(w, d.Validated) 867 return err 868} 869 870func (d *MsgClientEmailAddrInfo) Deserialize(r io.Reader) error { 871 var err error 872 d.PasswordStrength, err = rwu.ReadUint32(r) 873 if err != nil { 874 return err 875 } 876 d.FlagsAccountSecurityPolicy, err = rwu.ReadUint32(r) 877 if err != nil { 878 return err 879 } 880 d.Validated, err = rwu.ReadBool(r) 881 return err 882} 883 884type MsgClientUpdateGuestPassesList struct { 885 Result EResult 886 CountGuestPassesToGive int32 887 CountGuestPassesToRedeem int32 888} 889 890func NewMsgClientUpdateGuestPassesList() *MsgClientUpdateGuestPassesList { 891 return &MsgClientUpdateGuestPassesList{} 892} 893 894func (d *MsgClientUpdateGuestPassesList) GetEMsg() EMsg { 895 return EMsg_ClientUpdateGuestPassesList 896} 897 898func (d *MsgClientUpdateGuestPassesList) Serialize(w io.Writer) error { 899 var err error 900 err = binary.Write(w, binary.LittleEndian, d.Result) 901 if err != nil { 902 return err 903 } 904 err = binary.Write(w, binary.LittleEndian, d.CountGuestPassesToGive) 905 if err != nil { 906 return err 907 } 908 err = binary.Write(w, binary.LittleEndian, d.CountGuestPassesToRedeem) 909 return err 910} 911 912func (d *MsgClientUpdateGuestPassesList) Deserialize(r io.Reader) error { 913 var err error 914 t0, err := rwu.ReadInt32(r) 915 if err != nil { 916 return err 917 } 918 d.Result = EResult(t0) 919 d.CountGuestPassesToGive, err = rwu.ReadInt32(r) 920 if err != nil { 921 return err 922 } 923 d.CountGuestPassesToRedeem, err = rwu.ReadInt32(r) 924 return err 925} 926 927type MsgClientRequestedClientStats struct { 928 CountStats int32 929} 930 931func NewMsgClientRequestedClientStats() *MsgClientRequestedClientStats { 932 return &MsgClientRequestedClientStats{} 933} 934 935func (d *MsgClientRequestedClientStats) GetEMsg() EMsg { 936 return EMsg_ClientRequestedClientStats 937} 938 939func (d *MsgClientRequestedClientStats) Serialize(w io.Writer) error { 940 var err error 941 err = binary.Write(w, binary.LittleEndian, d.CountStats) 942 return err 943} 944 945func (d *MsgClientRequestedClientStats) Deserialize(r io.Reader) error { 946 var err error 947 d.CountStats, err = rwu.ReadInt32(r) 948 return err 949} 950 951type MsgClientP2PIntroducerMessage struct { 952 SteamID steamid.SteamId 953 RoutingType EIntroducerRouting 954 Data []uint8 955 DataLen uint32 956} 957 958func NewMsgClientP2PIntroducerMessage() *MsgClientP2PIntroducerMessage { 959 return &MsgClientP2PIntroducerMessage{ 960 Data: make([]uint8, 1450, 1450), 961 } 962} 963 964func (d *MsgClientP2PIntroducerMessage) GetEMsg() EMsg { 965 return EMsg_ClientP2PIntroducerMessage 966} 967 968func (d *MsgClientP2PIntroducerMessage) Serialize(w io.Writer) error { 969 var err error 970 err = binary.Write(w, binary.LittleEndian, d.SteamID) 971 if err != nil { 972 return err 973 } 974 err = binary.Write(w, binary.LittleEndian, d.RoutingType) 975 if err != nil { 976 return err 977 } 978 err = binary.Write(w, binary.LittleEndian, d.Data) 979 if err != nil { 980 return err 981 } 982 err = binary.Write(w, binary.LittleEndian, d.DataLen) 983 return err 984} 985 986func (d *MsgClientP2PIntroducerMessage) Deserialize(r io.Reader) error { 987 var err error 988 t0, err := rwu.ReadUint64(r) 989 if err != nil { 990 return err 991 } 992 d.SteamID = steamid.SteamId(t0) 993 t1, err := rwu.ReadInt32(r) 994 if err != nil { 995 return err 996 } 997 d.RoutingType = EIntroducerRouting(t1) 998 err = binary.Read(r, binary.LittleEndian, d.Data) 999 if err != nil { 1000 return err 1001 } 1002 d.DataLen, err = rwu.ReadUint32(r) 1003 return err 1004} 1005 1006type MsgClientOGSBeginSession struct { 1007 AccountType uint8 1008 AccountId steamid.SteamId 1009 AppId uint32 1010 TimeStarted uint32 1011} 1012 1013func NewMsgClientOGSBeginSession() *MsgClientOGSBeginSession { 1014 return &MsgClientOGSBeginSession{} 1015} 1016 1017func (d *MsgClientOGSBeginSession) GetEMsg() EMsg { 1018 return EMsg_ClientOGSBeginSession 1019} 1020 1021func (d *MsgClientOGSBeginSession) Serialize(w io.Writer) error { 1022 var err error 1023 err = binary.Write(w, binary.LittleEndian, d.AccountType) 1024 if err != nil { 1025 return err 1026 } 1027 err = binary.Write(w, binary.LittleEndian, d.AccountId) 1028 if err != nil { 1029 return err 1030 } 1031 err = binary.Write(w, binary.LittleEndian, d.AppId) 1032 if err != nil { 1033 return err 1034 } 1035 err = binary.Write(w, binary.LittleEndian, d.TimeStarted) 1036 return err 1037} 1038 1039func (d *MsgClientOGSBeginSession) Deserialize(r io.Reader) error { 1040 var err error 1041 d.AccountType, err = rwu.ReadUint8(r) 1042 if err != nil { 1043 return err 1044 } 1045 t0, err := rwu.ReadUint64(r) 1046 if err != nil { 1047 return err 1048 } 1049 d.AccountId = steamid.SteamId(t0) 1050 d.AppId, err = rwu.ReadUint32(r) 1051 if err != nil { 1052 return err 1053 } 1054 d.TimeStarted, err = rwu.ReadUint32(r) 1055 return err 1056} 1057 1058type MsgClientOGSBeginSessionResponse struct { 1059 Result EResult 1060 CollectingAny bool 1061 CollectingDetails bool 1062 SessionId uint64 1063} 1064 1065func NewMsgClientOGSBeginSessionResponse() *MsgClientOGSBeginSessionResponse { 1066 return &MsgClientOGSBeginSessionResponse{} 1067} 1068 1069func (d *MsgClientOGSBeginSessionResponse) GetEMsg() EMsg { 1070 return EMsg_ClientOGSBeginSessionResponse 1071} 1072 1073func (d *MsgClientOGSBeginSessionResponse) Serialize(w io.Writer) error { 1074 var err error 1075 err = binary.Write(w, binary.LittleEndian, d.Result) 1076 if err != nil { 1077 return err 1078 } 1079 err = rwu.WriteBool(w, d.CollectingAny) 1080 if err != nil { 1081 return err 1082 } 1083 err = rwu.WriteBool(w, d.CollectingDetails) 1084 if err != nil { 1085 return err 1086 } 1087 err = binary.Write(w, binary.LittleEndian, d.SessionId) 1088 return err 1089} 1090 1091func (d *MsgClientOGSBeginSessionResponse) Deserialize(r io.Reader) error { 1092 var err error 1093 t0, err := rwu.ReadInt32(r) 1094 if err != nil { 1095 return err 1096 } 1097 d.Result = EResult(t0) 1098 d.CollectingAny, err = rwu.ReadBool(r) 1099 if err != nil { 1100 return err 1101 } 1102 d.CollectingDetails, err = rwu.ReadBool(r) 1103 if err != nil { 1104 return err 1105 } 1106 d.SessionId, err = rwu.ReadUint64(r) 1107 return err 1108} 1109 1110type MsgClientOGSEndSession struct { 1111 SessionId uint64 1112 TimeEnded uint32 1113 ReasonCode int32 1114 CountAttributes int32 1115} 1116 1117func NewMsgClientOGSEndSession() *MsgClientOGSEndSession { 1118 return &MsgClientOGSEndSession{} 1119} 1120 1121func (d *MsgClientOGSEndSession) GetEMsg() EMsg { 1122 return EMsg_ClientOGSEndSession 1123} 1124 1125func (d *MsgClientOGSEndSession) Serialize(w io.Writer) error { 1126 var err error 1127 err = binary.Write(w, binary.LittleEndian, d.SessionId) 1128 if err != nil { 1129 return err 1130 } 1131 err = binary.Write(w, binary.LittleEndian, d.TimeEnded) 1132 if err != nil { 1133 return err 1134 } 1135 err = binary.Write(w, binary.LittleEndian, d.ReasonCode) 1136 if err != nil { 1137 return err 1138 } 1139 err = binary.Write(w, binary.LittleEndian, d.CountAttributes) 1140 return err 1141} 1142 1143func (d *MsgClientOGSEndSession) Deserialize(r io.Reader) error { 1144 var err error 1145 d.SessionId, err = rwu.ReadUint64(r) 1146 if err != nil { 1147 return err 1148 } 1149 d.TimeEnded, err = rwu.ReadUint32(r) 1150 if err != nil { 1151 return err 1152 } 1153 d.ReasonCode, err = rwu.ReadInt32(r) 1154 if err != nil { 1155 return err 1156 } 1157 d.CountAttributes, err = rwu.ReadInt32(r) 1158 return err 1159} 1160 1161type MsgClientOGSEndSessionResponse struct { 1162 Result EResult 1163} 1164 1165func NewMsgClientOGSEndSessionResponse() *MsgClientOGSEndSessionResponse { 1166 return &MsgClientOGSEndSessionResponse{} 1167} 1168 1169func (d *MsgClientOGSEndSessionResponse) GetEMsg() EMsg { 1170 return EMsg_ClientOGSEndSessionResponse 1171} 1172 1173func (d *MsgClientOGSEndSessionResponse) Serialize(w io.Writer) error { 1174 var err error 1175 err = binary.Write(w, binary.LittleEndian, d.Result) 1176 return err 1177} 1178 1179func (d *MsgClientOGSEndSessionResponse) Deserialize(r io.Reader) error { 1180 var err error 1181 t0, err := rwu.ReadInt32(r) 1182 d.Result = EResult(t0) 1183 return err 1184} 1185 1186type MsgClientOGSWriteRow struct { 1187 SessionId uint64 1188 CountAttributes int32 1189} 1190 1191func NewMsgClientOGSWriteRow() *MsgClientOGSWriteRow { 1192 return &MsgClientOGSWriteRow{} 1193} 1194 1195func (d *MsgClientOGSWriteRow) GetEMsg() EMsg { 1196 return EMsg_ClientOGSWriteRow 1197} 1198 1199func (d *MsgClientOGSWriteRow) Serialize(w io.Writer) error { 1200 var err error 1201 err = binary.Write(w, binary.LittleEndian, d.SessionId) 1202 if err != nil { 1203 return err 1204 } 1205 err = binary.Write(w, binary.LittleEndian, d.CountAttributes) 1206 return err 1207} 1208 1209func (d *MsgClientOGSWriteRow) Deserialize(r io.Reader) error { 1210 var err error 1211 d.SessionId, err = rwu.ReadUint64(r) 1212 if err != nil { 1213 return err 1214 } 1215 d.CountAttributes, err = rwu.ReadInt32(r) 1216 return err 1217} 1218 1219type MsgClientGetFriendsWhoPlayGame struct { 1220 GameId uint64 1221} 1222 1223func NewMsgClientGetFriendsWhoPlayGame() *MsgClientGetFriendsWhoPlayGame { 1224 return &MsgClientGetFriendsWhoPlayGame{} 1225} 1226 1227func (d *MsgClientGetFriendsWhoPlayGame) GetEMsg() EMsg { 1228 return EMsg_ClientGetFriendsWhoPlayGame 1229} 1230 1231func (d *MsgClientGetFriendsWhoPlayGame) Serialize(w io.Writer) error { 1232 var err error 1233 err = binary.Write(w, binary.LittleEndian, d.GameId) 1234 return err 1235} 1236 1237func (d *MsgClientGetFriendsWhoPlayGame) Deserialize(r io.Reader) error { 1238 var err error 1239 d.GameId, err = rwu.ReadUint64(r) 1240 return err 1241} 1242 1243type MsgClientGetFriendsWhoPlayGameResponse struct { 1244 Result EResult 1245 GameId uint64 1246 CountFriends uint32 1247} 1248 1249func NewMsgClientGetFriendsWhoPlayGameResponse() *MsgClientGetFriendsWhoPlayGameResponse { 1250 return &MsgClientGetFriendsWhoPlayGameResponse{} 1251} 1252 1253func (d *MsgClientGetFriendsWhoPlayGameResponse) GetEMsg() EMsg { 1254 return EMsg_ClientGetFriendsWhoPlayGameResponse 1255} 1256 1257func (d *MsgClientGetFriendsWhoPlayGameResponse) Serialize(w io.Writer) error { 1258 var err error 1259 err = binary.Write(w, binary.LittleEndian, d.Result) 1260 if err != nil { 1261 return err 1262 } 1263 err = binary.Write(w, binary.LittleEndian, d.GameId) 1264 if err != nil { 1265 return err 1266 } 1267 err = binary.Write(w, binary.LittleEndian, d.CountFriends) 1268 return err 1269} 1270 1271func (d *MsgClientGetFriendsWhoPlayGameResponse) Deserialize(r io.Reader) error { 1272 var err error 1273 t0, err := rwu.ReadInt32(r) 1274 if err != nil { 1275 return err 1276 } 1277 d.Result = EResult(t0) 1278 d.GameId, err = rwu.ReadUint64(r) 1279 if err != nil { 1280 return err 1281 } 1282 d.CountFriends, err = rwu.ReadUint32(r) 1283 return err 1284} 1285 1286type MsgGSPerformHardwareSurvey struct { 1287 Flags uint32 1288} 1289 1290func NewMsgGSPerformHardwareSurvey() *MsgGSPerformHardwareSurvey { 1291 return &MsgGSPerformHardwareSurvey{} 1292} 1293 1294func (d *MsgGSPerformHardwareSurvey) GetEMsg() EMsg { 1295 return EMsg_GSPerformHardwareSurvey 1296} 1297 1298func (d *MsgGSPerformHardwareSurvey) Serialize(w io.Writer) error { 1299 var err error 1300 err = binary.Write(w, binary.LittleEndian, d.Flags) 1301 return err 1302} 1303 1304func (d *MsgGSPerformHardwareSurvey) Deserialize(r io.Reader) error { 1305 var err error 1306 d.Flags, err = rwu.ReadUint32(r) 1307 return err 1308} 1309 1310type MsgGSGetPlayStatsResponse struct { 1311 Result EResult 1312 Rank int32 1313 LifetimeConnects uint32 1314 LifetimeMinutesPlayed uint32 1315} 1316 1317func NewMsgGSGetPlayStatsResponse() *MsgGSGetPlayStatsResponse { 1318 return &MsgGSGetPlayStatsResponse{} 1319} 1320 1321func (d *MsgGSGetPlayStatsResponse) GetEMsg() EMsg { 1322 return EMsg_GSGetPlayStatsResponse 1323} 1324 1325func (d *MsgGSGetPlayStatsResponse) Serialize(w io.Writer) error { 1326 var err error 1327 err = binary.Write(w, binary.LittleEndian, d.Result) 1328 if err != nil { 1329 return err 1330 } 1331 err = binary.Write(w, binary.LittleEndian, d.Rank) 1332 if err != nil { 1333 return err 1334 } 1335 err = binary.Write(w, binary.LittleEndian, d.LifetimeConnects) 1336 if err != nil { 1337 return err 1338 } 1339 err = binary.Write(w, binary.LittleEndian, d.LifetimeMinutesPlayed) 1340 return err 1341} 1342 1343func (d *MsgGSGetPlayStatsResponse) Deserialize(r io.Reader) error { 1344 var err error 1345 t0, err := rwu.ReadInt32(r) 1346 if err != nil { 1347 return err 1348 } 1349 d.Result = EResult(t0) 1350 d.Rank, err = rwu.ReadInt32(r) 1351 if err != nil { 1352 return err 1353 } 1354 d.LifetimeConnects, err = rwu.ReadUint32(r) 1355 if err != nil { 1356 return err 1357 } 1358 d.LifetimeMinutesPlayed, err = rwu.ReadUint32(r) 1359 return err 1360} 1361 1362type MsgGSGetReputationResponse struct { 1363 Result EResult 1364 ReputationScore uint32 1365 Banned bool 1366 BannedIp uint32 1367 BannedPort uint16 1368 BannedGameId uint64 1369 TimeBanExpires uint32 1370} 1371 1372func NewMsgGSGetReputationResponse() *MsgGSGetReputationResponse { 1373 return &MsgGSGetReputationResponse{} 1374} 1375 1376func (d *MsgGSGetReputationResponse) GetEMsg() EMsg { 1377 return EMsg_GSGetReputationResponse 1378} 1379 1380func (d *MsgGSGetReputationResponse) Serialize(w io.Writer) error { 1381 var err error 1382 err = binary.Write(w, binary.LittleEndian, d.Result) 1383 if err != nil { 1384 return err 1385 } 1386 err = binary.Write(w, binary.LittleEndian, d.ReputationScore) 1387 if err != nil { 1388 return err 1389 } 1390 err = rwu.WriteBool(w, d.Banned) 1391 if err != nil { 1392 return err 1393 } 1394 err = binary.Write(w, binary.LittleEndian, d.BannedIp) 1395 if err != nil { 1396 return err 1397 } 1398 err = binary.Write(w, binary.LittleEndian, d.BannedPort) 1399 if err != nil { 1400 return err 1401 } 1402 err = binary.Write(w, binary.LittleEndian, d.BannedGameId) 1403 if err != nil { 1404 return err 1405 } 1406 err = binary.Write(w, binary.LittleEndian, d.TimeBanExpires) 1407 return err 1408} 1409 1410func (d *MsgGSGetReputationResponse) Deserialize(r io.Reader) error { 1411 var err error 1412 t0, err := rwu.ReadInt32(r) 1413 if err != nil { 1414 return err 1415 } 1416 d.Result = EResult(t0) 1417 d.ReputationScore, err = rwu.ReadUint32(r) 1418 if err != nil { 1419 return err 1420 } 1421 d.Banned, err = rwu.ReadBool(r) 1422 if err != nil { 1423 return err 1424 } 1425 d.BannedIp, err = rwu.ReadUint32(r) 1426 if err != nil { 1427 return err 1428 } 1429 d.BannedPort, err = rwu.ReadUint16(r) 1430 if err != nil { 1431 return err 1432 } 1433 d.BannedGameId, err = rwu.ReadUint64(r) 1434 if err != nil { 1435 return err 1436 } 1437 d.TimeBanExpires, err = rwu.ReadUint32(r) 1438 return err 1439} 1440 1441type MsgGSDeny struct { 1442 SteamId steamid.SteamId 1443 DenyReason EDenyReason 1444} 1445 1446func NewMsgGSDeny() *MsgGSDeny { 1447 return &MsgGSDeny{} 1448} 1449 1450func (d *MsgGSDeny) GetEMsg() EMsg { 1451 return EMsg_GSDeny 1452} 1453 1454func (d *MsgGSDeny) Serialize(w io.Writer) error { 1455 var err error 1456 err = binary.Write(w, binary.LittleEndian, d.SteamId) 1457 if err != nil { 1458 return err 1459 } 1460 err = binary.Write(w, binary.LittleEndian, d.DenyReason) 1461 return err 1462} 1463 1464func (d *MsgGSDeny) Deserialize(r io.Reader) error { 1465 var err error 1466 t0, err := rwu.ReadUint64(r) 1467 if err != nil { 1468 return err 1469 } 1470 d.SteamId = steamid.SteamId(t0) 1471 t1, err := rwu.ReadInt32(r) 1472 d.DenyReason = EDenyReason(t1) 1473 return err 1474} 1475 1476type MsgGSApprove struct { 1477 SteamId steamid.SteamId 1478} 1479 1480func NewMsgGSApprove() *MsgGSApprove { 1481 return &MsgGSApprove{} 1482} 1483 1484func (d *MsgGSApprove) GetEMsg() EMsg { 1485 return EMsg_GSApprove 1486} 1487 1488func (d *MsgGSApprove) Serialize(w io.Writer) error { 1489 var err error 1490 err = binary.Write(w, binary.LittleEndian, d.SteamId) 1491 return err 1492} 1493 1494func (d *MsgGSApprove) Deserialize(r io.Reader) error { 1495 var err error 1496 t0, err := rwu.ReadUint64(r) 1497 if err != nil { 1498 return err 1499 } 1500 d.SteamId = steamid.SteamId(t0) 1501 return err 1502} 1503 1504type MsgGSKick struct { 1505 SteamId steamid.SteamId 1506 DenyReason EDenyReason 1507 WaitTilMapChange int32 1508} 1509 1510func NewMsgGSKick() *MsgGSKick { 1511 return &MsgGSKick{} 1512} 1513 1514func (d *MsgGSKick) GetEMsg() EMsg { 1515 return EMsg_GSKick 1516} 1517 1518func (d *MsgGSKick) Serialize(w io.Writer) error { 1519 var err error 1520 err = binary.Write(w, binary.LittleEndian, d.SteamId) 1521 if err != nil { 1522 return err 1523 } 1524 err = binary.Write(w, binary.LittleEndian, d.DenyReason) 1525 if err != nil { 1526 return err 1527 } 1528 err = binary.Write(w, binary.LittleEndian, d.WaitTilMapChange) 1529 return err 1530} 1531 1532func (d *MsgGSKick) Deserialize(r io.Reader) error { 1533 var err error 1534 t0, err := rwu.ReadUint64(r) 1535 if err != nil { 1536 return err 1537 } 1538 d.SteamId = steamid.SteamId(t0) 1539 t1, err := rwu.ReadInt32(r) 1540 if err != nil { 1541 return err 1542 } 1543 d.DenyReason = EDenyReason(t1) 1544 d.WaitTilMapChange, err = rwu.ReadInt32(r) 1545 return err 1546} 1547 1548type MsgGSGetUserGroupStatus struct { 1549 SteamIdUser steamid.SteamId 1550 SteamIdGroup steamid.SteamId 1551} 1552 1553func NewMsgGSGetUserGroupStatus() *MsgGSGetUserGroupStatus { 1554 return &MsgGSGetUserGroupStatus{} 1555} 1556 1557func (d *MsgGSGetUserGroupStatus) GetEMsg() EMsg { 1558 return EMsg_GSGetUserGroupStatus 1559} 1560 1561func (d *MsgGSGetUserGroupStatus) Serialize(w io.Writer) error { 1562 var err error 1563 err = binary.Write(w, binary.LittleEndian, d.SteamIdUser) 1564 if err != nil { 1565 return err 1566 } 1567 err = binary.Write(w, binary.LittleEndian, d.SteamIdGroup) 1568 return err 1569} 1570 1571func (d *MsgGSGetUserGroupStatus) Deserialize(r io.Reader) error { 1572 var err error 1573 t0, err := rwu.ReadUint64(r) 1574 if err != nil { 1575 return err 1576 } 1577 d.SteamIdUser = steamid.SteamId(t0) 1578 t1, err := rwu.ReadUint64(r) 1579 if err != nil { 1580 return err 1581 } 1582 d.SteamIdGroup = steamid.SteamId(t1) 1583 return err 1584} 1585 1586type MsgGSGetUserGroupStatusResponse struct { 1587 SteamIdUser steamid.SteamId 1588 SteamIdGroup steamid.SteamId 1589 ClanRelationship EClanRelationship 1590 ClanRank EClanRank 1591} 1592 1593func NewMsgGSGetUserGroupStatusResponse() *MsgGSGetUserGroupStatusResponse { 1594 return &MsgGSGetUserGroupStatusResponse{} 1595} 1596 1597func (d *MsgGSGetUserGroupStatusResponse) GetEMsg() EMsg { 1598 return EMsg_GSGetUserGroupStatusResponse 1599} 1600 1601func (d *MsgGSGetUserGroupStatusResponse) Serialize(w io.Writer) error { 1602 var err error 1603 err = binary.Write(w, binary.LittleEndian, d.SteamIdUser) 1604 if err != nil { 1605 return err 1606 } 1607 err = binary.Write(w, binary.LittleEndian, d.SteamIdGroup) 1608 if err != nil { 1609 return err 1610 } 1611 err = binary.Write(w, binary.LittleEndian, d.ClanRelationship) 1612 if err != nil { 1613 return err 1614 } 1615 err = binary.Write(w, binary.LittleEndian, d.ClanRank) 1616 return err 1617} 1618 1619func (d *MsgGSGetUserGroupStatusResponse) Deserialize(r io.Reader) error { 1620 var err error 1621 t0, err := rwu.ReadUint64(r) 1622 if err != nil { 1623 return err 1624 } 1625 d.SteamIdUser = steamid.SteamId(t0) 1626 t1, err := rwu.ReadUint64(r) 1627 if err != nil { 1628 return err 1629 } 1630 d.SteamIdGroup = steamid.SteamId(t1) 1631 t2, err := rwu.ReadInt32(r) 1632 if err != nil { 1633 return err 1634 } 1635 d.ClanRelationship = EClanRelationship(t2) 1636 t3, err := rwu.ReadInt32(r) 1637 d.ClanRank = EClanRank(t3) 1638 return err 1639} 1640 1641type MsgClientJoinChat struct { 1642 SteamIdChat steamid.SteamId 1643 IsVoiceSpeaker bool 1644} 1645 1646func NewMsgClientJoinChat() *MsgClientJoinChat { 1647 return &MsgClientJoinChat{} 1648} 1649 1650func (d *MsgClientJoinChat) GetEMsg() EMsg { 1651 return EMsg_ClientJoinChat 1652} 1653 1654func (d *MsgClientJoinChat) Serialize(w io.Writer) error { 1655 var err error 1656 err = binary.Write(w, binary.LittleEndian, d.SteamIdChat) 1657 if err != nil { 1658 return err 1659 } 1660 err = rwu.WriteBool(w, d.IsVoiceSpeaker) 1661 return err 1662} 1663 1664func (d *MsgClientJoinChat) Deserialize(r io.Reader) error { 1665 var err error 1666 t0, err := rwu.ReadUint64(r) 1667 if err != nil { 1668 return err 1669 } 1670 d.SteamIdChat = steamid.SteamId(t0) 1671 d.IsVoiceSpeaker, err = rwu.ReadBool(r) 1672 return err 1673} 1674 1675type MsgClientChatEnter struct { 1676 SteamIdChat steamid.SteamId 1677 SteamIdFriend steamid.SteamId 1678 ChatRoomType EChatRoomType 1679 SteamIdOwner steamid.SteamId 1680 SteamIdClan steamid.SteamId 1681 ChatFlags uint8 1682 EnterResponse EChatRoomEnterResponse 1683 NumMembers int32 1684} 1685 1686func NewMsgClientChatEnter() *MsgClientChatEnter { 1687 return &MsgClientChatEnter{} 1688} 1689 1690func (d *MsgClientChatEnter) GetEMsg() EMsg { 1691 return EMsg_ClientChatEnter 1692} 1693 1694func (d *MsgClientChatEnter) Serialize(w io.Writer) error { 1695 var err error 1696 err = binary.Write(w, binary.LittleEndian, d.SteamIdChat) 1697 if err != nil { 1698 return err 1699 } 1700 err = binary.Write(w, binary.LittleEndian, d.SteamIdFriend) 1701 if err != nil { 1702 return err 1703 } 1704 err = binary.Write(w, binary.LittleEndian, d.ChatRoomType) 1705 if err != nil { 1706 return err 1707 } 1708 err = binary.Write(w, binary.LittleEndian, d.SteamIdOwner) 1709 if err != nil { 1710 return err 1711 } 1712 err = binary.Write(w, binary.LittleEndian, d.SteamIdClan) 1713 if err != nil { 1714 return err 1715 } 1716 err = binary.Write(w, binary.LittleEndian, d.ChatFlags) 1717 if err != nil { 1718 return err 1719 } 1720 err = binary.Write(w, binary.LittleEndian, d.EnterResponse) 1721 if err != nil { 1722 return err 1723 } 1724 err = binary.Write(w, binary.LittleEndian, d.NumMembers) 1725 return err 1726} 1727 1728func (d *MsgClientChatEnter) Deserialize(r io.Reader) error { 1729 var err error 1730 t0, err := rwu.ReadUint64(r) 1731 if err != nil { 1732 return err 1733 } 1734 d.SteamIdChat = steamid.SteamId(t0) 1735 t1, err := rwu.ReadUint64(r) 1736 if err != nil { 1737 return err 1738 } 1739 d.SteamIdFriend = steamid.SteamId(t1) 1740 t2, err := rwu.ReadInt32(r) 1741 if err != nil { 1742 return err 1743 } 1744 d.ChatRoomType = EChatRoomType(t2) 1745 t3, err := rwu.ReadUint64(r) 1746 if err != nil { 1747 return err 1748 } 1749 d.SteamIdOwner = steamid.SteamId(t3) 1750 t4, err := rwu.ReadUint64(r) 1751 if err != nil { 1752 return err 1753 } 1754 d.SteamIdClan = steamid.SteamId(t4) 1755 d.ChatFlags, err = rwu.ReadUint8(r) 1756 if err != nil { 1757 return err 1758 } 1759 t5, err := rwu.ReadInt32(r) 1760 if err != nil { 1761 return err 1762 } 1763 d.EnterResponse = EChatRoomEnterResponse(t5) 1764 d.NumMembers, err = rwu.ReadInt32(r) 1765 return err 1766} 1767 1768type MsgClientChatMsg struct { 1769 SteamIdChatter steamid.SteamId 1770 SteamIdChatRoom steamid.SteamId 1771 ChatMsgType EChatEntryType 1772} 1773 1774func NewMsgClientChatMsg() *MsgClientChatMsg { 1775 return &MsgClientChatMsg{} 1776} 1777 1778func (d *MsgClientChatMsg) GetEMsg() EMsg { 1779 return EMsg_ClientChatMsg 1780} 1781 1782func (d *MsgClientChatMsg) Serialize(w io.Writer) error { 1783 var err error 1784 err = binary.Write(w, binary.LittleEndian, d.SteamIdChatter) 1785 if err != nil { 1786 return err 1787 } 1788 err = binary.Write(w, binary.LittleEndian, d.SteamIdChatRoom) 1789 if err != nil { 1790 return err 1791 } 1792 err = binary.Write(w, binary.LittleEndian, d.ChatMsgType) 1793 return err 1794} 1795 1796func (d *MsgClientChatMsg) Deserialize(r io.Reader) error { 1797 var err error 1798 t0, err := rwu.ReadUint64(r) 1799 if err != nil { 1800 return err 1801 } 1802 d.SteamIdChatter = steamid.SteamId(t0) 1803 t1, err := rwu.ReadUint64(r) 1804 if err != nil { 1805 return err 1806 } 1807 d.SteamIdChatRoom = steamid.SteamId(t1) 1808 t2, err := rwu.ReadInt32(r) 1809 d.ChatMsgType = EChatEntryType(t2) 1810 return err 1811} 1812 1813type MsgClientChatMemberInfo struct { 1814 SteamIdChat steamid.SteamId 1815 Type EChatInfoType 1816} 1817 1818func NewMsgClientChatMemberInfo() *MsgClientChatMemberInfo { 1819 return &MsgClientChatMemberInfo{} 1820} 1821 1822func (d *MsgClientChatMemberInfo) GetEMsg() EMsg { 1823 return EMsg_ClientChatMemberInfo 1824} 1825 1826func (d *MsgClientChatMemberInfo) Serialize(w io.Writer) error { 1827 var err error 1828 err = binary.Write(w, binary.LittleEndian, d.SteamIdChat) 1829 if err != nil { 1830 return err 1831 } 1832 err = binary.Write(w, binary.LittleEndian, d.Type) 1833 return err 1834} 1835 1836func (d *MsgClientChatMemberInfo) Deserialize(r io.Reader) error { 1837 var err error 1838 t0, err := rwu.ReadUint64(r) 1839 if err != nil { 1840 return err 1841 } 1842 d.SteamIdChat = steamid.SteamId(t0) 1843 t1, err := rwu.ReadInt32(r) 1844 d.Type = EChatInfoType(t1) 1845 return err 1846} 1847 1848type MsgClientChatAction struct { 1849 SteamIdChat steamid.SteamId 1850 SteamIdUserToActOn steamid.SteamId 1851 ChatAction EChatAction 1852} 1853 1854func NewMsgClientChatAction() *MsgClientChatAction { 1855 return &MsgClientChatAction{} 1856} 1857 1858func (d *MsgClientChatAction) GetEMsg() EMsg { 1859 return EMsg_ClientChatAction 1860} 1861 1862func (d *MsgClientChatAction) Serialize(w io.Writer) error { 1863 var err error 1864 err = binary.Write(w, binary.LittleEndian, d.SteamIdChat) 1865 if err != nil { 1866 return err 1867 } 1868 err = binary.Write(w, binary.LittleEndian, d.SteamIdUserToActOn) 1869 if err != nil { 1870 return err 1871 } 1872 err = binary.Write(w, binary.LittleEndian, d.ChatAction) 1873 return err 1874} 1875 1876func (d *MsgClientChatAction) Deserialize(r io.Reader) error { 1877 var err error 1878 t0, err := rwu.ReadUint64(r) 1879 if err != nil { 1880 return err 1881 } 1882 d.SteamIdChat = steamid.SteamId(t0) 1883 t1, err := rwu.ReadUint64(r) 1884 if err != nil { 1885 return err 1886 } 1887 d.SteamIdUserToActOn = steamid.SteamId(t1) 1888 t2, err := rwu.ReadInt32(r) 1889 d.ChatAction = EChatAction(t2) 1890 return err 1891} 1892 1893type MsgClientChatActionResult struct { 1894 SteamIdChat steamid.SteamId 1895 SteamIdUserActedOn steamid.SteamId 1896 ChatAction EChatAction 1897 ActionResult EChatActionResult 1898} 1899 1900func NewMsgClientChatActionResult() *MsgClientChatActionResult { 1901 return &MsgClientChatActionResult{} 1902} 1903 1904func (d *MsgClientChatActionResult) GetEMsg() EMsg { 1905 return EMsg_ClientChatActionResult 1906} 1907 1908func (d *MsgClientChatActionResult) Serialize(w io.Writer) error { 1909 var err error 1910 err = binary.Write(w, binary.LittleEndian, d.SteamIdChat) 1911 if err != nil { 1912 return err 1913 } 1914 err = binary.Write(w, binary.LittleEndian, d.SteamIdUserActedOn) 1915 if err != nil { 1916 return err 1917 } 1918 err = binary.Write(w, binary.LittleEndian, d.ChatAction) 1919 if err != nil { 1920 return err 1921 } 1922 err = binary.Write(w, binary.LittleEndian, d.ActionResult) 1923 return err 1924} 1925 1926func (d *MsgClientChatActionResult) Deserialize(r io.Reader) error { 1927 var err error 1928 t0, err := rwu.ReadUint64(r) 1929 if err != nil { 1930 return err 1931 } 1932 d.SteamIdChat = steamid.SteamId(t0) 1933 t1, err := rwu.ReadUint64(r) 1934 if err != nil { 1935 return err 1936 } 1937 d.SteamIdUserActedOn = steamid.SteamId(t1) 1938 t2, err := rwu.ReadInt32(r) 1939 if err != nil { 1940 return err 1941 } 1942 d.ChatAction = EChatAction(t2) 1943 t3, err := rwu.ReadInt32(r) 1944 d.ActionResult = EChatActionResult(t3) 1945 return err 1946} 1947 1948type MsgClientChatRoomInfo struct { 1949 SteamIdChat steamid.SteamId 1950 Type EChatInfoType 1951} 1952 1953func NewMsgClientChatRoomInfo() *MsgClientChatRoomInfo { 1954 return &MsgClientChatRoomInfo{} 1955} 1956 1957func (d *MsgClientChatRoomInfo) GetEMsg() EMsg { 1958 return EMsg_ClientChatRoomInfo 1959} 1960 1961func (d *MsgClientChatRoomInfo) Serialize(w io.Writer) error { 1962 var err error 1963 err = binary.Write(w, binary.LittleEndian, d.SteamIdChat) 1964 if err != nil { 1965 return err 1966 } 1967 err = binary.Write(w, binary.LittleEndian, d.Type) 1968 return err 1969} 1970 1971func (d *MsgClientChatRoomInfo) Deserialize(r io.Reader) error { 1972 var err error 1973 t0, err := rwu.ReadUint64(r) 1974 if err != nil { 1975 return err 1976 } 1977 d.SteamIdChat = steamid.SteamId(t0) 1978 t1, err := rwu.ReadInt32(r) 1979 d.Type = EChatInfoType(t1) 1980 return err 1981} 1982 1983type MsgClientSetIgnoreFriend struct { 1984 MySteamId steamid.SteamId 1985 SteamIdFriend steamid.SteamId 1986 Ignore uint8 1987} 1988 1989func NewMsgClientSetIgnoreFriend() *MsgClientSetIgnoreFriend { 1990 return &MsgClientSetIgnoreFriend{} 1991} 1992 1993func (d *MsgClientSetIgnoreFriend) GetEMsg() EMsg { 1994 return EMsg_ClientSetIgnoreFriend 1995} 1996 1997func (d *MsgClientSetIgnoreFriend) Serialize(w io.Writer) error { 1998 var err error 1999 err = binary.Write(w, binary.LittleEndian, d.MySteamId) 2000 if err != nil { 2001 return err 2002 } 2003 err = binary.Write(w, binary.LittleEndian, d.SteamIdFriend) 2004 if err != nil { 2005 return err 2006 } 2007 err = binary.Write(w, binary.LittleEndian, d.Ignore) 2008 return err 2009} 2010 2011func (d *MsgClientSetIgnoreFriend) Deserialize(r io.Reader) error { 2012 var err error 2013 t0, err := rwu.ReadUint64(r) 2014 if err != nil { 2015 return err 2016 } 2017 d.MySteamId = steamid.SteamId(t0) 2018 t1, err := rwu.ReadUint64(r) 2019 if err != nil { 2020 return err 2021 } 2022 d.SteamIdFriend = steamid.SteamId(t1) 2023 d.Ignore, err = rwu.ReadUint8(r) 2024 return err 2025} 2026 2027type MsgClientSetIgnoreFriendResponse struct { 2028 FriendId steamid.SteamId 2029 Result EResult 2030} 2031 2032func NewMsgClientSetIgnoreFriendResponse() *MsgClientSetIgnoreFriendResponse { 2033 return &MsgClientSetIgnoreFriendResponse{} 2034} 2035 2036func (d *MsgClientSetIgnoreFriendResponse) GetEMsg() EMsg { 2037 return EMsg_ClientSetIgnoreFriendResponse 2038} 2039 2040func (d *MsgClientSetIgnoreFriendResponse) Serialize(w io.Writer) error { 2041 var err error 2042 err = binary.Write(w, binary.LittleEndian, d.FriendId) 2043 if err != nil { 2044 return err 2045 } 2046 err = binary.Write(w, binary.LittleEndian, d.Result) 2047 return err 2048} 2049 2050func (d *MsgClientSetIgnoreFriendResponse) Deserialize(r io.Reader) error { 2051 var err error 2052 t0, err := rwu.ReadUint64(r) 2053 if err != nil { 2054 return err 2055 } 2056 d.FriendId = steamid.SteamId(t0) 2057 t1, err := rwu.ReadInt32(r) 2058 d.Result = EResult(t1) 2059 return err 2060} 2061 2062type MsgClientLoggedOff struct { 2063 Result EResult 2064 SecMinReconnectHint int32 2065 SecMaxReconnectHint int32 2066} 2067 2068func NewMsgClientLoggedOff() *MsgClientLoggedOff { 2069 return &MsgClientLoggedOff{} 2070} 2071 2072func (d *MsgClientLoggedOff) GetEMsg() EMsg { 2073 return EMsg_ClientLoggedOff 2074} 2075 2076func (d *MsgClientLoggedOff) Serialize(w io.Writer) error { 2077 var err error 2078 err = binary.Write(w, binary.LittleEndian, d.Result) 2079 if err != nil { 2080 return err 2081 } 2082 err = binary.Write(w, binary.LittleEndian, d.SecMinReconnectHint) 2083 if err != nil { 2084 return err 2085 } 2086 err = binary.Write(w, binary.LittleEndian, d.SecMaxReconnectHint) 2087 return err 2088} 2089 2090func (d *MsgClientLoggedOff) Deserialize(r io.Reader) error { 2091 var err error 2092 t0, err := rwu.ReadInt32(r) 2093 if err != nil { 2094 return err 2095 } 2096 d.Result = EResult(t0) 2097 d.SecMinReconnectHint, err = rwu.ReadInt32(r) 2098 if err != nil { 2099 return err 2100 } 2101 d.SecMaxReconnectHint, err = rwu.ReadInt32(r) 2102 return err 2103} 2104 2105type MsgClientLogOnResponse struct { 2106 Result EResult 2107 OutOfGameHeartbeatRateSec int32 2108 InGameHeartbeatRateSec int32 2109 ClientSuppliedSteamId steamid.SteamId 2110 IpPublic uint32 2111 ServerRealTime uint32 2112} 2113 2114func NewMsgClientLogOnResponse() *MsgClientLogOnResponse { 2115 return &MsgClientLogOnResponse{} 2116} 2117 2118func (d *MsgClientLogOnResponse) GetEMsg() EMsg { 2119 return EMsg_ClientLogOnResponse 2120} 2121 2122func (d *MsgClientLogOnResponse) Serialize(w io.Writer) error { 2123 var err error 2124 err = binary.Write(w, binary.LittleEndian, d.Result) 2125 if err != nil { 2126 return err 2127 } 2128 err = binary.Write(w, binary.LittleEndian, d.OutOfGameHeartbeatRateSec) 2129 if err != nil { 2130 return err 2131 } 2132 err = binary.Write(w, binary.LittleEndian, d.InGameHeartbeatRateSec) 2133 if err != nil { 2134 return err 2135 } 2136 err = binary.Write(w, binary.LittleEndian, d.ClientSuppliedSteamId) 2137 if err != nil { 2138 return err 2139 } 2140 err = binary.Write(w, binary.LittleEndian, d.IpPublic) 2141 if err != nil { 2142 return err 2143 } 2144 err = binary.Write(w, binary.LittleEndian, d.ServerRealTime) 2145 return err 2146} 2147 2148func (d *MsgClientLogOnResponse) Deserialize(r io.Reader) error { 2149 var err error 2150 t0, err := rwu.ReadInt32(r) 2151 if err != nil { 2152 return err 2153 } 2154 d.Result = EResult(t0) 2155 d.OutOfGameHeartbeatRateSec, err = rwu.ReadInt32(r) 2156 if err != nil { 2157 return err 2158 } 2159 d.InGameHeartbeatRateSec, err = rwu.ReadInt32(r) 2160 if err != nil { 2161 return err 2162 } 2163 t1, err := rwu.ReadUint64(r) 2164 if err != nil { 2165 return err 2166 } 2167 d.ClientSuppliedSteamId = steamid.SteamId(t1) 2168 d.IpPublic, err = rwu.ReadUint32(r) 2169 if err != nil { 2170 return err 2171 } 2172 d.ServerRealTime, err = rwu.ReadUint32(r) 2173 return err 2174} 2175 2176type MsgClientServerUnavailable struct { 2177 JobidSent uint64 2178 EMsgSent uint32 2179 EServerTypeUnavailable EServerType 2180} 2181 2182func NewMsgClientServerUnavailable() *MsgClientServerUnavailable { 2183 return &MsgClientServerUnavailable{} 2184} 2185 2186func (d *MsgClientServerUnavailable) GetEMsg() EMsg { 2187 return EMsg_ClientServerUnavailable 2188} 2189 2190func (d *MsgClientServerUnavailable) Serialize(w io.Writer) error { 2191 var err error 2192 err = binary.Write(w, binary.LittleEndian, d.JobidSent) 2193 if err != nil { 2194 return err 2195 } 2196 err = binary.Write(w, binary.LittleEndian, d.EMsgSent) 2197 if err != nil { 2198 return err 2199 } 2200 err = binary.Write(w, binary.LittleEndian, d.EServerTypeUnavailable) 2201 return err 2202} 2203 2204func (d *MsgClientServerUnavailable) Deserialize(r io.Reader) error { 2205 var err error 2206 d.JobidSent, err = rwu.ReadUint64(r) 2207 if err != nil { 2208 return err 2209 } 2210 d.EMsgSent, err = rwu.ReadUint32(r) 2211 if err != nil { 2212 return err 2213 } 2214 t0, err := rwu.ReadInt32(r) 2215 d.EServerTypeUnavailable = EServerType(t0) 2216 return err 2217} 2218 2219type MsgClientCreateChat struct { 2220 ChatRoomType EChatRoomType 2221 GameId uint64 2222 SteamIdClan steamid.SteamId 2223 PermissionOfficer EChatPermission 2224 PermissionMember EChatPermission 2225 PermissionAll EChatPermission 2226 MembersMax uint32 2227 ChatFlags uint8 2228 SteamIdFriendChat steamid.SteamId 2229 SteamIdInvited steamid.SteamId 2230} 2231 2232func NewMsgClientCreateChat() *MsgClientCreateChat { 2233 return &MsgClientCreateChat{} 2234} 2235 2236func (d *MsgClientCreateChat) GetEMsg() EMsg { 2237 return EMsg_ClientCreateChat 2238} 2239 2240func (d *MsgClientCreateChat) Serialize(w io.Writer) error { 2241 var err error 2242 err = binary.Write(w, binary.LittleEndian, d.ChatRoomType) 2243 if err != nil { 2244 return err 2245 } 2246 err = binary.Write(w, binary.LittleEndian, d.GameId) 2247 if err != nil { 2248 return err 2249 } 2250 err = binary.Write(w, binary.LittleEndian, d.SteamIdClan) 2251 if err != nil { 2252 return err 2253 } 2254 err = binary.Write(w, binary.LittleEndian, d.PermissionOfficer) 2255 if err != nil { 2256 return err 2257 } 2258 err = binary.Write(w, binary.LittleEndian, d.PermissionMember) 2259 if err != nil { 2260 return err 2261 } 2262 err = binary.Write(w, binary.LittleEndian, d.PermissionAll) 2263 if err != nil { 2264 return err 2265 } 2266 err = binary.Write(w, binary.LittleEndian, d.MembersMax) 2267 if err != nil { 2268 return err 2269 } 2270 err = binary.Write(w, binary.LittleEndian, d.ChatFlags) 2271 if err != nil { 2272 return err 2273 } 2274 err = binary.Write(w, binary.LittleEndian, d.SteamIdFriendChat) 2275 if err != nil { 2276 return err 2277 } 2278 err = binary.Write(w, binary.LittleEndian, d.SteamIdInvited) 2279 return err 2280} 2281 2282func (d *MsgClientCreateChat) Deserialize(r io.Reader) error { 2283 var err error 2284 t0, err := rwu.ReadInt32(r) 2285 if err != nil { 2286 return err 2287 } 2288 d.ChatRoomType = EChatRoomType(t0) 2289 d.GameId, err = rwu.ReadUint64(r) 2290 if err != nil { 2291 return err 2292 } 2293 t1, err := rwu.ReadUint64(r) 2294 if err != nil { 2295 return err 2296 } 2297 d.SteamIdClan = steamid.SteamId(t1) 2298 t2, err := rwu.ReadInt32(r) 2299 if err != nil { 2300 return err 2301 } 2302 d.PermissionOfficer = EChatPermission(t2) 2303 t3, err := rwu.ReadInt32(r) 2304 if err != nil { 2305 return err 2306 } 2307 d.PermissionMember = EChatPermission(t3) 2308 t4, err := rwu.ReadInt32(r) 2309 if err != nil { 2310 return err 2311 } 2312 d.PermissionAll = EChatPermission(t4) 2313 d.MembersMax, err = rwu.ReadUint32(r) 2314 if err != nil { 2315 return err 2316 } 2317 d.ChatFlags, err = rwu.ReadUint8(r) 2318 if err != nil { 2319 return err 2320 } 2321 t5, err := rwu.ReadUint64(r) 2322 if err != nil { 2323 return err 2324 } 2325 d.SteamIdFriendChat = steamid.SteamId(t5) 2326 t6, err := rwu.ReadUint64(r) 2327 if err != nil { 2328 return err 2329 } 2330 d.SteamIdInvited = steamid.SteamId(t6) 2331 return err 2332} 2333 2334type MsgClientCreateChatResponse struct { 2335 Result EResult 2336 SteamIdChat steamid.SteamId 2337 ChatRoomType EChatRoomType 2338 SteamIdFriendChat steamid.SteamId 2339} 2340 2341func NewMsgClientCreateChatResponse() *MsgClientCreateChatResponse { 2342 return &MsgClientCreateChatResponse{} 2343} 2344 2345func (d *MsgClientCreateChatResponse) GetEMsg() EMsg { 2346 return EMsg_ClientCreateChatResponse 2347} 2348 2349func (d *MsgClientCreateChatResponse) Serialize(w io.Writer) error { 2350 var err error 2351 err = binary.Write(w, binary.LittleEndian, d.Result) 2352 if err != nil { 2353 return err 2354 } 2355 err = binary.Write(w, binary.LittleEndian, d.SteamIdChat) 2356 if err != nil { 2357 return err 2358 } 2359 err = binary.Write(w, binary.LittleEndian, d.ChatRoomType) 2360 if err != nil { 2361 return err 2362 } 2363 err = binary.Write(w, binary.LittleEndian, d.SteamIdFriendChat) 2364 return err 2365} 2366 2367func (d *MsgClientCreateChatResponse) Deserialize(r io.Reader) error { 2368 var err error 2369 t0, err := rwu.ReadInt32(r) 2370 if err != nil { 2371 return err 2372 } 2373 d.Result = EResult(t0) 2374 t1, err := rwu.ReadUint64(r) 2375 if err != nil { 2376 return err 2377 } 2378 d.SteamIdChat = steamid.SteamId(t1) 2379 t2, err := rwu.ReadInt32(r) 2380 if err != nil { 2381 return err 2382 } 2383 d.ChatRoomType = EChatRoomType(t2) 2384 t3, err := rwu.ReadUint64(r) 2385 if err != nil { 2386 return err 2387 } 2388 d.SteamIdFriendChat = steamid.SteamId(t3) 2389 return err 2390} 2391 2392type MsgClientMarketingMessageUpdate2 struct { 2393 MarketingMessageUpdateTime uint32 2394 Count uint32 2395} 2396 2397func NewMsgClientMarketingMessageUpdate2() *MsgClientMarketingMessageUpdate2 { 2398 return &MsgClientMarketingMessageUpdate2{} 2399} 2400 2401func (d *MsgClientMarketingMessageUpdate2) GetEMsg() EMsg { 2402 return EMsg_ClientMarketingMessageUpdate2 2403} 2404 2405func (d *MsgClientMarketingMessageUpdate2) Serialize(w io.Writer) error { 2406 var err error 2407 err = binary.Write(w, binary.LittleEndian, d.MarketingMessageUpdateTime) 2408 if err != nil { 2409 return err 2410 } 2411 err = binary.Write(w, binary.LittleEndian, d.Count) 2412 return err 2413} 2414 2415func (d *MsgClientMarketingMessageUpdate2) Deserialize(r io.Reader) error { 2416 var err error 2417 d.MarketingMessageUpdateTime, err = rwu.ReadUint32(r) 2418 if err != nil { 2419 return err 2420 } 2421 d.Count, err = rwu.ReadUint32(r) 2422 return err 2423} 2424