steam-min-cpp
Loading...
Searching...
No Matches
SteamLanguageInternal.hpp
1// This file was majorly automatically generated.
2// Some changes were made because I was too lazy to make the C++ generator
3// extremely robust. Avoid modifying unless strictly necessary.
5#pragma once
6#include <cstddef>
7#include <cstdint>
8#include <iostream>
9#include <steamclient/utilities/msg_utils.hpp>
10#include <steamclient/utilities/stream.hpp>
11#include <string>
12#include <vector>
13
14#include "steammessages_base.pb.h"
15
16namespace Steam::Internal {
17
18struct SteamID {
19 private:
20 uint64_t value = 0;
21
22 static constexpr int ACCOUNT_ID_SHIFT = 0;
23 static constexpr int INSTANCE_SHIFT = 32;
24 static constexpr int ACCOUNT_TYPE_SHIFT = 52;
25 static constexpr int UNIVERSE_SHIFT = 56;
26
27 static constexpr uint64_t ACCOUNT_ID_MASK = 0xFFFFFFFFULL;
28 static constexpr uint64_t INSTANCE_MASK = 0xFFFFFULL;
29 static constexpr uint64_t ACCOUNT_TYPE_MASK = 0xFULL;
30 static constexpr uint64_t UNIVERSE_MASK = 0xFFULL;
31
32 public:
33 SteamID() = default;
34
35 SteamID(uint32_t accountID, uint32_t instance,
36 Steam::Internal::Enums::EUniverse universe,
37 Steam::Internal::Enums::EAccountType accountType) {
38 value = ((uint64_t)accountID << ACCOUNT_ID_SHIFT) |
39 ((uint64_t)instance << INSTANCE_SHIFT) |
40 ((uint64_t)accountType << ACCOUNT_TYPE_SHIFT) |
41 ((uint64_t)universe << UNIVERSE_SHIFT);
42 }
43
44 SteamID(uint64_t val) { value = val; }
45
46 uint64_t ConvertToUInt64() const { return value; }
47};
48
49struct GameID {
50 private:
51 uint64_t value;
52
53 public:
54 GameID() : value(0) {}
55 explicit GameID(uint64_t v) : value(v) {}
56
57 uint64_t ConvertToUInt64() const { return value; }
58};
59
60struct ISteamSerializable {
61 virtual void Serialize(Steam::Utils::Stream& stream) const = 0;
62 virtual void Deserialize(Steam::Utils::Stream& stream) = 0;
63 virtual ~ISteamSerializable() = default;
64};
65
66struct ISteamSerializableHeader : public ISteamSerializable {
67 virtual void SetEMsg(Steam::Internal::Enums::EMsg msg) = 0;
68};
69
70struct ISteamSerializableMessage : public ISteamSerializable {
71 virtual Steam::Internal::Enums::EMsg GetEMsg() const = 0;
72};
73
74struct IGCSerializableHeader : public ISteamSerializable {
75 virtual void SetEMsg(uint32_t msg) = 0;
76};
77
78struct IGCSerializableMessage : public ISteamSerializable {
79 virtual uint32_t GetEMsg() = 0;
80 virtual bool IsProto() const = 0;
81};
82
83struct UdpHeader : public ISteamSerializable {
84 static const uint32_t MAGIC = 0x31305356;
85 // Static size: 4
86 uint32_t magic;
87 // Static size: 2
88 uint16_t payloadSize;
89 // Static size: 1
90 Steam::Internal::Enums::EUdpPacketType packetType;
91 // Static size: 1
92 unsigned char flags;
93 // Static size: 4
94 uint32_t sourceConnID;
95 // Static size: 4
96 uint32_t destConnID;
97 // Static size: 4
98 uint32_t seqThis;
99 // Static size: 4
100 uint32_t seqAck;
101 // Static size: 4
102 uint32_t packetsInMsg;
103 // Static size: 4
104 uint32_t msgStartSeq;
105 // Static size: 4
106 uint32_t msgSize;
107
108 UdpHeader() {
109 magic = UdpHeader::MAGIC;
110 payloadSize = 0;
111 packetType = Steam::Internal::Enums::EUdpPacketType::Invalid;
112 flags = 0;
113 sourceConnID = 512;
114 destConnID = 0;
115 seqThis = 0;
116 seqAck = 0;
117 packetsInMsg = 0;
118 msgStartSeq = 0;
119 msgSize = 0;
120 }
121
122 void Serialize(Steam::Utils::Stream& stream) const {
123 stream.Write(magic);
124 stream.Write(payloadSize);
125 stream.Write((byte)packetType);
126 stream.Write(flags);
127 stream.Write(sourceConnID);
128 stream.Write(destConnID);
129 stream.Write(seqThis);
130 stream.Write(seqAck);
131 stream.Write(packetsInMsg);
132 stream.Write(msgStartSeq);
133 stream.Write(msgSize);
134 }
135
136 void Deserialize(Steam::Utils::Stream& stream) {
137 magic = (uint32_t)stream.Read<int32_t>();
138 payloadSize = (uint16_t)stream.Read<int16_t>();
139 packetType =
140 (Steam::Internal::Enums::EUdpPacketType)stream.Read<unsigned char>();
141 flags = (unsigned char)stream.Read<unsigned char>();
142 sourceConnID = (uint32_t)stream.Read<int32_t>();
143 destConnID = (uint32_t)stream.Read<int32_t>();
144 seqThis = (uint32_t)stream.Read<int32_t>();
145 seqAck = (uint32_t)stream.Read<int32_t>();
146 packetsInMsg = (uint32_t)stream.Read<int32_t>();
147 msgStartSeq = (uint32_t)stream.Read<int32_t>();
148 msgSize = (uint32_t)stream.Read<int32_t>();
149 }
150};
151
152struct ChallengeData : public ISteamSerializable {
153 static const uint32_t CHALLENGE_MASK = 0xA426DF2B;
154 // Static size: 4
155 uint32_t challengeValue;
156 // Static size: 4
157 uint32_t serverLoad;
158
159 ChallengeData() {
160 challengeValue = 0;
161 serverLoad = 0;
162 }
163
164 void Serialize(Steam::Utils::Stream& stream) const {
165 stream.Write(challengeValue);
166 stream.Write(serverLoad);
167 }
168
169 void Deserialize(Steam::Utils::Stream& stream) {
170 challengeValue = (uint32_t)stream.Read<int32_t>();
171 serverLoad = (uint32_t)stream.Read<int32_t>();
172 }
173};
174
175struct ConnectData : public ISteamSerializable {
176 static const uint32_t CHALLENGE_MASK = ChallengeData::CHALLENGE_MASK;
177 // Static size: 4
178 uint32_t challengeValue;
179
180 ConnectData() { challengeValue = 0; }
181
182 void Serialize(Steam::Utils::Stream& stream) const {
183 stream.Write(challengeValue);
184 }
185
186 void Deserialize(Steam::Utils::Stream& stream) {
187 challengeValue = (uint32_t)stream.Read<int32_t>();
188 }
189};
190
191struct Accept : public ISteamSerializable {
192 Accept() {}
193
194 void Serialize(Steam::Utils::Stream& stream) const {}
195
196 void Deserialize(Steam::Utils::Stream& stream) {}
197};
198
199struct Datagram : public ISteamSerializable {
200 Datagram() {}
201
202 void Serialize(Steam::Utils::Stream& stream) const {}
203
204 void Deserialize(Steam::Utils::Stream& stream) {}
205};
206
207struct Disconnect : public ISteamSerializable {
208 Disconnect() {}
209
210 void Serialize(Steam::Utils::Stream& stream) const {}
211
212 void Deserialize(Steam::Utils::Stream& stream) {}
213};
214
215// Sequential layout struct (originally StructLayout.Sequential)
216struct MsgHdr : public ISteamSerializableHeader {
217 void SetEMsg(Steam::Internal::Enums::EMsg msg) { Msg = msg; }
218
219 // Static size: 4
220 Steam::Internal::Enums::EMsg Msg;
221 // Static size: 8
222 uint64_t targetJobID;
223 // Static size: 8
224 uint64_t sourceJobID;
225
226 MsgHdr() {
227 Msg = Steam::Internal::Enums::EMsg::Invalid;
228 targetJobID = UINT64_MAX;
229 sourceJobID = UINT64_MAX;
230 }
231
232 void Serialize(Steam::Utils::Stream& stream) const {
233 stream.Write((int)Msg);
234 stream.Write(targetJobID);
235 stream.Write(sourceJobID);
236 }
237
238 void Deserialize(Steam::Utils::Stream& stream) {
239 Msg = (Steam::Internal::Enums::EMsg)stream.Read<int32_t>();
240 targetJobID = (uint64_t)stream.Read<int64_t>();
241 sourceJobID = (uint64_t)stream.Read<int64_t>();
242 }
243};
244
245// Sequential layout struct (originally StructLayout.Sequential)
246struct ExtendedClientMsgHdr : public ISteamSerializableHeader {
247 void SetEMsg(Steam::Internal::Enums::EMsg msg) { Msg = msg; }
248
249 // Static size: 4
250 Steam::Internal::Enums::EMsg Msg;
251 // Static size: 1
252 unsigned char headerSize;
253 // Static size: 2
254 uint16_t headerVersion;
255 // Static size: 8
256 uint64_t targetJobID;
257 // Static size: 8
258 uint64_t sourceJobID;
259 // Static size: 1
260 unsigned char headerCanary;
261 // Static size: 8
262 private:
263 uint64_t steamID;
264
265 public:
266 SteamID GetsteamID() const { return SteamID(steamID); }
267 void SetsteamID(const SteamID& val) { steamID = val.ConvertToUInt64(); }
268 // Static size: 4
269 int32_t sessionID;
270
271 ExtendedClientMsgHdr() {
272 Msg = Steam::Internal::Enums::EMsg::Invalid;
273 headerSize = 36;
274 headerVersion = 2;
275 targetJobID = UINT64_MAX;
276 sourceJobID = UINT64_MAX;
277 headerCanary = 239;
278 steamID = 0;
279 sessionID = 0;
280 }
281
282 void Serialize(Steam::Utils::Stream& stream) const {
283 stream.Write((int)Msg);
284 stream.Write(headerSize);
285 stream.Write(headerVersion);
286 stream.Write(targetJobID);
287 stream.Write(sourceJobID);
288 stream.Write(headerCanary);
289 stream.Write(steamID);
290 stream.Write(sessionID);
291 }
292
293 void Deserialize(Steam::Utils::Stream& stream) {
294 Msg = (Steam::Internal::Enums::EMsg)stream.Read<int32_t>();
295 headerSize = (unsigned char)stream.Read<unsigned char>();
296 headerVersion = (uint16_t)stream.Read<int16_t>();
297 targetJobID = (uint64_t)stream.Read<int64_t>();
298 sourceJobID = (uint64_t)stream.Read<int64_t>();
299 headerCanary = (unsigned char)stream.Read<unsigned char>();
300 steamID = (uint64_t)stream.Read<int64_t>();
301 sessionID = (int32_t)stream.Read<int32_t>();
302 }
303};
304
305// Sequential layout struct (originally StructLayout.Sequential)
306struct MsgHdrProtoBuf : public ISteamSerializableHeader {
307 void SetEMsg(Steam::Internal::Enums::EMsg msg) { Msg = msg; }
308
309 // Static size: 4
310 Steam::Internal::Enums::EMsg Msg;
311 // Static size: 4
312 mutable int32_t headerLength;
313 // Static size: 0
314 CMsgProtoBufHeader proto;
315
316 MsgHdrProtoBuf() {
317 Msg = Steam::Internal::Enums::EMsg::Invalid;
318 headerLength = 0;
319 proto = CMsgProtoBufHeader();
320 }
321
322 void Serialize(Steam::Utils::Stream& stream) const {
323 std::string protoData;
324 if (!proto.SerializeToString(&protoData)) {
325 throw std::runtime_error("Failed to serialize proto message");
326 }
327 headerLength = protoData.size();
328
329 stream.Write((int)Steam::Utils::MsgUtil::make_msg(Msg, true));
330 stream.Write(headerLength);
331 stream.Write(protoData.data(), protoData.size());
332 }
333
334 void Deserialize(Steam::Utils::Stream& stream) {
335 Msg = (Steam::Internal::Enums::EMsg)Steam::Utils::MsgUtil::get_msg(
336 static_cast<uint32_t>(stream.Read<int32_t>()));
337 headerLength = (int32_t)stream.Read<int32_t>();
338 if (headerLength < 0) throw std::out_of_range("Negative length");
339 std::vector<uint8_t> buffer(headerLength);
340 stream.Read(buffer.data(), headerLength);
341
342 if (!proto.ParseFromArray(buffer.data(), headerLength)) {
343 throw std::runtime_error("Failed to parse protobuf message");
344 }
345 }
346};
347
348// Sequential layout struct (originally StructLayout.Sequential)
349struct MsgGCHdrProtoBuf : public IGCSerializableHeader {
350 void SetEMsg(uint32_t msg) { Msg = msg; }
351
352 // Static size: 4
353 uint32_t Msg;
354 // Static size: 4
355 mutable int32_t headerLength;
356 // Static size: 0
357 CMsgProtoBufHeader proto;
358
359 MsgGCHdrProtoBuf() {
360 Msg = 0;
361 headerLength = 0;
362 proto = CMsgProtoBufHeader();
363 }
364
365 void Serialize(Steam::Utils::Stream& stream) const {
366 std::string protoData;
367 if (!proto.SerializeToString(&protoData)) {
368 throw std::runtime_error("Failed to serialize proto message");
369 }
370 headerLength = protoData.size();
371
372 stream.Write(Steam::Utils::MsgUtil::make_gc_msg(Msg, true));
373 stream.Write(headerLength);
374 }
375
376 void Deserialize(Steam::Utils::Stream& stream) {
377 Msg = (uint32_t)Steam::Utils::MsgUtil::get_gc_msg(
378 static_cast<uint32_t>(stream.Read<int32_t>()));
379 headerLength = (int32_t)stream.Read<int32_t>();
380 if (headerLength < 0) throw std::out_of_range("Negative length");
381
382 std::vector<uint8_t> buffer(headerLength);
383 stream.Read(buffer.data(), headerLength);
384
385 if (!proto.ParseFromArray(buffer.data(), headerLength)) {
386 throw std::runtime_error("Failed to parse protobuf message");
387 }
388 }
389};
390
391// Sequential layout struct (originally StructLayout.Sequential)
392struct MsgGCHdr : public IGCSerializableHeader {
393 void SetEMsg(uint32_t /*msg*/) {}
394
395 // Static size: 2
396 uint16_t headerVersion;
397 // Static size: 8
398 uint64_t targetJobID;
399 // Static size: 8
400 uint64_t sourceJobID;
401
402 MsgGCHdr() {
403 headerVersion = 1;
404 targetJobID = UINT64_MAX;
405 sourceJobID = UINT64_MAX;
406 }
407
408 void Serialize(Steam::Utils::Stream& stream) const {
409 stream.Write(headerVersion);
410 stream.Write(targetJobID);
411 stream.Write(sourceJobID);
412 }
413
414 void Deserialize(Steam::Utils::Stream& stream) {
415 headerVersion = (uint16_t)stream.Read<int16_t>();
416 targetJobID = (uint64_t)stream.Read<int64_t>();
417 sourceJobID = (uint64_t)stream.Read<int64_t>();
418 }
419};
420
421struct MsgClientJustStrings : public ISteamSerializableMessage {
422 Steam::Internal::Enums::EMsg GetEMsg() const {
423 return Steam::Internal::Enums::EMsg::Invalid;
424 }
425
426 MsgClientJustStrings() {}
427
428 void Serialize(Steam::Utils::Stream& stream) const {}
429
430 void Deserialize(Steam::Utils::Stream& stream) {}
431};
432
433struct MsgClientGenericResponse : public ISteamSerializableMessage {
434 Steam::Internal::Enums::EMsg GetEMsg() const {
435 return Steam::Internal::Enums::EMsg::Invalid;
436 }
437
438 // Static size: 4
439 Steam::Internal::Enums::EResult result;
440
441 MsgClientGenericResponse() {
442 result = Steam::Internal::Enums::EResult::Invalid;
443 }
444
445 void Serialize(Steam::Utils::Stream& stream) const {
446 stream.Write((int)result);
447 }
448
449 void Deserialize(Steam::Utils::Stream& stream) {
450 result = (Steam::Internal::Enums::EResult)stream.Read<int32_t>();
451 }
452};
453
454struct MsgChannelEncryptRequest : public ISteamSerializableMessage {
455 Steam::Internal::Enums::EMsg GetEMsg() const {
456 return Steam::Internal::Enums::EMsg::ChannelEncryptRequest;
457 }
458
459 static const uint32_t PROTOCOL_VERSION = 1;
460 // Static size: 4
461 uint32_t protocolVersion;
462 // Static size: 4
463 Steam::Internal::Enums::EUniverse universe;
464
465 MsgChannelEncryptRequest() {
466 protocolVersion = MsgChannelEncryptRequest::PROTOCOL_VERSION;
467 universe = Steam::Internal::Enums::EUniverse::Invalid;
468 }
469
470 void Serialize(Steam::Utils::Stream& stream) const {
471 stream.Write(protocolVersion);
472 stream.Write((int)universe);
473 }
474
475 void Deserialize(Steam::Utils::Stream& stream) {
476 protocolVersion = (uint32_t)stream.Read<int32_t>();
477 universe = (Steam::Internal::Enums::EUniverse)stream.Read<int32_t>();
478 }
479};
480
481struct MsgChannelEncryptResponse : public ISteamSerializableMessage {
482 Steam::Internal::Enums::EMsg GetEMsg() const {
483 return Steam::Internal::Enums::EMsg::ChannelEncryptResponse;
484 }
485
486 // Static size: 4
487 uint32_t protocolVersion;
488 // Static size: 4
489 uint32_t keySize;
490
491 MsgChannelEncryptResponse() {
492 protocolVersion = MsgChannelEncryptRequest::PROTOCOL_VERSION;
493 keySize = 128;
494 }
495
496 void Serialize(Steam::Utils::Stream& stream) const {
497 stream.Write(protocolVersion);
498 stream.Write(keySize);
499 }
500
501 void Deserialize(Steam::Utils::Stream& stream) {
502 protocolVersion = (uint32_t)stream.Read<int32_t>();
503 keySize = (uint32_t)stream.Read<int32_t>();
504 }
505};
506
507struct MsgChannelEncryptResult : public ISteamSerializableMessage {
508 Steam::Internal::Enums::EMsg GetEMsg() const {
509 return Steam::Internal::Enums::EMsg::ChannelEncryptResult;
510 }
511
512 // Static size: 4
513 Steam::Internal::Enums::EResult result;
514
515 MsgChannelEncryptResult() {
516 result = Steam::Internal::Enums::EResult::Invalid;
517 }
518
519 void Serialize(Steam::Utils::Stream& stream) const {
520 stream.Write((int)result);
521 }
522
523 void Deserialize(Steam::Utils::Stream& stream) {
524 result = (Steam::Internal::Enums::EResult)stream.Read<int32_t>();
525 }
526};
527
528struct MsgClientLogon : public ISteamSerializableMessage {
529 Steam::Internal::Enums::EMsg GetEMsg() const {
530 return Steam::Internal::Enums::EMsg::ClientLogon;
531 }
532
533 static const uint32_t ObfuscationMask = 0xBAADF00D;
534 static const uint32_t CurrentProtocol = 65581;
535 static const uint32_t ProtocolVerMajorMask = 0xFFFF0000;
536 static const uint32_t ProtocolVerMinorMask = 0xFFFF;
537 static const uint16_t ProtocolVerMinorMinGameServers = 4;
538 static const uint16_t ProtocolVerMinorMinForSupportingEMsgMulti = 12;
539 static const uint16_t ProtocolVerMinorMinForSupportingEMsgClientEncryptPct =
540 14;
541 static const uint16_t ProtocolVerMinorMinForExtendedMsgHdr = 17;
542 static const uint16_t ProtocolVerMinorMinForCellId = 18;
543 static const uint16_t ProtocolVerMinorMinForSessionIDLast = 19;
544 static const uint16_t ProtocolVerMinorMinForServerAvailablityMsgs = 24;
545 static const uint16_t ProtocolVerMinorMinClients = 25;
546 static const uint16_t ProtocolVerMinorMinForOSType = 26;
547 static const uint16_t ProtocolVerMinorMinForCegApplyPESig = 27;
548 static const uint16_t ProtocolVerMinorMinForMarketingMessages2 = 27;
549 static const uint16_t ProtocolVerMinorMinForAnyProtoBufMessages = 28;
550 static const uint16_t ProtocolVerMinorMinForProtoBufLoggedOffMessage = 28;
551 static const uint16_t ProtocolVerMinorMinForProtoBufMultiMessages = 28;
552 static const uint16_t ProtocolVerMinorMinForSendingProtocolToUFS = 30;
553 static const uint16_t ProtocolVerMinorMinForMachineAuth = 33;
554 static const uint16_t ProtocolVerMinorMinForSessionIDLastAnon = 36;
555 static const uint16_t ProtocolVerMinorMinForEnhancedAppList = 40;
556 static const uint16_t ProtocolVerMinorMinForSteamGuardNotificationUI = 41;
557 static const uint16_t ProtocolVerMinorMinForProtoBufServiceModuleCalls = 42;
558 static const uint16_t ProtocolVerMinorMinForGzipMultiMessages = 43;
559 static const uint16_t ProtocolVerMinorMinForNewVoiceCallAuthorize = 44;
560 static const uint16_t ProtocolVerMinorMinForClientInstanceIDs = 44;
561
562 MsgClientLogon() {}
563
564 void Serialize(Steam::Utils::Stream& stream) const {}
565
566 void Deserialize(Steam::Utils::Stream& stream) {}
567};
568
569struct MsgClientVACBanStatus : public ISteamSerializableMessage {
570 Steam::Internal::Enums::EMsg GetEMsg() const {
571 return Steam::Internal::Enums::EMsg::ClientVACBanStatus;
572 }
573
574 // Static size: 4
575 uint32_t numBans;
576
577 MsgClientVACBanStatus() { numBans = 0; }
578
579 void Serialize(Steam::Utils::Stream& stream) const { stream.Write(numBans); }
580
581 void Deserialize(Steam::Utils::Stream& stream) {
582 numBans = (uint32_t)stream.Read<int32_t>();
583 }
584};
585
586struct MsgClientAppUsageEvent : public ISteamSerializableMessage {
587 Steam::Internal::Enums::EMsg GetEMsg() const {
588 return Steam::Internal::Enums::EMsg::ClientAppUsageEvent;
589 }
590
591 // Static size: 4
592 Steam::Internal::Enums::EAppUsageEvent appUsageEvent;
593 // Static size: 8
594 private:
595 uint64_t gameID;
596
597 public:
598 GameID GetgameID() const { return GameID(gameID); }
599 void SetgameID(const GameID& val) { gameID = val.ConvertToUInt64(); }
600 // Static size: 2
601 uint16_t offline;
602
603 MsgClientAppUsageEvent() {
604 appUsageEvent = Steam::Internal::Enums::EAppUsageEvent::Unknown;
605 gameID = 0;
606 offline = 0;
607 }
608
609 void Serialize(Steam::Utils::Stream& stream) const {
610 stream.Write((int)appUsageEvent);
611 stream.Write(gameID);
612 stream.Write(offline);
613 }
614
615 void Deserialize(Steam::Utils::Stream& stream) {
616 appUsageEvent =
617 (Steam::Internal::Enums::EAppUsageEvent)stream.Read<int32_t>();
618 gameID = (uint64_t)stream.Read<int64_t>();
619 offline = (uint16_t)stream.Read<int16_t>();
620 }
621};
622
623struct MsgClientUpdateGuestPassesList : public ISteamSerializableMessage {
624 Steam::Internal::Enums::EMsg GetEMsg() const {
625 return Steam::Internal::Enums::EMsg::ClientUpdateGuestPassesList;
626 }
627
628 // Static size: 4
629 Steam::Internal::Enums::EResult result;
630 // Static size: 4
631 int32_t countGuestPassesToGive;
632 // Static size: 4
633 int32_t countGuestPassesToRedeem;
634
635 MsgClientUpdateGuestPassesList() {
636 result = Steam::Internal::Enums::EResult::Invalid;
637 countGuestPassesToGive = 0;
638 countGuestPassesToRedeem = 0;
639 }
640
641 void Serialize(Steam::Utils::Stream& stream) const {
642 stream.Write((int)result);
643 stream.Write(countGuestPassesToGive);
644 stream.Write(countGuestPassesToRedeem);
645 }
646
647 void Deserialize(Steam::Utils::Stream& stream) {
648 result = (Steam::Internal::Enums::EResult)stream.Read<int32_t>();
649 countGuestPassesToGive = (int32_t)stream.Read<int32_t>();
650 countGuestPassesToRedeem = (int32_t)stream.Read<int32_t>();
651 }
652};
653
654struct MsgClientP2PIntroducerMessage : public ISteamSerializableMessage {
655 Steam::Internal::Enums::EMsg GetEMsg() const {
656 return Steam::Internal::Enums::EMsg::ClientP2PIntroducerMessage;
657 }
658
659 // Static size: 8
660 private:
661 uint64_t steamID;
662
663 public:
664 SteamID GetsteamID() const { return SteamID(steamID); }
665 void SetsteamID(const SteamID& val) { steamID = val.ConvertToUInt64(); }
666 // Static size: 4
667 Steam::Internal::Enums::EIntroducerRouting routingType;
668 // Static size: 1450
669 std::vector<unsigned char> data;
670 // Static size: 4
671 uint32_t dataLen;
672
673 MsgClientP2PIntroducerMessage() {
674 steamID = 0;
675 routingType = Steam::Internal::Enums::EIntroducerRouting::Unknown;
676 data = std::vector<unsigned char>(1450);
677 dataLen = 0;
678 }
679
680 void Serialize(Steam::Utils::Stream& stream) const {
681 stream.Write(steamID);
682 stream.Write((int)routingType);
683 stream.Write(data);
684 stream.Write(dataLen);
685 }
686
687 void Deserialize(Steam::Utils::Stream& stream) {
688 steamID = (uint64_t)stream.Read<int64_t>();
689 routingType =
690 (Steam::Internal::Enums::EIntroducerRouting)stream.Read<int32_t>();
691 data = stream.ReadArray<unsigned char>(1450);
692 dataLen = (uint32_t)stream.Read<int32_t>();
693 }
694};
695
696struct MsgClientOGSBeginSession : public ISteamSerializableMessage {
697 Steam::Internal::Enums::EMsg GetEMsg() const {
698 return Steam::Internal::Enums::EMsg::ClientOGSBeginSession;
699 }
700
701 // Static size: 1
702 unsigned char accountType;
703 // Static size: 8
704 private:
705 uint64_t accountId;
706
707 public:
708 SteamID GetaccountId() const { return SteamID(accountId); }
709 void SetaccountId(const SteamID& val) { accountId = val.ConvertToUInt64(); }
710 // Static size: 4
711 uint32_t appId;
712 // Static size: 4
713 uint32_t timeStarted;
714
715 MsgClientOGSBeginSession() {
716 accountType = 0;
717 accountId = 0;
718 appId = 0;
719 timeStarted = 0;
720 }
721
722 void Serialize(Steam::Utils::Stream& stream) const {
723 stream.Write(accountType);
724 stream.Write(accountId);
725 stream.Write(appId);
726 stream.Write(timeStarted);
727 }
728
729 void Deserialize(Steam::Utils::Stream& stream) {
730 accountType = (unsigned char)stream.Read<unsigned char>();
731 accountId = (uint64_t)stream.Read<int64_t>();
732 appId = (uint32_t)stream.Read<int32_t>();
733 timeStarted = (uint32_t)stream.Read<int32_t>();
734 }
735};
736
737struct MsgClientOGSBeginSessionResponse : public ISteamSerializableMessage {
738 Steam::Internal::Enums::EMsg GetEMsg() const {
739 return Steam::Internal::Enums::EMsg::ClientOGSBeginSessionResponse;
740 }
741
742 // Static size: 4
743 Steam::Internal::Enums::EResult result;
744 // Static size: 1
745 unsigned char collectingAny;
746 // Static size: 1
747 unsigned char collectingDetails;
748 // Static size: 8
749 uint64_t sessionId;
750
751 MsgClientOGSBeginSessionResponse() {
752 result = Steam::Internal::Enums::EResult::Invalid;
753 collectingAny = 0;
754 collectingDetails = 0;
755 sessionId = 0;
756 }
757
758 void Serialize(Steam::Utils::Stream& stream) const {
759 stream.Write((int)result);
760 stream.Write(collectingAny);
761 stream.Write(collectingDetails);
762 stream.Write(sessionId);
763 }
764
765 void Deserialize(Steam::Utils::Stream& stream) {
766 result = (Steam::Internal::Enums::EResult)stream.Read<int32_t>();
767 collectingAny = (unsigned char)stream.Read<unsigned char>();
768 collectingDetails = (unsigned char)stream.Read<unsigned char>();
769 sessionId = (uint64_t)stream.Read<int64_t>();
770 }
771};
772
773struct MsgClientOGSEndSession : public ISteamSerializableMessage {
774 Steam::Internal::Enums::EMsg GetEMsg() const {
775 return Steam::Internal::Enums::EMsg::ClientOGSEndSession;
776 }
777
778 // Static size: 8
779 uint64_t sessionId;
780 // Static size: 4
781 uint32_t timeEnded;
782 // Static size: 4
783 int32_t reasonCode;
784 // Static size: 4
785 int32_t countAttributes;
786
787 MsgClientOGSEndSession() {
788 sessionId = 0;
789 timeEnded = 0;
790 reasonCode = 0;
791 countAttributes = 0;
792 }
793
794 void Serialize(Steam::Utils::Stream& stream) const {
795 stream.Write(sessionId);
796 stream.Write(timeEnded);
797 stream.Write(reasonCode);
798 stream.Write(countAttributes);
799 }
800
801 void Deserialize(Steam::Utils::Stream& stream) {
802 sessionId = (uint64_t)stream.Read<int64_t>();
803 timeEnded = (uint32_t)stream.Read<int32_t>();
804 reasonCode = (int32_t)stream.Read<int32_t>();
805 countAttributes = (int32_t)stream.Read<int32_t>();
806 }
807};
808
809struct MsgClientOGSEndSessionResponse : public ISteamSerializableMessage {
810 Steam::Internal::Enums::EMsg GetEMsg() const {
811 return Steam::Internal::Enums::EMsg::ClientOGSEndSessionResponse;
812 }
813
814 // Static size: 4
815 Steam::Internal::Enums::EResult result;
816
817 MsgClientOGSEndSessionResponse() {
818 result = Steam::Internal::Enums::EResult::Invalid;
819 }
820
821 void Serialize(Steam::Utils::Stream& stream) const {
822 stream.Write((int)result);
823 }
824
825 void Deserialize(Steam::Utils::Stream& stream) {
826 result = (Steam::Internal::Enums::EResult)stream.Read<int32_t>();
827 }
828};
829
830struct MsgClientOGSWriteRow : public ISteamSerializableMessage {
831 Steam::Internal::Enums::EMsg GetEMsg() const {
832 return Steam::Internal::Enums::EMsg::ClientOGSWriteRow;
833 }
834
835 // Static size: 8
836 uint64_t sessionId;
837 // Static size: 4
838 int32_t countAttributes;
839
840 MsgClientOGSWriteRow() {
841 sessionId = 0;
842 countAttributes = 0;
843 }
844
845 void Serialize(Steam::Utils::Stream& stream) const {
846 stream.Write(sessionId);
847 stream.Write(countAttributes);
848 }
849
850 void Deserialize(Steam::Utils::Stream& stream) {
851 sessionId = (uint64_t)stream.Read<int64_t>();
852 countAttributes = (int32_t)stream.Read<int32_t>();
853 }
854};
855
856struct MsgClientGetFriendsWhoPlayGame : public ISteamSerializableMessage {
857 Steam::Internal::Enums::EMsg GetEMsg() const {
858 return Steam::Internal::Enums::EMsg::ClientGetFriendsWhoPlayGame;
859 }
860
861 // Static size: 8
862 private:
863 uint64_t gameId;
864
865 public:
866 GameID GetgameId() const { return GameID(gameId); }
867 void SetgameId(const GameID& val) { gameId = val.ConvertToUInt64(); }
868
869 MsgClientGetFriendsWhoPlayGame() { gameId = 0; }
870
871 void Serialize(Steam::Utils::Stream& stream) const { stream.Write(gameId); }
872
873 void Deserialize(Steam::Utils::Stream& stream) {
874 gameId = (uint64_t)stream.Read<int64_t>();
875 }
876};
877
878struct MsgClientGetFriendsWhoPlayGameResponse
879 : public ISteamSerializableMessage {
880 Steam::Internal::Enums::EMsg GetEMsg() const {
881 return Steam::Internal::Enums::EMsg::ClientGetFriendsWhoPlayGameResponse;
882 }
883
884 // Static size: 4
885 Steam::Internal::Enums::EResult result;
886 // Static size: 8
887 private:
888 uint64_t gameId;
889
890 public:
891 GameID GetgameId() const { return GameID(gameId); }
892 void SetgameId(const GameID& val) { gameId = val.ConvertToUInt64(); }
893 // Static size: 4
894 uint32_t countFriends;
895
896 MsgClientGetFriendsWhoPlayGameResponse() {
897 result = Steam::Internal::Enums::EResult::Invalid;
898 gameId = 0;
899 countFriends = 0;
900 }
901
902 void Serialize(Steam::Utils::Stream& stream) const {
903 stream.Write((int)result);
904 stream.Write(gameId);
905 stream.Write(countFriends);
906 }
907
908 void Deserialize(Steam::Utils::Stream& stream) {
909 result = (Steam::Internal::Enums::EResult)stream.Read<int32_t>();
910 gameId = (uint64_t)stream.Read<int64_t>();
911 countFriends = (uint32_t)stream.Read<int32_t>();
912 }
913};
914
915struct MsgGSPerformHardwareSurvey : public ISteamSerializableMessage {
916 Steam::Internal::Enums::EMsg GetEMsg() const {
917 return Steam::Internal::Enums::EMsg::GSPerformHardwareSurvey;
918 }
919
920 // Static size: 4
921 uint32_t flags;
922
923 MsgGSPerformHardwareSurvey() { flags = 0; }
924
925 void Serialize(Steam::Utils::Stream& stream) const { stream.Write(flags); }
926
927 void Deserialize(Steam::Utils::Stream& stream) {
928 flags = (uint32_t)stream.Read<int32_t>();
929 }
930};
931
932struct MsgGSGetPlayStatsResponse : public ISteamSerializableMessage {
933 Steam::Internal::Enums::EMsg GetEMsg() const {
934 return Steam::Internal::Enums::EMsg::GSGetPlayStatsResponse;
935 }
936
937 // Static size: 4
938 Steam::Internal::Enums::EResult result;
939 // Static size: 4
940 int32_t rank;
941 // Static size: 4
942 uint32_t lifetimeConnects;
943 // Static size: 4
944 uint32_t lifetimeMinutesPlayed;
945
946 MsgGSGetPlayStatsResponse() {
947 result = Steam::Internal::Enums::EResult::Invalid;
948 rank = 0;
949 lifetimeConnects = 0;
950 lifetimeMinutesPlayed = 0;
951 }
952
953 void Serialize(Steam::Utils::Stream& stream) const {
954 stream.Write((int)result);
955 stream.Write(rank);
956 stream.Write(lifetimeConnects);
957 stream.Write(lifetimeMinutesPlayed);
958 }
959
960 void Deserialize(Steam::Utils::Stream& stream) {
961 result = (Steam::Internal::Enums::EResult)stream.Read<int32_t>();
962 rank = (int32_t)stream.Read<int32_t>();
963 lifetimeConnects = (uint32_t)stream.Read<int32_t>();
964 lifetimeMinutesPlayed = (uint32_t)stream.Read<int32_t>();
965 }
966};
967
968struct MsgGSGetReputationResponse : public ISteamSerializableMessage {
969 Steam::Internal::Enums::EMsg GetEMsg() const {
970 return Steam::Internal::Enums::EMsg::GSGetReputationResponse;
971 }
972
973 // Static size: 4
974 Steam::Internal::Enums::EResult result;
975 // Static size: 4
976 uint32_t reputationScore;
977 // Static size: 1
978 unsigned char banned;
979 // Static size: 4
980 uint32_t bannedIp;
981 // Static size: 2
982 uint16_t bannedPort;
983 // Static size: 8
984 uint64_t bannedGameId;
985 // Static size: 4
986 uint32_t timeBanExpires;
987
988 MsgGSGetReputationResponse() {
989 result = Steam::Internal::Enums::EResult::Invalid;
990 reputationScore = 0;
991 banned = 0;
992 bannedIp = 0;
993 bannedPort = 0;
994 bannedGameId = 0;
995 timeBanExpires = 0;
996 }
997
998 void Serialize(Steam::Utils::Stream& stream) const {
999 stream.Write((int)result);
1000 stream.Write(reputationScore);
1001 stream.Write(banned);
1002 stream.Write(bannedIp);
1003 stream.Write(bannedPort);
1004 stream.Write(bannedGameId);
1005 stream.Write(timeBanExpires);
1006 }
1007
1008 void Deserialize(Steam::Utils::Stream& stream) {
1009 result = (Steam::Internal::Enums::EResult)stream.Read<int32_t>();
1010 reputationScore = (uint32_t)stream.Read<int32_t>();
1011 banned = (unsigned char)stream.Read<unsigned char>();
1012 bannedIp = (uint32_t)stream.Read<int32_t>();
1013 bannedPort = (uint16_t)stream.Read<int16_t>();
1014 bannedGameId = (uint64_t)stream.Read<int64_t>();
1015 timeBanExpires = (uint32_t)stream.Read<int32_t>();
1016 }
1017};
1018
1019struct MsgGSDeny : public ISteamSerializableMessage {
1020 Steam::Internal::Enums::EMsg GetEMsg() const {
1021 return Steam::Internal::Enums::EMsg::GSDeny;
1022 }
1023
1024 // Static size: 8
1025 private:
1026 uint64_t steamId;
1027
1028 public:
1029 SteamID GetsteamId() const { return SteamID(steamId); }
1030 void SetsteamId(const SteamID& val) { steamId = val.ConvertToUInt64(); }
1031 // Static size: 4
1032 Steam::Internal::Enums::EDenyReason denyReason;
1033
1034 MsgGSDeny() {
1035 steamId = 0;
1036 denyReason = Steam::Internal::Enums::EDenyReason::Unknown;
1037 }
1038
1039 void Serialize(Steam::Utils::Stream& stream) const {
1040 stream.Write(steamId);
1041 stream.Write((int)denyReason);
1042 }
1043
1044 void Deserialize(Steam::Utils::Stream& stream) {
1045 steamId = (uint64_t)stream.Read<int64_t>();
1046 denyReason = (Steam::Internal::Enums::EDenyReason)stream.Read<int32_t>();
1047 }
1048};
1049
1050struct MsgGSApprove : public ISteamSerializableMessage {
1051 Steam::Internal::Enums::EMsg GetEMsg() const {
1052 return Steam::Internal::Enums::EMsg::GSApprove;
1053 }
1054
1055 // Static size: 8
1056 private:
1057 uint64_t steamId;
1058
1059 public:
1060 SteamID GetsteamId() const { return SteamID(steamId); }
1061 void SetsteamId(const SteamID& val) { steamId = val.ConvertToUInt64(); }
1062
1063 MsgGSApprove() { steamId = 0; }
1064
1065 void Serialize(Steam::Utils::Stream& stream) const { stream.Write(steamId); }
1066
1067 void Deserialize(Steam::Utils::Stream& stream) {
1068 steamId = (uint64_t)stream.Read<int64_t>();
1069 }
1070};
1071
1072struct MsgGSKick : public ISteamSerializableMessage {
1073 Steam::Internal::Enums::EMsg GetEMsg() const {
1074 return Steam::Internal::Enums::EMsg::GSKick;
1075 }
1076
1077 // Static size: 8
1078 private:
1079 uint64_t steamId;
1080
1081 public:
1082 SteamID GetsteamId() const { return SteamID(steamId); }
1083 void SetsteamId(const SteamID& val) { steamId = val.ConvertToUInt64(); }
1084 // Static size: 4
1085 Steam::Internal::Enums::EDenyReason denyReason;
1086 // Static size: 4
1087 int32_t waitTilMapChange;
1088
1089 MsgGSKick() {
1090 steamId = 0;
1091 denyReason = Steam::Internal::Enums::EDenyReason::Unknown;
1092 waitTilMapChange = 0;
1093 }
1094
1095 void Serialize(Steam::Utils::Stream& stream) const {
1096 stream.Write(steamId);
1097 stream.Write((int)denyReason);
1098 stream.Write(waitTilMapChange);
1099 }
1100
1101 void Deserialize(Steam::Utils::Stream& stream) {
1102 steamId = (uint64_t)stream.Read<int64_t>();
1103 denyReason = (Steam::Internal::Enums::EDenyReason)stream.Read<int32_t>();
1104 waitTilMapChange = (int32_t)stream.Read<int32_t>();
1105 }
1106};
1107
1108struct MsgGSGetUserGroupStatus : public ISteamSerializableMessage {
1109 Steam::Internal::Enums::EMsg GetEMsg() const {
1110 return Steam::Internal::Enums::EMsg::GSGetUserGroupStatus;
1111 }
1112
1113 // Static size: 8
1114 private:
1115 uint64_t steamIdUser;
1116
1117 public:
1118 SteamID GetsteamIdUser() const { return SteamID(steamIdUser); }
1119 void SetsteamIdUser(const SteamID& val) {
1120 steamIdUser = val.ConvertToUInt64();
1121 }
1122 // Static size: 8
1123 private:
1124 uint64_t steamIdGroup;
1125
1126 public:
1127 SteamID GetsteamIdGroup() const { return SteamID(steamIdGroup); }
1128 void SetsteamIdGroup(const SteamID& val) {
1129 steamIdGroup = val.ConvertToUInt64();
1130 }
1131
1132 MsgGSGetUserGroupStatus() {
1133 steamIdUser = 0;
1134 steamIdGroup = 0;
1135 }
1136
1137 void Serialize(Steam::Utils::Stream& stream) const {
1138 stream.Write(steamIdUser);
1139 stream.Write(steamIdGroup);
1140 }
1141
1142 void Deserialize(Steam::Utils::Stream& stream) {
1143 steamIdUser = (uint64_t)stream.Read<int64_t>();
1144 steamIdGroup = (uint64_t)stream.Read<int64_t>();
1145 }
1146};
1147
1148struct MsgGSGetUserGroupStatusResponse : public ISteamSerializableMessage {
1149 Steam::Internal::Enums::EMsg GetEMsg() const {
1150 return Steam::Internal::Enums::EMsg::GSGetUserGroupStatusResponse;
1151 }
1152
1153 // Static size: 8
1154 private:
1155 uint64_t steamIdUser;
1156
1157 public:
1158 SteamID GetsteamIdUser() const { return SteamID(steamIdUser); }
1159 void SetsteamIdUser(const SteamID& val) {
1160 steamIdUser = val.ConvertToUInt64();
1161 }
1162 // Static size: 8
1163 private:
1164 uint64_t steamIdGroup;
1165
1166 public:
1167 SteamID GetsteamIdGroup() const { return SteamID(steamIdGroup); }
1168 void SetsteamIdGroup(const SteamID& val) {
1169 steamIdGroup = val.ConvertToUInt64();
1170 }
1171 // Static size: 4
1172 Steam::Internal::Enums::EClanRelationship clanRelationship;
1173 // Static size: 4
1174 Steam::Internal::Enums::EClanRank clanRank;
1175
1176 MsgGSGetUserGroupStatusResponse() {
1177 steamIdUser = 0;
1178 steamIdGroup = 0;
1179 clanRelationship = Steam::Internal::Enums::EClanRelationship::None;
1180 clanRank = Steam::Internal::Enums::EClanRank::None;
1181 }
1182
1183 void Serialize(Steam::Utils::Stream& stream) const {
1184 stream.Write(steamIdUser);
1185 stream.Write(steamIdGroup);
1186 stream.Write((int)clanRelationship);
1187 stream.Write((int)clanRank);
1188 }
1189
1190 void Deserialize(Steam::Utils::Stream& stream) {
1191 steamIdUser = (uint64_t)stream.Read<int64_t>();
1192 steamIdGroup = (uint64_t)stream.Read<int64_t>();
1193 clanRelationship =
1194 (Steam::Internal::Enums::EClanRelationship)stream.Read<int32_t>();
1195 clanRank = (Steam::Internal::Enums::EClanRank)stream.Read<int32_t>();
1196 }
1197};
1198
1199struct MsgClientJoinChat : public ISteamSerializableMessage {
1200 Steam::Internal::Enums::EMsg GetEMsg() const {
1201 return Steam::Internal::Enums::EMsg::ClientJoinChat;
1202 }
1203
1204 // Static size: 8
1205 private:
1206 uint64_t steamIdChat;
1207
1208 public:
1209 SteamID GetsteamIdChat() const { return SteamID(steamIdChat); }
1210 void SetsteamIdChat(const SteamID& val) {
1211 steamIdChat = val.ConvertToUInt64();
1212 }
1213 // Static size: 1
1214 unsigned char isVoiceSpeaker;
1215
1216 MsgClientJoinChat() {
1217 steamIdChat = 0;
1218 isVoiceSpeaker = 0;
1219 }
1220
1221 void Serialize(Steam::Utils::Stream& stream) const {
1222 stream.Write(steamIdChat);
1223 stream.Write(isVoiceSpeaker);
1224 }
1225
1226 void Deserialize(Steam::Utils::Stream& stream) {
1227 steamIdChat = (uint64_t)stream.Read<int64_t>();
1228 isVoiceSpeaker = (unsigned char)stream.Read<unsigned char>();
1229 }
1230};
1231
1232struct MsgClientChatEnter : public ISteamSerializableMessage {
1233 Steam::Internal::Enums::EMsg GetEMsg() const {
1234 return Steam::Internal::Enums::EMsg::ClientChatEnter;
1235 }
1236
1237 // Static size: 8
1238 private:
1239 uint64_t steamIdChat;
1240
1241 public:
1242 SteamID GetsteamIdChat() const { return SteamID(steamIdChat); }
1243 void SetsteamIdChat(const SteamID& val) {
1244 steamIdChat = val.ConvertToUInt64();
1245 }
1246 // Static size: 8
1247 private:
1248 uint64_t steamIdFriend;
1249
1250 public:
1251 SteamID GetsteamIdFriend() const { return SteamID(steamIdFriend); }
1252 void SetsteamIdFriend(const SteamID& val) {
1253 steamIdFriend = val.ConvertToUInt64();
1254 }
1255 // Static size: 4
1256 Steam::Internal::Enums::EChatRoomType chatRoomType;
1257 // Static size: 8
1258 private:
1259 uint64_t steamIdOwner;
1260
1261 public:
1262 SteamID GetsteamIdOwner() const { return SteamID(steamIdOwner); }
1263 void SetsteamIdOwner(const SteamID& val) {
1264 steamIdOwner = val.ConvertToUInt64();
1265 }
1266 // Static size: 8
1267 private:
1268 uint64_t steamIdClan;
1269
1270 public:
1271 SteamID GetsteamIdClan() const { return SteamID(steamIdClan); }
1272 void SetsteamIdClan(const SteamID& val) {
1273 steamIdClan = val.ConvertToUInt64();
1274 }
1275 // Static size: 1
1276 unsigned char chatFlags;
1277 // Static size: 4
1278 Steam::Internal::Enums::EChatRoomEnterResponse enterResponse;
1279 // Static size: 4
1280 int32_t numMembers;
1281
1282 MsgClientChatEnter() {
1283 steamIdChat = 0;
1284 steamIdFriend = 0;
1285 chatRoomType = Steam::Internal::Enums::EChatRoomType::Unknown;
1286 steamIdOwner = 0;
1287 steamIdClan = 0;
1288 chatFlags = 0;
1289 enterResponse = Steam::Internal::Enums::EChatRoomEnterResponse::Unknown;
1290 numMembers = 0;
1291 }
1292
1293 void Serialize(Steam::Utils::Stream& stream) const {
1294 stream.Write(steamIdChat);
1295 stream.Write(steamIdFriend);
1296 stream.Write((int)chatRoomType);
1297 stream.Write(steamIdOwner);
1298 stream.Write(steamIdClan);
1299 stream.Write(chatFlags);
1300 stream.Write((int)enterResponse);
1301 stream.Write(numMembers);
1302 }
1303
1304 void Deserialize(Steam::Utils::Stream& stream) {
1305 steamIdChat = (uint64_t)stream.Read<int64_t>();
1306 steamIdFriend = (uint64_t)stream.Read<int64_t>();
1307 chatRoomType =
1308 (Steam::Internal::Enums::EChatRoomType)stream.Read<int32_t>();
1309 steamIdOwner = (uint64_t)stream.Read<int64_t>();
1310 steamIdClan = (uint64_t)stream.Read<int64_t>();
1311 chatFlags = (unsigned char)stream.Read<unsigned char>();
1312 enterResponse =
1313 (Steam::Internal::Enums::EChatRoomEnterResponse)stream.Read<int32_t>();
1314 numMembers = (int32_t)stream.Read<int32_t>();
1315 }
1316};
1317
1318struct MsgClientChatMsg : public ISteamSerializableMessage {
1319 Steam::Internal::Enums::EMsg GetEMsg() const {
1320 return Steam::Internal::Enums::EMsg::ClientChatMsg;
1321 }
1322
1323 // Static size: 8
1324 private:
1325 uint64_t steamIdChatter;
1326
1327 public:
1328 SteamID GetsteamIdChatter() const { return SteamID(steamIdChatter); }
1329 void SetsteamIdChatter(const SteamID& val) {
1330 steamIdChatter = val.ConvertToUInt64();
1331 }
1332 // Static size: 8
1333 private:
1334 uint64_t steamIdChatRoom;
1335
1336 public:
1337 SteamID GetsteamIdChatRoom() const { return SteamID(steamIdChatRoom); }
1338 void SetsteamIdChatRoom(const SteamID& val) {
1339 steamIdChatRoom = val.ConvertToUInt64();
1340 }
1341 // Static size: 4
1342 Steam::Internal::Enums::EChatEntryType chatMsgType;
1343
1344 MsgClientChatMsg() {
1345 steamIdChatter = 0;
1346 steamIdChatRoom = 0;
1347 chatMsgType = Steam::Internal::Enums::EChatEntryType::Invalid;
1348 }
1349
1350 void Serialize(Steam::Utils::Stream& stream) const {
1351 stream.Write(steamIdChatter);
1352 stream.Write(steamIdChatRoom);
1353 stream.Write((int)chatMsgType);
1354 }
1355
1356 void Deserialize(Steam::Utils::Stream& stream) {
1357 steamIdChatter = (uint64_t)stream.Read<int64_t>();
1358 steamIdChatRoom = (uint64_t)stream.Read<int64_t>();
1359 chatMsgType =
1360 (Steam::Internal::Enums::EChatEntryType)stream.Read<int32_t>();
1361 }
1362};
1363
1364struct MsgClientChatMemberInfo : public ISteamSerializableMessage {
1365 Steam::Internal::Enums::EMsg GetEMsg() const {
1366 return Steam::Internal::Enums::EMsg::ClientChatMemberInfo;
1367 }
1368
1369 // Static size: 8
1370 private:
1371 uint64_t steamIdChat;
1372
1373 public:
1374 SteamID GetsteamIdChat() const { return SteamID(steamIdChat); }
1375 void SetsteamIdChat(const SteamID& val) {
1376 steamIdChat = val.ConvertToUInt64();
1377 }
1378 // Static size: 4
1379 Steam::Internal::Enums::EChatInfoType type;
1380
1381 MsgClientChatMemberInfo() {
1382 steamIdChat = 0;
1383 type = Steam::Internal::Enums::EChatInfoType::Unknown;
1384 }
1385
1386 void Serialize(Steam::Utils::Stream& stream) const {
1387 stream.Write(steamIdChat);
1388 stream.Write((int)type);
1389 }
1390
1391 void Deserialize(Steam::Utils::Stream& stream) {
1392 steamIdChat = (uint64_t)stream.Read<int64_t>();
1393 type = (Steam::Internal::Enums::EChatInfoType)stream.Read<int32_t>();
1394 }
1395};
1396
1397struct MsgClientChatAction : public ISteamSerializableMessage {
1398 Steam::Internal::Enums::EMsg GetEMsg() const {
1399 return Steam::Internal::Enums::EMsg::ClientChatAction;
1400 }
1401
1402 // Static size: 8
1403 private:
1404 uint64_t steamIdChat;
1405
1406 public:
1407 SteamID GetsteamIdChat() const { return SteamID(steamIdChat); }
1408 void SetsteamIdChat(const SteamID& val) {
1409 steamIdChat = val.ConvertToUInt64();
1410 }
1411 // Static size: 8
1412 private:
1413 uint64_t steamIdUserToActOn;
1414
1415 public:
1416 SteamID GetsteamIdUserToActOn() const { return SteamID(steamIdUserToActOn); }
1417 void SetsteamIdUserToActOn(const SteamID& val) {
1418 steamIdUserToActOn = val.ConvertToUInt64();
1419 }
1420 // Static size: 4
1421 Steam::Internal::Enums::EChatAction chatAction;
1422
1423 MsgClientChatAction() {
1424 steamIdChat = 0;
1425 steamIdUserToActOn = 0;
1426 chatAction = Steam::Internal::Enums::EChatAction::Unknown;
1427 }
1428
1429 void Serialize(Steam::Utils::Stream& stream) const {
1430 stream.Write(steamIdChat);
1431 stream.Write(steamIdUserToActOn);
1432 stream.Write((int)chatAction);
1433 }
1434
1435 void Deserialize(Steam::Utils::Stream& stream) {
1436 steamIdChat = (uint64_t)stream.Read<int64_t>();
1437 steamIdUserToActOn = (uint64_t)stream.Read<int64_t>();
1438 chatAction = (Steam::Internal::Enums::EChatAction)stream.Read<int32_t>();
1439 }
1440};
1441
1442struct MsgClientChatActionResult : public ISteamSerializableMessage {
1443 Steam::Internal::Enums::EMsg GetEMsg() const {
1444 return Steam::Internal::Enums::EMsg::ClientChatActionResult;
1445 }
1446
1447 // Static size: 8
1448 private:
1449 uint64_t steamIdChat;
1450
1451 public:
1452 SteamID GetsteamIdChat() const { return SteamID(steamIdChat); }
1453 void SetsteamIdChat(const SteamID& val) {
1454 steamIdChat = val.ConvertToUInt64();
1455 }
1456 // Static size: 8
1457 private:
1458 uint64_t steamIdUserActedOn;
1459
1460 public:
1461 SteamID GetsteamIdUserActedOn() const { return SteamID(steamIdUserActedOn); }
1462 void SetsteamIdUserActedOn(const SteamID& val) {
1463 steamIdUserActedOn = val.ConvertToUInt64();
1464 }
1465 // Static size: 4
1466 Steam::Internal::Enums::EChatAction chatAction;
1467 // Static size: 4
1468 Steam::Internal::Enums::EChatActionResult actionResult;
1469
1470 MsgClientChatActionResult() {
1471 steamIdChat = 0;
1472 steamIdUserActedOn = 0;
1473 chatAction = Steam::Internal::Enums::EChatAction::Unknown;
1474 actionResult = Steam::Internal::Enums::EChatActionResult::Unknown;
1475 }
1476
1477 void Serialize(Steam::Utils::Stream& stream) const {
1478 stream.Write(steamIdChat);
1479 stream.Write(steamIdUserActedOn);
1480 stream.Write((int)chatAction);
1481 stream.Write((int)actionResult);
1482 }
1483
1484 void Deserialize(Steam::Utils::Stream& stream) {
1485 steamIdChat = (uint64_t)stream.Read<int64_t>();
1486 steamIdUserActedOn = (uint64_t)stream.Read<int64_t>();
1487 chatAction = (Steam::Internal::Enums::EChatAction)stream.Read<int32_t>();
1488 actionResult =
1489 (Steam::Internal::Enums::EChatActionResult)stream.Read<int32_t>();
1490 }
1491};
1492
1493struct MsgClientChatRoomInfo : public ISteamSerializableMessage {
1494 Steam::Internal::Enums::EMsg GetEMsg() const {
1495 return Steam::Internal::Enums::EMsg::ClientChatRoomInfo;
1496 }
1497
1498 // Static size: 8
1499 private:
1500 uint64_t steamIdChat;
1501
1502 public:
1503 SteamID GetsteamIdChat() const { return SteamID(steamIdChat); }
1504 void SetsteamIdChat(const SteamID& val) {
1505 steamIdChat = val.ConvertToUInt64();
1506 }
1507 // Static size: 4
1508 Steam::Internal::Enums::EChatInfoType type;
1509
1510 MsgClientChatRoomInfo() {
1511 steamIdChat = 0;
1512 type = Steam::Internal::Enums::EChatInfoType::Unknown;
1513 }
1514
1515 void Serialize(Steam::Utils::Stream& stream) const {
1516 stream.Write(steamIdChat);
1517 stream.Write((int)type);
1518 }
1519
1520 void Deserialize(Steam::Utils::Stream& stream) {
1521 steamIdChat = (uint64_t)stream.Read<int64_t>();
1522 type = (Steam::Internal::Enums::EChatInfoType)stream.Read<int32_t>();
1523 }
1524};
1525
1526struct MsgClientSetIgnoreFriend : public ISteamSerializableMessage {
1527 Steam::Internal::Enums::EMsg GetEMsg() const {
1528 return Steam::Internal::Enums::EMsg::ClientSetIgnoreFriend;
1529 }
1530
1531 // Static size: 8
1532 private:
1533 uint64_t mySteamId;
1534
1535 public:
1536 SteamID GetmySteamId() const { return SteamID(mySteamId); }
1537 void SetmySteamId(const SteamID& val) { mySteamId = val.ConvertToUInt64(); }
1538 // Static size: 8
1539 private:
1540 uint64_t steamIdFriend;
1541
1542 public:
1543 SteamID GetsteamIdFriend() const { return SteamID(steamIdFriend); }
1544 void SetsteamIdFriend(const SteamID& val) {
1545 steamIdFriend = val.ConvertToUInt64();
1546 }
1547 // Static size: 1
1548 unsigned char ignore;
1549
1550 MsgClientSetIgnoreFriend() {
1551 mySteamId = 0;
1552 steamIdFriend = 0;
1553 ignore = 0;
1554 }
1555
1556 void Serialize(Steam::Utils::Stream& stream) const {
1557 stream.Write(mySteamId);
1558 stream.Write(steamIdFriend);
1559 stream.Write(ignore);
1560 }
1561
1562 void Deserialize(Steam::Utils::Stream& stream) {
1563 mySteamId = (uint64_t)stream.Read<int64_t>();
1564 steamIdFriend = (uint64_t)stream.Read<int64_t>();
1565 ignore = (unsigned char)stream.Read<unsigned char>();
1566 }
1567};
1568
1569struct MsgClientSetIgnoreFriendResponse : public ISteamSerializableMessage {
1570 Steam::Internal::Enums::EMsg GetEMsg() const {
1571 return Steam::Internal::Enums::EMsg::ClientSetIgnoreFriendResponse;
1572 }
1573
1574 // Static size: 8
1575 private:
1576 uint64_t friendId;
1577
1578 public:
1579 SteamID GetfriendId() const { return SteamID(friendId); }
1580 void SetfriendId(const SteamID& val) { friendId = val.ConvertToUInt64(); }
1581 // Static size: 4
1582 Steam::Internal::Enums::EResult result;
1583
1584 MsgClientSetIgnoreFriendResponse() {
1585 friendId = 0;
1586 result = Steam::Internal::Enums::EResult::Invalid;
1587 }
1588
1589 void Serialize(Steam::Utils::Stream& stream) const {
1590 stream.Write(friendId);
1591 stream.Write((int)result);
1592 }
1593
1594 void Deserialize(Steam::Utils::Stream& stream) {
1595 friendId = (uint64_t)stream.Read<int64_t>();
1596 result = (Steam::Internal::Enums::EResult)stream.Read<int32_t>();
1597 }
1598};
1599
1600struct MsgClientLoggedOff : public ISteamSerializableMessage {
1601 Steam::Internal::Enums::EMsg GetEMsg() const {
1602 return Steam::Internal::Enums::EMsg::ClientLoggedOff;
1603 }
1604
1605 // Static size: 4
1606 Steam::Internal::Enums::EResult result;
1607 // Static size: 4
1608 int32_t secMinReconnectHint;
1609 // Static size: 4
1610 int32_t secMaxReconnectHint;
1611
1612 MsgClientLoggedOff() {
1613 result = Steam::Internal::Enums::EResult::Invalid;
1614 secMinReconnectHint = 0;
1615 secMaxReconnectHint = 0;
1616 }
1617
1618 void Serialize(Steam::Utils::Stream& stream) const {
1619 stream.Write((int)result);
1620 stream.Write(secMinReconnectHint);
1621 stream.Write(secMaxReconnectHint);
1622 }
1623
1624 void Deserialize(Steam::Utils::Stream& stream) {
1625 result = (Steam::Internal::Enums::EResult)stream.Read<int32_t>();
1626 secMinReconnectHint = (int32_t)stream.Read<int32_t>();
1627 secMaxReconnectHint = (int32_t)stream.Read<int32_t>();
1628 }
1629};
1630
1631struct MsgClientLogOnResponse : public ISteamSerializableMessage {
1632 Steam::Internal::Enums::EMsg GetEMsg() const {
1633 return Steam::Internal::Enums::EMsg::ClientLogOnResponse;
1634 }
1635
1636 // Static size: 4
1637 Steam::Internal::Enums::EResult result;
1638 // Static size: 4
1639 int32_t outOfGameHeartbeatRateSec;
1640 // Static size: 4
1641 int32_t inGameHeartbeatRateSec;
1642 // Static size: 8
1643 private:
1644 uint64_t clientSuppliedSteamId;
1645
1646 public:
1647 SteamID GetclientSuppliedSteamId() const {
1648 return SteamID(clientSuppliedSteamId);
1649 }
1650 void SetclientSuppliedSteamId(const SteamID& val) {
1651 clientSuppliedSteamId = val.ConvertToUInt64();
1652 }
1653 // Static size: 4
1654 uint32_t ipPublic;
1655 // Static size: 4
1656 uint32_t serverRealTime;
1657
1658 MsgClientLogOnResponse() {
1659 result = Steam::Internal::Enums::EResult::Invalid;
1660 outOfGameHeartbeatRateSec = 0;
1661 inGameHeartbeatRateSec = 0;
1662 clientSuppliedSteamId = 0;
1663 ipPublic = 0;
1664 serverRealTime = 0;
1665 }
1666
1667 void Serialize(Steam::Utils::Stream& stream) const {
1668 stream.Write((int)result);
1669 stream.Write(outOfGameHeartbeatRateSec);
1670 stream.Write(inGameHeartbeatRateSec);
1671 stream.Write(clientSuppliedSteamId);
1672 stream.Write(ipPublic);
1673 stream.Write(serverRealTime);
1674 }
1675
1676 void Deserialize(Steam::Utils::Stream& stream) {
1677 result = (Steam::Internal::Enums::EResult)stream.Read<int32_t>();
1678 outOfGameHeartbeatRateSec = (int32_t)stream.Read<int32_t>();
1679 inGameHeartbeatRateSec = (int32_t)stream.Read<int32_t>();
1680 clientSuppliedSteamId = (uint64_t)stream.Read<int64_t>();
1681 ipPublic = (uint32_t)stream.Read<int32_t>();
1682 serverRealTime = (uint32_t)stream.Read<int32_t>();
1683 }
1684};
1685
1686struct MsgClientServerUnavailable : public ISteamSerializableMessage {
1687 Steam::Internal::Enums::EMsg GetEMsg() const {
1688 return Steam::Internal::Enums::EMsg::ClientServerUnavailable;
1689 }
1690
1691 // Static size: 8
1692 uint64_t jobidSent;
1693 // Static size: 4
1694 uint32_t eMsgSent;
1695 // Static size: 4
1696 Steam::Internal::Enums::EServerType eServerTypeUnavailable;
1697
1698 MsgClientServerUnavailable() {
1699 jobidSent = 0;
1700 eMsgSent = 0;
1701 eServerTypeUnavailable = Steam::Internal::Enums::EServerType::First;
1702 }
1703
1704 void Serialize(Steam::Utils::Stream& stream) const {
1705 stream.Write(jobidSent);
1706 stream.Write(eMsgSent);
1707 stream.Write((int)eServerTypeUnavailable);
1708 }
1709
1710 void Deserialize(Steam::Utils::Stream& stream) {
1711 jobidSent = (uint64_t)stream.Read<int64_t>();
1712 eMsgSent = (uint32_t)stream.Read<int32_t>();
1713 eServerTypeUnavailable =
1714 (Steam::Internal::Enums::EServerType)stream.Read<int32_t>();
1715 }
1716};
1717
1718struct MsgClientCreateChat : public ISteamSerializableMessage {
1719 Steam::Internal::Enums::EMsg GetEMsg() const {
1720 return Steam::Internal::Enums::EMsg::ClientCreateChat;
1721 }
1722
1723 // Static size: 4
1724 Steam::Internal::Enums::EChatRoomType chatRoomType;
1725 // Static size: 8
1726 private:
1727 uint64_t gameId;
1728
1729 public:
1730 GameID GetgameId() const { return GameID(gameId); }
1731 void SetgameId(const GameID& val) { gameId = val.ConvertToUInt64(); }
1732 // Static size: 8
1733 private:
1734 uint64_t steamIdClan;
1735
1736 public:
1737 SteamID GetsteamIdClan() const { return SteamID(steamIdClan); }
1738 void SetsteamIdClan(const SteamID& val) {
1739 steamIdClan = val.ConvertToUInt64();
1740 }
1741 // Static size: 4
1742 Steam::Internal::Enums::EChatPermission permissionOfficer;
1743 // Static size: 4
1744 Steam::Internal::Enums::EChatPermission permissionMember;
1745 // Static size: 4
1746 Steam::Internal::Enums::EChatPermission permissionAll;
1747 // Static size: 4
1748 uint32_t membersMax;
1749 // Static size: 1
1750 unsigned char chatFlags;
1751 // Static size: 8
1752 private:
1753 uint64_t steamIdFriendChat;
1754
1755 public:
1756 SteamID GetsteamIdFriendChat() const { return SteamID(steamIdFriendChat); }
1757 void SetsteamIdFriendChat(const SteamID& val) {
1758 steamIdFriendChat = val.ConvertToUInt64();
1759 }
1760 // Static size: 8
1761 private:
1762 uint64_t steamIdInvited;
1763
1764 public:
1765 SteamID GetsteamIdInvited() const { return SteamID(steamIdInvited); }
1766 void SetsteamIdInvited(const SteamID& val) {
1767 steamIdInvited = val.ConvertToUInt64();
1768 }
1769
1770 MsgClientCreateChat() {
1771 chatRoomType = Steam::Internal::Enums::EChatRoomType::Unknown;
1772 gameId = 0;
1773 steamIdClan = 0;
1774 // These were 0; this may be completely incorrect now.
1775 permissionOfficer = Steam::Internal::Enums::EChatPermission::OfficerDefault;
1776 permissionMember = Steam::Internal::Enums::EChatPermission::MemberDefault;
1777 permissionAll = Steam::Internal::Enums::EChatPermission::OwnerDefault;
1778 // End block
1779 membersMax = 0;
1780 chatFlags = 0;
1781 steamIdFriendChat = 0;
1782 steamIdInvited = 0;
1783 }
1784
1785 void Serialize(Steam::Utils::Stream& stream) const {
1786 stream.Write((int)chatRoomType);
1787 stream.Write(gameId);
1788 stream.Write(steamIdClan);
1789 stream.Write((int)permissionOfficer);
1790 stream.Write((int)permissionMember);
1791 stream.Write((int)permissionAll);
1792 stream.Write(membersMax);
1793 stream.Write(chatFlags);
1794 stream.Write(steamIdFriendChat);
1795 stream.Write(steamIdInvited);
1796 }
1797
1798 void Deserialize(Steam::Utils::Stream& stream) {
1799 chatRoomType =
1800 (Steam::Internal::Enums::EChatRoomType)stream.Read<int32_t>();
1801 gameId = (uint64_t)stream.Read<int64_t>();
1802 steamIdClan = (uint64_t)stream.Read<int64_t>();
1803 permissionOfficer =
1804 (Steam::Internal::Enums::EChatPermission)stream.Read<int32_t>();
1805 permissionMember =
1806 (Steam::Internal::Enums::EChatPermission)stream.Read<int32_t>();
1807 permissionAll =
1808 (Steam::Internal::Enums::EChatPermission)stream.Read<int32_t>();
1809 membersMax = (uint32_t)stream.Read<int32_t>();
1810 chatFlags = (unsigned char)stream.Read<unsigned char>();
1811 steamIdFriendChat = (uint64_t)stream.Read<int64_t>();
1812 steamIdInvited = (uint64_t)stream.Read<int64_t>();
1813 }
1814};
1815
1816struct MsgClientCreateChatResponse : public ISteamSerializableMessage {
1817 Steam::Internal::Enums::EMsg GetEMsg() const {
1818 return Steam::Internal::Enums::EMsg::ClientCreateChatResponse;
1819 }
1820
1821 // Static size: 4
1822 Steam::Internal::Enums::EResult result;
1823 // Static size: 8
1824 private:
1825 uint64_t steamIdChat;
1826
1827 public:
1828 SteamID GetsteamIdChat() const { return SteamID(steamIdChat); }
1829 void SetsteamIdChat(const SteamID& val) {
1830 steamIdChat = val.ConvertToUInt64();
1831 }
1832 // Static size: 4
1833 Steam::Internal::Enums::EChatRoomType chatRoomType;
1834 // Static size: 8
1835 private:
1836 uint64_t steamIdFriendChat;
1837
1838 public:
1839 SteamID GetsteamIdFriendChat() const { return SteamID(steamIdFriendChat); }
1840 void SetsteamIdFriendChat(const SteamID& val) {
1841 steamIdFriendChat = val.ConvertToUInt64();
1842 }
1843
1844 MsgClientCreateChatResponse() {
1845 result = Steam::Internal::Enums::EResult::Invalid;
1846 steamIdChat = 0;
1847 chatRoomType = Steam::Internal::Enums::EChatRoomType::Unknown;
1848 steamIdFriendChat = 0;
1849 }
1850
1851 void Serialize(Steam::Utils::Stream& stream) const {
1852 stream.Write((int)result);
1853 stream.Write(steamIdChat);
1854 stream.Write((int)chatRoomType);
1855 stream.Write(steamIdFriendChat);
1856 }
1857
1858 void Deserialize(Steam::Utils::Stream& stream) {
1859 result = (Steam::Internal::Enums::EResult)stream.Read<int32_t>();
1860 steamIdChat = (uint64_t)stream.Read<int64_t>();
1861 chatRoomType =
1862 (Steam::Internal::Enums::EChatRoomType)stream.Read<int32_t>();
1863 steamIdFriendChat = (uint64_t)stream.Read<int64_t>();
1864 }
1865};
1866
1867struct MsgClientMarketingMessageUpdate2 : public ISteamSerializableMessage {
1868 Steam::Internal::Enums::EMsg GetEMsg() const {
1869 return Steam::Internal::Enums::EMsg::ClientMarketingMessageUpdate2;
1870 }
1871
1872 // Static size: 4
1873 uint32_t marketingMessageUpdateTime;
1874 // Static size: 4
1875 uint32_t count;
1876
1877 MsgClientMarketingMessageUpdate2() {
1878 marketingMessageUpdateTime = 0;
1879 count = 0;
1880 }
1881
1882 void Serialize(Steam::Utils::Stream& stream) const {
1883 stream.Write(marketingMessageUpdateTime);
1884 stream.Write(count);
1885 }
1886
1887 void Deserialize(Steam::Utils::Stream& stream) {
1888 marketingMessageUpdateTime = (uint32_t)stream.Read<int32_t>();
1889 count = (uint32_t)stream.Read<int32_t>();
1890 }
1891};
1892
1893struct MsgClientGetLegacyGameKey : public ISteamSerializableMessage {
1894 Steam::Internal::Enums::EMsg GetEMsg() const {
1895 return Steam::Internal::Enums::EMsg::ClientGetLegacyGameKey;
1896 }
1897
1898 // Static size: 4
1899 uint32_t appId;
1900
1901 MsgClientGetLegacyGameKey() { appId = 0; }
1902
1903 void Serialize(Steam::Utils::Stream& stream) const { stream.Write(appId); }
1904
1905 void Deserialize(Steam::Utils::Stream& stream) {
1906 appId = (uint32_t)stream.Read<int32_t>();
1907 }
1908};
1909
1910struct MsgClientGetLegacyGameKeyResponse : public ISteamSerializableMessage {
1911 Steam::Internal::Enums::EMsg GetEMsg() const {
1912 return Steam::Internal::Enums::EMsg::ClientGetLegacyGameKeyResponse;
1913 }
1914
1915 // Static size: 4
1916 uint32_t appId;
1917 // Static size: 4
1918 Steam::Internal::Enums::EResult result;
1919 // Static size: 4
1920 uint32_t length;
1921
1922 MsgClientGetLegacyGameKeyResponse() {
1923 appId = 0;
1924 result = Steam::Internal::Enums::EResult::Invalid;
1925 length = 0;
1926 }
1927
1928 void Serialize(Steam::Utils::Stream& stream) const {
1929 stream.Write(appId);
1930 stream.Write((int)result);
1931 stream.Write(length);
1932 }
1933
1934 void Deserialize(Steam::Utils::Stream& stream) {
1935 appId = (uint32_t)stream.Read<int32_t>();
1936 result = (Steam::Internal::Enums::EResult)stream.Read<int32_t>();
1937 length = (uint32_t)stream.Read<int32_t>();
1938 }
1939};
1940
1941} // namespace Steam::Internal