Monobit Unity Networking ver.2.8.0 Server API Reference (C++)
MunStream.hpp
Go to the documentation of this file.
1 
8 #ifndef __MUN_STREAM_HPP__
9 #define __MUN_STREAM_HPP__
10 
11 #include <vector>
12 #include <assert.h>
13 #include <mrs.hpp>
14 #include <buffer/MunBuffer.hpp>
15 
19 namespace STREAM {
23  enum RESOLVER_FUNCID {
24  RESOLVER_FUNCID_QUERYCONNECTRESOLVER = 0,
25  RESOLVER_FUNCID_QUERYCONNECTRESOLVERRESULT = 1,
26  RESOLVER_FUNCID_QUERYHEALTHCHECKRESOLVER = 2,
27  RESOLVER_FUNCID_QUERYHEALTHCHECKRESOLVERRESULT = 3,
28  RESOLVER_FUNCID_RESOLVER_RESOLVEADDRESS = 4,
29  RESOLVER_FUNCID_RESOLVER_RESOLVEADDRESSRESULT = 5,
30  RESOLVER_FUNCID_QUERYDISCONNECTRESOLVER = 6,
31  RESOLVER_FUNCID_MAX = 7,
32  };
36  enum PROXYRESOLVER_FUNCID {
37  PROXYRESOLVER_FUNCID_QUERYCONNECTPROXYRESOLVER = 1000,
38  PROXYRESOLVER_FUNCID_QUERYCONNECTPROXYRESOLVERRESULT = 1001,
39  PROXYRESOLVER_FUNCID_QUERYHEALTHCHECKPROXYRESOLVER = 1002,
40  PROXYRESOLVER_FUNCID_QUERYHEALTHCHECKPROXYRESOLVERRESULT = 1003,
41  PROXYRESOLVER_FUNCID_PROXYRESOLVER_SETADDRESS = 1004,
42  PROXYRESOLVER_FUNCID_PROXYRESOLVER_SETWEIGHT = 1005,
43  PROXYRESOLVER_FUNCID_QUERYDISCONNECTPROXYRESOLVER = 1006,
44  PROXYRESOLVER_FUNCID_MAX = 1007,
45  };
49  enum MASTER_FUNCID {
50  MASTER_FUNCID_QUERYCONNECTMASTER = 2000,
51  MASTER_FUNCID_QUERYCONNECTMASTERRESULT = 2001,
52  MASTER_FUNCID_QUERYHEALTHCHECKMASTER = 2002,
53  MASTER_FUNCID_QUERYHEALTHCHECKMASTERRESULT = 2003,
54  MASTER_FUNCID_PROXY_CHECK = 2004,
55  MASTER_FUNCID_PROXY_CHECKRESULT = 2005,
56  MASTER_FUNCID_MASTER_CHECK = 2006,
57  MASTER_FUNCID_MASTER_CHECKRESULT = 2007,
58  MASTER_FUNCID_MASTER_LOBBY_FORCEJOIN = 2008,
59  MASTER_FUNCID_MASTER_LOBBY_FORCEJOINRESULT = 2009,
60  MASTER_FUNCID_MASTER_LOBBY_LEAVE = 2010,
61  MASTER_FUNCID_MASTER_LOBBY_UPDATE = 2011,
62  MASTER_FUNCID_MASTER_LOBBY_UPDATERESULT = 2012,
63  MASTER_FUNCID_MASTER_ROOM_CREATE = 2013,
64  MASTER_FUNCID_MASTER_ROOM_CREATERESULT = 2014,
65  MASTER_FUNCID_MASTER_ROOM_FORCEJOIN = 2015,
66  MASTER_FUNCID_MASTER_ROOM_FORCEJOINRESULT = 2016,
67  MASTER_FUNCID_MASTER_ROOM_JOIN = 2017,
68  MASTER_FUNCID_MASTER_ROOM_JOINRESULT = 2018,
69  MASTER_FUNCID_MASTER_ROOM_RANDOMJOIN = 2019,
70  MASTER_FUNCID_MASTER_ROOM_RANDOMJOINRESULT = 2020,
71  MASTER_FUNCID_MASTER_ROOM_LEAVE = 2021,
72  MASTER_FUNCID_MASTER_ROOM_LEAVERESULT = 2022,
73  MASTER_FUNCID_MASTER_ROOM_UPDATEMAXPLAYERS = 2023,
74  MASTER_FUNCID_MASTER_ROOM_UPDATEMAXPLAYERSRESULT = 2024,
75  MASTER_FUNCID_MASTER_ROOM_UPDATEISVISIBLE = 2025,
76  MASTER_FUNCID_MASTER_ROOM_UPDATEISVISIBLERESULT = 2026,
77  MASTER_FUNCID_MASTER_ROOM_UPDATEISOPEN = 2027,
78  MASTER_FUNCID_MASTER_ROOM_UPDATEISOPENRESULT = 2028,
79  MASTER_FUNCID_MASTER_ROOM_UPDATEROOMPARAMETERS = 2029,
80  MASTER_FUNCID_MASTER_ROOM_UPDATEROOMPARAMETERSRESULT = 2030,
81  MASTER_FUNCID_MASTER_ROOM_UPDATELOBBYPARAMETERS = 2031,
82  MASTER_FUNCID_MASTER_ROOM_UPDATELOBBYPARAMETERSRESULT = 2032,
83  MASTER_FUNCID_MASTER_ROOM_UPDATE = 2033,
84  MASTER_FUNCID_MASTER_ROOM_UPDATERESULT = 2034,
85  MASTER_FUNCID_MASTER_SEARCHPLAYERS = 2035,
86  MASTER_FUNCID_MASTER_SEARCHPLAYERSRESULT = 2036,
87  MASTER_FUNCID_MASTER_STATS_UPDATE = 2037,
88  MASTER_FUNCID_MASTER_STATS_UPDATERESULT = 2038,
89  MASTER_FUNCID_MASTER_ROOM_UPDATEPLAYERPARAMETERS = 2039,
90  MASTER_FUNCID_MASTER_ROOM_UPDATEPLAYERPARAMETERSRESULT = 2040,
91  MASTER_FUNCID_MASTER_UPDATEPLAYERNAME = 2041,
92  MASTER_FUNCID_MASTER_UPDATEPLAYERNAMERESULT = 2042,
93  MASTER_FUNCID_QUERYDISCONNECTMASTER = 2043,
94  MASTER_FUNCID_MAX = 2044,
95  };
99  enum ROOMMASTER_FUNCID {
100  ROOMMASTER_FUNCID_QUERYCONNECTROOMMASTER = 3000,
101  ROOMMASTER_FUNCID_QUERYCONNECTROOMMASTERRESULT = 3001,
102  ROOMMASTER_FUNCID_QUERYHEALTHCHECKROOMMASTER = 3002,
103  ROOMMASTER_FUNCID_QUERYHEALTHCHECKROOMMASTERRESULT = 3003,
104  ROOMMASTER_FUNCID_ROOMMASTER_SETADDRESS = 3004,
105  ROOMMASTER_FUNCID_ROOMMASTER_SETWEIGHT = 3005,
106  ROOMMASTER_FUNCID_ROOMMASTER_LOGINPLAYER = 3006,
107  ROOMMASTER_FUNCID_ROOMMASTER_LOGINPLAYERRESULT = 3007,
108  ROOMMASTER_FUNCID_ROOMMASTER_LOGOUTPLAYER = 3008,
109  ROOMMASTER_FUNCID_ROOMMASTER_LOGOUTPLAYERRESULT = 3009,
110  ROOMMASTER_FUNCID_ROOMMASTER_UPDATEHOSTID = 3010,
111  ROOMMASTER_FUNCID_ROOMMASTER_UPDATEHOSTIDRESULT = 3011,
112  ROOMMASTER_FUNCID_ROOMMASTER_UPDATEPLAYERPARAMETERS = 3012,
113  ROOMMASTER_FUNCID_ROOMMASTER_UPDATEPLAYERNAME = 3013,
114  ROOMMASTER_FUNCID_QUERYDISCONNECTROOMMASTER = 3014,
115  ROOMMASTER_FUNCID_MAX = 3015,
116  };
120  enum ROOM_FUNCID {
121  ROOM_FUNCID_QUERYCONNECTROOM = 4000,
122  ROOM_FUNCID_QUERYCONNECTROOMRESULT = 4001,
123  ROOM_FUNCID_QUERYHEALTHCHECKROOM = 4002,
124  ROOM_FUNCID_QUERYHEALTHCHECKROOMRESULT = 4003,
125  ROOM_FUNCID_ROOM_LOGINPLAYER = 4004,
126  ROOM_FUNCID_ROOM_LOGINPLAYERRESULT = 4005,
127  ROOM_FUNCID_ROOM_JOINEDPLAYER = 4006,
128  ROOM_FUNCID_ROOM_JOINEDPLAYERRESULT = 4007,
129  ROOM_FUNCID_ROOM_LEFTPLAYER = 4008,
130  ROOM_FUNCID_ROOM_LEFTPLAYERRESULT = 4009,
131  ROOM_FUNCID_ROOM_UPDATEHOSTID = 4010,
132  ROOM_FUNCID_ROOM_UPDATEHOSTIDRESULT = 4011,
133  ROOM_FUNCID_ROOM_RPC = 4012,
134  ROOM_FUNCID_ROOM_RPCRESULT = 4013,
135  ROOM_FUNCID_ROOM_KICKPLAYER = 4014,
136  ROOM_FUNCID_ROOM_KICKPLAYERRESULT = 4015,
137  ROOM_FUNCID_QUERYDISCONNECTROOM = 4016,
138  ROOM_FUNCID_SERVERSVC_INSTANTIATE = 4017,
139  ROOM_FUNCID_SERVERSVC_DESTROY = 4018,
140  ROOM_FUNCID_SERVERSVC_RPC = 4019,
141  ROOM_FUNCID_MAX = 4020,
142  };
146  enum MASTERPROXY_FUNCID {
147  MASTERPROXY_FUNCID_CLIENT_DISCONNECTED = 5000,
148  };
152  enum MONITOR_FUNCID {
153  MONITOR_FUNCID_MONITORING_PULL_REQUEST = 6000,
154  MONITOR_FUNCID_MONITORING_PULL_RESPONSE = 6001,
155  };
159  enum ERRORCODE_ID {
160  RESULT_SUCCESS = 0,
161  RESULT_FAILURE = -1,
163  RESULT_FAILURE_RESOLVER = -1000,
164  RESULT_FAILURE_RESOLVER_MISMATCH_MRS_VERSION = -1001,
165  RESULT_FAILURE_RESOLVER_MISMATCH_MUN_VERSION = -1002,
166  RESULT_FAILURE_RESOLVER_MUN_PROXY_NOT_FOUND = -1003,
168  RESULT_FAILURE_PROXY = -2000,
169  RESULT_FAILURE_PROXY_MISMATCH_MRS_VERSION = -2001,
170  RESULT_FAILURE_PROXY_MISMATCH_MUN_VERSION = -2002,
171  RESULT_FAILURE_PROXY_DENYED_CUSTOM_AUTH = -2003,
172  RESULT_FAILURE_PROXY_ENTRY_CLIENT = -2004,
174  RESULT_FAILURE_MASTER = -3000,
175  RESULT_FAILURE_MASTER_MISMATCH_MRS_VERSION = -3001,
176  RESULT_FAILURE_MASTER_MISMATCH_MUN_VERSION = -3002,
177  RESULT_FAILURE_MASTER_UNCREATED_MATCHING_DATABASE = -3003,
178  RESULT_FAILURE_MASTER_MISMATCHED_MATCHING_DATABASE = -3004,
179  RESULT_FAILURE_MASTER_UNCREATED_CLIENT_DATABASE = -3005,
180  RESULT_FAILURE_MASTER_MISMATCHED_CLIENT_DATABASE = -3006,
181  RESULT_FAILURE_MASTER_UNUPDATE_CLIENT_DATABASE = -3007,
182  RESULT_FAILURE_MASTER_UNUPDATE_ROOM_DATABASE = -3008,
183  RESULT_FAILURE_MASTER_UNUPDATE_LOBBY_DATABASE = -3009,
184  RESULT_FAILURE_MASTER_CLIENT_MAX_OVER = -3010,
185  RESULT_FAILURE_MASTER_LOBBY_MAX_OVER = -3011,
186  RESULT_FAILURE_MASTER_ROOM_MAX_OVER = -3012,
187  RESULT_FAILURE_MASTER_MISMATCHED_LOBBY = -3013,
188  RESULT_FAILURE_MASTER_UNSUPPORTED_LOBBY_KIND = -3014,
189  RESULT_FAILURE_MASTER_FAILED_FORCEJOIN_LOBBY = -3015,
190  RESULT_FAILURE_MASTER_FAILED_JOIN_LOBBY = -3016,
191  RESULT_FAILURE_MASTER_MISMATCHED_ROOM = -3017,
192  RESULT_FAILURE_MASTER_ALREADY_CREATED_ROOM = -3018,
193  RESULT_FAILURE_MASTER_ALREADY_JOINED_ROOM = -3019,
194  RESULT_FAILURE_MASTER_CLOSED_ROOM = -3020,
195  RESULT_FAILURE_MASTER_UNCREATE_ROOM = -3021,
196  RESULT_FAILURE_MASTER_UNUPDATE_ROOM_FILTER = -3022,
197  RESULT_FAILURE_MASTER_AUTHENTICATION = -3023,
199  RESULT_FAILURE_ROOM = -4000,
200  RESULT_FAILURE_ROOM_MISMATCH_MRS_VERSION = -4001,
201  RESULT_FAILURE_ROOM_MISMATCH_MUN_VERSION = -4002,
202  };
206  enum PROTOCOL_ID {
207  PROTOCOL_NONE = 0,
208  PROTOCOL_TCP = 1,
209  PROTOCOL_UDP = 2,
210  PROTOCOL_WS = 3,
211  PROTOCOL_WSS = 4,
212  };
216  enum TARGETS_TYPE {
217  TARGETS_ALL = 0,
218  TARGETS_OTHERS = 1,
219  TARGETS_PLAYER = 2,
220  };
224  enum LOBBYKIND_ID {
225  LOBBYKIND_DEFAULT = 0,
226  LOBBYKIND_SQL = 2,
227  LOBBYKIND_RANDOM = 3,
228  };
232  enum MATCHING_MODE {
233  MATCHINGMODE_DEFAULT = 0,
234  MATCHINGMODE_UNIFORM = 1,
235  MATCHINGMODE_RANDOM = 2,
236  };
240  enum SEARCHPLAYER_RESULT_STATUS {
241  SEARCHPLAYER_IS_OFFLINE = 0,
242  SEARCHPLAYER_IS_ONLINE = 1,
243  SEARCHPLAYER_IS_IN_ROOM = 2,
244  };
248  enum ROOM_TRANS_TYPE
249  {
250  ROOM_TRANS_CUSTOM = 215,
251  ROOM_TRANS_VOICE = 216,
252  ROOM_TRANS_RPC = 217,
253  ROOM_TRANS_STREAM = 218,
254  };
258  enum ROOM_RPC_TYPE
259  {
260  ROOM_RPC_FOR_TARGET = 0,
261  ROOM_RPC_FOR_PLAYER = 1,
262  ROOM_RPC_FOR_INSTANTIATE = 2,
263  ROOM_RPC_FOR_TEST = 255,
264  };
268  enum MAX_LIMIT {
269  LOBBY_LIST_MAX = 255,
270  ROOM_LIST_MAX = 255,
271  PLAYER_MAX = 255,
272  PLAYER_PARAMETERS_MAX = 10,
273  ROOM_PARAMETERS_MAX = 15,
274  LOBBY_PARAMETERS_MAX = ROOM_PARAMETERS_MAX,
275  ROOM_RPC_BUFFER_MAX = 255,
276  CUSTOM_AUTH_PARAMETERS_MAX = 15,
277  };
281  enum UNIONTYPE {
282  UNIONTYPE_NULL = 0,
284  UNIONTYPE_VECTOR2 = 112,
285  UNIONTYPE_VECTOR3 = 113,
286  UNIONTYPE_VECTOR4 = 114,
287  UNIONTYPE_QUATERNION = 115,
288  UNIONTYPE_MONOBIT_PLAYER = 116,
290  UNIONTYPE_BOOL = 129,
291  UNIONTYPE_INT8 = 130,
292  UNIONTYPE_INT16 = 132,
293  UNIONTYPE_INT32 = 133,
294  UNIONTYPE_INT64 = 134,
295  UNIONTYPE_UINT8 = 135,
296  UNIONTYPE_UINT16 = 136,
297  UNIONTYPE_UINT32 = 137,
298  UNIONTYPE_UINT64 = 138,
299  UNIONTYPE_FLOAT = 139,
300  UNIONTYPE_DOUBLE = 140,
301  UNIONTYPE_STRING = 141,
303  UNIONTYPE_ARRAY_VECTOR2 = 172,
304  UNIONTYPE_ARRAY_VECTOR3 = 173,
305  UNIONTYPE_ARRAY_VECTOR4 = 174,
306  UNIONTYPE_ARRAY_QUATERNION = 175,
307  UNIONTYPE_ARRAY_MONOBIT_PLAYER = 176,
309  UNIONTYPE_ARRAY_OBJECT = 192,
310  UNIONTYPE_ARRAY_BOOL = 193,
311  UNIONTYPE_ARRAY_INT8 = 194,
312  UNIONTYPE_ARRAY_INT16 = 196,
313  UNIONTYPE_ARRAY_INT32 = 197,
314  UNIONTYPE_ARRAY_INT64 = 198,
315  UNIONTYPE_ARRAY_UINT8 = 199,
316  UNIONTYPE_ARRAY_UINT16 = 200,
317  UNIONTYPE_ARRAY_UINT32 = 201,
318  UNIONTYPE_ARRAY_UINT64 = 202,
319  UNIONTYPE_ARRAY_FLOAT = 203,
320  UNIONTYPE_ARRAY_DOUBLE = 204,
321  UNIONTYPE_ARRAY_STRING = 205,
323  UNIONTYPE_HASH = 224,
324  UNIONTYPE_HASH_TABLE = 225,
326  UNIONTYPE_OBJECT = 255,
327  };
331  class Text
332  {
333  public:
335  std::string text;
339  Text() {}
345  Text(const char* _text, uint16 _textlength) {
346  this->text = std::string(_text, _textlength);
347  }
352  Text(const std::string& _text) {
353  this->text = _text;
354  }
359  Text& operator = (const Text& rRef) {
360  this->text = rRef.text;
361  return *this;
362  }
367  bool operator == (const Text& rRef) const {
368  return (this->text == rRef.text);
369  }
373  virtual ~Text() {}
378  inline uint32 Size() {
379  uint32 byteLen = 0;
380  byteLen += sizeof(uint32);
381  byteLen += this->text.size();
382  return byteLen;
383  }
388  inline bool Pack(MunBuffer& buffer) {
389  // 文字列長の格納
390  if (!buffer.WriteUInt32(this->text.size())) return false;
391  // 文字列データ実体の格納
392  return buffer.Write((const void*)this->text.c_str(), this->text.size());
393  }
398  inline bool Unpack(MunBuffer& buffer) {
399  // 文字列長の抽出
400  uint32 _length = buffer.ReadUInt32();
401  // 文字列データ実体の抽出
402  char * _text = (char*)MRS_MALLOC(_length);
403  if (!buffer.Read(_text, _length)) {
404  MRS_FREE(_text);
405  return false;
406  }
407  this->text = std::string( _text, _length );
408  MRS_FREE(_text);
409  return true;
410  }
411  };
415  class Binary
416  {
417  public:
419  uint8* data;
421  uint32 size;
425  Binary() {
426  this->data = NULL;
427  this->size = 0;
428  }
434  Binary(void* _data, uint32 _size) {
435  this->data = NULL;
436  this->size = 0;
437  Add(_data, _size);
438  }
443  Binary(const Binary& binary) {
444  this->data = NULL;
445  this->size = 0;
446  Add(binary.data, binary.size);
447  }
451  virtual void Clear() {
452  if (this->data != NULL) {
453  MRS_FREE(this->data);
454  this->data = NULL;
455  this->size = 0;
456  }
457  }
463  virtual void Add(void* _data, uint32 _size) {
464  this->data = (uint8*)MRS_REALLOC(this->data, this->size + _size);
465  if (this->data == NULL) {
466  this->size = 0;
467  return;
468  }
469  memcpy(&(this->data[this->size]), _data, _size);
470  this->size += _size;
471  }
476  Binary& operator = (const Binary& rRef) {
477  Clear();
478  Add(rRef.data, rRef.size);
479  return *this;
480  }
485  bool operator == (const Binary& rRef) const {
486  if (this->size != rRef.size) return false;
487  return (memcmp(rRef.data, this->data, this->size) == 0);
488  }
492  virtual ~Binary() {
493  Clear();
494  }
499  inline uint32 Size() {
500  uint32 byteLen = 0;
501  byteLen += sizeof(this->size);
502  byteLen += this->size;
503  return byteLen;
504  }
509  inline bool Pack(MunBuffer& buffer) {
510  // バイナリデータサイズの格納
511  if (!buffer.WriteUInt32(this->size)) return false;
512  // バイナリデータ本体の格納
513  return buffer.Write((const void*)this->data, this->size);
514  }
519  inline bool Unpack(MunBuffer& buffer) {
520  Clear();
521  // バイナリデータサイズの抽出
522  this->size = buffer.ReadUInt32();
523  // バイナリデータ本体の抽出
524  this->data = (uint8*)MRS_MALLOC(this->size);
525  return buffer.Read(this->data, this->size);
526  }
527  };
531  class Union
532  {
533  public:
535  uint8 type;
537  Binary data;
541  Union() {
542  this->type = 0;
543  }
549  Union(uint8 _type, Binary& _data) {
550  this->type = _type;
551  this->data = _data;
552  }
556  virtual ~Union() {
557  data.Clear();
558  }
563  Union& operator = (const Union& rRef) {
564  this->type = rRef.type;
565  this->data = rRef.data;
566  return *this;
567  }
572  inline uint32 Size() {
573  uint32 byteLen = 0;
574  byteLen += sizeof(this->type);
575  byteLen += this->data.Size();
576  return byteLen;
577  }
582  inline bool Pack(MunBuffer& buffer) {
583  // 変数型の格納
584  if (!buffer.WriteUInt8(this->type)) return false;
585  // 変数データ本体の格納
586  return this->data.Pack(buffer);
587  }
592  inline bool Unpack(MunBuffer& buffer) {
593  // 変数型の抽出
594  this->type = buffer.ReadUInt8();
595  // 変数データ本体の抽出
596  return this->data.Unpack(buffer);
597  }
598  };
602  class KeyValue
603  {
604  public:
606  Text key;
608  Union value;
612  KeyValue() {}
618  KeyValue(Text& _key, Union& _value) {
619  this->key = _key;
620  this->value = _value;
621  }
626  KeyValue& operator = (const KeyValue& rRef) {
627  this->key = rRef.key;
628  this->value = rRef.value;
629  return *this;
630  }
635  inline uint32 Size() {
636  uint32 byteLen = 0;
637  byteLen += this->key.Size();
638  byteLen += this->value.Size();
639  return byteLen;
640  }
645  inline bool Pack(MunBuffer& buffer) {
646  if (!this->key.Pack(buffer)) return false;
647  return this->value.Pack(buffer);
648  }
653  inline bool Unpack(MunBuffer& buffer) {
654  if (!this->key.Unpack(buffer)) return false;
655  return this->value.Unpack(buffer);
656  }
657  };
661  class CreateLobbyInfo
662  {
663  public:
665  Text lobbyName;
667  uint8 lobbyKind;
671  CreateLobbyInfo() {
672  this->lobbyKind = 0;
673  }
679  CreateLobbyInfo(Text& _lobbyName, uint8 _lobbyKind) {
680  this->lobbyName = _lobbyName;
681  this->lobbyKind = _lobbyKind;
682  }
687  CreateLobbyInfo& operator = (const CreateLobbyInfo& rRef) {
688  this->lobbyName = rRef.lobbyName;
689  this->lobbyKind = rRef.lobbyKind;
690  return *this;
691  }
696  inline uint32 Size() {
697  uint32 byteLen = 0;
698  byteLen += this->lobbyName.Size();
699  byteLen += sizeof(this->lobbyKind);
700  return byteLen;
701  }
706  inline bool Pack(MunBuffer& buffer) {
707  if (!this->lobbyName.Pack(buffer)) return false;
708  return buffer.WriteUInt8(this->lobbyKind);
709  }
714  inline bool Unpack(MunBuffer& buffer) {
715  if (!this->lobbyName.Unpack(buffer)) return false;
716  this->lobbyKind = buffer.ReadUInt8();
717  return true;
718  }
719  };
723  class LobbyInfo
724  {
725  public:
727  Text lobbyName;
729  uint8 lobbyKind;
733  LobbyInfo() {
734  this->lobbyKind = 0;
735  }
741  LobbyInfo(Text& _lobbyName, uint8 _lobbyKind) {
742  this->lobbyName = _lobbyName;
743  this->lobbyKind = _lobbyKind;
744  }
749  LobbyInfo& operator = (const LobbyInfo& rRef) {
750  this->lobbyName = rRef.lobbyName;
751  this->lobbyKind = rRef.lobbyKind;
752  return *this;
753  }
758  inline uint32 Size() {
759  uint32 byteLen = 0;
760  byteLen += this->lobbyName.Size();
761  byteLen += sizeof(this->lobbyKind);
762  return byteLen;
763  }
768  inline bool Pack(MunBuffer& buffer) {
769  if (!this->lobbyName.Pack(buffer)) return false;
770  return buffer.WriteUInt8(this->lobbyKind);
771  }
776  inline bool Unpack(MunBuffer& buffer) {
777  if (!this->lobbyName.Unpack(buffer)) return false;
778  this->lobbyKind = buffer.ReadUInt8();
779  return true;
780  }
781  };
785  class SummaryLobbyInfo
786  {
787  public:
789  Text lobbyName;
791  uint8 lobbyKind;
793  int32 roomCount;
795  int32 playerCount;
799  SummaryLobbyInfo() {
800  this->lobbyKind = 0;
801  this->roomCount = 0;
802  this->playerCount = 0;
803  }
811  SummaryLobbyInfo(Text& _lobbyName, uint8 _lobbyKind, int32 _roomCount, int32 _playerCount) {
812  this->lobbyName = _lobbyName;
813  this->lobbyKind = _lobbyKind;
814  this->roomCount = _roomCount;
815  this->playerCount = _playerCount;
816  }
821  SummaryLobbyInfo& operator = (const SummaryLobbyInfo& rRef) {
822  this->lobbyName = rRef.lobbyName;
823  this->lobbyKind = rRef.lobbyKind;
824  this->roomCount = rRef.roomCount;
825  this->playerCount = rRef.playerCount;
826  return *this;
827  }
832  inline uint32 Size() {
833  uint32 byteLen = 0;
834  byteLen += this->lobbyName.Size();
835  byteLen += sizeof(this->lobbyKind);
836  byteLen += sizeof(this->roomCount);
837  byteLen += sizeof(this->playerCount);
838  return byteLen;
839  }
844  inline bool Pack(MunBuffer& buffer) {
845  if (!this->lobbyName.Pack(buffer)) return false;
846  if (!buffer.WriteUInt8(this->lobbyKind)) return false;
847  if (!buffer.WriteInt32(this->roomCount)) return false;
848  return buffer.WriteInt32(this->playerCount);
849  }
854  inline bool Unpack(MunBuffer& buffer) {
855  if (!this->lobbyName.Unpack(buffer)) return false;
856  this->lobbyKind = buffer.ReadUInt8();
857  this->roomCount = buffer.ReadInt32();
858  this->playerCount = buffer.ReadInt32();
859  return true;
860  }
861  };
865  class CreateRoomInfo
866  {
867  public:
869  Text name;
871  uint32 maxPlayers;
873  uint8 isVisible;
875  uint8 isOpen;
877  KeyValue roomParameters[ROOM_PARAMETERS_MAX];
879  uint16 roomParametersLen;
881  Text lobbyParameters[LOBBY_PARAMETERS_MAX];
883  uint16 lobbyParametersLen;
885  KeyValue playerParameters[PLAYER_PARAMETERS_MAX];
887  uint16 playerParametersLen;
889  uint8 isNeedHostPlayer;
893  CreateRoomInfo() {
894  this->maxPlayers = 0;
895  this->isVisible = 0;
896  this->isOpen = 0;
897  this->roomParametersLen = 0;
898  this->lobbyParametersLen = 0;
899  this->playerParametersLen = 0;
900  this->isNeedHostPlayer = 1;
901  }
916  CreateRoomInfo(Text& _name, uint32 _maxPlayers, uint8 _isVisible, uint8 _isOpen, KeyValue* _roomParameters, uint16 _roomParametersLen, Text* _lobbyParameters, uint16 _lobbyParametersLen, KeyValue* _playerParameters, uint16 _playerParametersLen, uint8 _isNeedHostPlayer) {
917  assert(_roomParametersLen <= ROOM_PARAMETERS_MAX);
918  assert(_lobbyParametersLen <= LOBBY_PARAMETERS_MAX);
919  assert(_playerParametersLen <= PLAYER_PARAMETERS_MAX);
920  this->name = _name;
921  this->maxPlayers = _maxPlayers;
922  this->isVisible = _isVisible;
923  this->isOpen = _isOpen;
924  this->roomParametersLen = _roomParametersLen;
925  for (uint16 index = 0; index < this->roomParametersLen; ++index) {
926  this->roomParameters[index] = _roomParameters[index];
927  }
928  this->lobbyParametersLen = _lobbyParametersLen;
929  for (uint16 index = 0; index < this->lobbyParametersLen; ++index) {
930  this->lobbyParameters[index] = _lobbyParameters[index];
931  }
932  this->playerParametersLen = _playerParametersLen;
933  for (uint16 index = 0; index < this->playerParametersLen; ++index) {
934  this->playerParameters[index] = _playerParameters[index];
935  }
936  this->isNeedHostPlayer = _isNeedHostPlayer;
937  }
942  CreateRoomInfo& operator = (const CreateRoomInfo& rRef) {
943  assert(rRef.roomParametersLen <= ROOM_PARAMETERS_MAX);
944  assert(rRef.lobbyParametersLen <= LOBBY_PARAMETERS_MAX);
945  assert(rRef.playerParametersLen <= PLAYER_PARAMETERS_MAX);
946  this->name = rRef.name;
947  this->maxPlayers = rRef.maxPlayers;
948  this->isVisible = rRef.isVisible;
949  this->isOpen = rRef.isOpen;
950  this->roomParametersLen = rRef.roomParametersLen;
951  for (uint16 index = 0; index < this->roomParametersLen; ++index) {
952  this->roomParameters[index] = rRef.roomParameters[index];
953  }
954  this->lobbyParametersLen = rRef.lobbyParametersLen;
955  for (uint16 index = 0; index < this->lobbyParametersLen; ++index) {
956  this->lobbyParameters[index] = rRef.lobbyParameters[index];
957  }
958  this->playerParametersLen = rRef.playerParametersLen;
959  for (uint16 index = 0; index < this->playerParametersLen; ++index) {
960  this->playerParameters[index] = rRef.playerParameters[index];
961  }
962  this->isNeedHostPlayer = rRef.isNeedHostPlayer;
963  return *this;
964  }
969  inline uint32 Size() {
970  uint32 byteLen = 0;
971  byteLen += this->name.Size();
972  byteLen += sizeof(this->maxPlayers);
973  byteLen += sizeof(this->isVisible);
974  byteLen += sizeof(this->isOpen);
975  byteLen += sizeof(this->roomParametersLen);
976  for (uint16 index = 0; index < this->roomParametersLen; ++index) {
977  byteLen += this->roomParameters[index].Size();
978  }
979  byteLen += sizeof(this->lobbyParametersLen);
980  for (uint16 index = 0; index < this->lobbyParametersLen; ++index) {
981  byteLen += this->lobbyParameters[index].Size();
982  }
983  byteLen += sizeof(this->playerParametersLen);
984  for (uint16 index = 0; index < this->playerParametersLen; ++index) {
985  byteLen += this->playerParameters[index].Size();
986  }
987  byteLen += sizeof( this->isNeedHostPlayer );
988  return byteLen;
989  }
994  inline bool Pack(MunBuffer& buffer) {
995  if (this->roomParametersLen > ROOM_PARAMETERS_MAX) {
996  return false;
997  }
998  if (this->lobbyParametersLen > LOBBY_PARAMETERS_MAX) {
999  return false;
1000  }
1001  if (this->playerParametersLen > PLAYER_PARAMETERS_MAX) {
1002  return false;
1003  }
1004  if (!this->name.Pack(buffer)) return false;
1005  if (!buffer.WriteUInt32(this->maxPlayers)) return false;
1006  if (!buffer.WriteUInt8(this->isVisible)) return false;
1007  if (!buffer.WriteUInt8(this->isOpen)) return false;
1008  if (!buffer.WriteUInt16(this->roomParametersLen)) return false;
1009  for (uint16 index = 0; index < this->roomParametersLen; ++index) {
1010  if (!this->roomParameters[index].Pack(buffer)) return false;
1011  }
1012  if (!buffer.WriteUInt16(this->lobbyParametersLen)) return false;
1013  for (uint16 index = 0; index < this->lobbyParametersLen; ++index) {
1014  if (!this->lobbyParameters[index].Pack(buffer)) return false;
1015  }
1016  if (!buffer.WriteUInt16(this->playerParametersLen)) return false;
1017  for (uint16 index = 0; index < this->playerParametersLen; ++index) {
1018  if (!this->playerParameters[index].Pack(buffer)) return false;
1019  }
1020  if (!buffer.WriteUInt8(this->isNeedHostPlayer)) return false;
1021  return true;
1022  }
1027  inline bool Unpack(MunBuffer& buffer) {
1028  if (!this->name.Unpack(buffer)) return false;
1029  this->maxPlayers = buffer.ReadUInt32();
1030  this->isVisible = buffer.ReadUInt8();
1031  this->isOpen = buffer.ReadUInt8();
1032  this->roomParametersLen = buffer.ReadUInt16();
1033  if (this->roomParametersLen > ROOM_PARAMETERS_MAX) {
1034  return false;
1035  }
1036  for (uint16 index = 0; index < this->roomParametersLen; ++index) {
1037  if (!this->roomParameters[index].Unpack(buffer)) return false;
1038  }
1039  this->lobbyParametersLen = buffer.ReadUInt16();
1040  if (this->lobbyParametersLen > LOBBY_PARAMETERS_MAX) {
1041  return false;
1042  }
1043  for (uint16 index = 0; index < this->lobbyParametersLen; ++index) {
1044  if (!this->lobbyParameters[index].Unpack(buffer)) return false;
1045  }
1046  this->playerParametersLen = buffer.ReadUInt16();
1047  if (this->playerParametersLen > PLAYER_PARAMETERS_MAX) {
1048  return false;
1049  }
1050  for (uint16 index = 0; index < this->playerParametersLen; ++index) {
1051  if (!this->playerParameters[index].Unpack(buffer)) return false;
1052  }
1053  this->isNeedHostPlayer = buffer.ReadUInt8();
1054  return true;
1055  }
1056  };
1060  class PlayerInfo
1061  {
1062  public:
1064  int32 id;
1066  Text name;
1068  KeyValue parameters[PLAYER_PARAMETERS_MAX];
1070  uint16 parametersLen;
1074  PlayerInfo() {
1075  this->id = 0;
1076  this->parametersLen = 0;
1077  }
1085  PlayerInfo(int32 _id, Text& _name, KeyValue* _parameters, uint16 _parametersLen) {
1086  assert(_parametersLen <= PLAYER_PARAMETERS_MAX);
1087  this->id = _id;
1088  this->name = _name;
1089  this->parametersLen = _parametersLen;
1090  for (uint16 index = 0; index < this->parametersLen; ++index) {
1091  this->parameters[index] = _parameters[index];
1092  }
1093  }
1098  PlayerInfo& operator = (const PlayerInfo& rRef) {
1099  assert(rRef.parametersLen <= PLAYER_PARAMETERS_MAX);
1100  this->id = rRef.id;
1101  this->name = rRef.name;
1102  this->parametersLen = rRef.parametersLen;
1103  for (uint16 index = 0; index < this->parametersLen; ++index) {
1104  this->parameters[index] = rRef.parameters[index];
1105  }
1106  return *this;
1107  }
1112  inline uint32 Size() {
1113  uint32 byteLen = 0;
1114  byteLen += sizeof(this->id);
1115  byteLen += this->name.Size();
1116  byteLen += sizeof(this->parametersLen);
1117  for (uint16 index = 0; index < this->parametersLen; ++index) {
1118  byteLen += this->parameters[index].Size();
1119  }
1120  return byteLen;
1121  }
1126  inline bool Pack(MunBuffer& buffer) {
1127  if (this->parametersLen > PLAYER_PARAMETERS_MAX) {
1128  return false;
1129  }
1130  if (!buffer.WriteInt32(this->id)) return false;
1131  if (!this->name.Pack(buffer)) return false;
1132  if (!buffer.WriteUInt16(this->parametersLen)) return false;
1133  for (uint16 index = 0; index < this->parametersLen; ++index) {
1134  if (!this->parameters[index].Pack(buffer)) return false;
1135  }
1136  return true;
1137  }
1142  inline bool Unpack(MunBuffer& buffer) {
1143  this->id = buffer.ReadInt32();
1144  if (!this->name.Unpack(buffer)) return false;
1145  this->parametersLen = buffer.ReadUInt16();
1146  if (this->parametersLen > PLAYER_PARAMETERS_MAX) {
1147  return false;
1148  }
1149  for (uint16 index = 0; index < this->parametersLen; ++index) {
1150  if (!this->parameters[index].Unpack(buffer)) return false;
1151  }
1152  return true;
1153  }
1154  };
1158  class SummaryPlayerInfo
1159  {
1160  public:
1162  int32 id;
1164  Text name;
1168  SummaryPlayerInfo() {
1169  this->id = 0;
1170  }
1176  SummaryPlayerInfo(int32 _id, Text& _name) {
1177  this->id = _id;
1178  this->name = _name;
1179  }
1184  SummaryPlayerInfo& operator = (const SummaryPlayerInfo& rRef) {
1185  this->id = rRef.id;
1186  this->name = rRef.name;
1187  return *this;
1188  }
1193  inline uint32 Size() {
1194  uint32 byteLen = 0;
1195  byteLen += sizeof(this->id);
1196  byteLen += this->name.Size();
1197  return byteLen;
1198  }
1203  inline bool Pack(MunBuffer& buffer) {
1204  if (!buffer.WriteInt32(this->id)) return false;
1205  if (!this->name.Pack(buffer)) return false;
1206  return true;
1207  }
1212  inline bool Unpack(MunBuffer& buffer) {
1213  this->id = buffer.ReadInt32();
1214  if (!this->name.Unpack(buffer)) return false;
1215  return true;
1216  }
1217  };
1221  class SearchedPlayerInfo
1222  {
1223  public:
1225  uint8 isOnline;
1227  Text roomName;
1231  SearchedPlayerInfo() {
1232  this->isOnline = 0;
1233  }
1239  SearchedPlayerInfo(uint8 _isOnline, Text& _roomName) {
1240  this->isOnline = _isOnline;
1241  this->roomName = _roomName;
1242  }
1247  SearchedPlayerInfo& operator = (const SearchedPlayerInfo& rRef) {
1248  this->isOnline = rRef.isOnline;
1249  this->roomName = rRef.roomName;
1250  return *this;
1251  }
1256  inline uint32 Size() {
1257  uint32 byteLen = 0;
1258  byteLen += sizeof(this->isOnline);
1259  byteLen += this->roomName.Size();
1260  return byteLen;
1261  }
1266  inline bool Pack(MunBuffer& buffer) {
1267  if (!buffer.WriteUInt8(this->isOnline)) return false;
1268  return this->roomName.Pack(buffer);
1269  }
1274  inline bool Unpack(MunBuffer& buffer) {
1275  this->isOnline = buffer.ReadUInt8();
1276  return this->roomName.Unpack(buffer);
1277  }
1278  };
1282  class RoomInfo
1283  {
1284  public:
1286  Text name;
1288  uint32 maxPlayers;
1290  uint8 isVisible;
1292  uint8 isOpen;
1294  int32 hostId;
1296  uint32 playersLen;
1298  KeyValue roomParameters[ROOM_PARAMETERS_MAX];
1300  uint16 roomParametersLen;
1302  Text lobbyParameters[LOBBY_PARAMETERS_MAX];
1304  uint16 lobbyParametersLen;
1308  RoomInfo() {
1309  this->maxPlayers = 0;
1310  this->isVisible = 0;
1311  this->isOpen = 0;
1312  this->hostId = 0;
1313  this->playersLen = 0;
1314  this->roomParametersLen = 0;
1315  this->lobbyParametersLen = 0;
1316  }
1330  RoomInfo(Text& _name, uint32 _maxPlayers, uint8 _isVisible, uint8 _isOpen, int32 _hostId, uint32 _playersLen, KeyValue* _roomParameters, uint16 _roomParametersLen, Text* _lobbyParameters, uint16 _lobbyParametersLen) {
1331  assert(_playersLen <= PLAYER_MAX);
1332  assert(_roomParametersLen <= ROOM_PARAMETERS_MAX);
1333  assert(_lobbyParametersLen <= LOBBY_PARAMETERS_MAX);
1334  this->name = _name;
1335  this->maxPlayers = _maxPlayers;
1336  this->isVisible = _isVisible;
1337  this->isOpen = _isOpen;
1338  this->hostId = _hostId;
1339  this->playersLen = _playersLen;
1340  this->roomParametersLen = _roomParametersLen;
1341  for (uint16 index = 0; index < this->roomParametersLen; ++index) {
1342  this->roomParameters[index] = _roomParameters[index];
1343  }
1344  this->lobbyParametersLen = _lobbyParametersLen;
1345  for (uint16 index = 0; index < this->lobbyParametersLen; ++index) {
1346  this->lobbyParameters[index] = _lobbyParameters[index];
1347  }
1348  }
1353  RoomInfo& operator = (const RoomInfo& rRef) {
1354  assert(rRef.playersLen <= PLAYER_MAX);
1355  assert(rRef.roomParametersLen <= ROOM_PARAMETERS_MAX);
1356  assert(rRef.lobbyParametersLen <= LOBBY_PARAMETERS_MAX);
1357  this->name = rRef.name;
1358  this->maxPlayers = rRef.maxPlayers;
1359  this->isVisible = rRef.isVisible;
1360  this->isOpen = rRef.isOpen;
1361  this->hostId = rRef.hostId;
1362  this->playersLen = rRef.playersLen;
1363  this->roomParametersLen = rRef.roomParametersLen;
1364  for (uint16 index = 0; index < this->roomParametersLen; ++index) {
1365  this->roomParameters[index] = rRef.roomParameters[index];
1366  }
1367  this->lobbyParametersLen = rRef.lobbyParametersLen;
1368  for (uint16 index = 0; index < this->lobbyParametersLen; ++index) {
1369  this->lobbyParameters[index] = rRef.lobbyParameters[index];
1370  }
1371  return *this;
1372  }
1377  inline uint32 Size() {
1378  uint32 byteLen = 0;
1379  byteLen += this->name.Size();
1380  byteLen += sizeof(this->maxPlayers);
1381  byteLen += sizeof(this->isVisible);
1382  byteLen += sizeof(this->isOpen);
1383  byteLen += sizeof(this->hostId);
1384  byteLen += sizeof(this->playersLen);
1385  byteLen += sizeof(this->roomParametersLen);
1386  for (uint16 index = 0; index < this->roomParametersLen; ++index) {
1387  byteLen += this->roomParameters[index].Size();
1388  }
1389  byteLen += sizeof(this->lobbyParametersLen);
1390  for (uint16 index = 0; index < this->lobbyParametersLen; ++index) {
1391  byteLen += this->lobbyParameters[index].Size();
1392  }
1393  return byteLen;
1394  }
1399  inline bool Pack(MunBuffer& buffer) {
1400  if (this->playersLen > PLAYER_MAX) {
1401  return false;
1402  }
1403  if (this->roomParametersLen > ROOM_PARAMETERS_MAX) {
1404  return false;
1405  }
1406  if (this->lobbyParametersLen > LOBBY_PARAMETERS_MAX) {
1407  return false;
1408  }
1409  if (!this->name.Pack(buffer)) return false;
1410  if (!buffer.WriteUInt32(this->maxPlayers)) return false;
1411  if (!buffer.WriteUInt8(this->isVisible)) return false;
1412  if (!buffer.WriteUInt8(this->isOpen)) return false;
1413  if (!buffer.WriteInt32(this->hostId)) return false;
1414  if (!buffer.WriteUInt32(this->playersLen)) return false;
1415  if (!buffer.WriteUInt16(this->roomParametersLen)) return false;
1416  for (uint16 index = 0; index < this->roomParametersLen; ++index) {
1417  if (!this->roomParameters[index].Pack(buffer)) return false;
1418  }
1419  if (!buffer.WriteUInt16(this->lobbyParametersLen)) return false;
1420  for (uint16 index = 0; index < this->lobbyParametersLen; ++index) {
1421  if (!this->lobbyParameters[index].Pack(buffer)) return false;
1422  }
1423  return true;
1424  }
1429  inline bool Unpack(MunBuffer& buffer) {
1430  if (!this->name.Unpack(buffer)) return false;
1431  this->maxPlayers = buffer.ReadUInt32();
1432  this->isVisible = buffer.ReadUInt8();
1433  this->isOpen = buffer.ReadUInt8();
1434  this->hostId = buffer.ReadInt32();
1435  this->playersLen = buffer.ReadUInt32();
1436  if (this->playersLen > PLAYER_MAX) {
1437  return false;
1438  }
1439  this->roomParametersLen = buffer.ReadUInt16();
1440  if (this->roomParametersLen > ROOM_PARAMETERS_MAX) {
1441  return false;
1442  }
1443  for (uint16 index = 0; index < this->roomParametersLen; ++index) {
1444  if (!this->roomParameters[index].Unpack(buffer)) return false;
1445  }
1446  this->lobbyParametersLen = buffer.ReadUInt16();
1447  if (this->lobbyParametersLen > LOBBY_PARAMETERS_MAX) {
1448  return false;
1449  }
1450  for (uint16 index = 0; index < this->lobbyParametersLen; ++index) {
1451  if (!this->lobbyParameters[index].Unpack(buffer)) return false;
1452  }
1453  return true;
1454  }
1455  };
1459  class SummaryRoomInfo
1460  {
1461  public:
1463  Text name;
1465  uint32 maxPlayers;
1467  uint8 isVisible;
1469  uint8 isOpen;
1471  int32 hostId;
1473  uint32 playersLen;
1475  KeyValue roomParameters[ROOM_PARAMETERS_MAX];
1477  uint16 roomParametersLen;
1481  SummaryRoomInfo() {
1482  this->maxPlayers = 0;
1483  this->isVisible = 0;
1484  this->isOpen = 0;
1485  this->hostId = 0;
1486  this->playersLen = 0;
1487  this->roomParametersLen = 0;
1488  }
1500  SummaryRoomInfo(Text& _name, uint8 _maxPlayers, uint8 _isVisible, uint8 _isOpen, int32 _hostId, uint32 _playersLen, KeyValue* _roomParameters, uint16 _roomParametersLen) {
1501  assert(_playersLen <= PLAYER_MAX);
1502  assert(_roomParametersLen <= ROOM_PARAMETERS_MAX);
1503  this->name = _name;
1504  this->maxPlayers = _maxPlayers;
1505  this->isVisible = _isVisible;
1506  this->isOpen = _isOpen;
1507  this->hostId = _hostId;
1508  this->playersLen = _playersLen;
1509  this->roomParametersLen = _roomParametersLen;
1510  for (uint16 index = 0; index < this->roomParametersLen; ++index) {
1511  this->roomParameters[index] = _roomParameters[index];
1512  }
1513  }
1518  SummaryRoomInfo& operator = (const SummaryRoomInfo& rRef) {
1519  assert(rRef.playersLen <= PLAYER_MAX);
1520  assert(rRef.roomParametersLen <= ROOM_PARAMETERS_MAX);
1521  this->name = rRef.name;
1522  this->maxPlayers = rRef.maxPlayers;
1523  this->isVisible = rRef.isVisible;
1524  this->isOpen = rRef.isOpen;
1525  this->hostId = rRef.hostId;
1526  this->playersLen = rRef.playersLen;
1527  this->roomParametersLen = rRef.roomParametersLen;
1528  for (uint16 index = 0; index < this->roomParametersLen; ++index) {
1529  this->roomParameters[index] = rRef.roomParameters[index];
1530  }
1531  return *this;
1532  }
1537  inline uint32 Size() {
1538  uint32 byteLen = 0;
1539  byteLen += this->name.Size();
1540  byteLen += sizeof(this->maxPlayers);
1541  byteLen += sizeof(this->isVisible);
1542  byteLen += sizeof(this->isOpen);
1543  byteLen += sizeof(this->hostId);
1544  byteLen += sizeof(this->playersLen);
1545  byteLen += sizeof(this->roomParametersLen);
1546  for (uint16 index = 0; index < this->roomParametersLen; ++index) {
1547  byteLen += this->roomParameters[index].Size();
1548  }
1549  return byteLen;
1550  }
1555  inline bool Pack(MunBuffer& buffer) {
1556  if (this->playersLen > PLAYER_MAX) {
1557  return false;
1558  }
1559  if (this->roomParametersLen > ROOM_PARAMETERS_MAX) {
1560  return false;
1561  }
1562  if (!this->name.Pack(buffer)) return false;
1563  if (!buffer.WriteUInt32(this->maxPlayers)) return false;
1564  if (!buffer.WriteUInt8(this->isVisible)) return false;
1565  if (!buffer.WriteUInt8(this->isOpen)) return false;
1566  if (!buffer.WriteInt32(this->hostId)) return false;
1567  if (!buffer.WriteUInt32(this->playersLen)) return false;
1568  if (!buffer.WriteUInt16(this->roomParametersLen)) return false;
1569  for (uint16 index = 0; index < this->roomParametersLen; ++index) {
1570  if (!this->roomParameters[index].Pack(buffer)) return false;
1571  }
1572  return true;
1573  }
1578  inline bool Unpack(MunBuffer& buffer) {
1579  if (!this->name.Unpack(buffer)) return false;
1580  this->maxPlayers = buffer.ReadUInt32();
1581  this->isVisible = buffer.ReadUInt8();
1582  this->isOpen = buffer.ReadUInt8();
1583  this->hostId = buffer.ReadInt32();
1584  this->playersLen = buffer.ReadUInt32();
1585  if (this->playersLen > PLAYER_MAX) {
1586  return false;
1587  }
1588  this->roomParametersLen = buffer.ReadUInt16();
1589  if (this->roomParametersLen > ROOM_PARAMETERS_MAX) {
1590  return false;
1591  }
1592  for (uint16 index = 0; index < this->roomParametersLen; ++index) {
1593  if (!this->roomParameters[index].Unpack(buffer)) return false;
1594  }
1595  return true;
1596  }
1597  };
1601  class StatsInfo
1602  {
1603  public:
1605  int32 clientCountInServer;
1607  int32 clientCountInLobby;
1609  int32 clientCountInRoom;
1611  int32 roomCountInLobby;
1615  StatsInfo() {
1616  this->clientCountInServer = 0;
1617  this->clientCountInLobby = 0;
1618  this->clientCountInRoom = 0;
1619  this->roomCountInLobby = 0;
1620  }
1628  StatsInfo(int32 _clientCountInServer, int32 _clientCountInLobby, int32 _clientCountInRoom, int32 _roomCountInLobby) {
1629  this->clientCountInServer = _clientCountInServer;
1630  this->clientCountInLobby = _clientCountInLobby;
1631  this->clientCountInRoom = _clientCountInRoom;
1632  this->roomCountInLobby = _roomCountInLobby;
1633  }
1638  StatsInfo& operator = (const StatsInfo& rRef) {
1639  this->clientCountInServer = rRef.clientCountInServer;
1640  this->clientCountInLobby = rRef.clientCountInLobby;
1641  this->clientCountInRoom = rRef.clientCountInRoom;
1642  this->roomCountInLobby = rRef.roomCountInLobby;
1643  return *this;
1644  }
1649  inline uint32 Size() {
1650  uint32 byteLen = 0;
1651  byteLen += sizeof(this->clientCountInServer);
1652  byteLen += sizeof(this->clientCountInLobby);
1653  byteLen += sizeof(this->clientCountInRoom);
1654  byteLen += sizeof(this->roomCountInLobby);
1655  return byteLen;
1656  }
1661  inline bool Pack(MunBuffer& buffer) {
1662  if (!buffer.WriteInt32(this->clientCountInServer)) return false;
1663  if (!buffer.WriteInt32(this->clientCountInLobby)) return false;
1664  if (!buffer.WriteInt32(this->clientCountInRoom)) return false;
1665  return buffer.WriteInt32(this->roomCountInLobby);
1666  }
1671  inline bool Unpack(MunBuffer& buffer) {
1672  this->clientCountInServer = buffer.ReadInt32();
1673  this->clientCountInLobby = buffer.ReadInt32();
1674  this->clientCountInRoom = buffer.ReadInt32();
1675  this->roomCountInLobby = buffer.ReadInt32();
1676  return true;
1677  }
1678  };
1682  class AddressInfo
1683  {
1684  public:
1686  Text address;
1688  uint16 port;
1692  AddressInfo() {
1693  this->port = 0;
1694  }
1700  AddressInfo(Text& _address, uint16 _port) {
1701  this->address = _address;
1702  this->port = _port;
1703  }
1708  AddressInfo& operator = (const AddressInfo& rRef) {
1709  this->address = rRef.address;
1710  this->port = rRef.port;
1711  return *this;
1712  }
1717  inline uint32 Size() {
1718  uint32 byteLen = 0;
1719  byteLen += this->address.Size();
1720  byteLen += sizeof(this->port);
1721  return byteLen;
1722  }
1727  inline bool Pack(MunBuffer& buffer) {
1728  if (!this->address.Pack(buffer)) return false;
1729  return buffer.WriteUInt16(this->port);
1730  }
1735  inline bool Unpack(MunBuffer& buffer) {
1736  if (!this->address.Unpack(buffer)) return false;
1737  this->port = buffer.ReadUInt16();
1738  return true;
1739  }
1740  };
1744  class ResolverResolveAddressRequest
1745  {
1746  public:
1748  static const uint16 payloadType = RESOLVER_FUNCID_RESOLVER_RESOLVEADDRESS;
1750  uint16 connectType;
1754  ResolverResolveAddressRequest() {
1755  this->connectType = 0;
1756  }
1761  ResolverResolveAddressRequest(uint16 _connectType) {
1762  this->connectType = _connectType;
1763  }
1768  ResolverResolveAddressRequest& operator = (const ResolverResolveAddressRequest& rRef) {
1769  this->connectType = rRef.connectType;
1770  return *this;
1771  }
1776  inline uint32 Size() {
1777  uint32 byteLen = 0;
1778  byteLen += sizeof(this->connectType);
1779  return byteLen;
1780  }
1785  inline bool Pack(MunBuffer& buffer) {
1786  return buffer.WriteUInt16(this->connectType);
1787  }
1792  inline bool Unpack(MunBuffer& buffer) {
1793  this->connectType = buffer.ReadUInt16();
1794  return true;
1795  }
1796  };
1800  class ResolverResolveAddressResponse
1801  {
1802  public:
1804  static const uint16 payloadType = RESOLVER_FUNCID_RESOLVER_RESOLVEADDRESSRESULT;
1806  int32 result;
1808  AddressInfo proxyAddressInfo;
1812  ResolverResolveAddressResponse() {
1813  this->result = 0;
1814  }
1820  ResolverResolveAddressResponse(int32 _result, AddressInfo& _proxyAddressInfo) {
1821  this->result = _result;
1822  this->proxyAddressInfo = _proxyAddressInfo;
1823  }
1828  ResolverResolveAddressResponse& operator = (const ResolverResolveAddressResponse& rRef) {
1829  this->result = rRef.result;
1830  this->proxyAddressInfo = rRef.proxyAddressInfo;
1831  return *this;
1832  }
1837  inline uint32 Size() {
1838  uint32 byteLen = 0;
1839  byteLen += sizeof(this->result);
1840  byteLen += this->proxyAddressInfo.Size();
1841  return byteLen;
1842  }
1847  inline bool Pack(MunBuffer& buffer) {
1848  if (!buffer.WriteInt32(this->result)) return false;
1849  return this->proxyAddressInfo.Pack(buffer);
1850  }
1855  inline bool Unpack(MunBuffer& buffer) {
1856  this->result = buffer.ReadInt32();
1857  return this->proxyAddressInfo.Unpack(buffer);
1858  }
1859  };
1863  class ProxyResolverSetAddressRequest
1864  {
1865  public:
1867  static const uint16 payloadType = PROXYRESOLVER_FUNCID_PROXYRESOLVER_SETADDRESS;
1869  uint64 proxyUid;
1871  Text address;
1873  uint16 tcp_port;
1875  uint16 udp_port;
1877  uint16 ws_port;
1879  uint16 wss_port;
1883  ProxyResolverSetAddressRequest() {
1884  this->proxyUid = 0;
1885  this->address = Text("");
1886  this->tcp_port = 0;
1887  this->udp_port = 0;
1888  this->ws_port = 0;
1889  this->wss_port = 0;
1890  }
1900  ProxyResolverSetAddressRequest(uint64 _proxyUid, Text& _address, uint16 _tcp_port, uint16 _udp_port, uint16 _ws_port, uint16 _wss_port) {
1901  this->proxyUid = _proxyUid;
1902  this->address = Text(_address);
1903  this->tcp_port = _tcp_port;
1904  this->udp_port = _udp_port;
1905  this->ws_port = _ws_port;
1906  this->wss_port = _wss_port;
1907  }
1912  ProxyResolverSetAddressRequest& operator = (const ProxyResolverSetAddressRequest& rRef) {
1913  this->proxyUid = rRef.proxyUid;
1914  this->address = Text(rRef.address);
1915  this->tcp_port = rRef.tcp_port;
1916  this->udp_port = rRef.udp_port;
1917  this->ws_port = rRef.ws_port;
1918  this->wss_port = rRef.wss_port;
1919  return *this;
1920  }
1925  inline uint32 Size() {
1926  uint32 byteLen = 0;
1927  byteLen += sizeof(this->proxyUid);
1928  byteLen += this->address.Size();
1929  byteLen += sizeof(this->tcp_port);
1930  byteLen += sizeof(this->udp_port);
1931  byteLen += sizeof(this->ws_port);
1932  byteLen += sizeof(this->wss_port);
1933  return byteLen;
1934  }
1939  inline bool Pack(MunBuffer& buffer) {
1940  if (!buffer.WriteUInt64(this->proxyUid)) return false;
1941  if (!this->address.Pack(buffer)) return false;
1942  if (!buffer.WriteUInt16(this->tcp_port)) return false;
1943  if (!buffer.WriteUInt16(this->udp_port)) return false;
1944  if (!buffer.WriteUInt16(this->ws_port)) return false;
1945  if (!buffer.WriteUInt16(this->wss_port)) return false;
1946  return true;
1947  }
1952  inline bool Unpack(MunBuffer& buffer) {
1953  this->proxyUid = buffer.ReadUInt64();
1954  if (!this->address.Unpack(buffer)) return false;
1955  this->tcp_port = buffer.ReadUInt16();
1956  this->udp_port = buffer.ReadUInt16();
1957  this->ws_port = buffer.ReadUInt16();
1958  this->wss_port = buffer.ReadUInt16();
1959  return true;
1960  }
1961  };
1965  class ProxyResolverSetWeightRequest
1966  {
1967  public:
1969  static const uint16 payloadType = PROXYRESOLVER_FUNCID_PROXYRESOLVER_SETWEIGHT;
1971  uint64 proxyUid;
1973  int32 weight;
1977  ProxyResolverSetWeightRequest() {
1978  this->proxyUid = 0;
1979  this->weight = 0;
1980  }
1986  ProxyResolverSetWeightRequest(uint64 _proxyUid, int32 _weight) {
1987  this->proxyUid = _proxyUid;
1988  this->weight = _weight;
1989  }
1994  ProxyResolverSetWeightRequest& operator = (const ProxyResolverSetWeightRequest& rRef) {
1995  this->proxyUid = rRef.proxyUid;
1996  this->weight = rRef.weight;
1997  return *this;
1998  }
2003  inline uint32 Size() {
2004  uint32 byteLen = 0;
2005  byteLen += sizeof(this->proxyUid);
2006  byteLen += sizeof(this->weight);
2007  return byteLen;
2008  }
2013  inline bool Pack(MunBuffer& buffer) {
2014  if (!buffer.WriteUInt64(this->proxyUid)) return false;
2015  return buffer.WriteInt32(this->weight);
2016  }
2021  inline bool Unpack(MunBuffer& buffer) {
2022  this->proxyUid = buffer.ReadUInt64();
2023  this->weight = buffer.ReadInt32();
2024  return true;
2025  }
2026  };
2030  class ProxyCheckRequest
2031  {
2032  public:
2034  static const uint16 payloadType = MASTER_FUNCID_PROXY_CHECK;
2036  uint8 isUseCustomAuth;
2038  uint8 isUseClientCustomAuthServerAddress;
2040  Text customAuthServerAddress;
2042  uint8 isIgnoreCustomAuthError;
2044  KeyValue customAuthParameters[CUSTOM_AUTH_PARAMETERS_MAX];
2046  uint16 customAuthParametersLen;
2050  ProxyCheckRequest() {
2051  this->isUseCustomAuth = 0;
2052  this->isUseClientCustomAuthServerAddress = 0;
2053  this->isIgnoreCustomAuthError = 0;
2054  this->customAuthParametersLen = 0;
2055  }
2065  ProxyCheckRequest(uint8 _isUseCustomAuth, uint8 _isUseClientCustomAuthServerAddress, Text& _customAuthServerAddress, uint8 _isIgnoreCustomAuthError, KeyValue* _customAuthParameters, uint16 _customAuthParametersLen) {
2066  assert(_customAuthParametersLen <= CUSTOM_AUTH_PARAMETERS_MAX);
2067  this->isUseCustomAuth = _isUseCustomAuth;
2068  this->isUseClientCustomAuthServerAddress = _isUseClientCustomAuthServerAddress;
2069  this->customAuthServerAddress = _customAuthServerAddress;
2070  this->isIgnoreCustomAuthError = _isIgnoreCustomAuthError;
2071  this->customAuthParametersLen = _customAuthParametersLen;
2072  for (uint16 index = 0; index < this->customAuthParametersLen; ++index) {
2073  this->customAuthParameters[index] = _customAuthParameters[index];
2074  }
2075  }
2080  ProxyCheckRequest& operator = (const ProxyCheckRequest& rRef) {
2081  assert(rRef.customAuthParametersLen <= CUSTOM_AUTH_PARAMETERS_MAX);
2082  this->isUseCustomAuth = rRef.isUseCustomAuth;
2083  this->isUseClientCustomAuthServerAddress = rRef.isUseClientCustomAuthServerAddress;
2084  this->customAuthServerAddress = rRef.customAuthServerAddress;
2085  this->isIgnoreCustomAuthError = rRef.isIgnoreCustomAuthError;
2086  this->customAuthParametersLen = rRef.customAuthParametersLen;
2087  for (uint16 index = 0; index < this->customAuthParametersLen; ++index) {
2088  this->customAuthParameters[index] = rRef.customAuthParameters[index];
2089  }
2090  return *this;
2091  }
2096  inline uint32 Size() {
2097  uint32 byteLen = 0;
2098  byteLen += sizeof(this->isUseCustomAuth);
2099  byteLen += sizeof(this->isUseClientCustomAuthServerAddress);
2100  byteLen += this->customAuthServerAddress.Size();
2101  byteLen += sizeof(this->isIgnoreCustomAuthError);
2102  byteLen += sizeof(this->customAuthParametersLen);
2103  for (uint16 index = 0; index < this->customAuthParametersLen; ++index) {
2104  byteLen += this->customAuthParameters[index].Size();
2105  }
2106  return byteLen;
2107  }
2112  inline bool Pack(MunBuffer& buffer) {
2113  assert(this->customAuthParametersLen <= CUSTOM_AUTH_PARAMETERS_MAX);
2114  if (!buffer.WriteUInt8(this->isUseCustomAuth)) return false;
2115  if (!buffer.WriteUInt8(this->isUseClientCustomAuthServerAddress)) return false;
2116  if (!this->customAuthServerAddress.Pack(buffer)) return false;
2117  if (!buffer.WriteUInt8(this->isIgnoreCustomAuthError)) return false;
2118  if (!buffer.WriteUInt16(this->customAuthParametersLen)) return false;
2119  for (uint16 index = 0; index < this->customAuthParametersLen; ++index) {
2120  if (!this->customAuthParameters[index].Pack(buffer)) return false;
2121  }
2122  return true;
2123  }
2128  inline bool Unpack(MunBuffer& buffer) {
2129  this->isUseCustomAuth = buffer.ReadUInt8();
2130  this->isUseClientCustomAuthServerAddress = buffer.ReadUInt8();
2131  if (!this->customAuthServerAddress.Unpack(buffer)) return false;
2132  this->isIgnoreCustomAuthError = buffer.ReadUInt8();
2133  this->customAuthParametersLen = buffer.ReadUInt16();
2134  assert(this->customAuthParametersLen <= CUSTOM_AUTH_PARAMETERS_MAX);
2135  for (uint16 index = 0; index < this->customAuthParametersLen; ++index) {
2136  if (!this->customAuthParameters[index].Unpack(buffer)) return false;
2137  }
2138  return true;
2139  }
2140  };
2144  class ProxyCheckResponse
2145  {
2146  public:
2148  static const uint16 payloadType = MASTER_FUNCID_PROXY_CHECKRESULT;
2150  uint64 clientUid;
2152  int32 result;
2154  Text authServerRawData;
2158  ProxyCheckResponse() {
2159  this->clientUid = 0;
2160  this->result = 0;
2161  }
2167  ProxyCheckResponse(uint64 _clientUid, int32 _result, Text& _authServerRawData) {
2168  this->clientUid = _clientUid;
2169  this->result = _result;
2170  this->authServerRawData = _authServerRawData;
2171  }
2176  ProxyCheckResponse& operator = (const ProxyCheckResponse& rRef) {
2177  this->result = rRef.result;
2178  this->clientUid = rRef.clientUid;
2179  this->authServerRawData = rRef.authServerRawData;
2180  return *this;
2181  }
2186  inline uint32 Size() {
2187  uint32 byteLen = 0;
2188  byteLen += sizeof(this->clientUid);
2189  byteLen += sizeof(this->result);
2190  byteLen += this->authServerRawData.Size();
2191  return byteLen;
2192  }
2197  inline bool Pack(MunBuffer& buffer) {
2198  if (!buffer.WriteUInt64(this->clientUid)) return false;
2199  if (!buffer.WriteInt32(this->result)) return false;
2200  return this->authServerRawData.Pack(buffer);
2201  }
2206  inline bool Unpack(MunBuffer& buffer) {
2207  this->clientUid = buffer.ReadUInt64();
2208  this->result = buffer.ReadInt32();
2209  return this->authServerRawData.Unpack(buffer);
2210  }
2211  };
2215  class MasterCheckRequest
2216  {
2217  public:
2219  static const uint16 payloadType = MASTER_FUNCID_MASTER_CHECK;
2221  Text appName;
2223  Text munVer;
2225  Text authId;
2227  Text clientName;
2229  uint64 clientUid;
2231  uint8 isUpdateLobbyInfo;
2235  MasterCheckRequest() {
2236  this->clientUid = 0;
2237  this->isUpdateLobbyInfo = 0;
2238  }
2248  MasterCheckRequest(Text& _appName, Text& _munVer, Text& _authId, Text& _clientName, uint64 _clientUid, uint8 _isUpdateLobbyInfo) {
2249  this->appName = _appName;
2250  this->munVer = _munVer;
2251  this->authId = _authId;
2252  this->clientName = _clientName;
2253  this->clientUid = _clientUid;
2254  this->isUpdateLobbyInfo = _isUpdateLobbyInfo;
2255  }
2260  MasterCheckRequest& operator = (const MasterCheckRequest& rRef) {
2261  this->appName = rRef.appName;
2262  this->munVer = rRef.munVer;
2263  this->authId = rRef.authId;
2264  this->clientName = rRef.clientName;
2265  this->clientUid = rRef.clientUid;
2266  this->isUpdateLobbyInfo = rRef.isUpdateLobbyInfo;
2267  return *this;
2268  }
2273  inline uint32 Size() {
2274  uint32 byteLen = 0;
2275  byteLen += this->appName.Size();
2276  byteLen += this->munVer.Size();
2277  byteLen += this->authId.Size();
2278  byteLen += this->clientName.Size();
2279  byteLen += sizeof(this->clientUid);
2280  byteLen += sizeof(this->isUpdateLobbyInfo);
2281  return byteLen;
2282  }
2287  inline bool Pack(MunBuffer& buffer) {
2288  if (!this->appName.Pack(buffer)) return false;
2289  if (!this->munVer.Pack(buffer)) return false;
2290  if (!this->authId.Pack(buffer)) return false;
2291  if (!this->clientName.Pack(buffer)) return false;
2292  if (!buffer.WriteUInt64(this->clientUid)) return false;
2293  return buffer.WriteUInt8(this->isUpdateLobbyInfo);
2294  }
2299  inline bool Unpack(MunBuffer& buffer) {
2300  if (!this->appName.Unpack(buffer)) return false;
2301  if (!this->munVer.Unpack(buffer)) return false;
2302  if (!this->authId.Unpack(buffer)) return false;
2303  if (!this->clientName.Unpack(buffer)) return false;
2304  this->clientUid = buffer.ReadUInt64();
2305  this->isUpdateLobbyInfo = buffer.ReadUInt8();
2306  return true;
2307  }
2308  };
2312  class MasterCheckResponse
2313  {
2314  public:
2316  static const uint16 payloadType = MASTER_FUNCID_MASTER_CHECKRESULT;
2318  int32 result;
2320  Text msg;
2322  uint32 clientUid;
2324  SummaryLobbyInfo lobbyInfo[LOBBY_LIST_MAX];
2326  uint16 lobbyInfoLen;
2330  MasterCheckResponse() {
2331  this->result = 0;
2332  this->clientUid = 0;
2333  this->lobbyInfoLen = 0;
2334  }
2343  MasterCheckResponse(int32 _result, Text& _msg, uint32 _clientUid, SummaryLobbyInfo* _lobbyInfo, uint16 _lobbyInfoLen) {
2344  assert(_lobbyInfoLen <= LOBBY_LIST_MAX);
2345  this->result = _result;
2346  this->msg = _msg;
2347  this->clientUid = _clientUid;
2348  this->lobbyInfoLen = _lobbyInfoLen;
2349  for (uint16 index = 0; index < this->lobbyInfoLen; ++index) {
2350  this->lobbyInfo[index] = _lobbyInfo[index];
2351  }
2352  }
2357  MasterCheckResponse& operator = (const MasterCheckResponse& rRef) {
2358  assert(rRef.lobbyInfoLen <= LOBBY_LIST_MAX);
2359  this->result = rRef.result;
2360  this->msg = rRef.msg;
2361  this->clientUid = rRef.clientUid;
2362  this->lobbyInfoLen = rRef.lobbyInfoLen;
2363  for (uint16 index = 0; index < this->lobbyInfoLen; ++index) {
2364  this->lobbyInfo[index] = rRef.lobbyInfo[index];
2365  }
2366  return *this;
2367  }
2372  inline uint32 Size() {
2373  uint32 byteLen = 0;
2374  byteLen += sizeof(this->result);
2375  byteLen += this->msg.Size();
2376  byteLen += sizeof(this->clientUid);
2377  byteLen += sizeof(this->lobbyInfoLen);
2378  for (uint16 index = 0; index < this->lobbyInfoLen; ++index) {
2379  byteLen += this->lobbyInfo[index].Size();
2380  }
2381  return byteLen;
2382  }
2387  inline bool Pack(MunBuffer& buffer) {
2388  if (this->lobbyInfoLen > LOBBY_LIST_MAX) {
2389  return false;
2390  }
2391  if (!buffer.WriteInt32(this->result)) return false;
2392  if (!this->msg.Pack(buffer)) return false;
2393  if (!buffer.WriteUInt32(this->clientUid)) return false;
2394  if (!buffer.WriteUInt16(this->lobbyInfoLen)) return false;
2395  for (uint16 index = 0; index < this->lobbyInfoLen; ++index) {
2396  if (!this->lobbyInfo[index].Pack(buffer)) return false;
2397  }
2398  return true;
2399  }
2404  inline bool Unpack(MunBuffer& buffer) {
2405  this->result = buffer.ReadInt32();
2406  if (!this->msg.Unpack(buffer)) return false;
2407  this->clientUid = buffer.ReadUInt32();
2408  this->lobbyInfoLen = buffer.ReadUInt16();
2409  if (this->lobbyInfoLen > LOBBY_LIST_MAX) {
2410  return false;
2411  }
2412  for (uint16 index = 0; index < this->lobbyInfoLen; ++index) {
2413  if (!this->lobbyInfo[index].Unpack(buffer)) return false;
2414  }
2415  return true;
2416  }
2417  };
2421  class MasterLobbyForceJoinRequest
2422  {
2423  public:
2425  static const uint16 payloadType = MASTER_FUNCID_MASTER_LOBBY_FORCEJOIN;
2427  CreateLobbyInfo lobbyInfo;
2431  MasterLobbyForceJoinRequest() {}
2436  MasterLobbyForceJoinRequest(CreateLobbyInfo& _lobbyInfo) {
2437  this->lobbyInfo = _lobbyInfo;
2438  }
2443  MasterLobbyForceJoinRequest& operator = (const MasterLobbyForceJoinRequest& rRef) {
2444  this->lobbyInfo = rRef.lobbyInfo;
2445  return *this;
2446  }
2451  inline uint32 Size() {
2452  uint32 byteLen = 0;
2453  byteLen += this->lobbyInfo.Size();
2454  return byteLen;
2455  }
2460  inline bool Pack(MunBuffer& buffer) {
2461  return this->lobbyInfo.Pack(buffer);
2462  }
2467  inline bool Unpack(MunBuffer& buffer) {
2468  return this->lobbyInfo.Unpack(buffer);
2469  }
2470  };
2474  class MasterLobbyForceJoinResponse
2475  {
2476  public:
2478  static const uint16 payloadType = MASTER_FUNCID_MASTER_LOBBY_FORCEJOINRESULT;
2480  int32 result;
2482  SummaryRoomInfo roomInfo[ROOM_LIST_MAX];
2484  uint16 roomInfoLen;
2488  MasterLobbyForceJoinResponse() {
2489  this->result = 0;
2490  this->roomInfoLen = 0;
2491  }
2498  MasterLobbyForceJoinResponse(int32 _result, SummaryRoomInfo* _roomInfo, uint16 _roomInfoLen) {
2499  assert(_roomInfoLen <= ROOM_LIST_MAX);
2500  this->result = _result;
2501  this->roomInfoLen = _roomInfoLen;
2502  for (uint16 index = 0; index < this->roomInfoLen; ++index) {
2503  this->roomInfo[index] = _roomInfo[index];
2504  }
2505  }
2510  MasterLobbyForceJoinResponse& operator = (const MasterLobbyForceJoinResponse& rRef) {
2511  assert(rRef.roomInfoLen <= ROOM_LIST_MAX);
2512  this->result = rRef.result;
2513  this->roomInfoLen = rRef.roomInfoLen;
2514  for (uint16 index = 0; index < this->roomInfoLen; ++index) {
2515  this->roomInfo[index] = rRef.roomInfo[index];
2516  }
2517  return *this;
2518  }
2523  inline uint32 Size() {
2524  uint32 byteLen = 0;
2525  byteLen += sizeof(this->result);
2526  byteLen += sizeof(this->roomInfoLen);
2527  for (uint16 index = 0; index < this->roomInfoLen; ++index) {
2528  byteLen += this->roomInfo[index].Size();
2529  }
2530  return byteLen;
2531  }
2536  inline bool Pack(MunBuffer& buffer) {
2537  if (this->roomInfoLen > ROOM_LIST_MAX) {
2538  return false;
2539  }
2540  if (!buffer.WriteInt32(this->result)) return false;
2541  if (!buffer.WriteUInt16(this->roomInfoLen)) return false;
2542  for (uint16 index = 0; index < this->roomInfoLen; ++index) {
2543  if (!this->roomInfo[index].Pack(buffer)) return false;
2544  }
2545  return true;
2546  }
2551  inline bool Unpack(MunBuffer& buffer) {
2552  this->result = buffer.ReadInt32();
2553  this->roomInfoLen = buffer.ReadUInt16();
2554  if (this->roomInfoLen > ROOM_LIST_MAX) {
2555  return false;
2556  }
2557  for (uint16 index = 0; index < this->roomInfoLen; ++index) {
2558  if (!this->roomInfo[index].Unpack(buffer)) return false;
2559  }
2560  return true;
2561  }
2562  };
2566  class MasterLobbyUpdateResponse
2567  {
2568  public:
2570  static const uint16 payloadType = MASTER_FUNCID_MASTER_LOBBY_UPDATERESULT;
2572  SummaryLobbyInfo lobbyInfo;
2574  uint8 isRemove;
2578  MasterLobbyUpdateResponse() {
2579  this->isRemove = 0;
2580  }
2586  MasterLobbyUpdateResponse(SummaryLobbyInfo& _lobbyInfo, uint8 _isRemove) {
2587  this->lobbyInfo = _lobbyInfo;
2588  this->isRemove = _isRemove;
2589  }
2594  MasterLobbyUpdateResponse& operator = (const MasterLobbyUpdateResponse& rRef) {
2595  this->lobbyInfo = rRef.lobbyInfo;
2596  this->isRemove = rRef.isRemove;
2597  return *this;
2598  }
2603  inline uint32 Size() {
2604  uint32 byteLen = 0;
2605  byteLen += this->lobbyInfo.Size();
2606  byteLen += sizeof(this->isRemove);
2607  return byteLen;
2608  }
2613  inline bool Pack(MunBuffer& buffer) {
2614  if (!this->lobbyInfo.Pack(buffer)) return false;
2615  return buffer.WriteUInt8(this->isRemove);
2616  }
2621  inline bool Unpack(MunBuffer& buffer) {
2622  if (!this->lobbyInfo.Unpack(buffer)) return false;
2623  this->isRemove = buffer.ReadUInt8();
2624  return true;
2625  }
2626  };
2630  class MasterRoomCreateRequest
2631  {
2632  public:
2634  static const uint16 payloadType = MASTER_FUNCID_MASTER_ROOM_CREATE;
2636  uint8 protocol;
2638  CreateRoomInfo roomInfo;
2640  CreateLobbyInfo lobbyInfo;
2644  MasterRoomCreateRequest() {
2645  this->protocol = 0;
2646  }
2653  MasterRoomCreateRequest(uint8 _protocol, CreateRoomInfo& _roomInfo, CreateLobbyInfo& _lobbyInfo) {
2654  this->protocol = _protocol;
2655  this->roomInfo = _roomInfo;
2656  this->lobbyInfo = _lobbyInfo;
2657  }
2662  MasterRoomCreateRequest& operator = (const MasterRoomCreateRequest& rRef) {
2663  this->protocol = rRef.protocol;
2664  this->roomInfo = rRef.roomInfo;
2665  this->lobbyInfo = rRef.lobbyInfo;
2666  return *this;
2667  }
2672  inline uint32 Size() {
2673  uint32 byteLen = 0;
2674  byteLen += sizeof(this->protocol);
2675  byteLen += this->roomInfo.Size();
2676  byteLen += this->lobbyInfo.Size();
2677  return byteLen;
2678  }
2683  inline bool Pack(MunBuffer& buffer) {
2684  if (!buffer.WriteUInt8(this->protocol)) return false;
2685  if (!this->roomInfo.Pack(buffer)) return false;
2686  return this->lobbyInfo.Pack(buffer);
2687  }
2692  inline bool Unpack(MunBuffer& buffer) {
2693  this->protocol = buffer.ReadUInt8();
2694  if (!this->roomInfo.Unpack(buffer)) return false;
2695  return this->lobbyInfo.Unpack(buffer);
2696  }
2697  };
2701  class MasterRoomCreateResponse
2702  {
2703  public:
2705  static const uint16 payloadType = MASTER_FUNCID_MASTER_ROOM_CREATERESULT;
2707  int32 result;
2709  AddressInfo roomAddressInfo;
2711  uint64 roomUid;
2715  MasterRoomCreateResponse() {
2716  this->result = 0;
2717  this->roomUid = 0;
2718  }
2725  MasterRoomCreateResponse(int32 _result, AddressInfo& _roomAddressInfo, uint64 _roomUid) {
2726  this->result = _result;
2727  this->roomAddressInfo = _roomAddressInfo;
2728  this->roomUid = _roomUid;
2729  }
2734  MasterRoomCreateResponse& operator = (const MasterRoomCreateResponse& rRef) {
2735  this->result = rRef.result;
2736  this->roomAddressInfo = rRef.roomAddressInfo;
2737  this->roomUid = rRef.roomUid;
2738  return *this;
2739  }
2744  inline uint32 Size() {
2745  uint32 byteLen = 0;
2746  byteLen += sizeof(this->result);
2747  byteLen += this->roomAddressInfo.Size();
2748  byteLen += sizeof(this->roomUid);
2749  return byteLen;
2750  }
2755  inline bool Pack(MunBuffer& buffer) {
2756  if (!buffer.WriteInt32(this->result)) return false;
2757  if (!this->roomAddressInfo.Pack(buffer)) return false;
2758  return buffer.WriteUInt64(this->roomUid);
2759  }
2764  inline bool Unpack(MunBuffer& buffer) {
2765  this->result = buffer.ReadInt32();
2766  if (!this->roomAddressInfo.Unpack(buffer)) return false;
2767  this->roomUid = buffer.ReadUInt64();
2768  return true;
2769  }
2770  };
2774  class MasterRoomForceJoinRequest
2775  {
2776  public:
2778  static const uint16 payloadType = MASTER_FUNCID_MASTER_ROOM_FORCEJOIN;
2780  uint8 protocol;
2782  CreateRoomInfo roomInfo;
2784  CreateLobbyInfo lobbyInfo;
2788  MasterRoomForceJoinRequest() {
2789  this->protocol = 0;
2790  }
2797  MasterRoomForceJoinRequest(uint8 _protocol, CreateRoomInfo& _roomInfo, CreateLobbyInfo& _lobbyInfo) {
2798  this->protocol = _protocol;
2799  this->roomInfo = _roomInfo;
2800  this->lobbyInfo = _lobbyInfo;
2801  }
2806  MasterRoomForceJoinRequest& operator = (const MasterRoomForceJoinRequest& rRef) {
2807  this->protocol = rRef.protocol;
2808  this->roomInfo = rRef.roomInfo;
2809  this->lobbyInfo = rRef.lobbyInfo;
2810  return *this;
2811  }
2816  inline uint32 Size() {
2817  uint32 byteLen = 0;
2818  byteLen += sizeof(this->protocol);
2819  byteLen += this->roomInfo.Size();
2820  byteLen += this->lobbyInfo.Size();
2821  return byteLen;
2822  }
2827  inline bool Pack(MunBuffer& buffer) {
2828  if (!buffer.WriteUInt8(this->protocol)) return false;
2829  if (!this->roomInfo.Pack(buffer)) return false;
2830  return this->lobbyInfo.Pack(buffer);
2831  }
2836  inline bool Unpack(MunBuffer& buffer) {
2837  this->protocol = buffer.ReadUInt8();
2838  if (!this->roomInfo.Unpack(buffer)) return false;
2839  return this->lobbyInfo.Unpack(buffer);
2840  }
2841  };
2845  class MasterRoomForceJoinResponse
2846  {
2847  public:
2849  static const uint16 payloadType = MASTER_FUNCID_MASTER_ROOM_FORCEJOINRESULT;
2851  int32 result;
2853  AddressInfo roomAddressInfo;
2855  uint64 roomUid;
2859  MasterRoomForceJoinResponse() {
2860  this->result = 0;
2861  this->roomUid = 0;
2862  }
2869  MasterRoomForceJoinResponse(int32 _result, AddressInfo& _roomAddressInfo, uint64 _roomUid) {
2870  this->result = _result;
2871  this->roomAddressInfo = _roomAddressInfo;
2872  this->roomUid = _roomUid;
2873  }
2878  MasterRoomForceJoinResponse& operator = (const MasterRoomForceJoinResponse& rRef) {
2879  this->result = rRef.result;
2880  this->roomAddressInfo = rRef.roomAddressInfo;
2881  this->roomUid = rRef.roomUid;
2882  return *this;
2883  }
2888  inline uint32 Size() {
2889  uint32 byteLen = 0;
2890  byteLen += sizeof(this->result);
2891  byteLen += this->roomAddressInfo.Size();
2892  byteLen += sizeof(this->roomUid);
2893  return byteLen;
2894  }
2899  inline bool Pack(MunBuffer& buffer) {
2900  if (!buffer.WriteInt32(this->result)) return false;
2901  if (!this->roomAddressInfo.Pack(buffer)) return false;
2902  return buffer.WriteUInt64(this->roomUid);
2903  }
2908  inline bool Unpack(MunBuffer& buffer) {
2909  this->result = buffer.ReadInt32();
2910  if (!this->roomAddressInfo.Unpack(buffer)) return false;
2911  this->roomUid = buffer.ReadUInt64();
2912  return true;
2913  }
2914  };
2918  class MasterRoomJoinRequest
2919  {
2920  public:
2922  static const uint16 payloadType = MASTER_FUNCID_MASTER_ROOM_JOIN;
2924  uint8 protocol;
2926  Text roomName;
2928  KeyValue playerParameters[PLAYER_PARAMETERS_MAX];
2930  uint16 playerParametersLen;
2934  MasterRoomJoinRequest() {
2935  this->protocol = 0;
2936  this->playerParametersLen = 0;
2937  }
2945  MasterRoomJoinRequest(uint8 _protocol, Text& _roomName, KeyValue* _playerParameters, uint16 _playerParametersLen) {
2946  assert(_playerParametersLen <= PLAYER_PARAMETERS_MAX);
2947  this->protocol = _protocol;
2948  this->roomName = _roomName;
2949  this->playerParametersLen = _playerParametersLen;
2950  for (uint16 index = 0; index < this->playerParametersLen; ++index) {
2951  this->playerParameters[index] = _playerParameters[index];
2952  }
2953  }
2958  MasterRoomJoinRequest& operator = (const MasterRoomJoinRequest& rRef) {
2959  assert(rRef.playerParametersLen <= PLAYER_PARAMETERS_MAX);
2960  this->protocol = rRef.protocol;
2961  this->roomName = rRef.roomName;
2962  this->playerParametersLen = rRef.playerParametersLen;
2963  for (uint16 index = 0; index < this->playerParametersLen; ++index) {
2964  this->playerParameters[index] = rRef.playerParameters[index];
2965  }
2966  return *this;
2967  }
2972  inline uint32 Size() {
2973  uint32 byteLen = 0;
2974  byteLen += sizeof(this->protocol);
2975  byteLen += this->roomName.Size();
2976  byteLen += sizeof(this->playerParametersLen);
2977  for (uint16 index = 0; index < this->playerParametersLen; ++index) {
2978  byteLen += this->playerParameters[index].Size();
2979  }
2980  return byteLen;
2981  }
2986  inline bool Pack(MunBuffer& buffer) {
2987  if (this->playerParametersLen > PLAYER_PARAMETERS_MAX) {
2988  return false;
2989  }
2990  if (!buffer.WriteUInt8(this->protocol)) return false;
2991  if (!this->roomName.Pack(buffer)) return false;
2992  if (!buffer.WriteUInt16(this->playerParametersLen)) return false;
2993  for (uint16 index = 0; index < this->playerParametersLen; ++index) {
2994  if (!this->playerParameters[index].Pack(buffer)) return false;
2995  }
2996  return true;
2997  }
3002  inline bool Unpack(MunBuffer& buffer) {
3003  this->protocol = buffer.ReadUInt8();
3004  if (!this->roomName.Unpack(buffer)) return false;
3005  this->playerParametersLen = buffer.ReadUInt16();
3006  if (this->playerParametersLen > PLAYER_PARAMETERS_MAX) {
3007  return false;
3008  }
3009  for (uint16 index = 0; index < this->playerParametersLen; ++index) {
3010  if (!this->playerParameters[index].Unpack(buffer)) return false;
3011  }
3012  return true;
3013  }
3014  };
3018  class MasterRoomJoinResponse
3019  {
3020  public:
3022  static const uint16 payloadType = MASTER_FUNCID_MASTER_ROOM_JOINRESULT;
3024  int32 result;
3026  AddressInfo roomAddressInfo;
3028  uint64 roomUid;
3032  MasterRoomJoinResponse() {
3033  this->result = 0;
3034  this->roomUid = 0;
3035  }
3042  MasterRoomJoinResponse(int32 _result, AddressInfo& _roomAddressInfo, uint64 _roomUid) {
3043  this->result = _result;
3044  this->roomAddressInfo = _roomAddressInfo;
3045  this->roomUid = _roomUid;
3046  }
3051  MasterRoomJoinResponse& operator = (const MasterRoomJoinResponse& rRef) {
3052  this->result = rRef.result;
3053  this->roomAddressInfo = rRef.roomAddressInfo;
3054  this->roomUid = rRef.roomUid;
3055  return *this;
3056  }
3061  inline uint32 Size() {
3062  uint32 byteLen = 0;
3063  byteLen += sizeof(this->result);
3064  byteLen += this->roomAddressInfo.Size();
3065  byteLen += sizeof(this->roomUid);
3066  return byteLen;
3067  }
3072  inline bool Pack(MunBuffer& buffer) {
3073  if (!buffer.WriteInt32(this->result)) return false;
3074  if (!this->roomAddressInfo.Pack(buffer)) return false;
3075  return buffer.WriteUInt64(this->roomUid);
3076  }
3081  inline bool Unpack(MunBuffer& buffer) {
3082  this->result = buffer.ReadInt32();
3083  if (!this->roomAddressInfo.Unpack(buffer)) return false;
3084  this->roomUid = buffer.ReadUInt64();
3085  return true;
3086  }
3087  };
3091  class MasterRoomRandomJoinRequest
3092  {
3093  public:
3095  static const uint16 payloadType = MASTER_FUNCID_MASTER_ROOM_RANDOMJOIN;
3097  uint8 protocol;
3099  uint32 maxPlayers;
3101  uint8 matchingMode;
3103  LobbyInfo lobbyInfo;
3105  Text keyValueFilter;
3107  KeyValue roomParameters[ROOM_PARAMETERS_MAX];
3109  uint16 roomParametersLen;
3111  KeyValue playerParameters[PLAYER_PARAMETERS_MAX];
3113  uint16 playerParametersLen;
3117  MasterRoomRandomJoinRequest() {
3118  this->protocol = 0;
3119  this->maxPlayers = 0;
3120  this->matchingMode = 0;
3121  this->roomParametersLen = 0;
3122  this->playerParametersLen = 0;
3123  }
3136  MasterRoomRandomJoinRequest(uint8 _protocol, uint32 _maxPlayers, uint8 _matchingMode, LobbyInfo& _lobbyInfo, Text& _keyValueFilter, KeyValue* _roomParameters, uint16 _roomParametersLen, KeyValue* _playerParameters, uint16 _playerParametersLen) {
3137  assert(_roomParametersLen <= ROOM_PARAMETERS_MAX);
3138  assert(_playerParametersLen <= PLAYER_PARAMETERS_MAX);
3139  this->protocol = _protocol;
3140  this->maxPlayers = _maxPlayers;
3141  this->matchingMode = _matchingMode;
3142  this->lobbyInfo = _lobbyInfo;
3143  this->keyValueFilter = _keyValueFilter;
3144  this->roomParametersLen = _roomParametersLen;
3145  for (uint16 index = 0; index < this->roomParametersLen; ++index) {
3146  this->roomParameters[index] = _roomParameters[index];
3147  }
3148  this->playerParametersLen = _playerParametersLen;
3149  for (uint16 index = 0; index < this->playerParametersLen; ++index) {
3150  this->playerParameters[index] = _playerParameters[index];
3151  }
3152  }
3157  MasterRoomRandomJoinRequest& operator = (const MasterRoomRandomJoinRequest& rRef) {
3158  assert(rRef.roomParametersLen <= ROOM_PARAMETERS_MAX);
3159  assert(rRef.playerParametersLen <= PLAYER_PARAMETERS_MAX);
3160  this->protocol = rRef.protocol;
3161  this->maxPlayers = rRef.maxPlayers;
3162  this->matchingMode = rRef.matchingMode;
3163  this->lobbyInfo = rRef.lobbyInfo;
3164  this->keyValueFilter = rRef.keyValueFilter;
3165  this->roomParametersLen = rRef.roomParametersLen;
3166  for (uint16 index = 0; index < this->roomParametersLen; ++index) {
3167  this->roomParameters[index] = rRef.roomParameters[index];
3168  }
3169  this->playerParametersLen = rRef.playerParametersLen;
3170  for (uint16 index = 0; index < this->playerParametersLen; ++index) {
3171  this->playerParameters[index] = rRef.playerParameters[index];
3172  }
3173  return *this;
3174  }
3179  inline uint32 Size() {
3180  uint32 byteLen = 0;
3181  byteLen += sizeof(this->protocol);
3182  byteLen += sizeof(this->maxPlayers);
3183  byteLen += sizeof(this->matchingMode);
3184  byteLen += this->lobbyInfo.Size();
3185  byteLen += this->keyValueFilter.Size();
3186  byteLen += sizeof(this->roomParametersLen);
3187  for (uint16 index = 0; index < this->roomParametersLen; ++index) {
3188  byteLen += this->roomParameters[index].Size();
3189  }
3190  byteLen += sizeof(this->playerParametersLen);
3191  for (uint16 index = 0; index < this->playerParametersLen; ++index) {
3192  byteLen += this->playerParameters[index].Size();
3193  }
3194  return byteLen;
3195  }
3200  inline bool Pack(MunBuffer& buffer) {
3201  if (this->roomParametersLen > ROOM_PARAMETERS_MAX) {
3202  return false;
3203  }
3204  if (this->playerParametersLen > PLAYER_PARAMETERS_MAX) {
3205  return false;
3206  }
3207  if (!buffer.WriteUInt8(this->protocol)) return false;
3208  if (!buffer.WriteUInt32(this->maxPlayers)) return false;
3209  if (!buffer.WriteUInt8(this->matchingMode)) return false;
3210  if (!this->lobbyInfo.Pack(buffer)) return false;
3211  if (!this->keyValueFilter.Pack(buffer)) return false;
3212  if (!buffer.WriteUInt16(this->roomParametersLen)) return false;
3213  for (uint16 index = 0; index < this->roomParametersLen; ++index) {
3214  if (!this->roomParameters[index].Pack(buffer)) return false;
3215  }
3216  if (!buffer.WriteUInt16(this->playerParametersLen)) return false;
3217  for (uint16 index = 0; index < this->playerParametersLen; ++index) {
3218  if (!this->playerParameters[index].Pack(buffer)) return false;
3219  }
3220  return true;
3221  }
3226  inline bool Unpack(MunBuffer& buffer) {
3227  this->protocol = buffer.ReadUInt8();
3228  this->maxPlayers = buffer.ReadUInt32();
3229  this->matchingMode = buffer.ReadUInt8();
3230  if (!this->lobbyInfo.Unpack(buffer)) return false;
3231  if (!this->keyValueFilter.Unpack(buffer)) return false;
3232  this->roomParametersLen = buffer.ReadUInt16();
3233  if (this->roomParametersLen > ROOM_PARAMETERS_MAX) {
3234  return false;
3235  }
3236  for (uint16 index = 0; index < this->roomParametersLen; ++index) {
3237  if (!this->roomParameters[index].Unpack(buffer)) return false;
3238  }
3239  this->playerParametersLen = buffer.ReadUInt16();
3240  if (this->playerParametersLen > PLAYER_PARAMETERS_MAX) {
3241  return false;
3242  }
3243  for (uint16 index = 0; index < this->playerParametersLen; ++index) {
3244  if (!this->playerParameters[index].Unpack(buffer)) return false;
3245  }
3246  return true;
3247  }
3248  };
3252  class MasterRoomRandomJoinResponse
3253  {
3254  public:
3256  static const uint16 payloadType = MASTER_FUNCID_MASTER_ROOM_RANDOMJOINRESULT;
3258  int32 result;
3260  Text msg;
3262  AddressInfo roomAddressInfo;
3264  uint64 roomUid;
3268  MasterRoomRandomJoinResponse() {
3269  this->result = 0;
3270  this->roomUid = 0;
3271  }
3278  MasterRoomRandomJoinResponse(int32 _result, Text& _msg, AddressInfo& _roomAddressInfo, uint64 _roomUid) {
3279  this->result = _result;
3280  this->msg = _msg;
3281  this->roomAddressInfo = _roomAddressInfo;
3282  this->roomUid = _roomUid;
3283  }
3288  MasterRoomRandomJoinResponse& operator = (const MasterRoomRandomJoinResponse& rRef) {
3289  this->result = rRef.result;
3290  this->msg = rRef.msg;
3291  this->roomAddressInfo = rRef.roomAddressInfo;
3292  this->roomUid = rRef.roomUid;
3293  return *this;
3294  }
3299  inline uint32 Size() {
3300  uint32 byteLen = 0;
3301  byteLen += sizeof(this->result);
3302  byteLen += this->msg.Size();
3303  byteLen += this->roomAddressInfo.Size();
3304  byteLen += sizeof(this->roomUid);
3305  return byteLen;
3306  }
3311  inline bool Pack(MunBuffer& buffer) {
3312  if (!buffer.WriteInt32(this->result)) return false;
3313  if (!this->msg.Pack(buffer)) return false;
3314  if (!this->roomAddressInfo.Pack(buffer)) return false;
3315  return buffer.WriteUInt64(this->roomUid);
3316  }
3321  inline bool Unpack(MunBuffer& buffer) {
3322  this->result = buffer.ReadInt32();
3323  if (!this->msg.Unpack(buffer)) return false;
3324  if (!this->roomAddressInfo.Unpack(buffer)) return false;
3325  this->roomUid = buffer.ReadUInt64();
3326  return true;
3327  }
3328  };
3332  class MasterRoomLeaveResponse
3333  {
3334  public:
3336  static const uint16 payloadType = MASTER_FUNCID_MASTER_ROOM_LEAVERESULT;
3338  int32 result;
3340  SummaryRoomInfo roomInfo[ROOM_LIST_MAX];
3342  uint16 roomInfoLen;
3346  MasterRoomLeaveResponse() {
3347  this->result = 0;
3348  this->roomInfoLen = 0;
3349  }
3356  MasterRoomLeaveResponse(int32 _result, SummaryRoomInfo* _roomInfo, uint16 _roomInfoLen) {
3357  assert(_roomInfoLen <= ROOM_LIST_MAX);
3358  this->result = _result;
3359  this->roomInfoLen = _roomInfoLen;
3360  for (uint16 index = 0; index < this->roomInfoLen; ++index) {
3361  this->roomInfo[index] = _roomInfo[index];
3362  }
3363  }
3368  MasterRoomLeaveResponse& operator = (const MasterRoomLeaveResponse& rRef) {
3369  assert(rRef.roomInfoLen <= ROOM_LIST_MAX);
3370  this->result = rRef.result;
3371  this->roomInfoLen = rRef.roomInfoLen;
3372  for (uint16 index = 0; index < this->roomInfoLen; ++index) {
3373  this->roomInfo[index] = rRef.roomInfo[index];
3374  }
3375  return *this;
3376  }
3381  inline uint32 Size() {
3382  uint32 byteLen = 0;
3383  byteLen += sizeof(this->result);
3384  byteLen += sizeof(this->roomInfoLen);
3385  for (uint16 index = 0; index < this->roomInfoLen; ++index) {
3386  byteLen += this->roomInfo[index].Size();
3387  }
3388  return byteLen;
3389  }
3394  inline bool Pack(MunBuffer& buffer) {
3395  if (this->roomInfoLen > ROOM_LIST_MAX) {
3396  return false;
3397  }
3398  if (!buffer.WriteInt32(this->result)) return false;
3399  if (!buffer.WriteUInt16(this->roomInfoLen)) return false;
3400  for (uint16 index = 0; index < this->roomInfoLen; ++index) {
3401  if (!this->roomInfo[index].Pack(buffer)) return false;
3402  }
3403  return true;
3404  }
3409  inline bool Unpack(MunBuffer& buffer) {
3410  this->result = buffer.ReadUInt32();
3411  this->roomInfoLen = buffer.ReadUInt16();
3412  if (this->roomInfoLen > ROOM_LIST_MAX) {
3413  return false;
3414  }
3415  for (uint16 index = 0; index < this->roomInfoLen; ++index) {
3416  if (!this->roomInfo[index].Unpack(buffer)) return false;
3417  }
3418  return true;
3419  }
3420  };
3424  class MasterRoomUpdateMaxPlayersRequest
3425  {
3426  public:
3428  static const uint16 payloadType = MASTER_FUNCID_MASTER_ROOM_UPDATEMAXPLAYERS;
3430  uint32 maxPlayers;
3434  MasterRoomUpdateMaxPlayersRequest() {
3435  this->maxPlayers = 0;
3436  }
3441  MasterRoomUpdateMaxPlayersRequest(uint32 _maxPlayers) {
3442  this->maxPlayers = _maxPlayers;
3443  }
3448  MasterRoomUpdateMaxPlayersRequest& operator = (const MasterRoomUpdateMaxPlayersRequest& rRef) {
3449  this->maxPlayers = rRef.maxPlayers;
3450  return *this;
3451  }
3456  inline uint32 Size() {
3457  uint32 byteLen = 0;
3458  byteLen += sizeof(this->maxPlayers);
3459  return byteLen;
3460  }
3465  inline bool Pack(MunBuffer& buffer) {
3466  return buffer.WriteUInt32(this->maxPlayers);
3467  }
3472  inline bool Unpack(MunBuffer& buffer) {
3473  this->maxPlayers = buffer.ReadUInt32();
3474  return true;
3475  }
3476  };
3480  class MasterRoomUpdateMaxPlayersResponse
3481  {
3482  public:
3484  static const uint16 payloadType = MASTER_FUNCID_MASTER_ROOM_UPDATEMAXPLAYERSRESULT;
3486  uint32 maxPlayers;
3490  MasterRoomUpdateMaxPlayersResponse() {
3491  this->maxPlayers = 0;
3492  }
3497  MasterRoomUpdateMaxPlayersResponse(uint32 _maxPlayers) {
3498  this->maxPlayers = _maxPlayers;
3499  }
3504  MasterRoomUpdateMaxPlayersResponse& operator = (const MasterRoomUpdateMaxPlayersResponse& rRef) {
3505  this->maxPlayers = rRef.maxPlayers;
3506  return *this;
3507  }
3512  inline uint32 Size() {
3513  uint32 byteLen = 0;
3514  byteLen += sizeof(this->maxPlayers);
3515  return byteLen;
3516  }
3521  inline bool Pack(MunBuffer& buffer) {
3522  return buffer.WriteUInt32(this->maxPlayers);
3523  }
3528  inline bool Unpack(MunBuffer& buffer) {
3529  this->maxPlayers = buffer.ReadUInt32();
3530  return true;
3531  }
3532  };
3536  class MasterRoomUpdateIsVisibleRequest
3537  {
3538  public:
3540  static const uint16 payloadType = MASTER_FUNCID_MASTER_ROOM_UPDATEISVISIBLE;
3542  uint8 isVisible;
3546  MasterRoomUpdateIsVisibleRequest() {
3547  this->isVisible = 0;
3548  }
3553  MasterRoomUpdateIsVisibleRequest(uint8 _isVisible) {
3554  this->isVisible = _isVisible;
3555  }
3560  MasterRoomUpdateIsVisibleRequest& operator = (const MasterRoomUpdateIsVisibleRequest& rRef) {
3561  this->isVisible = rRef.isVisible;
3562  return *this;
3563  }
3568  inline uint32 Size() {
3569  uint32 byteLen = 0;
3570  byteLen += sizeof(this->isVisible);
3571  return byteLen;
3572  }
3577  inline bool Pack(MunBuffer& buffer) {
3578  return buffer.WriteUInt8(this->isVisible);
3579  }
3584  inline bool Unpack(MunBuffer& buffer) {
3585  this->isVisible = buffer.ReadUInt8();
3586  return true;
3587  }
3588  };
3592  class MasterRoomUpdateIsVisibleResponse
3593  {
3594  public:
3596  static const uint16 payloadType = MASTER_FUNCID_MASTER_ROOM_UPDATEISVISIBLERESULT;
3598  uint8 isVisible;
3602  MasterRoomUpdateIsVisibleResponse() {
3603  this->isVisible = 0;
3604  }
3609  MasterRoomUpdateIsVisibleResponse(uint8 _isVisible) {
3610  this->isVisible = _isVisible;
3611  }
3616  MasterRoomUpdateIsVisibleResponse& operator = (const MasterRoomUpdateIsVisibleResponse& rRef) {
3617  this->isVisible = rRef.isVisible;
3618  return *this;
3619  }
3624  inline uint32 Size() {
3625  uint32 byteLen = 0;
3626  byteLen += sizeof(this->isVisible);
3627  return byteLen;
3628  }
3633  inline bool Pack(MunBuffer& buffer) {
3634  return buffer.WriteUInt8(this->isVisible);
3635  }
3640  inline bool Unpack(MunBuffer& buffer) {
3641  this->isVisible = buffer.ReadUInt8();
3642  return true;
3643  }
3644  };
3648  class MasterRoomUpdateIsOpenRequest
3649  {
3650  public:
3652  static const uint16 payloadType = MASTER_FUNCID_MASTER_ROOM_UPDATEISOPEN;
3654  uint8 isOpen;
3658  MasterRoomUpdateIsOpenRequest() {
3659  this->isOpen = 0;
3660  }
3665  MasterRoomUpdateIsOpenRequest(uint8 _isOpen) {
3666  this->isOpen = _isOpen;
3667  }
3672  MasterRoomUpdateIsOpenRequest& operator = (const MasterRoomUpdateIsOpenRequest& rRef) {
3673  this->isOpen = rRef.isOpen;
3674  return *this;
3675  }
3680  inline uint32 Size() {
3681  uint32 byteLen = 0;
3682  byteLen += sizeof(this->isOpen);
3683  return byteLen;
3684  }
3689  inline bool Pack(MunBuffer& buffer) {
3690  return buffer.WriteUInt8(this->isOpen);
3691  }
3696  inline bool Unpack(MunBuffer& buffer) {
3697  this->isOpen = buffer.ReadUInt8();
3698  return true;
3699  }
3700  };
3704  class MasterRoomUpdateIsOpenResponse
3705  {
3706  public:
3708  static const uint16 payloadType = MASTER_FUNCID_MASTER_ROOM_UPDATEISOPENRESULT;
3710  uint8 isOpen;
3714  MasterRoomUpdateIsOpenResponse() {
3715  this->isOpen = 0;
3716  }
3721  MasterRoomUpdateIsOpenResponse(uint8 _isOpen) {
3722  this->isOpen = _isOpen;
3723  }
3728  MasterRoomUpdateIsOpenResponse& operator = (const MasterRoomUpdateIsOpenResponse& rRef) {
3729  this->isOpen = rRef.isOpen;
3730  return *this;
3731  }
3736  inline uint32 Size() {
3737  uint32 byteLen = 0;
3738  byteLen += sizeof(this->isOpen);
3739  return byteLen;
3740  }
3745  inline bool Pack(MunBuffer& buffer) {
3746  return buffer.WriteUInt8(this->isOpen);
3747  }
3752  inline bool Unpack(MunBuffer& buffer) {
3753  this->isOpen = buffer.ReadUInt8();
3754  return true;
3755  }
3756  };
3760  class MasterRoomUpdateRoomParametersRequest
3761  {
3762  public:
3764  static const uint16 payloadType = MASTER_FUNCID_MASTER_ROOM_UPDATEROOMPARAMETERS;
3766  KeyValue roomParameters[ROOM_PARAMETERS_MAX];
3768  uint16 roomParametersLen;
3772  MasterRoomUpdateRoomParametersRequest() {
3773  this->roomParametersLen = 0;
3774  }
3780  MasterRoomUpdateRoomParametersRequest(KeyValue* _roomParameters, uint16 _roomParametersLen) {
3781  assert(_roomParametersLen <= ROOM_PARAMETERS_MAX);
3782  this->roomParametersLen = _roomParametersLen;
3783  for (uint16 index = 0; index < this->roomParametersLen; ++index) {
3784  this->roomParameters[index] = _roomParameters[index];
3785  }
3786  }
3791  MasterRoomUpdateRoomParametersRequest& operator = (const MasterRoomUpdateRoomParametersRequest& rRef) {
3792  assert(rRef.roomParametersLen <= ROOM_PARAMETERS_MAX);
3793  this->roomParametersLen = rRef.roomParametersLen;
3794  for (uint16 index = 0; index < this->roomParametersLen; ++index) {
3795  this->roomParameters[index] = rRef.roomParameters[index];
3796  }
3797  return *this;
3798  }
3803  inline uint32 Size() {
3804  uint32 byteLen = 0;
3805  byteLen += sizeof(this->roomParametersLen);
3806  for (uint16 index = 0; index < this->roomParametersLen; ++index) {
3807  byteLen += this->roomParameters[index].Size();
3808  }
3809  return byteLen;
3810  }
3815  inline bool Pack(MunBuffer& buffer) {
3816  if (this->roomParametersLen > ROOM_PARAMETERS_MAX) {
3817  return false;
3818  }
3819  if (!buffer.WriteUInt16(this->roomParametersLen)) return false;
3820  for (uint16 index = 0; index < this->roomParametersLen; ++index) {
3821  if (!this->roomParameters[index].Pack(buffer)) return false;
3822  }
3823  return true;
3824  }
3829  inline bool Unpack(MunBuffer& buffer) {
3830  this->roomParametersLen = buffer.ReadUInt16();
3831  if (this->roomParametersLen > ROOM_PARAMETERS_MAX) {
3832  return false;
3833  }
3834  for (uint16 index = 0; index < this->roomParametersLen; ++index) {
3835  if (!this->roomParameters[index].Unpack(buffer)) return false;
3836  }
3837  return true;
3838  }
3839  };
3843  class MasterRoomUpdateRoomParametersResponse
3844  {
3845  public:
3847  static const uint16 payloadType = MASTER_FUNCID_MASTER_ROOM_UPDATEROOMPARAMETERSRESULT;
3849  KeyValue roomParameters[ROOM_PARAMETERS_MAX];
3851  uint16 roomParametersLen;
3855  MasterRoomUpdateRoomParametersResponse() {
3856  this->roomParametersLen = 0;
3857  }
3863  MasterRoomUpdateRoomParametersResponse(KeyValue* _roomParameters, uint16 _roomParametersLen) {
3864  assert(_roomParametersLen <= ROOM_PARAMETERS_MAX);
3865  this->roomParametersLen = _roomParametersLen;
3866  for (uint16 index = 0; index < this->roomParametersLen; ++index) {
3867  this->roomParameters[index] = _roomParameters[index];
3868  }
3869  }
3874  MasterRoomUpdateRoomParametersResponse& operator = (const MasterRoomUpdateRoomParametersResponse& rRef) {
3875  assert(rRef.roomParametersLen <= ROOM_PARAMETERS_MAX);
3876  this->roomParametersLen = rRef.roomParametersLen;
3877  for (uint16 index = 0; index < this->roomParametersLen; ++index) {
3878  this->roomParameters[index] = rRef.roomParameters[index];
3879  }
3880  return *this;
3881  }
3886  inline uint32 Size() {
3887  uint32 byteLen = 0;
3888  byteLen += sizeof(this->roomParametersLen);
3889  for (uint16 index = 0; index < this->roomParametersLen; ++index) {
3890  byteLen += this->roomParameters[index].Size();
3891  }
3892  return byteLen;
3893  }
3898  inline bool Pack(MunBuffer& buffer) {
3899  if (this->roomParametersLen > ROOM_PARAMETERS_MAX) {
3900  return false;
3901  }
3902  if (!buffer.WriteUInt16(this->roomParametersLen)) return false;
3903  for (uint16 index = 0; index < this->roomParametersLen; ++index) {
3904  if (!this->roomParameters[index].Pack(buffer)) return false;
3905  }
3906  return true;
3907  }
3912  inline bool Unpack(MunBuffer& buffer) {
3913  this->roomParametersLen = buffer.ReadUInt16();
3914  if (this->roomParametersLen > ROOM_PARAMETERS_MAX) {
3915  return false;
3916  }
3917  for (uint16 index = 0; index < this->roomParametersLen; ++index) {
3918  if (!this->roomParameters[index].Unpack(buffer)) return false;
3919  }
3920  return true;
3921  }
3922  };
3926  class MasterRoomUpdateLobbyParametersRequest
3927  {
3928  public:
3930  static const uint16 payloadType = MASTER_FUNCID_MASTER_ROOM_UPDATELOBBYPARAMETERS;
3932  Text lobbyParameters[LOBBY_PARAMETERS_MAX];
3934  uint16 lobbyParametersLen;
3938  MasterRoomUpdateLobbyParametersRequest() {
3939  this->lobbyParametersLen = 0;
3940  }
3946  MasterRoomUpdateLobbyParametersRequest(Text* _lobbyParameters, uint16 _lobbyParametersLen) {
3947  assert(_lobbyParametersLen <= LOBBY_PARAMETERS_MAX);
3948  this->lobbyParametersLen = _lobbyParametersLen;
3949  for (uint16 index = 0; index < this->lobbyParametersLen; ++index) {
3950  this->lobbyParameters[index] = _lobbyParameters[index];
3951  }
3952  }
3957  MasterRoomUpdateLobbyParametersRequest& operator = (const MasterRoomUpdateLobbyParametersRequest& rRef) {
3958  assert(rRef.lobbyParametersLen <= LOBBY_PARAMETERS_MAX);
3959  this->lobbyParametersLen = rRef.lobbyParametersLen;
3960  for (uint16 index = 0; index < this->lobbyParametersLen; ++index) {
3961  this->lobbyParameters[index] = rRef.lobbyParameters[index];
3962  }
3963  return *this;
3964  }
3969  inline uint32 Size() {
3970  uint32 byteLen = 0;
3971  byteLen += sizeof(this->lobbyParametersLen);
3972  for (uint16 index = 0; index < this->lobbyParametersLen; ++index) {
3973  byteLen += this->lobbyParameters[index].Size();
3974  }
3975  return byteLen;
3976  }
3981  inline bool Pack(MunBuffer& buffer) {
3982  if (this->lobbyParametersLen > LOBBY_PARAMETERS_MAX) {
3983  return false;
3984  }
3985  if (!buffer.WriteUInt16(this->lobbyParametersLen)) return false;
3986  for (uint16 index = 0; index < this->lobbyParametersLen; ++index) {
3987  if (!this->lobbyParameters[index].Pack(buffer)) return false;
3988  }
3989  return true;
3990  }
3995  inline bool Unpack(MunBuffer& buffer) {
3996  this->lobbyParametersLen = buffer.ReadUInt16();
3997  if (this->lobbyParametersLen > LOBBY_PARAMETERS_MAX) {
3998  return false;
3999  }
4000  for (uint16 index = 0; index < this->lobbyParametersLen; ++index) {
4001  if (!this->lobbyParameters[index].Unpack(buffer)) return false;
4002  }
4003  return true;
4004  }
4005  };
4009  class MasterRoomUpdateLobbyParametersResponse
4010  {
4011  public:
4013  static const uint16 payloadType = MASTER_FUNCID_MASTER_ROOM_UPDATELOBBYPARAMETERSRESULT;
4015  Text lobbyParameters[LOBBY_PARAMETERS_MAX];
4017  uint16 lobbyParametersLen;
4021  MasterRoomUpdateLobbyParametersResponse() {
4022  this->lobbyParametersLen = 0;
4023  }
4029  MasterRoomUpdateLobbyParametersResponse(Text* _lobbyParameters, uint16 _lobbyParametersLen) {
4030  assert(_lobbyParametersLen <= LOBBY_PARAMETERS_MAX);
4031  this->lobbyParametersLen = _lobbyParametersLen;
4032  for (uint16 index = 0; index < this->lobbyParametersLen; ++index) {
4033  this->lobbyParameters[index] = _lobbyParameters[index];
4034  }
4035  }
4040  MasterRoomUpdateLobbyParametersResponse& operator = (const MasterRoomUpdateLobbyParametersResponse& rRef) {
4041  assert(rRef.lobbyParametersLen <= LOBBY_PARAMETERS_MAX);
4042  this->lobbyParametersLen = rRef.lobbyParametersLen;
4043  for (uint16 index = 0; index < this->lobbyParametersLen; ++index) {
4044  this->lobbyParameters[index] = rRef.lobbyParameters[index];
4045  }
4046  return *this;
4047  }
4052  inline uint32 Size() {
4053  uint32 byteLen = 0;
4054  byteLen += sizeof(this->lobbyParametersLen);
4055  for (uint16 index = 0; index < this->lobbyParametersLen; ++index) {
4056  byteLen += this->lobbyParameters[index].Size();
4057  }
4058  return byteLen;
4059  }
4064  inline bool Pack(MunBuffer& buffer) {
4065  if (this->lobbyParametersLen > LOBBY_PARAMETERS_MAX) {
4066  return false;
4067  }
4068  if (!buffer.WriteUInt16(this->lobbyParametersLen)) return false;
4069  for (uint16 index = 0; index < this->lobbyParametersLen; ++index) {
4070  if (!this->lobbyParameters[index].Pack(buffer)) return false;
4071  }
4072  return true;
4073  }
4078  inline bool Unpack(MunBuffer& buffer) {
4079  this->lobbyParametersLen = buffer.ReadUInt16();
4080  if (this->lobbyParametersLen > LOBBY_PARAMETERS_MAX) {
4081  return false;
4082  }
4083  for (uint16 index = 0; index < this->lobbyParametersLen; ++index) {
4084  if (!this->lobbyParameters[index].Unpack(buffer)) return false;
4085  }
4086  return true;
4087  }
4088  };
4092  class MasterRoomUpdateResponse
4093  {
4094  public:
4096  static const uint16 payloadType = MASTER_FUNCID_MASTER_ROOM_UPDATERESULT;
4098  SummaryRoomInfo roomInfo;
4100  uint8 isRemove;
4104  MasterRoomUpdateResponse() {
4105  this->isRemove = 0;
4106  }
4112  MasterRoomUpdateResponse(SummaryRoomInfo& _roomInfo, uint8 _isRemove) {
4113  this->roomInfo = _roomInfo;
4114  this->isRemove = _isRemove;
4115  }
4120  MasterRoomUpdateResponse& operator = (const MasterRoomUpdateResponse& rRef) {
4121  this->roomInfo = rRef.roomInfo;
4122  this->isRemove = rRef.isRemove;
4123  return *this;
4124  }
4129  inline uint32 Size() {
4130  uint32 byteLen = 0;
4131  byteLen += this->roomInfo.Size();
4132  byteLen += sizeof(this->isRemove);
4133  return byteLen;
4134  }
4139  inline bool Pack(MunBuffer& buffer) {
4140  if (!this->roomInfo.Pack(buffer)) return false;
4141  return buffer.WriteUInt8(this->isRemove);
4142  }
4147  inline bool Unpack(MunBuffer& buffer) {
4148  if (!this->roomInfo.Unpack(buffer)) return false;
4149  this->isRemove = buffer.ReadUInt8();
4150  return true;
4151  }
4152  };
4156  class MasterSearchPlayersRequest
4157  {
4158  public:
4160  static const uint16 payloadType = MASTER_FUNCID_MASTER_SEARCHPLAYERS;
4162  Text playerNames[PLAYER_MAX];
4164  uint32 playerNamesLen;
4168  MasterSearchPlayersRequest() {
4169  this->playerNamesLen = 0;
4170  }
4176  MasterSearchPlayersRequest(Text* _playerNames, uint32 _playerNamesLen) {
4177  assert(_playerNamesLen <= PLAYER_MAX);
4178  this->playerNamesLen = _playerNamesLen;
4179  for (uint32 index = 0; index < this->playerNamesLen; ++index) {
4180  this->playerNames[index] = _playerNames[index];
4181  }
4182  }
4187  MasterSearchPlayersRequest& operator = (const MasterSearchPlayersRequest& rRef) {
4188  assert(rRef.playerNamesLen <= PLAYER_MAX);
4189  this->playerNamesLen = rRef.playerNamesLen;
4190  for (uint32 index = 0; index < this->playerNamesLen; ++index) {
4191  this->playerNames[index] = rRef.playerNames[index];
4192  }
4193  return *this;
4194  }
4199  inline uint32 Size() {
4200  uint32 byteLen = 0;
4201  byteLen += sizeof(this->playerNamesLen);
4202  for (uint32 index = 0; index < this->playerNamesLen; ++index) {
4203  byteLen += this->playerNames[index].Size();
4204  }
4205  return byteLen;
4206  }
4211  inline bool Pack(MunBuffer& buffer) {
4212  if (this->playerNamesLen > PLAYER_MAX) {
4213  return false;
4214  }
4215  if (!buffer.WriteUInt32(this->playerNamesLen)) return false;
4216  for (uint32 index = 0; index < this->playerNamesLen; ++index) {
4217  if (!this->playerNames[index].Pack(buffer)) return false;
4218  }
4219  return true;
4220  }
4225  inline bool Unpack(MunBuffer& buffer) {
4226  this->playerNamesLen = buffer.ReadUInt32();
4227  if (this->playerNamesLen > PLAYER_MAX) {
4228  return false;
4229  }
4230  for (uint32 index = 0; index < this->playerNamesLen; ++index) {
4231  if (!this->playerNames[index].Unpack(buffer)) return false;
4232  }
4233  return true;
4234  }
4235  };
4239  class MasterSearchPlayersResponse
4240  {
4241  public:
4243  static const uint16 payloadType = MASTER_FUNCID_MASTER_SEARCHPLAYERSRESULT;
4245  SearchedPlayerInfo playerInfo[PLAYER_MAX];
4247  uint32 playerInfoLen;
4251  MasterSearchPlayersResponse() {
4252  this->playerInfoLen = 0;
4253  }
4259  MasterSearchPlayersResponse(SearchedPlayerInfo* _playerInfo, uint32 _playerInfoLen) {
4260  assert(_playerInfoLen <= PLAYER_MAX);
4261  this->playerInfoLen = _playerInfoLen;
4262  for (uint32 index = 0; index < this->playerInfoLen; ++index) {
4263  this->playerInfo[index] = _playerInfo[index];
4264  }
4265  }
4270  MasterSearchPlayersResponse& operator = (const MasterSearchPlayersResponse& rRef) {
4271  assert(rRef.playerInfoLen <= PLAYER_MAX);
4272  this->playerInfoLen = rRef.playerInfoLen;
4273  for (uint32 index = 0; index < this->playerInfoLen; ++index) {
4274  this->playerInfo[index] = rRef.playerInfo[index];
4275  }
4276  return *this;
4277  }
4282  inline uint32 Size() {
4283  uint32 byteLen = 0;
4284  byteLen += sizeof(this->playerInfoLen);
4285  for (uint32 index = 0; index < this->playerInfoLen; ++index) {
4286  byteLen += this->playerInfo[index].Size();
4287  }
4288  return byteLen;
4289  }
4294  inline bool Pack(MunBuffer& buffer) {
4295  if (this->playerInfoLen > PLAYER_MAX) {
4296  return false;
4297  }
4298  if (!buffer.WriteUInt32(this->playerInfoLen)) return false;
4299  for (uint32 index = 0; index < this->playerInfoLen; ++index) {
4300  if (!this->playerInfo[index].Pack(buffer)) return false;
4301  }
4302  return true;
4303  }
4308  inline bool Unpack(MunBuffer& buffer) {
4309  this->playerInfoLen = buffer.ReadUInt32();
4310  if (this->playerInfoLen > PLAYER_MAX) {
4311  return false;
4312  }
4313  for (uint32 index = 0; index < this->playerInfoLen; ++index) {
4314  if (!this->playerInfo[index].Unpack(buffer)) return false;
4315  }
4316  return true;
4317  }
4318  };
4322  class MasterStatsUpdateResponse
4323  {
4324  public:
4326  static const uint16 payloadType = MASTER_FUNCID_MASTER_STATS_UPDATERESULT;
4328  StatsInfo statsInfo;
4332  MasterStatsUpdateResponse() {
4333  }
4338  MasterStatsUpdateResponse(StatsInfo& _statsInfo) {
4339  this->statsInfo = _statsInfo;
4340  }
4345  MasterStatsUpdateResponse& operator = (const MasterStatsUpdateResponse& rRef) {
4346  this->statsInfo = rRef.statsInfo;
4347  return *this;
4348  }
4353  inline uint32 Size() {
4354  uint32 byteLen = 0;
4355  byteLen += this->statsInfo.Size();
4356  return byteLen;
4357  }
4362  inline bool Pack(MunBuffer& buffer) {
4363  return this->statsInfo.Pack(buffer);
4364  }
4369  inline bool Unpack(MunBuffer& buffer) {
4370  return this->statsInfo.Unpack(buffer);
4371  }
4372  };
4376  class MasterRoomUpdatePlayerParametersRequest
4377  {
4378  public:
4380  static const uint16 payloadType = MASTER_FUNCID_MASTER_ROOM_UPDATEPLAYERPARAMETERS;
4382  KeyValue playerParameters[PLAYER_PARAMETERS_MAX];
4384  uint16 playerParametersLen;
4388  MasterRoomUpdatePlayerParametersRequest() {
4389  this->playerParametersLen = 0;
4390  }
4396  MasterRoomUpdatePlayerParametersRequest(KeyValue* _playerParameters, uint16 _playerParametersLen) {
4397  assert(_playerParametersLen <= PLAYER_PARAMETERS_MAX);
4398  this->playerParametersLen = _playerParametersLen;
4399  for (uint16 index = 0; index < this->playerParametersLen; ++index) {
4400  this->playerParameters[index] = _playerParameters[index];
4401  }
4402  }
4407  MasterRoomUpdatePlayerParametersRequest& operator = (const MasterRoomUpdatePlayerParametersRequest& rRef) {
4408  assert(rRef.playerParametersLen <= PLAYER_PARAMETERS_MAX);
4409  this->playerParametersLen = rRef.playerParametersLen;
4410  for (uint16 index = 0; index < this->playerParametersLen; ++index) {
4411  this->playerParameters[index] = rRef.playerParameters[index];
4412  }
4413  return *this;
4414  }
4419  inline uint32 Size() {
4420  uint32 byteLen = 0;
4421  byteLen += sizeof(this->playerParametersLen);
4422  for (uint16 index = 0; index < this->playerParametersLen; ++index) {
4423  byteLen += this->playerParameters[index].Size();
4424  }
4425  return byteLen;
4426  }
4431  inline bool Pack(MunBuffer& buffer) {
4432  if (this->playerParametersLen > PLAYER_PARAMETERS_MAX) {
4433  return false;
4434  }
4435  if (!buffer.WriteUInt16(this->playerParametersLen)) return false;
4436  for (uint16 index = 0; index < this->playerParametersLen; ++index) {
4437  if (!this->playerParameters[index].Pack(buffer)) return false;
4438  }
4439  return true;
4440  }
4445  inline bool Unpack(MunBuffer& buffer) {
4446  this->playerParametersLen = buffer.ReadUInt16();
4447  if (this->playerParametersLen > PLAYER_PARAMETERS_MAX) {
4448  return false;
4449  }
4450  for (uint16 index = 0; index < this->playerParametersLen; ++index) {
4451  if (!this->playerParameters[index].Unpack(buffer)) return false;
4452  }
4453  return true;
4454  }
4455  };
4459  class MasterRoomUpdatePlayerParametersResponse
4460  {
4461  public:
4463  static const uint16 payloadType = MASTER_FUNCID_MASTER_ROOM_UPDATEPLAYERPARAMETERSRESULT;
4465  int32 playerId;
4467  KeyValue playerParameters[PLAYER_PARAMETERS_MAX];
4469  uint16 playerParametersLen;
4473  MasterRoomUpdatePlayerParametersResponse() {
4474  this->playerId = 0;
4475  this->playerParametersLen = 0;
4476  }
4483  MasterRoomUpdatePlayerParametersResponse(int32 _playerId, KeyValue* _playerParameters, uint16 _playerParametersLen) {
4484  assert(_playerParametersLen <= PLAYER_PARAMETERS_MAX);
4485  this->playerId = _playerId;
4486  this->playerParametersLen = _playerParametersLen;
4487  for (uint16 index = 0; index < this->playerParametersLen; ++index) {
4488  this->playerParameters[index] = _playerParameters[index];
4489  }
4490  }
4495  MasterRoomUpdatePlayerParametersResponse& operator = (const MasterRoomUpdatePlayerParametersResponse& rRef) {
4496  assert(rRef.playerParametersLen <= PLAYER_PARAMETERS_MAX);
4497  this->playerId = rRef.playerId;
4498  this->playerParametersLen = rRef.playerParametersLen;
4499  for (uint16 index = 0; index < this->playerParametersLen; ++index) {
4500  this->playerParameters[index] = rRef.playerParameters[index];
4501  }
4502  return *this;
4503  }
4508  inline uint32 Size() {
4509  uint32 byteLen = 0;
4510  byteLen += sizeof(this->playerId);
4511  byteLen += sizeof(this->playerParametersLen);
4512  for (uint16 index = 0; index < this->playerParametersLen; ++index) {
4513  byteLen += this->playerParameters[index].Size();
4514  }
4515  return byteLen;
4516  }
4521  inline bool Pack(MunBuffer& buffer) {
4522  if (!buffer.WriteInt32(this->playerId)) return false;
4523  if (this->playerParametersLen > PLAYER_PARAMETERS_MAX) {
4524  return false;
4525  }
4526  if (!buffer.WriteUInt16(this->playerParametersLen)) return false;
4527  for (uint16 index = 0; index < this->playerParametersLen; ++index) {
4528  if (!this->playerParameters[index].Pack(buffer)) return false;
4529  }
4530  return true;
4531  }
4536  inline bool Unpack(MunBuffer& buffer) {
4537  this->playerId = buffer.ReadInt32();
4538  this->playerParametersLen = buffer.ReadUInt16();
4539  if (this->playerParametersLen > PLAYER_PARAMETERS_MAX) {
4540  return false;
4541  }
4542  for (uint16 index = 0; index < this->playerParametersLen; ++index) {
4543  if (!this->playerParameters[index].Unpack(buffer)) return false;
4544  }
4545  return true;
4546  }
4547  };
4551  class MasterUpdatePlayerNameRequest
4552  {
4553  public:
4555  static const uint16 payloadType = MASTER_FUNCID_MASTER_UPDATEPLAYERNAME;
4557  Text playerName;
4561  MasterUpdatePlayerNameRequest() {
4562  }
4567  MasterUpdatePlayerNameRequest(Text& _playerName) {
4568  this->playerName = _playerName;
4569  }
4574  MasterUpdatePlayerNameRequest& operator = (const MasterUpdatePlayerNameRequest& rRef) {
4575  this->playerName = rRef.playerName;
4576  return *this;
4577  }
4582  inline uint32 Size() {
4583  uint32 byteLen = 0;
4584  byteLen += this->playerName.Size();
4585  return byteLen;
4586  }
4591  inline bool Pack(MunBuffer& buffer) {
4592  if (!this->playerName.Pack(buffer)) return false;
4593  return true;
4594  }
4599  inline bool Unpack(MunBuffer& buffer) {
4600  if (!this->playerName.Unpack(buffer)) return false;
4601  return true;
4602  }
4603  };
4607  class MasterUpdatePlayerNameResponse
4608  {
4609  public:
4611  static const uint16 payloadType = MASTER_FUNCID_MASTER_UPDATEPLAYERNAMERESULT;
4613  int32 playerId;
4615  Text playerName;
4619  MasterUpdatePlayerNameResponse() {
4620  this->playerId = 0;
4621  }
4627  MasterUpdatePlayerNameResponse(int32 _playerId, Text& _playerName) {
4628  this->playerId = _playerId;
4629  this->playerName = _playerName;
4630  }
4635  MasterUpdatePlayerNameResponse& operator = (const MasterUpdatePlayerNameResponse& rRef) {
4636  this->playerId = rRef.playerId;
4637  this->playerName = rRef.playerName;
4638  return *this;
4639  }
4644  inline uint32 Size() {
4645  uint32 byteLen = 0;
4646  byteLen += sizeof(this->playerId);
4647  byteLen += this->playerName.Size();
4648  return byteLen;
4649  }
4654  inline bool Pack(MunBuffer& buffer) {
4655  if (!buffer.WriteInt32(this->playerId)) return false;
4656  if (!this->playerName.Pack(buffer)) return false;
4657  return true;
4658  }
4663  inline bool Unpack(MunBuffer& buffer) {
4664  this->playerId = buffer.ReadInt32();
4665  if (!this->playerName.Unpack(buffer)) return false;
4666  return true;
4667  }
4668  };
4672  class RoomMasterSetAddressRequest
4673  {
4674  public:
4676  static const uint16 payloadType = ROOMMASTER_FUNCID_ROOMMASTER_SETADDRESS;
4678  uint64 roomUid;
4680  Text address;
4682  uint16 tcp_port;
4684  uint16 udp_port;
4686  uint16 ws_port;
4688  uint16 wss_port;
4692  RoomMasterSetAddressRequest() {
4693  this->roomUid = 0;
4694  this->address = Text("");
4695  this->tcp_port = 0;
4696  this->udp_port = 0;
4697  this->ws_port = 0;
4698  this->wss_port = 0;
4699  }
4709  RoomMasterSetAddressRequest(uint64 _roomUid, Text& _address, uint16 _tcp_port, uint16 _udp_port, uint16 _ws_port, uint16 _wss_port) {
4710  this->roomUid = _roomUid;
4711  this->address = Text(_address);
4712  this->tcp_port = _tcp_port;
4713  this->udp_port = _udp_port;
4714  this->ws_port = _ws_port;
4715  this->wss_port = _wss_port;
4716  }
4721  RoomMasterSetAddressRequest& operator = (const RoomMasterSetAddressRequest& rRef) {
4722  this->roomUid = rRef.roomUid;
4723  this->address = Text(rRef.address);
4724  this->tcp_port = rRef.tcp_port;
4725  this->udp_port = rRef.udp_port;
4726  this->ws_port = rRef.ws_port;
4727  this->wss_port = rRef.wss_port;
4728  return *this;
4729  }
4734  inline uint32 Size() {
4735  uint32 byteLen = 0;
4736  byteLen += sizeof(this->roomUid);
4737  byteLen += this->address.Size();
4738  byteLen += sizeof(this->tcp_port);
4739  byteLen += sizeof(this->udp_port);
4740  byteLen += sizeof(this->ws_port);
4741  byteLen += sizeof(this->wss_port);
4742  return byteLen;
4743  }
4748  inline bool Pack(MunBuffer& buffer) {
4749  if (!buffer.WriteUInt64(this->roomUid)) return false;
4750  if (!this->address.Pack(buffer)) return false;
4751  if (!buffer.WriteUInt16(this->tcp_port)) return false;
4752  if (!buffer.WriteUInt16(this->udp_port)) return false;
4753  if (!buffer.WriteUInt16(this->ws_port)) return false;
4754  if (!buffer.WriteUInt16(this->wss_port)) return false;
4755  return true;
4756  }
4761  inline bool Unpack(MunBuffer& buffer) {
4762  this->roomUid = buffer.ReadUInt64();
4763  if (!this->address.Unpack(buffer)) return false;
4764  this->tcp_port = buffer.ReadUInt16();
4765  this->udp_port = buffer.ReadUInt16();
4766  this->ws_port = buffer.ReadUInt16();
4767  this->wss_port = buffer.ReadUInt16();
4768  return true;
4769  }
4770  };
4774  class RoomMasterSetWeightRequest
4775  {
4776  public:
4778  static const uint16 payloadType = ROOMMASTER_FUNCID_ROOMMASTER_SETWEIGHT;
4780  uint64 roomUid;
4782  int32 weight;
4786  RoomMasterSetWeightRequest() {
4787  this->roomUid = 0;
4788  this->weight = 0;
4789  }
4795  RoomMasterSetWeightRequest(uint64 _roomUid, int32 _weight) {
4796  this->roomUid = _roomUid;
4797  this->weight = _weight;
4798  }
4803  RoomMasterSetWeightRequest& operator = (const RoomMasterSetWeightRequest& rRef) {
4804  this->roomUid = rRef.roomUid;
4805  this->weight = rRef.weight;
4806  return *this;
4807  }
4812  inline uint32 Size() {
4813  uint32 byteLen = 0;
4814  byteLen += sizeof(this->roomUid);
4815  byteLen += sizeof(this->weight);
4816  return byteLen;
4817  }
4822  inline bool Pack(MunBuffer& buffer) {
4823  if (!buffer.WriteUInt64(this->roomUid)) return false;
4824  return buffer.WriteInt32(this->weight);
4825  }
4830  inline bool Unpack(MunBuffer& buffer) {
4831  this->roomUid = buffer.ReadUInt64();
4832  this->weight = buffer.ReadInt32();
4833  return true;
4834  }
4835  };
4839  class RoomMasterLoginPlayerRequest
4840  {
4841  public:
4843  static const uint16 payloadType = ROOMMASTER_FUNCID_ROOMMASTER_LOGINPLAYER;
4845  uint32 clientUidForMasterServer;
4847  uint64 clientUidForProxyServer;
4851  RoomMasterLoginPlayerRequest() {
4852  this->clientUidForMasterServer = 0;
4853  this->clientUidForProxyServer = 0;
4854  }
4860  RoomMasterLoginPlayerRequest(uint32 _clientUidForMasterServer, uint64 _clientUidForProxyServer) {
4861  this->clientUidForMasterServer = _clientUidForMasterServer;
4862  this->clientUidForProxyServer = _clientUidForProxyServer;
4863  }
4868  RoomMasterLoginPlayerRequest& operator = (const RoomMasterLoginPlayerRequest& rRef) {
4869  this->clientUidForMasterServer = rRef.clientUidForMasterServer;
4870  this->clientUidForProxyServer = rRef.clientUidForProxyServer;
4871  return *this;
4872  }
4877  inline uint32 Size() {
4878  uint32 byteLen = 0;
4879  byteLen += sizeof(this->clientUidForMasterServer);
4880  byteLen += sizeof(this->clientUidForProxyServer);
4881  return byteLen;
4882  }
4887  inline bool Pack(MunBuffer& buffer) {
4888  if (!buffer.WriteUInt32(this->clientUidForMasterServer)) return false;
4889  return buffer.WriteUInt64(this->clientUidForProxyServer);
4890  }
4895  inline bool Unpack(MunBuffer& buffer) {
4896  this->clientUidForMasterServer = buffer.ReadUInt32();
4897  this->clientUidForProxyServer = buffer.ReadUInt64();
4898  return true;
4899  }
4900  };
4904  class RoomMasterLoginPlayerResponse
4905  {
4906  public:
4908  static const uint16 payloadType = ROOMMASTER_FUNCID_ROOMMASTER_LOGINPLAYERRESULT;
4910  uint32 clientUidForMasterServer;
4912  uint64 clientUidForProxyServer;
4914  int32 result;
4916  uint64 roomId;
4918  RoomInfo roomInfo;
4920  PlayerInfo playerInfo;
4922  uint8 isNeedHostPlayer;
4926  RoomMasterLoginPlayerResponse() {
4927  this->clientUidForMasterServer = 0;
4928  this->clientUidForProxyServer = 0;
4929  this->result = 0;
4930  this->roomId = 0;
4931  this->isNeedHostPlayer = 1;
4932  }
4943  RoomMasterLoginPlayerResponse(uint32 _clientUidForMasterServer, uint64 _clientUidForProxyServer, int32 _result, uint64 _roomId, RoomInfo& _roomInfo, PlayerInfo& _playerInfo, uint8 _isNeedHostPlayer) {
4944  this->clientUidForMasterServer = _clientUidForMasterServer;
4945  this->clientUidForProxyServer = _clientUidForProxyServer;
4946  this->result = _result;
4947  this->roomId = _roomId;
4948  this->roomInfo = _roomInfo;
4949  this->playerInfo = _playerInfo;
4950  this->isNeedHostPlayer = _isNeedHostPlayer;
4951  }
4956  RoomMasterLoginPlayerResponse& operator = (const RoomMasterLoginPlayerResponse& rRef) {
4957  this->clientUidForMasterServer = rRef.clientUidForMasterServer;
4958  this->clientUidForProxyServer = rRef.clientUidForProxyServer;
4959  this->result = rRef.result;
4960  this->roomId = rRef.roomId;
4961  this->roomInfo = rRef.roomInfo;
4962  this->playerInfo = rRef.playerInfo;
4963  this->isNeedHostPlayer = rRef.isNeedHostPlayer;
4964  return *this;
4965  }
4970  inline uint32 Size() {
4971  uint32 byteLen = 0;
4972  byteLen += sizeof(this->clientUidForMasterServer);
4973  byteLen += sizeof(this->clientUidForProxyServer);
4974  byteLen += sizeof(this->result);
4975  byteLen += sizeof(this->roomId);
4976  byteLen += this->roomInfo.Size();
4977  byteLen += this->playerInfo.Size();
4978  byteLen += sizeof( this->isNeedHostPlayer );
4979  return byteLen;
4980  }
4985  inline bool Pack(MunBuffer& buffer) {
4986  if (!buffer.WriteUInt32(this->clientUidForMasterServer)) return false;
4987  if (!buffer.WriteUInt64(this->clientUidForProxyServer)) return false;
4988  if (!buffer.WriteInt32(this->result)) return false;
4989  if (!buffer.WriteUInt64(this->roomId)) return false;
4990  if (!this->roomInfo.Pack(buffer)) return false;
4991  if (!this->playerInfo.Pack(buffer)) return false;
4992  if (!buffer.WriteUInt8(this->isNeedHostPlayer)) return false;
4993  return true;
4994  }
4999  inline bool Unpack(MunBuffer& buffer) {
5000  this->clientUidForMasterServer = buffer.ReadUInt32();
5001  this->clientUidForProxyServer = buffer.ReadUInt64();
5002  this->result = buffer.ReadInt32();
5003  this->roomId = buffer.ReadUInt64();
5004  if (!this->roomInfo.Unpack(buffer)) return false;
5005  if (!this->playerInfo.Unpack(buffer)) return false;
5006  this->isNeedHostPlayer = buffer.ReadUInt8();
5007  return true;
5008  }
5009  };
5013  class RoomMasterLogoutPlayerRequest
5014  {
5015  public:
5017  static const uint16 payloadType = ROOMMASTER_FUNCID_ROOMMASTER_LOGOUTPLAYER;
5019  uint64 roomId;
5021  int32 playerId;
5025  RoomMasterLogoutPlayerRequest() {
5026  this->roomId = 0;
5027  this->playerId = 0;
5028  }
5034  RoomMasterLogoutPlayerRequest(uint64 _roomId, int32 _playerId) {
5035  this->roomId = _roomId;
5036  this->playerId = _playerId;
5037  }
5042  RoomMasterLogoutPlayerRequest& operator = (const RoomMasterLogoutPlayerRequest& rRef) {
5043  this->roomId = rRef.roomId;
5044  this->playerId = rRef.playerId;
5045  return *this;
5046  }
5051  inline uint32 Size() {
5052  uint32 byteLen = 0;
5053  byteLen += sizeof(this->roomId);
5054  byteLen += sizeof(this->playerId);
5055  return byteLen;
5056  }
5061  inline bool Pack(MunBuffer& buffer) {
5062  if (!buffer.WriteUInt64(this->roomId)) return false;
5063  return buffer.WriteInt32(this->playerId);
5064  }
5069  inline bool Unpack(MunBuffer& buffer) {
5070  this->roomId = buffer.ReadUInt64();
5071  this->playerId = buffer.ReadInt32();
5072  return true;
5073  }
5074  };
5078  class RoomMasterLogoutPlayerResponse
5079  {
5080  public:
5082  static const uint16 payloadType = ROOMMASTER_FUNCID_ROOMMASTER_LOGOUTPLAYERRESULT;
5084  uint64 roomId;
5086  RoomInfo roomInfo;
5088  int32 playerId;
5092  RoomMasterLogoutPlayerResponse() {
5093  this->roomId = 0;
5094  this->playerId = 0;
5095  }
5102  RoomMasterLogoutPlayerResponse(uint64 _roomId, RoomInfo& _roomInfo, int32 _playerId) {
5103  this->roomId = _roomId;
5104  this->roomInfo = _roomInfo;
5105  this->playerId = _playerId;
5106  }
5111  RoomMasterLogoutPlayerResponse& operator = (const RoomMasterLogoutPlayerResponse& rRef) {
5112  this->roomId = rRef.roomId;
5113  this->roomInfo = rRef.roomInfo;
5114  this->playerId = rRef.playerId;
5115  return *this;
5116  }
5121  inline uint32 Size() {
5122  uint32 byteLen = 0;
5123  byteLen += sizeof(this->roomId);
5124  byteLen += this->roomInfo.Size();
5125  byteLen += sizeof(this->playerId);
5126  return byteLen;
5127  }
5132  inline bool Pack(MunBuffer& buffer) {
5133  if (!buffer.WriteUInt64(this->roomId)) return false;
5134  if (!this->roomInfo.Pack(buffer)) return false;
5135  return buffer.WriteInt32(this->playerId);
5136  }
5141  inline bool Unpack(MunBuffer& buffer) {
5142  this->roomId = buffer.ReadUInt64();
5143  if (!this->roomInfo.Unpack(buffer)) return false;
5144  this->playerId = buffer.ReadInt32();
5145  return true;
5146  }
5147  };
5151  class RoomMasterUpdateHostIdRequest
5152  {
5153  public:
5155  static const uint16 payloadType = ROOMMASTER_FUNCID_ROOMMASTER_UPDATEHOSTID;
5157  uint64 roomId;
5159  int32 hostId;
5163  RoomMasterUpdateHostIdRequest() {
5164  this->roomId = 0;
5165  this->hostId = 0;
5166  }
5172  RoomMasterUpdateHostIdRequest(uint64 _roomId, int32 _hostId) {
5173  this->roomId = _roomId;
5174  this->hostId = _hostId;
5175  }
5180  RoomMasterUpdateHostIdRequest& operator = (const RoomMasterUpdateHostIdRequest& rRef) {
5181  this->roomId = rRef.roomId;
5182  this->hostId = rRef.hostId;
5183  return *this;
5184  }
5189  inline uint32 Size() {
5190  uint32 byteLen = 0;
5191  byteLen += sizeof(this->roomId);
5192  byteLen += sizeof(this->hostId);
5193  return byteLen;
5194  }
5199  inline bool Pack(MunBuffer& buffer) {
5200  if (!buffer.WriteUInt64(this->roomId)) return false;
5201  return buffer.WriteInt32(this->hostId);
5202  }
5207  inline bool Unpack(MunBuffer& buffer) {
5208  this->roomId = buffer.ReadUInt64();
5209  this->hostId = buffer.ReadInt32();
5210  return true;
5211  }
5212  };
5216  class RoomMasterUpdateHostIdResponse
5217  {
5218  public:
5220  static const uint16 payloadType = ROOMMASTER_FUNCID_ROOMMASTER_UPDATEHOSTIDRESULT;
5222  uint64 roomId;
5224  int32 hostId;
5228  RoomMasterUpdateHostIdResponse() {
5229  this->roomId = 0;
5230  this->hostId = 0;
5231  }
5237  RoomMasterUpdateHostIdResponse(uint64 _roomId, int32 _hostId) {
5238  this->roomId = _roomId;
5239  this->hostId = _hostId;
5240  }
5245  RoomMasterUpdateHostIdResponse& operator = (const RoomMasterUpdateHostIdResponse& rRef) {
5246  this->roomId = rRef.roomId;
5247  this->hostId = rRef.hostId;
5248  return *this;
5249  }
5254  inline uint32 Size() {
5255  uint32 byteLen = 0;
5256  byteLen += sizeof(this->roomId);
5257  byteLen += sizeof(this->hostId);
5258  return byteLen;
5259  }
5264  inline bool Pack(MunBuffer& buffer) {
5265  if (!buffer.WriteUInt64(this->roomId)) return false;
5266  return buffer.WriteInt32(this->hostId);
5267  }
5272  inline bool Unpack(MunBuffer& buffer) {
5273  this->roomId = buffer.ReadUInt64();
5274  this->hostId = buffer.ReadInt32();
5275  return true;
5276  }
5277  };
5281  class RoomMasterUpdatePlayerParametersRequest
5282  {
5283  public:
5285  static const uint16 payloadType = ROOMMASTER_FUNCID_ROOMMASTER_UPDATEPLAYERPARAMETERS;
5287  uint64 roomId;
5289  int32 playerId;
5291  KeyValue playerParameters[PLAYER_PARAMETERS_MAX];
5293  uint16 playerParametersLen;
5297  RoomMasterUpdatePlayerParametersRequest() {
5298  this->roomId = 0;
5299  this->playerId = 0;
5300  this->playerParametersLen = 0;
5301  }
5307  RoomMasterUpdatePlayerParametersRequest(uint64 _roomId, int32 _playerId, KeyValue* _playerParameters, uint16 _playerParametersLen) {
5308  assert(_playerParametersLen <= PLAYER_PARAMETERS_MAX);
5309  this->roomId = _roomId;
5310  this->playerId = _playerId;
5311  this->playerParametersLen = _playerParametersLen;
5312  for (uint16 index = 0; index < this->playerParametersLen; ++index) {
5313  this->playerParameters[index] = _playerParameters[index];
5314  }
5315  }
5320  RoomMasterUpdatePlayerParametersRequest& operator = (const RoomMasterUpdatePlayerParametersRequest& rRef) {
5321  assert(rRef.playerParametersLen <= PLAYER_PARAMETERS_MAX);
5322  this->roomId = rRef.roomId;
5323  this->playerId = rRef.playerId;
5324  this->playerParametersLen = rRef.playerParametersLen;
5325  for (uint16 index = 0; index < this->playerParametersLen; ++index) {
5326  this->playerParameters[index] = rRef.playerParameters[index];
5327  }
5328  return *this;
5329  }
5334  inline uint32 Size() {
5335  uint32 byteLen = 0;
5336  byteLen += sizeof(this->roomId);
5337  byteLen += sizeof(this->playerId);
5338  byteLen += sizeof(this->playerParametersLen);
5339  for (uint16 index = 0; index < this->playerParametersLen; ++index) {
5340  byteLen += this->playerParameters[index].Size();
5341  }
5342  return byteLen;
5343  }
5348  inline bool Pack(MunBuffer& buffer) {
5349  if (!buffer.WriteUInt64(this->roomId)) return false;
5350  if (!buffer.WriteInt32(this->playerId)) return false;
5351  if (this->playerParametersLen > PLAYER_PARAMETERS_MAX) {
5352  return false;
5353  }
5354  if (!buffer.WriteUInt16(this->playerParametersLen)) return false;
5355  for (uint16 index = 0; index < this->playerParametersLen; ++index) {
5356  if (!this->playerParameters[index].Pack(buffer)) return false;
5357  }
5358  return true;
5359  }
5364  inline bool Unpack(MunBuffer& buffer) {
5365  this->roomId = buffer.ReadUInt64();
5366  this->playerId = buffer.ReadInt32();
5367  this->playerParametersLen = buffer.ReadUInt16();
5368  if (this->playerParametersLen > PLAYER_PARAMETERS_MAX) {
5369  return false;
5370  }
5371  for (uint16 index = 0; index < this->playerParametersLen; ++index) {
5372  if (!this->playerParameters[index].Unpack(buffer)) return false;
5373  }
5374  return true;
5375  }
5376  };
5380  class RoomMasterUpdatePlayerNameRequest
5381  {
5382  public:
5384  static const uint16 payloadType = ROOMMASTER_FUNCID_ROOMMASTER_UPDATEPLAYERNAME;
5386  uint64 roomId;
5388  int32 playerId;
5390  Text playerName;
5392  uint16 playerParametersLen;
5396  RoomMasterUpdatePlayerNameRequest() {
5397  this->roomId = 0;
5398  this->playerId = 0;
5399  this->playerParametersLen = 0;
5400  }
5406  RoomMasterUpdatePlayerNameRequest(uint64 _roomId, int32 _playerId, std::string _playerName) {
5407  this->roomId = _roomId;
5408  this->playerId = _playerId;
5409  this->playerName = Text(_playerName);
5410  }
5415  RoomMasterUpdatePlayerNameRequest& operator = (const RoomMasterUpdatePlayerNameRequest& rRef) {
5416  this->roomId = rRef.roomId;
5417  this->playerId = rRef.playerId;
5418  this->playerName = Text(rRef.playerName);
5419  return *this;
5420  }
5425  inline uint32 Size() {
5426  uint32 byteLen = 0;
5427  byteLen += sizeof(this->roomId);
5428  byteLen += sizeof(this->playerId);
5429  byteLen += this->playerName.Size();
5430  return byteLen;
5431  }
5436  inline bool Pack(MunBuffer& buffer) {
5437  if (!buffer.WriteUInt64(this->roomId)) return false;
5438  if (!buffer.WriteInt32(this->playerId)) return false;
5439  return this->playerName.Pack(buffer);
5440  }
5445  inline bool Unpack(MunBuffer& buffer) {
5446  this->roomId = buffer.ReadUInt64();
5447  this->playerId = buffer.ReadInt32();
5448  return this->playerName.Unpack(buffer);
5449  }
5450  };
5454  class RoomLoginPlayerRequest
5455  {
5456  public:
5458  static const uint16 payloadType = ROOM_FUNCID_ROOM_LOGINPLAYER;
5460  uint32 clientUidForMasterServer;
5462  uint64 clientUidForProxyServer;
5466  RoomLoginPlayerRequest() {
5467  this->clientUidForMasterServer = 0;
5468  this->clientUidForProxyServer = 0;
5469  }
5475  RoomLoginPlayerRequest(uint32 _clientUidForMasterServer, uint64 _clientUidForProxyServer) {
5476  this->clientUidForMasterServer = _clientUidForMasterServer;
5477  this->clientUidForProxyServer = _clientUidForProxyServer;
5478  }
5483  RoomLoginPlayerRequest& operator = (const RoomLoginPlayerRequest& rRef) {
5484  this->clientUidForMasterServer = rRef.clientUidForMasterServer;
5485  this->clientUidForProxyServer = rRef.clientUidForProxyServer;
5486  return *this;
5487  }
5492  inline uint32 Size() {
5493  uint32 byteLen = 0;
5494  byteLen += sizeof(this->clientUidForMasterServer);
5495  byteLen += sizeof(this->clientUidForProxyServer);
5496  return byteLen;
5497  }
5502  inline bool Pack(MunBuffer& buffer) {
5503  if (!buffer.WriteUInt32(this->clientUidForMasterServer)) return false;
5504  return buffer.WriteUInt64(this->clientUidForProxyServer);
5505  }
5510  inline bool Unpack(MunBuffer& buffer) {
5511  this->clientUidForMasterServer = buffer.ReadUInt32();
5512  this->clientUidForProxyServer = buffer.ReadUInt64();
5513  return true;
5514  }
5515  };
5519  class RoomLoginPlayerResponse
5520  {
5521  public:
5523  static const uint16 payloadType = ROOM_FUNCID_ROOM_LOGINPLAYERRESULT;
5525  int32 result;
5527  uint64 roomId;
5529  RoomInfo roomInfo;
5531  int32 playerId;
5533  PlayerInfo players[PLAYER_MAX];
5535  uint32 playersLen;
5539  RoomLoginPlayerResponse() {
5540  this->result = 0;
5541  this->roomId = 0;
5542  this->playerId = 0;
5543  this->playersLen = 0;
5544  }
5554  RoomLoginPlayerResponse(int32 _result, uint64 _roomId, RoomInfo& _roomInfo, int32 _playerId, PlayerInfo* _players, uint32 _playersLen) {
5555  assert(_playersLen <= PLAYER_MAX);
5556  this->result = _result;
5557  this->roomId = _roomId;
5558  this->roomInfo = _roomInfo;
5559  this->playerId = _playerId;
5560  this->playersLen = _playersLen;
5561  for (uint32 index = 0; index < this->playersLen; ++index)
5562  {
5563  this->players[index] = _players[index];
5564  }
5565  }
5570  RoomLoginPlayerResponse& operator = (const RoomLoginPlayerResponse& rRef) {
5571  assert(rRef.playersLen <= PLAYER_MAX);
5572  this->result = rRef.result;
5573  this->roomId = rRef.roomId;
5574  this->roomInfo = rRef.roomInfo;
5575  this->playerId = rRef.playerId;
5576  this->playersLen = rRef.playersLen;
5577  for (uint32 index = 0; index < this->playersLen; ++index)
5578  {
5579  this->players[index] = rRef.players[index];
5580  }
5581  return *this;
5582  }
5587  inline uint32 Size() {
5588  uint32 byteLen = 0;
5589  byteLen += sizeof(this->result);
5590  byteLen += sizeof(this->roomId);
5591  byteLen += this->roomInfo.Size();
5592  byteLen += sizeof(this->playerId);
5593  byteLen += sizeof(this->playersLen);
5594  for (uint32 index = 0; index < this->playersLen; ++index)
5595  {
5596  byteLen += this->players[index].Size();
5597  }
5598  return byteLen;
5599  }
5604  inline bool Pack(MunBuffer& buffer) {
5605  if (!buffer.WriteInt32(this->result)) return false;
5606  if (!buffer.WriteUInt64(this->roomId)) return false;
5607  if (!this->roomInfo.Pack(buffer)) return false;
5608  if (!buffer.WriteInt32(this->playerId)) return false;
5609  if (!buffer.WriteUInt32(this->playersLen)) return false;
5610  if (this->playersLen > 0) {
5611  for (uint32 index = 0; index < this->playersLen; index++)
5612  {
5613  if (!this->players[index].Pack(buffer)) return false;
5614  }
5615  }
5616  return true;
5617  }
5622  inline bool Unpack(MunBuffer& buffer) {
5623  this->result = buffer.ReadInt32();
5624  this->roomId = buffer.ReadUInt64();
5625  if (!this->roomInfo.Unpack(buffer)) return false;
5626  this->playerId = buffer.ReadInt32();
5627  this->playersLen = buffer.ReadUInt32();
5628  assert(this->playersLen<=PLAYER_MAX);
5629  for (uint32 index = 0; index < this->playersLen; ++index)
5630  {
5631  if (!this->players[index].Unpack(buffer)) return false;
5632  }
5633  return true;
5634  }
5635  };
5639  class RoomJoinedPlayerResponse
5640  {
5641  public:
5643  static const uint16 payloadType = ROOM_FUNCID_ROOM_JOINEDPLAYERRESULT;
5645  int32 hostId;
5647  PlayerInfo playerInfo;
5651  RoomJoinedPlayerResponse() {
5652  this->hostId = 0;
5653  }
5659  RoomJoinedPlayerResponse(int32 _hostId, PlayerInfo& _playerInfo) {
5660  this->hostId = _hostId;
5661  this->playerInfo = _playerInfo;
5662  }
5667  RoomJoinedPlayerResponse& operator = (const RoomJoinedPlayerResponse& rRef) {
5668  this->hostId = rRef.hostId;
5669  this->playerInfo = rRef.playerInfo;
5670  return *this;
5671  }
5676  inline uint32 Size() {
5677  uint32 byteLen = 0;
5678  byteLen += sizeof(this->hostId);
5679  byteLen += this->playerInfo.Size();
5680  return byteLen;
5681  }
5686  inline bool Pack(MunBuffer& buffer) {
5687  if (!buffer.WriteInt32(this->hostId)) return false;
5688  return this->playerInfo.Pack(buffer);
5689  }
5694  inline bool Unpack(MunBuffer& buffer) {
5695  this->hostId = buffer.ReadInt32();
5696  return this->playerInfo.Unpack(buffer);
5697  }
5698  };
5702  class RoomLeftPlayerResponse
5703  {
5704  public:
5706  static const uint16 payloadType = ROOM_FUNCID_ROOM_LEFTPLAYERRESULT;
5708  int32 hostId;
5710  int32 playerId;
5714  RoomLeftPlayerResponse() {
5715  this->hostId = 0;
5716  this->playerId = 0;
5717  }
5723  RoomLeftPlayerResponse(int32 _hostId, int32 _playerId) {
5724  this->hostId = _hostId;
5725  this->playerId = _playerId;
5726  }
5731  RoomLeftPlayerResponse& operator = (const RoomLeftPlayerResponse& rRef) {
5732  this->hostId = rRef.hostId;
5733  this->playerId = rRef.playerId;
5734  return *this;
5735  }
5740  inline uint32 Size() {
5741  uint32 byteLen = 0;
5742  byteLen += sizeof(this->hostId);
5743  byteLen += sizeof(this->playerId);
5744  return byteLen;
5745  }
5750  inline bool Pack(MunBuffer& buffer) {
5751  if (!buffer.WriteInt32(this->hostId)) return false;
5752  return buffer.WriteInt32(this->playerId);
5753  }
5758  inline bool Unpack(MunBuffer& buffer) {
5759  this->hostId = buffer.ReadInt32();
5760  this->playerId = buffer.ReadInt32();
5761  return true;
5762  }
5763  };
5767  class RoomUpdateHostIdRequest
5768  {
5769  public:
5771  static const uint16 payloadType = ROOM_FUNCID_ROOM_UPDATEHOSTID;
5773  int32 hostId;
5777  RoomUpdateHostIdRequest() {
5778  this->hostId = 0;
5779  }
5784  RoomUpdateHostIdRequest(int32 _hostId) {
5785  this->hostId = _hostId;
5786  }
5791  RoomUpdateHostIdRequest& operator = (const RoomUpdateHostIdRequest& rRef) {
5792  this->hostId = rRef.hostId;
5793  return *this;
5794  }
5799  inline uint32 Size() {
5800  uint32 byteLen = 0;
5801  byteLen += sizeof(this->hostId);
5802  return byteLen;
5803  }
5808  inline bool Pack(MunBuffer& buffer) {
5809  return buffer.WriteInt32(this->hostId);
5810  }
5815  inline bool Unpack(MunBuffer& buffer) {
5816  this->hostId = buffer.ReadInt32();
5817  return true;
5818  }
5819  };
5823  class RoomUpdateHostIdResponse
5824  {
5825  public:
5827  static const uint16 payloadType = ROOM_FUNCID_ROOM_UPDATEHOSTIDRESULT;
5829  int32 hostId;
5833  RoomUpdateHostIdResponse() {
5834  this->hostId = 0;
5835  }
5840  RoomUpdateHostIdResponse(int32 _hostId) {
5841  this->hostId = _hostId;
5842  }
5847  RoomUpdateHostIdResponse& operator = (const RoomUpdateHostIdResponse& rRef) {
5848  this->hostId = rRef.hostId;
5849  return *this;
5850  }
5855  inline uint32 Size() {
5856  uint32 byteLen = 0;
5857  byteLen += sizeof(this->hostId);
5858  return byteLen;
5859  }
5864  inline bool Pack(MunBuffer& buffer) {
5865  return buffer.WriteInt32(this->hostId);
5866  }
5871  inline bool Unpack(MunBuffer& buffer) {
5872  this->hostId = buffer.ReadInt32();
5873  return true;
5874  }
5875  };
5879  class RoomRPCRequest
5880  {
5881  public:
5883  static const uint16 payloadType = ROOM_FUNCID_ROOM_RPC;
5885  uint64 roomId;
5887  uint8 targets;
5889  int32 senderId;
5891  int32 targetIds[PLAYER_MAX];
5893  uint32 targetIdsLen;
5895  Binary data;
5899  RoomRPCRequest() {
5900  this->roomId = 0;
5901  this->targets = 0;
5902  this->senderId = 0;
5903  this->targetIdsLen = 0;
5904  }
5908  virtual ~RoomRPCRequest() {
5909  data.Clear();
5910  }
5920  RoomRPCRequest(uint64 _roomId, uint8 _targets, int32 _senderId, int32 * _targetIds, uint32 _targetIdsLen, Binary& _data) {
5921  assert(_targetIdsLen <= PLAYER_MAX);
5922  this->roomId = _roomId;
5923  this->targets = _targets;
5924  this->senderId = _senderId;
5925  this->targetIdsLen = _targetIdsLen;
5926  for (uint16 index = 0; index < this->targetIdsLen; ++index) {
5927  this->targetIds[index] = _targetIds[index];
5928  }
5929  this->data = _data;
5930  }
5935  RoomRPCRequest& operator = (const RoomRPCRequest& rRef) {
5936  assert(rRef.targetIdsLen <= PLAYER_MAX);
5937  this->roomId = rRef.roomId;
5938  this->targets = rRef.targets;
5939  this->senderId = rRef.senderId;
5940  this->targetIdsLen = rRef.targetIdsLen;
5941  for (uint16 index = 0; index < this->targetIdsLen; ++index) {
5942  this->targetIds[index] = rRef.targetIds[index];
5943  }
5944  this->data = rRef.data;
5945  return *this;
5946  }
5951  inline uint32 Size() {
5952  uint32 byteLen = 0;
5953  byteLen += sizeof(this->roomId);
5954  byteLen += sizeof(this->targets);
5955  byteLen += sizeof(this->senderId);
5956  byteLen += sizeof(this->targetIdsLen);
5957  for (uint16 index = 0; index < this->targetIdsLen; ++index) {
5958  byteLen += sizeof(this->targetIds[index]);
5959  }
5960  byteLen += this->data.Size();
5961  return byteLen;
5962  }
5967  inline bool Pack(MunBuffer& buffer) {
5968  if (this->targetIdsLen > PLAYER_MAX) {
5969  return false;
5970  }
5971  if (!buffer.WriteUInt64(this->roomId)) return false;
5972  if (!buffer.WriteUInt8(this->targets)) return false;
5973  if (!buffer.WriteInt32(this->senderId)) return false;
5974  if (!buffer.WriteUInt32(this->targetIdsLen)) return false;
5975  for (uint16 index = 0; index < this->targetIdsLen; ++index) {
5976  if (!buffer.WriteInt32(this->targetIds[index])) return false;
5977  }
5978  return this->data.Pack(buffer);
5979  }
5984  inline bool Unpack(MunBuffer& buffer) {
5985  this->roomId = buffer.ReadUInt64();
5986  this->targets = buffer.ReadUInt8();
5987  this->senderId = buffer.ReadInt32();
5988  this->targetIdsLen = buffer.ReadUInt32();
5989  if (this->targetIdsLen > PLAYER_MAX) {
5990  return false;
5991  }
5992  for (uint16 index = 0; index < this->targetIdsLen; ++index) {
5993  this->targetIds[index] = buffer.ReadInt32();
5994  }
5995  return this->data.Unpack(buffer);
5996  }
5997  };
6001  class RoomRPCResponse
6002  {
6003  public:
6005  static const uint16 payloadType = ROOM_FUNCID_ROOM_RPCRESULT;
6007  Binary data;
6011  RoomRPCResponse() {}
6015  virtual ~RoomRPCResponse() {
6016  data.Clear();
6017  }
6022  RoomRPCResponse(Binary& _data) {
6023  this->data = _data;
6024  }
6029  RoomRPCResponse& operator = (const RoomRPCResponse& rRef) {
6030  this->data = rRef.data;
6031  return *this;
6032  }
6037  inline uint32 Size() {
6038  uint32 byteLen = 0;
6039  byteLen += this->data.Size();
6040  return byteLen;
6041  }
6046  inline bool Pack(MunBuffer& buffer) {
6047  return this->data.Pack(buffer);
6048  }
6053  inline bool Unpack(MunBuffer& buffer) {
6054  return this->data.Unpack(buffer);
6055  }
6056  };
6060  class RoomKickPlayerRequest
6061  {
6062  public:
6064  static const uint16 payloadType = ROOM_FUNCID_ROOM_KICKPLAYER;
6066  int32 playerId;
6070  RoomKickPlayerRequest() {
6071  this->playerId = 0;
6072  }
6077  RoomKickPlayerRequest(int32 _playerId) {
6078  this->playerId = _playerId;
6079  }
6084  RoomKickPlayerRequest& operator = (const RoomKickPlayerRequest& rRef) {
6085  this->playerId = rRef.playerId;
6086  return *this;
6087  }
6092  inline uint32 Size() {
6093  uint32 byteLen = 0;
6094  byteLen += sizeof(this->playerId);
6095  return byteLen;
6096  }
6101  inline bool Pack(MunBuffer& buffer) {
6102  if (!buffer.WriteInt32(this->playerId)) return false;
6103  return true;
6104  }
6109  inline bool Unpack(MunBuffer& buffer) {
6110  this->playerId = buffer.ReadInt32();
6111  return true;
6112  }
6113  };
6117  class RoomKickPlayerResponse
6118  {
6119  public:
6121  static const uint16 payloadType = ROOM_FUNCID_ROOM_KICKPLAYERRESULT;
6123  int32 playerId;
6127  RoomKickPlayerResponse() {
6128  this->playerId = 0;
6129  }
6134  RoomKickPlayerResponse(int32 _playerId) {
6135  this->playerId = _playerId;
6136  }
6141  RoomKickPlayerResponse& operator = (const RoomKickPlayerResponse& rRef) {
6142  this->playerId = rRef.playerId;
6143  return *this;
6144  }
6149  inline uint32 Size() {
6150  uint32 byteLen = 0;
6151  byteLen += sizeof(this->playerId);
6152  return byteLen;
6153  }
6158  inline bool Pack(MunBuffer& buffer) {
6159  if (!buffer.WriteInt32(this->playerId)) return false;
6160  return true;
6161  }
6166  inline bool Unpack(MunBuffer& buffer) {
6167  this->playerId = buffer.ReadInt32();
6168  return true;
6169  }
6170  };
6174  class MonitoringPullRequest
6175  {
6176  public:
6178  static const uint16 payloadType = MONITOR_FUNCID_MONITORING_PULL_REQUEST;
6182  MonitoringPullRequest() {
6183  }
6188  inline uint32 Size() {
6189  uint32 byteLen = 0;
6190  return byteLen;
6191  }
6196  inline bool Pack(MunBuffer& buffer) {
6197  return true;
6198  }
6203  inline bool Unpack(MunBuffer& buffer) {
6204  return true;
6205  }
6206  };
6210  class MonitoringPullResponse
6211  {
6212  public:
6214  static const uint16 payloadType = MONITOR_FUNCID_MONITORING_PULL_RESPONSE;
6216  Text text;
6220  MonitoringPullResponse() {
6221  }
6226  MonitoringPullResponse(Text& _text) {
6227  this->text = _text;
6228  }
6233  MonitoringPullResponse& operator = (const MonitoringPullResponse& rRef) {
6234  this->text = rRef.text;
6235  return *this;
6236  }
6241  inline uint32 Size() {
6242  uint32 byteLen = 0;
6243  byteLen += this->text.Size();
6244  return byteLen;
6245  }
6250  inline bool Pack(MunBuffer& buffer) {
6251  if (!this->text.Pack(buffer)) return false;
6252  return true;
6253  }
6258  inline bool Unpack(MunBuffer& buffer) {
6259  if (!this->text.Unpack(buffer)) return false;
6260  return true;
6261  }
6262  };
6263 }
6264 
6265 #endif /* __MUN_STREAM_HPP__ */
STREAM::KeyValue::KeyValue
KeyValue()
コンストラクタ.
Definition: MunStream.hpp:612
STREAM::MASTER_FUNCID_MASTER_LOBBY_FORCEJOINRESULT
mun_master サーバから送信される、ロビー入室結果の通知.
Definition: MunStream.hpp:59
STREAM::RoomLoginPlayerRequest::clientUidForProxyServer
uint64 clientUidForProxyServer
mun_proxyサーバ側におけるクライアント識別ユニークID.
Definition: MunStream.hpp:5462
STREAM::ResolverResolveAddressRequest::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:1776
STREAM::RoomInfo::RoomInfo
RoomInfo(Text &_name, uint32 _maxPlayers, uint8 _isVisible, uint8 _isOpen, int32 _hostId, uint32 _playersLen, KeyValue *_roomParameters, uint16 _roomParametersLen, Text *_lobbyParameters, uint16 _lobbyParametersLen)
コンストラクタ.
Definition: MunStream.hpp:1330
STREAM::MasterRoomLeaveResponse::roomInfo
SummaryRoomInfo roomInfo[ROOM_LIST_MAX]
ルーム統計情報.
Definition: MunStream.hpp:3340
STREAM::ProxyCheckRequest::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:2096
STREAM::RoomMasterLogoutPlayerResponse::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:5132
STREAM::MasterRoomLeaveResponse::MasterRoomLeaveResponse
MasterRoomLeaveResponse(int32 _result, SummaryRoomInfo *_roomInfo, uint16 _roomInfoLen)
コンストラクタ.
Definition: MunStream.hpp:3356
STREAM::MasterRoomUpdatePlayerParametersResponse::playerId
int32 playerId
プレイヤーID.
Definition: MunStream.hpp:4465
STREAM::ProxyCheckResponse::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:2206
STREAM::MasterRoomRandomJoinRequest::MasterRoomRandomJoinRequest
MasterRoomRandomJoinRequest(uint8 _protocol, uint32 _maxPlayers, uint8 _matchingMode, LobbyInfo &_lobbyInfo, Text &_keyValueFilter, KeyValue *_roomParameters, uint16 _roomParametersLen, KeyValue *_playerParameters, uint16 _playerParametersLen)
コンストラクタ.
Definition: MunStream.hpp:3136
STREAM::RoomInfo::isOpen
uint8 isOpen
他プレイヤーのルーム入室を許可するかどうかのフラグ.
Definition: MunStream.hpp:1292
STREAM::ProxyCheckRequest
MUN クライアントから mun_proxy サーバに対して送信される、mun_proxyサーバ認証要求. ...
Definition: MunStream.hpp:2030
STREAM::UNIONTYPE_HASH
System.Collections.Generic.Dictionary 型.
Definition: MunStream.hpp:323
STREAM::MasterRoomUpdateRoomParametersResponse::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:3898
STREAM::MASTER_FUNCID_MASTER_ROOM_CREATERESULT
mun_master サーバから送信される、ルーム作成結果の通知.
Definition: MunStream.hpp:64
STREAM::Text::operator==
bool operator==(const Text &rRef) const
比較処理.
Definition: MunStream.hpp:367
STREAM::RoomMasterUpdatePlayerNameRequest::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:5445
STREAM::ProxyCheckRequest::customAuthParametersLen
uint16 customAuthParametersLen
カスタム認証サーバに送信するパラメータの登録数.
Definition: MunStream.hpp:2046
STREAM::RoomUpdateHostIdRequest::hostId
int32 hostId
ホストID.
Definition: MunStream.hpp:5773
STREAM::MonitoringPullResponse::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:6250
STREAM::MasterRoomUpdateMaxPlayersResponse
mun_masterサーバからMUNクライアントに対して送信される、ルーム内プレイヤー人数の上限変更処理結果.
Definition: MunStream.hpp:3480
STREAM::MasterRoomUpdateIsOpenRequest::isOpen
uint8 isOpen
他プレイヤーのルーム入室を許可するかどうかのフラグ.
Definition: MunStream.hpp:3654
STREAM::RoomKickPlayerResponse::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:6158
STREAM::MasterRoomRandomJoinRequest::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:3179
STREAM::RoomLeftPlayerResponse::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:5740
STREAM::RESULT_FAILURE_PROXY_ENTRY_CLIENT
mun_proxy サーバにおいて、MUN クライアントの登録に失敗した.
Definition: MunStream.hpp:172
STREAM::RoomKickPlayerRequest::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:6092
STREAM::MasterUpdatePlayerNameRequest::MasterUpdatePlayerNameRequest
MasterUpdatePlayerNameRequest()
コンストラクタ.
Definition: MunStream.hpp:4561
STREAM::MASTER_FUNCID_MASTER_ROOM_FORCEJOINRESULT
mun_master サーバから送信される、ルーム強制入室結果の通知.
Definition: MunStream.hpp:66
STREAM::RoomMasterSetAddressRequest::wss_port
uint16 wss_port
WebSocketSecureポート番号.
Definition: MunStream.hpp:4688
STREAM::RoomMasterUpdatePlayerNameRequest::playerName
Text playerName
プレイヤー名.
Definition: MunStream.hpp:5390
STREAM::MasterCheckResponse::MasterCheckResponse
MasterCheckResponse()
コンストラクタ.
Definition: MunStream.hpp:2330
STREAM::PROXYRESOLVER_FUNCID_PROXYRESOLVER_SETWEIGHT
mun_proxy サーバから送信される、mun_proxy サーバの接続負荷情報の通知.
Definition: MunStream.hpp:42
STREAM::MasterRoomUpdatePlayerParametersRequest::playerParametersLen
uint16 playerParametersLen
プレイヤーパラメータの登録数.
Definition: MunStream.hpp:4384
STREAM::MasterRoomUpdateRoomParametersResponse::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:3886
STREAM::RoomMasterUpdateHostIdResponse
mun_roomサーバからmun_masterサーバに対して送信される、ホストの変更処理結果.
Definition: MunStream.hpp:5216
MunBuffer
mrs::Buffer の拡張クラス.
Definition: MunBuffer.hpp:17
STREAM::RoomMasterLoginPlayerResponse::playerInfo
PlayerInfo playerInfo
プレイヤー情報.
Definition: MunStream.hpp:4920
STREAM::PlayerInfo::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:1126
STREAM::RoomRPCResponse::RoomRPCResponse
RoomRPCResponse(Binary &_data)
コンストラクタ.
Definition: MunStream.hpp:6022
STREAM::CreateRoomInfo::playerParametersLen
uint16 playerParametersLen
プレイヤーパラメータの登録数.
Definition: MunStream.hpp:887
STREAM::MasterRoomUpdateResponse::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:4129
STREAM::RoomMasterUpdateHostIdRequest::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:5199
STREAM::MasterRoomUpdateIsOpenResponse
mun_masterサーバからMUNクライアントに対して送信される、ルーム入室可否設定変更処理結果.
Definition: MunStream.hpp:3704
STREAM::ResolverResolveAddressResponse::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:1855
STREAM::UNIONTYPE_HASH_TABLE
System.Collections.Hashtable 型.
Definition: MunStream.hpp:324
STREAM::RESULT_FAILURE_MASTER_UNCREATE_ROOM
mun_master サーバで、ルームの生成に失敗した.
Definition: MunStream.hpp:195
STREAM::RoomLoginPlayerRequest::RoomLoginPlayerRequest
RoomLoginPlayerRequest()
コンストラクタ.
Definition: MunStream.hpp:5466
STREAM::RoomUpdateHostIdRequest
MUNクライアントからmun_roomサーバに対して送信される、ホストの変更要求.
Definition: MunStream.hpp:5767
STREAM::PROXYRESOLVER_FUNCID_QUERYHEALTHCHECKPROXYRESOLVER
未使用（MUN1.x互換のために残している情報）.
Definition: MunStream.hpp:39
STREAM::RoomMasterLogoutPlayerRequest::RoomMasterLogoutPlayerRequest
RoomMasterLogoutPlayerRequest()
コンストラクタ.
Definition: MunStream.hpp:5025
STREAM::ROOMMASTER_FUNCID_ROOMMASTER_SETADDRESS
mun_room サーバから送信される、mun_room サーバのクライアントリスニングアドレスの通知.
Definition: MunStream.hpp:104
STREAM::MasterRoomUpdatePlayerParametersRequest::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:4419
STREAM::RoomMasterSetAddressRequest::tcp_port
uint16 tcp_port
TCPポート番号.
Definition: MunStream.hpp:4682
STREAM::UNIONTYPE_VECTOR2
UnityEngine.Vector2 型.
Definition: MunStream.hpp:284
STREAM::MASTER_FUNCID_MASTER_ROOM_UPDATEROOMPARAMETERS
MUN クライアントから送信される、ルームパラメータ変更要求.
Definition: MunStream.hpp:79
STREAM::MasterRoomUpdateIsOpenResponse::MasterRoomUpdateIsOpenResponse
MasterRoomUpdateIsOpenResponse()
コンストラクタ.
Definition: MunStream.hpp:3714
STREAM::AddressInfo
アドレス情報.
Definition: MunStream.hpp:1682
STREAM::MasterLobbyUpdateResponse::MasterLobbyUpdateResponse
MasterLobbyUpdateResponse()
コンストラクタ.
Definition: MunStream.hpp:2578
STREAM::RoomInfo::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:1399
STREAM::RoomMasterSetAddressRequest::RoomMasterSetAddressRequest
RoomMasterSetAddressRequest()
コンストラクタ.
Definition: MunStream.hpp:4692
STREAM::MasterRoomUpdateMaxPlayersResponse::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:3512
STREAM::RoomRPCResponse::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:6037
STREAM::SummaryRoomInfo::name
Text name
ルーム名.
Definition: MunStream.hpp:1463
STREAM::MasterUpdatePlayerNameResponse::MasterUpdatePlayerNameResponse
MasterUpdatePlayerNameResponse()
コンストラクタ.
Definition: MunStream.hpp:4619
STREAM::RoomInfo::isVisible
uint8 isVisible
ルーム情報をロビーに通知するかどうかのフラグ.
Definition: MunStream.hpp:1290
STREAM::RoomMasterLoginPlayerResponse::roomId
uint64 roomId
ルームID.
Definition: MunStream.hpp:4916
STREAM::SummaryRoomInfo::roomParameters
KeyValue roomParameters[ROOM_PARAMETERS_MAX]
ルームパラメータ.
Definition: MunStream.hpp:1475
STREAM::ROOM_FUNCID_QUERYHEALTHCHECKROOMRESULT
未使用（MUN1.x互換のために残している情報）.
Definition: MunStream.hpp:124
STREAM::MasterRoomJoinRequest::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:2972
STREAM::MasterRoomUpdateResponse::roomInfo
SummaryRoomInfo roomInfo
ルーム統計パラメータ.
Definition: MunStream.hpp:4098
STREAM::RESULT_FAILURE_MASTER_MISMATCHED_MATCHING_DATABASE
mun_master サーバにおいて、マッチングデータベースの照合に失敗した.
Definition: MunStream.hpp:178
STREAM::RoomRPCRequest::data
Binary data
送信データ本体.
Definition: MunStream.hpp:5895
STREAM::SummaryRoomInfo::roomParametersLen
uint16 roomParametersLen
ルームパラメータの登録数.
Definition: MunStream.hpp:1477
STREAM::SummaryRoomInfo::isOpen
uint8 isOpen
他プレイヤーのルーム入室を許可するかどうかのフラグ.
Definition: MunStream.hpp:1469
STREAM::SearchedPlayerInfo::SearchedPlayerInfo
SearchedPlayerInfo()
コンストラクタ.
Definition: MunStream.hpp:1231
STREAM::MasterRoomUpdatePlayerParametersResponse::MasterRoomUpdatePlayerParametersResponse
MasterRoomUpdatePlayerParametersResponse()
コンストラクタ.
Definition: MunStream.hpp:4473
STREAM::RoomInfo::maxPlayers
uint32 maxPlayers
ルーム内プレイヤー人数の上限.
Definition: MunStream.hpp:1288
STREAM::MasterRoomUpdatePlayerParametersResponse::playerParametersLen
uint16 playerParametersLen
プレイヤーパラメータの登録数.
Definition: MunStream.hpp:4469
STREAM::RoomMasterLoginPlayerRequest::RoomMasterLoginPlayerRequest
RoomMasterLoginPlayerRequest(uint32 _clientUidForMasterServer, uint64 _clientUidForProxyServer)
コンストラクタ.
Definition: MunStream.hpp:4860
STREAM::RoomInfo::roomParameters
KeyValue roomParameters[ROOM_PARAMETERS_MAX]
ルームパラメータ.
Definition: MunStream.hpp:1298
STREAM::MASTER_FUNCID_MASTER_LOBBY_UPDATERESULT
mun_master サーバから送信される、ロビー更新情報の通知.
Definition: MunStream.hpp:62
STREAM::RESULT_FAILURE_MASTER_UNUPDATE_LOBBY_DATABASE
mun_master サーバにおいて、ロビーデータベースへの更新に失敗した.
Definition: MunStream.hpp:183
STREAM::LOBBYKIND_RANDOM
ランダム入室において、「条件に適合するルーム群の中から、完全なランダムな１つのルーム」を自動選択しま...
Definition: MunStream.hpp:227
STREAM::MasterRoomUpdateResponse::MasterRoomUpdateResponse
MasterRoomUpdateResponse()
コンストラクタ.
Definition: MunStream.hpp:4104
STREAM::RoomKickPlayerRequest
MUN クライアントから送信される、対象プレイヤーの強制退室要求.
Definition: MunStream.hpp:6060
STREAM::RoomMasterLoginPlayerResponse
mun_masterサーバからmun_roomサーバに対して送信される、プレイヤーのルームログイン処理結果.
Definition: MunStream.hpp:4904
STREAM::MasterRoomUpdateRoomParametersRequest::roomParametersLen
uint16 roomParametersLen
ルームパラメータの登録数.
Definition: MunStream.hpp:3768
STREAM::MasterRoomUpdateMaxPlayersRequest::MasterRoomUpdateMaxPlayersRequest
MasterRoomUpdateMaxPlayersRequest(uint32 _maxPlayers)
コンストラクタ.
Definition: MunStream.hpp:3441
STREAM::MasterRoomUpdatePlayerParametersResponse
MUNクライアントからmun_masterサーバに対して送信される、プレイヤーパラメータ変更処理結果.
Definition: MunStream.hpp:4459
STREAM::UNIONTYPE_UINT64
System.UInt64 型.
Definition: MunStream.hpp:298
STREAM::SummaryRoomInfo::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:1578
STREAM::Text::Text
Text(const std::string &_text)
コンストラクタ.
Definition: MunStream.hpp:352
STREAM::ROOM_FUNCID_ROOM_LOGINPLAYER
MUN クライアントから送信される、自身のログイン処理要求.
Definition: MunStream.hpp:125
STREAM::MASTER_FUNCID_PROXY_CHECK
MUN クライアントから送信される、クライアント識別用ユニークIDの発行要求.
Definition: MunStream.hpp:54
STREAM::RoomUpdateHostIdRequest::RoomUpdateHostIdRequest
RoomUpdateHostIdRequest(int32 _hostId)
コンストラクタ.
Definition: MunStream.hpp:5784
STREAM::SummaryLobbyInfo::SummaryLobbyInfo
SummaryLobbyInfo(Text &_lobbyName, uint8 _lobbyKind, int32 _roomCount, int32 _playerCount)
コンストラクタ.
Definition: MunStream.hpp:811
STREAM::SummaryLobbyInfo
ロビー統計情報.
Definition: MunStream.hpp:785
STREAM::ROOM_FUNCID_QUERYCONNECTROOM
未使用（MUN1.x互換のために残している情報）.
Definition: MunStream.hpp:121
STREAM::MasterRoomUpdatePlayerParametersRequest::playerParameters
KeyValue playerParameters[PLAYER_PARAMETERS_MAX]
プレイヤーパラメータ.
Definition: MunStream.hpp:4382
STREAM::RoomMasterLoginPlayerResponse::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:4970
STREAM::MonitoringPullResponse::MonitoringPullResponse
MonitoringPullResponse(Text &_text)
コンストラクタ.
Definition: MunStream.hpp:6226
STREAM::SummaryPlayerInfo::id
int32 id
プレイヤーID.
Definition: MunStream.hpp:1162
STREAM::Text::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:388
STREAM::ROOM_FUNCID_QUERYHEALTHCHECKROOM
未使用（MUN1.x互換のために残している情報）.
Definition: MunStream.hpp:123
STREAM::Union::Union
Union(uint8 _type, Binary &_data)
コンストラクタ.
Definition: MunStream.hpp:549
STREAM::MasterRoomUpdateLobbyParametersRequest::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:3981
STREAM::MASTER_FUNCID_MASTER_ROOM_UPDATE
MUN クライアントから送信される、ルーム更新情報の通知要求.
Definition: MunStream.hpp:83
STREAM::ProxyResolverSetAddressRequest::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:1939
STREAM::MasterStatsUpdateResponse::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:4353
STREAM::MasterRoomUpdateLobbyParametersResponse::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:4064
STREAM::RoomKickPlayerRequest::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:6109
STREAM::RoomMasterUpdatePlayerNameRequest::roomId
uint64 roomId
ルームID.
Definition: MunStream.hpp:5386
STREAM::RoomMasterLogoutPlayerRequest::RoomMasterLogoutPlayerRequest
RoomMasterLogoutPlayerRequest(uint64 _roomId, int32 _playerId)
コンストラクタ.
Definition: MunStream.hpp:5034
STREAM::MasterRoomUpdateIsVisibleRequest::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:3568
STREAM::UNIONTYPE_ARRAY_FLOAT
System.Single[] 型.
Definition: MunStream.hpp:319
STREAM::MasterRoomUpdateIsVisibleRequest::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:3584
STREAM::MasterLobbyUpdateResponse::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:2613
STREAM::MasterUpdatePlayerNameResponse
MUNクライアントからmun_masterサーバに対して送信される、プレイヤー名変更処理結果.
Definition: MunStream.hpp:4607
STREAM::StatsInfo::StatsInfo
StatsInfo(int32 _clientCountInServer, int32 _clientCountInLobby, int32 _clientCountInRoom, int32 _roomCountInLobby)
コンストラクタ.
Definition: MunStream.hpp:1628
STREAM::MasterRoomUpdatePlayerParametersResponse::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:4521
STREAM::MASTER_FUNCID_MASTER_SEARCHPLAYERS
MUN クライアントから送信される、プレイヤー検索要求.
Definition: MunStream.hpp:85
STREAM::MasterRoomJoinResponse::result
int32 result
ルーム入室処理結果（列挙型ERRORCODE_IDの定数）.
Definition: MunStream.hpp:3024
STREAM::MasterRoomRandomJoinResponse::MasterRoomRandomJoinResponse
MasterRoomRandomJoinResponse()
コンストラクタ.
Definition: MunStream.hpp:3268
STREAM::MasterRoomUpdateRoomParametersResponse::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:3912
STREAM::MasterRoomUpdateIsVisibleResponse::MasterRoomUpdateIsVisibleResponse
MasterRoomUpdateIsVisibleResponse(uint8 _isVisible)
コンストラクタ.
Definition: MunStream.hpp:3609
STREAM::AddressInfo::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:1735
STREAM::RESULT_FAILURE_ROOM
未使用（mun_room サーバからのエラーコードの最小値閾値）.
Definition: MunStream.hpp:199
STREAM::RESULT_FAILURE_RESOLVER_MISMATCH_MUN_VERSION
MUN クライアントと mun_resolver サーバとの MUN バージョンが不一致.
Definition: MunStream.hpp:165
STREAM::LobbyInfo::LobbyInfo
LobbyInfo()
コンストラクタ.
Definition: MunStream.hpp:733
STREAM::RoomLeftPlayerResponse::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:5758
STREAM::RoomJoinedPlayerResponse
mun_roomサーバからMUNクライアントに対して送信される、誰かがルームにログインした結果.
Definition: MunStream.hpp:5639
STREAM::SummaryPlayerInfo::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:1212
STREAM::ROOM_FUNCID_ROOM_RPC
MUN クライアントから送信される、RPC メッセージの unicast 配信、または broadcast 配信要求.
Definition: MunStream.hpp:133
STREAM::MonitoringPullResponse::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:6241
STREAM::MasterRoomForceJoinRequest
MUNクライアントからmun_masterサーバに対して送信される、ルーム強制入室要求.
Definition: MunStream.hpp:2774
STREAM::MasterRoomUpdateRoomParametersResponse::roomParametersLen
uint16 roomParametersLen
ルームパラメータの登録数.
Definition: MunStream.hpp:3851
STREAM::RoomMasterLoginPlayerResponse::RoomMasterLoginPlayerResponse
RoomMasterLoginPlayerResponse()
コンストラクタ.
Definition: MunStream.hpp:4926
STREAM::MasterRoomForceJoinResponse::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:2888
STREAM::RoomUpdateHostIdRequest::RoomUpdateHostIdRequest
RoomUpdateHostIdRequest()
コンストラクタ.
Definition: MunStream.hpp:5777
STREAM::SummaryRoomInfo::SummaryRoomInfo
SummaryRoomInfo(Text &_name, uint8 _maxPlayers, uint8 _isVisible, uint8 _isOpen, int32 _hostId, uint32 _playersLen, KeyValue *_roomParameters, uint16 _roomParametersLen)
コンストラクタ.
Definition: MunStream.hpp:1500
STREAM::ProxyResolverSetAddressRequest::udp_port
uint16 udp_port
UDPポート番号.
Definition: MunStream.hpp:1875
STREAM::ROOMMASTER_FUNCID_ROOMMASTER_LOGINPLAYERRESULT
mun_master サーバから送信される、ルームに対するプレイヤーのログイン結果の通知.
Definition: MunStream.hpp:107
STREAM::MasterSearchPlayersRequest::MasterSearchPlayersRequest
MasterSearchPlayersRequest()
コンストラクタ.
Definition: MunStream.hpp:4168
STREAM::MASTER_FUNCID_MASTER_ROOM_UPDATEISOPENRESULT
mun_master サーバから送信される、ルーム入室可否設定の変更結果の通知.
Definition: MunStream.hpp:78
STREAM::MasterRoomRandomJoinRequest::matchingMode
uint8 matchingMode
マッチングモード.
Definition: MunStream.hpp:3101
STREAM::RESULT_FAILURE_MASTER_ALREADY_JOINED_ROOM
mun_master サーバで、既に同一プレイヤーがルームに入室済みである.
Definition: MunStream.hpp:193
STREAM::AddressInfo::address
Text address
IPアドレス.
Definition: MunStream.hpp:1686
STREAM::RoomRPCResponse::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:6053
STREAM::MasterRoomForceJoinRequest::roomInfo
CreateRoomInfo roomInfo
強制入室するルーム情報.
Definition: MunStream.hpp:2782
STREAM::RoomMasterSetAddressRequest::RoomMasterSetAddressRequest
RoomMasterSetAddressRequest(uint64 _roomUid, Text &_address, uint16 _tcp_port, uint16 _udp_port, uint16 _ws_port, uint16 _wss_port)
コンストラクタ.
Definition: MunStream.hpp:4709
STREAM::UNIONTYPE_INT32
System.Int32 型.
Definition: MunStream.hpp:293
STREAM::MasterRoomUpdateRoomParametersRequest::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:3815
STREAM::MasterRoomUpdateIsVisibleRequest::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:3577
STREAM::ProxyCheckResponse
mun_proxyサーバからMUNクライアントに対して送信される、mun_proxyサーバ認証結果.
Definition: MunStream.hpp:2144
STREAM::RoomMasterUpdatePlayerParametersRequest::roomId
uint64 roomId
ルームID.
Definition: MunStream.hpp:5287
STREAM::SummaryLobbyInfo::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:844
STREAM::MasterRoomForceJoinRequest::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:2836
STREAM::UNIONTYPE
UNIONTYPE
Unionクラスで管理するtypeキー.
Definition: MunStream.hpp:281
STREAM::RoomMasterLogoutPlayerResponse::roomInfo
RoomInfo roomInfo
ルーム情報.
Definition: MunStream.hpp:5086
STREAM::MasterLobbyUpdateResponse::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:2603
STREAM::MATCHINGMODE_RANDOM
ランダム入室において、「条件に適合するルーム群の中から、完全なランダムな１つのルーム」を自動選択しま...
Definition: MunStream.hpp:235
STREAM::CreateRoomInfo::lobbyParameters
Text lobbyParameters[LOBBY_PARAMETERS_MAX]
ロビー通知パラメータ.
Definition: MunStream.hpp:881
STREAM::RoomKickPlayerResponse
mun_room サーバから送信される、対象プレイヤーの強制退室結果.
Definition: MunStream.hpp:6117
STREAM::Union::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:592
STREAM::MasterSearchPlayersRequest::playerNamesLen
uint32 playerNamesLen
検索対象となるプレイヤー名リストの登録数.
Definition: MunStream.hpp:4164
STREAM::RoomUpdateHostIdResponse::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:5871
STREAM::RoomMasterUpdatePlayerParametersRequest::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:5348
STREAM::ROOMMASTER_FUNCID_ROOMMASTER_UPDATEPLAYERNAME
mun_master サーバから送信される、プレイヤーパラメータ変更通知.
Definition: MunStream.hpp:113
STREAM::MasterStatsUpdateResponse::statsInfo
StatsInfo statsInfo
サーバ統計情報.
Definition: MunStream.hpp:4328
STREAM::RoomLoginPlayerResponse::result
int32 result
ログイン処理結果（列挙型ERRORCODE_IDの定数）.
Definition: MunStream.hpp:5525
STREAM::MasterRoomLeaveResponse::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:3381
STREAM::SummaryRoomInfo::SummaryRoomInfo
SummaryRoomInfo()
コンストラクタ.
Definition: MunStream.hpp:1481
STREAM::RoomMasterUpdateHostIdRequest::hostId
int32 hostId
ホストID.
Definition: MunStream.hpp:5159
STREAM::RESULT_FAILURE_MASTER_MISMATCHED_LOBBY
mun_master サーバにおいて、適合するロビーが見つからなかった.
Definition: MunStream.hpp:187
STREAM::MasterLobbyUpdateResponse
mun_masterサーバからMUNクライアントに対して送信される、ロビー更新情報.
Definition: MunStream.hpp:2566
STREAM::MonitoringPullRequest::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:6203
STREAM::MASTER_FUNCID_MASTER_ROOM_UPDATEISVISIBLE
MUN クライアントから送信される、ルーム情報に関するロビー通知設定の変更要求.
Definition: MunStream.hpp:75
STREAM::RESULT_SUCCESS
処理成功.
Definition: MunStream.hpp:160
STREAM::UNIONTYPE_ARRAY_UINT64
System.UInt64[] 型.
Definition: MunStream.hpp:318
STREAM::SummaryLobbyInfo::SummaryLobbyInfo
SummaryLobbyInfo()
コンストラクタ.
Definition: MunStream.hpp:799
STREAM::ProxyResolverSetWeightRequest::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:2013
STREAM::RoomInfo::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:1429
STREAM::RESULT_FAILURE_RESOLVER_MUN_PROXY_NOT_FOUND
mun_resolver サーバにおいて、mun_proxy サーバの接続IPアドレスを取得できない（mun_proxy サーバが mun_r...
Definition: MunStream.hpp:166
STREAM::MasterRoomUpdateRoomParametersRequest::MasterRoomUpdateRoomParametersRequest
MasterRoomUpdateRoomParametersRequest(KeyValue *_roomParameters, uint16 _roomParametersLen)
コンストラクタ.
Definition: MunStream.hpp:3780
STREAM::RoomMasterUpdatePlayerParametersRequest::RoomMasterUpdatePlayerParametersRequest
RoomMasterUpdatePlayerParametersRequest(uint64 _roomId, int32 _playerId, KeyValue *_playerParameters, uint16 _playerParametersLen)
コンストラクタ.
Definition: MunStream.hpp:5307
STREAM::RoomUpdateHostIdRequest::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:5815
MunBuffer.hpp
mrs::Buffer の拡張制御.
STREAM::RoomMasterSetAddressRequest::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:4748
STREAM::PROXYRESOLVER_FUNCID_QUERYDISCONNECTPROXYRESOLVER
未使用（MUN1.x互換のために残している情報）.
Definition: MunStream.hpp:43
STREAM::AddressInfo::AddressInfo
AddressInfo()
コンストラクタ.
Definition: MunStream.hpp:1692
STREAM::RoomMasterLoginPlayerRequest::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:4895
STREAM::MasterRoomUpdateIsVisibleResponse::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:3633
STREAM::Union::Union
Union()
コンストラクタ.
Definition: MunStream.hpp:541
STREAM::UNIONTYPE_BOOL
System.Bool 型.
Definition: MunStream.hpp:290
STREAM::PROXYRESOLVER_FUNCID_QUERYCONNECTPROXYRESOLVER
未使用（MUN1.x互換のために残している情報）.
Definition: MunStream.hpp:37
STREAM::RoomUpdateHostIdResponse::RoomUpdateHostIdResponse
RoomUpdateHostIdResponse(int32 _hostId)
コンストラクタ.
Definition: MunStream.hpp:5840
STREAM::RoomMasterLoginPlayerResponse::RoomMasterLoginPlayerResponse
RoomMasterLoginPlayerResponse(uint32 _clientUidForMasterServer, uint64 _clientUidForProxyServer, int32 _result, uint64 _roomId, RoomInfo &_roomInfo, PlayerInfo &_playerInfo, uint8 _isNeedHostPlayer)
コンストラクタ.
Definition: MunStream.hpp:4943
STREAM::ProxyResolverSetAddressRequest::ProxyResolverSetAddressRequest
ProxyResolverSetAddressRequest(uint64 _proxyUid, Text &_address, uint16 _tcp_port, uint16 _udp_port, uint16 _ws_port, uint16 _wss_port)
コンストラクタ.
Definition: MunStream.hpp:1900
STREAM::ProxyResolverSetAddressRequest::ProxyResolverSetAddressRequest
ProxyResolverSetAddressRequest()
コンストラクタ.
Definition: MunStream.hpp:1883
STREAM::MasterSearchPlayersRequest::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:4211
STREAM::MasterRoomUpdatePlayerParametersResponse::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:4508
STREAM::MasterRoomUpdatePlayerParametersResponse::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:4536
STREAM::ProxyResolverSetWeightRequest::ProxyResolverSetWeightRequest
ProxyResolverSetWeightRequest(uint64 _proxyUid, int32 _weight)
コンストラクタ.
Definition: MunStream.hpp:1986
STREAM::RoomJoinedPlayerResponse::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:5686
STREAM::UNIONTYPE_VECTOR4
UnityEngine.Vector4 型.
Definition: MunStream.hpp:286
STREAM::MasterCheckResponse::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:2387
STREAM::MASTER_FUNCID_MASTER_ROOM_UPDATERESULT
mun_master サーバから送信される、ルーム更新情報の通知.
Definition: MunStream.hpp:84
STREAM::MasterRoomLeaveResponse::result
int32 result
ルーム退室処理結果（列挙型ERRORCODE_IDの定数）.
Definition: MunStream.hpp:3338
STREAM::RoomMasterUpdatePlayerNameRequest::RoomMasterUpdatePlayerNameRequest
RoomMasterUpdatePlayerNameRequest()
コンストラクタ.
Definition: MunStream.hpp:5396
STREAM::ProxyCheckResponse::result
int32 result
認証結果（列挙型ERRORCODE_IDの定数）.
Definition: MunStream.hpp:2152
STREAM::MASTERPROXY_FUNCID_CLIENT_DISCONNECTED
mun_master サーバから送信される、MUN クライアントの切断通知.
Definition: MunStream.hpp:147
STREAM::CreateLobbyInfo::CreateLobbyInfo
CreateLobbyInfo(Text &_lobbyName, uint8 _lobbyKind)
コンストラクタ.
Definition: MunStream.hpp:679
STREAM::RoomMasterUpdateHostIdRequest::RoomMasterUpdateHostIdRequest
RoomMasterUpdateHostIdRequest(uint64 _roomId, int32 _hostId)
コンストラクタ.
Definition: MunStream.hpp:5172
STREAM::Binary::Add
virtual void Add(void *_data, uint32 _size)
バイナリデータの追記.
Definition: MunStream.hpp:463
STREAM::MasterRoomRandomJoinRequest::playerParametersLen
uint16 playerParametersLen
プレイヤーパラメータの登録数.
Definition: MunStream.hpp:3113
STREAM::RoomRPCResponse::data
Binary data
送信データ本体.
Definition: MunStream.hpp:6007
STREAM::ProxyResolverSetAddressRequest::ws_port
uint16 ws_port
WebSocketポート番号.
Definition: MunStream.hpp:1877
STREAM::ProxyResolverSetAddressRequest
mun_proxyサーバからmun_resolverサーバに対して送信される、mun_proxyサーバのアドレス情報.
Definition: MunStream.hpp:1863
STREAM::TARGETS_PLAYER
ある特定の、単一または複数の MUN クライアントに対して、unicast または multicast で配信する.
Definition: MunStream.hpp:219
STREAM::MasterCheckResponse::msg
Text msg
認証結果（メッセージ文字列）.
Definition: MunStream.hpp:2320
STREAM::MasterRoomUpdateRoomParametersResponse::MasterRoomUpdateRoomParametersResponse
MasterRoomUpdateRoomParametersResponse(KeyValue *_roomParameters, uint16 _roomParametersLen)
コンストラクタ.
Definition: MunStream.hpp:3863
STREAM::Binary::size
uint32 size
可変長バイナリのデータサイズ.
Definition: MunStream.hpp:421
STREAM::Union::~Union
virtual ~Union()
デストラクタ.
Definition: MunStream.hpp:556
STREAM::RoomLoginPlayerResponse::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:5622
STREAM::MASTER_FUNCID_MASTER_CHECK
MUN クライアントから送信される、アプリケーション認証要求.
Definition: MunStream.hpp:56
STREAM::MasterSearchPlayersRequest::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:4225
STREAM::MasterRoomUpdateLobbyParametersResponse
mun_masterサーバからMUNクライアントに対して送信される、ロビー通知パラメータ変更要求.
Definition: MunStream.hpp:4009
STREAM::MasterRoomUpdateMaxPlayersResponse::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:3521
STREAM::MasterRoomUpdateRoomParametersResponse
MUNクライアントからmun_masterサーバに対して送信される、ルームパラメータ変更処理結果.
Definition: MunStream.hpp:3843
STREAM::MasterRoomCreateRequest::protocol
uint8 protocol
問い合わせするルームサーバの接続プロトコルの要求について。0 なら TCP, 1なら UDP.
Definition: MunStream.hpp:2636
STREAM::Text::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:378
STREAM::MasterRoomJoinResponse
mun_masterサーバからMUNクライアントに対して送信される、ルーム入室処理結果.
Definition: MunStream.hpp:3018
STREAM::MasterCheckRequest::clientName
Text clientName
クライアント名.
Definition: MunStream.hpp:2227
STREAM::MasterLobbyUpdateResponse::MasterLobbyUpdateResponse
MasterLobbyUpdateResponse(SummaryLobbyInfo &_lobbyInfo, uint8 _isRemove)
コンストラクタ.
Definition: MunStream.hpp:2586
STREAM::UNIONTYPE_INT8
System.SByte 型.
Definition: MunStream.hpp:291
STREAM::RESULT_FAILURE_MASTER_MISMATCHED_CLIENT_DATABASE
mun_master サーバにおいて、クライアントデータベースの照合に失敗した.
Definition: MunStream.hpp:180
STREAM::UNIONTYPE_ARRAY_INT32
System.Int32[] 型.
Definition: MunStream.hpp:313
STREAM::CreateLobbyInfo
ロビー作成情報.
Definition: MunStream.hpp:661
STREAM::PROXYRESOLVER_FUNCID_PROXYRESOLVER_SETADDRESS
mun_proxy サーバから送信される、mun_proxy サーバのクライアントリスニングアドレス情報の通知.
Definition: MunStream.hpp:41
STREAM::ResolverResolveAddressRequest::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:1785
STREAM::RoomKickPlayerResponse::playerId
int32 playerId
プレイヤーID.
Definition: MunStream.hpp:6123
STREAM::MasterRoomUpdateRoomParametersRequest::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:3829
STREAM::MASTER_FUNCID_MASTER_ROOM_UPDATELOBBYPARAMETERS
MUN クライアントから送信される、ロビーパラメータ変更要求.
Definition: MunStream.hpp:81
STREAM::SEARCHPLAYER_IS_OFFLINE
検索対象のプレイヤーは見つからなかった。あるいは、サーバに接続していない.
Definition: MunStream.hpp:241
STREAM::ProxyResolverSetWeightRequest::ProxyResolverSetWeightRequest
ProxyResolverSetWeightRequest()
コンストラクタ.
Definition: MunStream.hpp:1977
STREAM::MasterCheckRequest::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:2287
STREAM::MASTER_FUNCID_MASTER_LOBBY_UPDATE
MUN クライアントから送信される、ロビー更新情報の通知要求.
Definition: MunStream.hpp:61
STREAM::UNIONTYPE_ARRAY_MONOBIT_PLAYER
MonobitEngine.MonobitPlayer[] 型.
Definition: MunStream.hpp:307
STREAM::RoomMasterUpdateHostIdRequest::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:5207
STREAM::MasterRoomUpdatePlayerParametersRequest::MasterRoomUpdatePlayerParametersRequest
MasterRoomUpdatePlayerParametersRequest(KeyValue *_playerParameters, uint16 _playerParametersLen)
コンストラクタ.
Definition: MunStream.hpp:4396
STREAM::MasterRoomCreateResponse::MasterRoomCreateResponse
MasterRoomCreateResponse(int32 _result, AddressInfo &_roomAddressInfo, uint64 _roomUid)
コンストラクタ.
Definition: MunStream.hpp:2725
STREAM::MasterRoomUpdateIsOpenRequest
MUNクライアントからmun_masterサーバに対して送信される、ルーム入室可否設定変更要求.
Definition: MunStream.hpp:3648
STREAM::LobbyInfo::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:758
STREAM::ROOMMASTER_FUNCID_QUERYDISCONNECTROOMMASTER
未使用（MUN1.x互換のために残している情報）.
Definition: MunStream.hpp:114
STREAM::RESULT_FAILURE_ROOM_MISMATCH_MUN_VERSION
MUN クライアントと mun_room サーバとの MUN バージョンが不一致.
Definition: MunStream.hpp:201
STREAM::SummaryRoomInfo::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:1555
STREAM::RoomMasterUpdateHostIdRequest::roomId
uint64 roomId
ルームID.
Definition: MunStream.hpp:5157
STREAM::MASTER_FUNCID_MASTER_STATS_UPDATE
MUN クライアントから送信される、サーバ情報の通知要求.
Definition: MunStream.hpp:87
STREAM::RoomMasterSetAddressRequest::ws_port
uint16 ws_port
WebSocketポート番号.
Definition: MunStream.hpp:4686
STREAM::MASTER_FUNCID_MASTER_ROOM_UPDATEISVISIBLERESULT
mun_master サーバから送信される、ルーム情報に関するロビー通知設定の変更結果の通知.
Definition: MunStream.hpp:76
STREAM::MasterRoomUpdateResponse::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:4147
STREAM::ResolverResolveAddressResponse::ResolverResolveAddressResponse
ResolverResolveAddressResponse()
コンストラクタ.
Definition: MunStream.hpp:1812
STREAM::MasterRoomUpdatePlayerParametersRequest::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:4445
STREAM::MasterRoomCreateRequest
MUNクライアントからmun_masterサーバに対して送信される、ルーム作成要求.
Definition: MunStream.hpp:2630
STREAM::MasterRoomUpdateIsOpenRequest::MasterRoomUpdateIsOpenRequest
MasterRoomUpdateIsOpenRequest()
コンストラクタ.
Definition: MunStream.hpp:3658
STREAM::RESULT_FAILURE_PROXY
未使用（mun_proxy サーバからのエラーコードの最小値閾値）.
Definition: MunStream.hpp:168
STREAM::SearchedPlayerInfo::isOnline
uint8 isOnline
プレイヤーがオンラインかどうかのフラグ.
Definition: MunStream.hpp:1225
STREAM::MasterLobbyUpdateResponse::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:2621
STREAM::MasterSearchPlayersRequest
MUNクライアントからmun_masterサーバに対して送信される、プレイヤー検索要求.
Definition: MunStream.hpp:4156
STREAM::PROTOCOL_WS
WebSocket接続.
Definition: MunStream.hpp:210
STREAM::MASTER_FUNCID_MASTER_ROOM_CREATE
MUN クライアントから送信される、ルーム作成要求.
Definition: MunStream.hpp:63
STREAM::MasterCheckRequest::authId
Text authId
GUID認証コード.
Definition: MunStream.hpp:2225
STREAM::MasterLobbyForceJoinRequest
MUNクライアントからmun_masterサーバに対して送信される、ロビー強制入室要求.
Definition: MunStream.hpp:2421
STREAM::MasterUpdatePlayerNameRequest
MUNクライアントからmun_masterサーバに対して送信される、プレイヤー名変更要求.
Definition: MunStream.hpp:4551
STREAM::RoomMasterSetWeightRequest
mun_roomサーバからmun_masterサーバに対して送信される、mun_roomサーバの負荷情報.
Definition: MunStream.hpp:4774
STREAM::MASTER_FUNCID_QUERYCONNECTMASTER
未使用（MUN1.x互換のために残している情報）.
Definition: MunStream.hpp:50
STREAM::RoomMasterUpdatePlayerParametersRequest
mun_masterサーバからmun_roomサーバに対して送信される、プレイヤーパラメータの変更通知.
Definition: MunStream.hpp:5281
STREAM::SummaryLobbyInfo::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:832
STREAM::RoomLoginPlayerResponse::players
PlayerInfo players[PLAYER_MAX]
ルーム内プレイヤー情報.
Definition: MunStream.hpp:5533
STREAM::RoomRPCRequest::targets
uint8 targets
送信モード（列挙型TARGETS_TYPEの定数）.
Definition: MunStream.hpp:5887
STREAM::MONITOR_FUNCID_MONITORING_PULL_RESPONSE
mun_monitorから送信される、モニタリング情報取得応答.
Definition: MunStream.hpp:154
STREAM::RoomMasterUpdatePlayerParametersRequest::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:5334
STREAM::UNIONTYPE_INT16
System.Int16 型.
Definition: MunStream.hpp:292
STREAM::RESULT_FAILURE_MASTER_FAILED_JOIN_LOBBY
mun_master サーバにおいて、ロビーへの入室に失敗した.
Definition: MunStream.hpp:190
STREAM::ROOMMASTER_FUNCID_ROOMMASTER_LOGOUTPLAYERRESULT
mun_master サーバから送信される、ルームに対するプレイヤーのログアウト結果の通知.
Definition: MunStream.hpp:109
STREAM::RoomMasterUpdateHostIdRequest::RoomMasterUpdateHostIdRequest
RoomMasterUpdateHostIdRequest()
コンストラクタ.
Definition: MunStream.hpp:5163
STREAM::MasterCheckRequest::MasterCheckRequest
MasterCheckRequest()
コンストラクタ.
Definition: MunStream.hpp:2235
STREAM::ResolverResolveAddressRequest::ResolverResolveAddressRequest
ResolverResolveAddressRequest(uint16 _connectType)
コンストラクタ.
Definition: MunStream.hpp:1761
STREAM::RoomMasterLogoutPlayerResponse::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:5121
STREAM::MasterCheckRequest::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:2273
STREAM::ProxyResolverSetAddressRequest::tcp_port
uint16 tcp_port
TCPポート番号.
Definition: MunStream.hpp:1873
STREAM::ROOMMASTER_FUNCID
ROOMMASTER_FUNCID
RoomMasterRPC における payload_type の ID.
Definition: MunStream.hpp:99
STREAM::MASTER_FUNCID_MASTER_ROOM_UPDATEMAXPLAYERS
MUN クライアントから送信される、ルーム収容最大人数変更要求.
Definition: MunStream.hpp:73
STREAM::ROOM_RPC_FOR_TARGET
MonobitTargetによる送信方法を指定する方式.
Definition: MunStream.hpp:260
STREAM::UNIONTYPE_ARRAY_UINT16
System.UInt16[] 型.
Definition: MunStream.hpp:316
STREAM::RoomMasterUpdatePlayerParametersRequest::playerParametersLen
uint16 playerParametersLen
プレイヤーパラメータの登録数.
Definition: MunStream.hpp:5293
STREAM::KeyValue
任意のKey-Valueペア.
Definition: MunStream.hpp:602
STREAM::RoomMasterUpdatePlayerNameRequest::RoomMasterUpdatePlayerNameRequest
RoomMasterUpdatePlayerNameRequest(uint64 _roomId, int32 _playerId, std::string _playerName)
コンストラクタ.
Definition: MunStream.hpp:5406
STREAM::MonitoringPullResponse
mun_monitorから送信される、モニタリング情報取得応答.
Definition: MunStream.hpp:6210
STREAM::MASTER_FUNCID_MASTER_LOBBY_FORCEJOIN
MUN クライアントから送信される、ロビー入室要求.
Definition: MunStream.hpp:58
STREAM::MasterLobbyUpdateResponse::isRemove
uint8 isRemove
そのロビーが削除されたかどうかのフラグ.
Definition: MunStream.hpp:2574
STREAM::MasterRoomUpdateResponse::isRemove
uint8 isRemove
そのルームが削除されたかどうかのフラグ.
Definition: MunStream.hpp:4100
STREAM::RESULT_FAILURE_MASTER_LOBBY_MAX_OVER
mun_master サーバにおいて、管理可能なロビーの上限数を超えてロビーを作成しようとした.
Definition: MunStream.hpp:185
STREAM::RoomLeftPlayerResponse::RoomLeftPlayerResponse
RoomLeftPlayerResponse(int32 _hostId, int32 _playerId)
コンストラクタ.
Definition: MunStream.hpp:5723
STREAM::MasterUpdatePlayerNameResponse::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:4663
STREAM::RoomMasterSetAddressRequest::udp_port
uint16 udp_port
UDPポート番号.
Definition: MunStream.hpp:4684
STREAM::RoomMasterLoginPlayerRequest::clientUidForMasterServer
uint32 clientUidForMasterServer
mun_masterサーバ側におけるクライアント識別ユニークID.
Definition: MunStream.hpp:4845
STREAM::MasterLobbyForceJoinRequest::lobbyInfo
CreateLobbyInfo lobbyInfo
ロビー作成情報.
Definition: MunStream.hpp:2427
STREAM::RoomKickPlayerRequest::playerId
int32 playerId
プレイヤーID.
Definition: MunStream.hpp:6066
STREAM::MASTER_FUNCID_MASTER_UPDATEPLAYERNAMERESULT
mun_master サーバから送信される、プレイヤー名変更結果の通知.
Definition: MunStream.hpp:92
STREAM::MasterRoomCreateResponse::MasterRoomCreateResponse
MasterRoomCreateResponse()
コンストラクタ.
Definition: MunStream.hpp:2715
STREAM::RoomMasterSetWeightRequest::RoomMasterSetWeightRequest
RoomMasterSetWeightRequest()
コンストラクタ.
Definition: MunStream.hpp:4786
STREAM::MATCHINGMODE_DEFAULT
標準的なマッチング。ランダム入室において、「無条件で、最も古いルーム」を自動選択します.
Definition: MunStream.hpp:233
STREAM::SEARCHPLAYER_IS_ONLINE
検索対象のプレイヤーは接続中で、かつ、ルームには入室していない.
Definition: MunStream.hpp:242
STREAM::MasterRoomRandomJoinRequest::lobbyInfo
LobbyInfo lobbyInfo
ロビー情報.
Definition: MunStream.hpp:3103
STREAM::MasterRoomUpdateMaxPlayersRequest::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:3465
STREAM::RESULT_FAILURE_MASTER_CLIENT_MAX_OVER
mun_master サーバにおいて、同時接続可能な MUN クライアントの上限数を超えて接続した（MUNサーバ固有で設...
Definition: MunStream.hpp:184
STREAM::UNIONTYPE_FLOAT
System.Single 型.
Definition: MunStream.hpp:299
STREAM::CreateRoomInfo::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:1027
STREAM::RESULT_FAILURE_PROXY_MISMATCH_MRS_VERSION
MUN クライアントと mun_proxy サーバとの MRS バージョンが不一致.
Definition: MunStream.hpp:169
STREAM::PlayerInfo::id
int32 id
プレイヤーID.
Definition: MunStream.hpp:1064
STREAM::ROOM_RPC_FOR_PLAYER
MonobitPlayer.ID を指定する方式.
Definition: MunStream.hpp:261
STREAM::ResolverResolveAddressRequest::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:1792
STREAM::MasterRoomUpdateMaxPlayersRequest::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:3472
STREAM::Binary::Binary
Binary(void *_data, uint32 _size)
コンストラクタ.
Definition: MunStream.hpp:434
STREAM::UNIONTYPE_NULL
NULL 値.
Definition: MunStream.hpp:282
STREAM::Binary::~Binary
virtual ~Binary()
デストラクタ.
Definition: MunStream.hpp:492
STREAM::CreateRoomInfo::lobbyParametersLen
uint16 lobbyParametersLen
ロビー通知パラメータの登録数.
Definition: MunStream.hpp:883
STREAM::ROOM_FUNCID_ROOM_LEFTPLAYERRESULT
mun_room サーバから送信される、ルームに別の MUN クライアントが退室したことへの通知.
Definition: MunStream.hpp:130
STREAM::RoomRPCRequest::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:5967
STREAM::RoomJoinedPlayerResponse::RoomJoinedPlayerResponse
RoomJoinedPlayerResponse()
コンストラクタ.
Definition: MunStream.hpp:5651
STREAM::MasterRoomJoinRequest::playerParametersLen
uint16 playerParametersLen
プレイヤーパラメータの登録数.
Definition: MunStream.hpp:2930
STREAM::ROOM_FUNCID_QUERYCONNECTROOMRESULT
未使用（MUN1.x互換のために残している情報）.
Definition: MunStream.hpp:122
STREAM::MasterRoomUpdateRoomParametersRequest::roomParameters
KeyValue roomParameters[ROOM_PARAMETERS_MAX]
ルームパラメータ.
Definition: MunStream.hpp:3766
STREAM::ProxyCheckRequest::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:2112
STREAM::ROOM_RPC_FOR_INSTANTIATE
MonobitNetwork.Instantiate によるオブジェクト生成.
Definition: MunStream.hpp:262
STREAM::RESULT_FAILURE_RESOLVER_MISMATCH_MRS_VERSION
MUN クライアントと mun_resolver サーバとの MRS バージョンが不一致.
Definition: MunStream.hpp:164
STREAM::RoomMasterLogoutPlayerResponse::roomId
uint64 roomId
ルームID.
Definition: MunStream.hpp:5084
STREAM::MasterRoomUpdateMaxPlayersResponse::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:3528
STREAM::SummaryPlayerInfo::name
Text name
プレイヤー名.
Definition: MunStream.hpp:1164
STREAM::RoomMasterUpdateHostIdResponse::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:5272
STREAM::MasterCheckRequest::munVer
Text munVer
MUNライブラリバージョン.
Definition: MunStream.hpp:2223
STREAM::RESULT_FAILURE_MASTER_AUTHENTICATION
mun_master サーバにおいて、クライアントの認証に失敗した.
Definition: MunStream.hpp:197
STREAM::RESULT_FAILURE_MASTER_MISMATCH_MUN_VERSION
MUN クライアントと mun_master サーバとの MUN バージョンが不一致.
Definition: MunStream.hpp:176
STREAM::MasterRoomUpdateMaxPlayersRequest::MasterRoomUpdateMaxPlayersRequest
MasterRoomUpdateMaxPlayersRequest()
コンストラクタ.
Definition: MunStream.hpp:3434
STREAM::ROOM_RPC_FOR_TEST
負荷テスト用.
Definition: MunStream.hpp:263
STREAM::RoomMasterLoginPlayerRequest::clientUidForProxyServer
uint64 clientUidForProxyServer
mun_proxyサーバ側におけるクライアント識別ユニークID.
Definition: MunStream.hpp:4847
STREAM::RoomMasterLogoutPlayerResponse::RoomMasterLogoutPlayerResponse
RoomMasterLogoutPlayerResponse(uint64 _roomId, RoomInfo &_roomInfo, int32 _playerId)
コンストラクタ.
Definition: MunStream.hpp:5102
STREAM::MasterRoomUpdateLobbyParametersRequest::MasterRoomUpdateLobbyParametersRequest
MasterRoomUpdateLobbyParametersRequest()
コンストラクタ.
Definition: MunStream.hpp:3938
STREAM::UNIONTYPE_ARRAY_VECTOR4
UnityEngine.Vector4[] 型.
Definition: MunStream.hpp:305
STREAM::MasterRoomForceJoinRequest::MasterRoomForceJoinRequest
MasterRoomForceJoinRequest()
コンストラクタ.
Definition: MunStream.hpp:2788
STREAM::ProxyCheckRequest::isUseCustomAuth
uint8 isUseCustomAuth
カスタム認証サーバへの認証処理を行なうかどうかのフラグ.
Definition: MunStream.hpp:2036
STREAM::ROOM_TRANS_VOICE
クライアントから送信される、ボイスチャット情報（MonobitVoice）.
Definition: MunStream.hpp:251
STREAM::ResolverResolveAddressRequest
MUNクライアントからmun_resolverサーバに対して送信される、mun_proxyサーバのアドレス情報取得要求.
Definition: MunStream.hpp:1744
STREAM::MasterCheckRequest::clientUid
uint64 clientUid
MUNクライアント自身の識別用ユニークID.
Definition: MunStream.hpp:2229
STREAM::RoomRPCRequest::RoomRPCRequest
RoomRPCRequest(uint64 _roomId, uint8 _targets, int32 _senderId, int32 *_targetIds, uint32 _targetIdsLen, Binary &_data)
コンストラクタ.
Definition: MunStream.hpp:5920
STREAM::MasterRoomRandomJoinRequest
MUNクライアントからmun_masterサーバに対して送信される、条件付きランダムルーム入室要求.
Definition: MunStream.hpp:3091
STREAM::RoomRPCRequest::RoomRPCRequest
RoomRPCRequest()
コンストラクタ.
Definition: MunStream.hpp:5899
STREAM::SummaryPlayerInfo::SummaryPlayerInfo
SummaryPlayerInfo()
コンストラクタ.
Definition: MunStream.hpp:1168
STREAM::ROOM_RPC_TYPE
ROOM_RPC_TYPE
ルーム内RPC送信タイプ.
Definition: MunStream.hpp:258
STREAM::RoomMasterUpdateHostIdResponse::RoomMasterUpdateHostIdResponse
RoomMasterUpdateHostIdResponse()
コンストラクタ.
Definition: MunStream.hpp:5228
STREAM::UNIONTYPE_ARRAY_STRING
System.String[] 型.
Definition: MunStream.hpp:321
STREAM::ResolverResolveAddressResponse::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:1847
STREAM::MasterRoomCreateRequest::MasterRoomCreateRequest
MasterRoomCreateRequest()
コンストラクタ.
Definition: MunStream.hpp:2644
STREAM::MasterSearchPlayersRequest::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:4199
STREAM::RoomUpdateHostIdResponse::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:5864
STREAM::ProxyCheckResponse::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:2197
STREAM::ROOM_TRANS_TYPE
ROOM_TRANS_TYPE
ルーム内送信データの属性.
Definition: MunStream.hpp:248
STREAM::LobbyInfo::LobbyInfo
LobbyInfo(Text &_lobbyName, uint8 _lobbyKind)
コンストラクタ.
Definition: MunStream.hpp:741
STREAM::RESULT_FAILURE_MASTER_UNSUPPORTED_LOBBY_KIND
MUN クライアントから指定されたロビー属性が不正、もしくは現在の MUN ではサポートされていない.
Definition: MunStream.hpp:188
STREAM::PROTOCOL_TCP
TCP 接続.
Definition: MunStream.hpp:208
STREAM::RoomKickPlayerRequest::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:6101
STREAM::ERRORCODE_ID
ERRORCODE_ID
エラーコードID.
Definition: MunStream.hpp:159
STREAM::RoomRPCRequest::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:5951
STREAM::MasterRoomUpdateMaxPlayersResponse::maxPlayers
uint32 maxPlayers
ルーム内プレイヤー人数の上限.
Definition: MunStream.hpp:3486
STREAM::MasterRoomUpdateMaxPlayersResponse::MasterRoomUpdateMaxPlayersResponse
MasterRoomUpdateMaxPlayersResponse(uint32 _maxPlayers)
コンストラクタ.
Definition: MunStream.hpp:3497
STREAM::StatsInfo::clientCountInServer
int32 clientCountInServer
サーバに接続しているプレイヤーの人数.
Definition: MunStream.hpp:1605
STREAM::MasterRoomJoinResponse::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:3072
STREAM::RoomRPCRequest
MUNクライアントからmun_roomサーバに対して送信される、汎用的なRPC送信要求.
Definition: MunStream.hpp:5879
STREAM::TARGETS_OTHERS
送信元の MUN クライアントを含めず、ルーム所属クライアント全員に対して broadcast で配信する.
Definition: MunStream.hpp:218
STREAM::SummaryLobbyInfo::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:854
STREAM::UNIONTYPE_ARRAY_INT16
System.Int16[] 型.
Definition: MunStream.hpp:312
STREAM::CreateLobbyInfo::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:706
STREAM::MasterRoomUpdateIsOpenRequest::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:3680
STREAM::RoomMasterUpdatePlayerNameRequest::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:5425
STREAM::Text::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:398
STREAM::RoomKickPlayerResponse::RoomKickPlayerResponse
RoomKickPlayerResponse()
コンストラクタ.
Definition: MunStream.hpp:6127
STREAM::PlayerInfo::PlayerInfo
PlayerInfo(int32 _id, Text &_name, KeyValue *_parameters, uint16 _parametersLen)
コンストラクタ.
Definition: MunStream.hpp:1085
STREAM::RoomInfo::hostId
int32 hostId
ホストID.
Definition: MunStream.hpp:1294
STREAM::PROTOCOL_WSS
WebSocketSecure接続.
Definition: MunStream.hpp:211
STREAM::MasterStatsUpdateResponse::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:4369
STREAM::MASTER_FUNCID_MASTER_ROOM_UPDATELOBBYPARAMETERSRESULT
mun_master サーバから送信される、ロビーパラメータ変更結果の通知.
Definition: MunStream.hpp:82
STREAM::StatsInfo::roomCountInLobby
int32 roomCountInLobby
ルームに入室しているプレイヤーの人数.
Definition: MunStream.hpp:1611
STREAM::MasterRoomUpdatePlayerParametersRequest
MUNクライアントからmun_masterサーバに対して送信される、プレイヤーパラメータ変更要求.
Definition: MunStream.hpp:4376
STREAM::ROOM_FUNCID_SERVERSVC_DESTROY
mun_room サーバから送信される、シーン静的オブジェクトの破棄要求.
Definition: MunStream.hpp:139
STREAM::KeyValue::key
Text key
キー情報.
Definition: MunStream.hpp:606
STREAM::RoomUpdateHostIdRequest::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:5808
STREAM::MasterRoomCreateResponse::result
int32 result
ルーム作成処理結果（列挙型ERRORCODE_IDの定数）.
Definition: MunStream.hpp:2707
STREAM::MasterRoomLeaveResponse
mun_masterサーバからMUNクライアントに対して送信される、ルーム退室処理結果.
Definition: MunStream.hpp:3332
STREAM::RoomMasterUpdateHostIdResponse::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:5264
STREAM::CreateLobbyInfo::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:696
STREAM::ROOM_TRANS_CUSTOM
クライアントから送信される、カスタム情報.
Definition: MunStream.hpp:250
STREAM::RESULT_FAILURE_MASTER_UNUPDATE_ROOM_FILTER
mun_master サーバで、ルームカスタムパラメータの更新に失敗した.
Definition: MunStream.hpp:196
STREAM::UNIONTYPE_OBJECT
System.Object 型.
Definition: MunStream.hpp:326
STREAM::MasterRoomUpdateRoomParametersRequest
MUNクライアントからmun_masterサーバに対して送信される、ルームパラメータ変更要求.
Definition: MunStream.hpp:3760
STREAM::RESULT_FAILURE_MASTER_MISMATCHED_ROOM
mun_master サーバで、該当するルームが生成されていない.
Definition: MunStream.hpp:191
STREAM::MasterRoomRandomJoinRequest::roomParametersLen
uint16 roomParametersLen
ルームパラメータの登録数.
Definition: MunStream.hpp:3109
STREAM::UNIONTYPE_ARRAY_INT64
System.Int64[] 型.
Definition: MunStream.hpp:314
STREAM::RoomMasterUpdateHostIdResponse::hostId
int32 hostId
ホストID.
Definition: MunStream.hpp:5224
STREAM::RoomMasterUpdatePlayerParametersRequest::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:5364
STREAM::RoomMasterUpdatePlayerParametersRequest::playerId
int32 playerId
プレイヤーID.
Definition: MunStream.hpp:5289
STREAM::ROOM_FUNCID_QUERYDISCONNECTROOM
未使用（MUN1.x互換のために残している情報）.
Definition: MunStream.hpp:137
STREAM::KeyValue::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:635
STREAM::RESULT_FAILURE_MASTER_ALREADY_CREATED_ROOM
mun_master サーバで、既に同一ユニークIDを持つルームが生成済みである.
Definition: MunStream.hpp:192
STREAM::MasterSearchPlayersResponse::MasterSearchPlayersResponse
MasterSearchPlayersResponse()
コンストラクタ.
Definition: MunStream.hpp:4251
STREAM::MasterRoomUpdateIsVisibleRequest::isVisible
uint8 isVisible
ルーム情報をロビーに通知するかどうかのフラグ.
Definition: MunStream.hpp:3542
STREAM::RoomInfo::RoomInfo
RoomInfo()
コンストラクタ.
Definition: MunStream.hpp:1308
STREAM::RESULT_FAILURE_MASTER_UNUPDATE_CLIENT_DATABASE
mun_master サーバにおいて、クライアントデータベースへの更新に失敗した.
Definition: MunStream.hpp:181
STREAM::ROOMMASTER_FUNCID_MAX
未使用（ROOMMASTER_FUNCID の最大値閾値）.
Definition: MunStream.hpp:115
STREAM::ProxyCheckRequest::customAuthServerAddress
Text customAuthServerAddress
カスタム認証サーバのアドレス.
Definition: MunStream.hpp:2040
STREAM::MasterRoomUpdateIsVisibleResponse
mun_masterサーバからMUNクライアントに対して送信される、ルーム情報可視化設定変更処理結果.
Definition: MunStream.hpp:3592
STREAM::MasterRoomRandomJoinResponse::result
int32 result
条件付きランダムルーム入室処理結果（列挙型ERRORCODE_IDの定数）.
Definition: MunStream.hpp:3258
STREAM::RoomKickPlayerRequest::RoomKickPlayerRequest
RoomKickPlayerRequest()
コンストラクタ.
Definition: MunStream.hpp:6070
STREAM::KeyValue::value
Union value
値情報.
Definition: MunStream.hpp:608
STREAM::MASTER_FUNCID_QUERYCONNECTMASTERRESULT
未使用（MUN1.x互換のために残している情報）.
Definition: MunStream.hpp:51
STREAM::RoomInfo::name
Text name
ルーム名.
Definition: MunStream.hpp:1286
STREAM::ResolverResolveAddressRequest::ResolverResolveAddressRequest
ResolverResolveAddressRequest()
コンストラクタ.
Definition: MunStream.hpp:1754
STREAM::MonitoringPullResponse::text
Text text
テキスト.
Definition: MunStream.hpp:6216
STREAM::PROXYRESOLVER_FUNCID_MAX
未使用（PROXYRESOLVER_FUNCID の最大値閾値）.
Definition: MunStream.hpp:44
STREAM::CreateRoomInfo::playerParameters
KeyValue playerParameters[PLAYER_PARAMETERS_MAX]
プレイヤーパラメータ.
Definition: MunStream.hpp:885
STREAM::MASTER_FUNCID_MASTER_STATS_UPDATERESULT
mun_master サーバから送信される、サーバ情報の通知.
Definition: MunStream.hpp:88
STREAM::MASTER_FUNCID_MASTER_ROOM_JOIN
MUN クライアントから送信される、ルーム入室要求.
Definition: MunStream.hpp:67
STREAM::RoomMasterLogoutPlayerRequest::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:5069
STREAM::RoomMasterLogoutPlayerRequest
mun_roomサーバからmun_masterサーバに対して送信される、プレイヤーのルームログアウト要求.
Definition: MunStream.hpp:5013
STREAM::MasterRoomRandomJoinResponse::MasterRoomRandomJoinResponse
MasterRoomRandomJoinResponse(int32 _result, Text &_msg, AddressInfo &_roomAddressInfo, uint64 _roomUid)
コンストラクタ.
Definition: MunStream.hpp:3278
STREAM::Text::Text
Text(const char *_text, uint16 _textlength)
コンストラクタ.
Definition: MunStream.hpp:345
STREAM::StatsInfo::clientCountInRoom
int32 clientCountInRoom
ロビーに所属しているルームの数.
Definition: MunStream.hpp:1609
STREAM::MasterRoomUpdateIsVisibleResponse::MasterRoomUpdateIsVisibleResponse
MasterRoomUpdateIsVisibleResponse()
コンストラクタ.
Definition: MunStream.hpp:3602
STREAM::ROOM_FUNCID_SERVERSVC_RPC
mun_room サーバから送信される、RPC メッセージの送信.
Definition: MunStream.hpp:140
STREAM::RoomMasterUpdatePlayerParametersRequest::playerParameters
KeyValue playerParameters[PLAYER_PARAMETERS_MAX]
プレイヤーパラメータ.
Definition: MunStream.hpp:5291
STREAM::MATCHING_MODE
MATCHING_MODE
マッチングモードの設定値.
Definition: MunStream.hpp:232
STREAM::MasterRoomLeaveResponse::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:3394
STREAM::MasterRoomUpdateLobbyParametersResponse::lobbyParametersLen
uint16 lobbyParametersLen
ロビー通知パラメータの登録数.
Definition: MunStream.hpp:4017
STREAM::PlayerInfo::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:1142
STREAM::MasterStatsUpdateResponse::MasterStatsUpdateResponse
MasterStatsUpdateResponse(StatsInfo &_statsInfo)
コンストラクタ.
Definition: MunStream.hpp:4338
STREAM::MASTER_FUNCID_MASTER_ROOM_UPDATEMAXPLAYERSRESULT
mun_master サーバから送信される、ルーム収容最大人数変更結果の通知.
Definition: MunStream.hpp:74
STREAM::ResolverResolveAddressResponse::ResolverResolveAddressResponse
ResolverResolveAddressResponse(int32 _result, AddressInfo &_proxyAddressInfo)
コンストラクタ.
Definition: MunStream.hpp:1820
STREAM::MasterRoomUpdateIsOpenRequest::MasterRoomUpdateIsOpenRequest
MasterRoomUpdateIsOpenRequest(uint8 _isOpen)
コンストラクタ.
Definition: MunStream.hpp:3665
STREAM::MasterLobbyForceJoinResponse::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:2523
STREAM::SummaryRoomInfo::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:1537
STREAM::MasterRoomRandomJoinRequest::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:3226
STREAM::RoomMasterUpdateHostIdResponse::roomId
uint64 roomId
ルームID.
Definition: MunStream.hpp:5222
STREAM::RESOLVER_FUNCID_QUERYHEALTHCHECKRESOLVERRESULT
未使用（MUN1.x互換のために残している情報）.
Definition: MunStream.hpp:27
STREAM::SearchedPlayerInfo::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:1266
STREAM::MasterUpdatePlayerNameRequest::MasterUpdatePlayerNameRequest
MasterUpdatePlayerNameRequest(Text &_playerName)
コンストラクタ.
Definition: MunStream.hpp:4567
STREAM::StatsInfo::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:1661
STREAM::RoomLoginPlayerRequest::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:5502
STREAM::MasterLobbyForceJoinRequest::MasterLobbyForceJoinRequest
MasterLobbyForceJoinRequest(CreateLobbyInfo &_lobbyInfo)
コンストラクタ.
Definition: MunStream.hpp:2436
STREAM::MasterRoomRandomJoinResponse::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:3321
STREAM::MasterCheckRequest::MasterCheckRequest
MasterCheckRequest(Text &_appName, Text &_munVer, Text &_authId, Text &_clientName, uint64 _clientUid, uint8 _isUpdateLobbyInfo)
コンストラクタ.
Definition: MunStream.hpp:2248
STREAM::CreateLobbyInfo::lobbyKind
uint8 lobbyKind
ロビーの属性.
Definition: MunStream.hpp:667
STREAM::RoomRPCRequest::targetIds
int32 targetIds[PLAYER_MAX]
送信相手となるプレイヤーID群.
Definition: MunStream.hpp:5891
STREAM::MasterRoomCreateRequest::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:2692
STREAM::CreateLobbyInfo::CreateLobbyInfo
CreateLobbyInfo()
コンストラクタ.
Definition: MunStream.hpp:671
STREAM::ROOMMASTER_FUNCID_ROOMMASTER_UPDATEPLAYERPARAMETERS
mun_master サーバから送信される、プレイヤーパラメータ変更通知.
Definition: MunStream.hpp:112
STREAM::RoomInfo::playersLen
uint32 playersLen
プレイヤーの登録数.
Definition: MunStream.hpp:1296
STREAM::PROXYRESOLVER_FUNCID
PROXYRESOLVER_FUNCID
ProxyResolverRPC における payload_type の ID.
Definition: MunStream.hpp:36
STREAM::RoomLeftPlayerResponse::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:5750
STREAM::CreateRoomInfo::roomParametersLen
uint16 roomParametersLen
ルームパラメータの登録数.
Definition: MunStream.hpp:879
STREAM::RoomLeftPlayerResponse::RoomLeftPlayerResponse
RoomLeftPlayerResponse()
コンストラクタ.
Definition: MunStream.hpp:5714
STREAM::SummaryPlayerInfo
プレイヤー統計情報.
Definition: MunStream.hpp:1158
STREAM::ROOM_FUNCID_ROOM_JOINEDPLAYER
未使用.
Definition: MunStream.hpp:127
STREAM::MasterRoomForceJoinResponse::result
int32 result
ルーム強制入室処理結果（列挙型ERRORCODE_IDの定数）.
Definition: MunStream.hpp:2851
STREAM::MASTER_FUNCID_MASTER_ROOM_LEAVERESULT
mun_master サーバから送信される、ルーム退室結果の通知.
Definition: MunStream.hpp:72
STREAM::ProxyCheckResponse::authServerRawData
Text authServerRawData
カスタム認証サーバから返信されてきた生データ.
Definition: MunStream.hpp:2154
STREAM::RoomRPCRequest::roomId
uint64 roomId
ルームID.
Definition: MunStream.hpp:5885
STREAM::RoomMasterLogoutPlayerResponse::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:5141
STREAM::SummaryPlayerInfo::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:1203
STREAM::SummaryRoomInfo::isVisible
uint8 isVisible
ルーム情報をロビーに通知するかどうかのフラグ.
Definition: MunStream.hpp:1467
STREAM::RoomMasterSetAddressRequest::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:4734
STREAM::KeyValue::KeyValue
KeyValue(Text &_key, Union &_value)
コンストラクタ.
Definition: MunStream.hpp:618
STREAM::RoomMasterLoginPlayerResponse::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:4999
STREAM::MasterRoomJoinRequest::playerParameters
KeyValue playerParameters[PLAYER_PARAMETERS_MAX]
プレイヤーパラメータ.
Definition: MunStream.hpp:2928
STREAM::MasterRoomLeaveResponse::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:3409
STREAM::RoomLoginPlayerRequest::RoomLoginPlayerRequest
RoomLoginPlayerRequest(uint32 _clientUidForMasterServer, uint64 _clientUidForProxyServer)
コンストラクタ.
Definition: MunStream.hpp:5475
STREAM::SummaryRoomInfo::playersLen
uint32 playersLen
プレイヤーの登録数.
Definition: MunStream.hpp:1473
STREAM::MasterRoomJoinRequest::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:2986
STREAM::RoomMasterUpdatePlayerNameRequest::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:5436
STREAM::MasterUpdatePlayerNameResponse::playerName
Text playerName
プレイヤー名.
Definition: MunStream.hpp:4615
STREAM::ROOMMASTER_FUNCID_QUERYCONNECTROOMMASTERRESULT
未使用（MUN1.x互換のために残している情報）.
Definition: MunStream.hpp:101
STREAM::RoomMasterLogoutPlayerRequest::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:5061
STREAM::ROOM_FUNCID_ROOM_KICKPLAYERRESULT
mun_room サーバから送信される、対象プレイヤーの強制退室結果.
Definition: MunStream.hpp:136
STREAM::MasterCheckRequest::appName
Text appName
アプリケーション名.
Definition: MunStream.hpp:2221
STREAM::CUSTOM_AUTH_PARAMETERS_MAX
MUN クライアントから設定可能な、カスタム認証におけるパラメータの最大値.
Definition: MunStream.hpp:276
STREAM::RoomInfo::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:1377
STREAM::RoomLoginPlayerRequest::clientUidForMasterServer
uint32 clientUidForMasterServer
mun_masterサーバ側におけるクライアント識別ユニークID.
Definition: MunStream.hpp:5460
STREAM::RoomJoinedPlayerResponse::RoomJoinedPlayerResponse
RoomJoinedPlayerResponse(int32 _hostId, PlayerInfo &_playerInfo)
コンストラクタ.
Definition: MunStream.hpp:5659
STREAM::MONITOR_FUNCID_MONITORING_PULL_REQUEST
mun_monitorに対して送信する、モニタリング情報取得要求.
Definition: MunStream.hpp:153
STREAM::CreateRoomInfo::isOpen
uint8 isOpen
他プレイヤーのルーム入室を許可するかどうかのフラグ.
Definition: MunStream.hpp:875
STREAM::CreateRoomInfo::maxPlayers
uint32 maxPlayers
ルーム内プレイヤー人数の上限.
Definition: MunStream.hpp:871
STREAM::UNIONTYPE_UINT8
System.Byte 型.
Definition: MunStream.hpp:295
STREAM::Binary::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:499
STREAM::MasterRoomUpdatePlayerParametersResponse::playerParameters
KeyValue playerParameters[PLAYER_PARAMETERS_MAX]
プレイヤーパラメータ.
Definition: MunStream.hpp:4467
STREAM::MasterUpdatePlayerNameResponse::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:4644
STREAM::MasterCheckResponse::MasterCheckResponse
MasterCheckResponse(int32 _result, Text &_msg, uint32 _clientUid, SummaryLobbyInfo *_lobbyInfo, uint16 _lobbyInfoLen)
コンストラクタ.
Definition: MunStream.hpp:2343
STREAM::RoomMasterLoginPlayerRequest::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:4887
STREAM::RoomUpdateHostIdResponse
mun_roomサーバからMUNクライアントに対して送信される、ホストの変更処理結果.
Definition: MunStream.hpp:5823
STREAM::MasterRoomUpdateResponse
mun_masterサーバからMUNクライアントに対して送信される、ルーム情報更新処理結果.
Definition: MunStream.hpp:4092
STREAM::ROOM_FUNCID_ROOM_UPDATEHOSTID
MUN クライアントから送信される、ルームホスト変更要求.
Definition: MunStream.hpp:131
STREAM::AddressInfo::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:1727
STREAM::MasterStatsUpdateResponse::MasterStatsUpdateResponse
MasterStatsUpdateResponse()
コンストラクタ.
Definition: MunStream.hpp:4332
STREAM::MasterSearchPlayersResponse::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:4308
STREAM::MasterRoomCreateResponse::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:2744
STREAM::RoomMasterSetAddressRequest::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:4761
STREAM::MasterRoomUpdatePlayerParametersRequest::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:4431
STREAM::MasterRoomCreateResponse::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:2764
STREAM::StatsInfo::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:1649
STREAM::MasterRoomUpdateMaxPlayersRequest::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:3456
STREAM::LobbyInfo
ロビー情報.
Definition: MunStream.hpp:723
STREAM::RoomMasterSetWeightRequest::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:4812
STREAM::ResolverResolveAddressRequest::connectType
uint16 connectType
接続プロトコルの種類.
Definition: MunStream.hpp:1750
STREAM::MasterRoomUpdateMaxPlayersRequest::maxPlayers
uint32 maxPlayers
ルーム内プレイヤー人数の上限.
Definition: MunStream.hpp:3430
STREAM::MASTER_FUNCID_MASTER_ROOM_RANDOMJOINRESULT
mun_master サーバから送信される、ルームランダム入室結果の通知.
Definition: MunStream.hpp:70
STREAM::MasterCheckRequest
MUNクライアントからmun_masterサーバに対して送信される、mun_masterサーバ認証情報.
Definition: MunStream.hpp:2215
STREAM::RoomMasterUpdateHostIdRequest
mun_roomサーバからmun_masterサーバに対して送信される、ホストの変更要求.
Definition: MunStream.hpp:5151
STREAM::MasterRoomUpdateRoomParametersRequest::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:3803
STREAM::MasterRoomUpdatePlayerParametersRequest::MasterRoomUpdatePlayerParametersRequest
MasterRoomUpdatePlayerParametersRequest()
コンストラクタ.
Definition: MunStream.hpp:4388
STREAM::MATCHINGMODE_UNIFORM
ランダム入室において、「条件に適合する、最も古いルーム」を自動選択します.
Definition: MunStream.hpp:234
STREAM::UNIONTYPE_DOUBLE
System.Double 型.
Definition: MunStream.hpp:300
STREAM::MasterCheckRequest::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:2299
STREAM::MasterLobbyForceJoinResponse::result
int32 result
ロビー強制入室処理結果（列挙型ERRORCODE_IDの定数）.
Definition: MunStream.hpp:2480
STREAM::MasterLobbyForceJoinResponse
mun_masterサーバからMUNクライアントに対して送信される、ロビー強制入室処理結果.
Definition: MunStream.hpp:2474
STREAM::ProxyCheckRequest::customAuthParameters
KeyValue customAuthParameters[CUSTOM_AUTH_PARAMETERS_MAX]
カスタム認証サーバに送信するパラメータ.
Definition: MunStream.hpp:2044
STREAM::RoomMasterLogoutPlayerRequest::playerId
int32 playerId
プレイヤーID.
Definition: MunStream.hpp:5021
STREAM::MasterRoomLeaveResponse::roomInfoLen
uint16 roomInfoLen
ルーム統計の登録数.
Definition: MunStream.hpp:3342
STREAM::RoomJoinedPlayerResponse::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:5676
STREAM::RoomKickPlayerResponse::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:6166
STREAM::MASTER_FUNCID_MASTER_ROOM_FORCEJOIN
MUN クライアントから送信される、ルーム強制入室要求.
Definition: MunStream.hpp:65
STREAM::MasterRoomRandomJoinRequest::roomParameters
KeyValue roomParameters[ROOM_PARAMETERS_MAX]
ルームパラメータ.
Definition: MunStream.hpp:3107
STREAM::SummaryLobbyInfo::roomCount
int32 roomCount
ロビー内ルーム数.
Definition: MunStream.hpp:793
STREAM::RoomMasterLogoutPlayerResponse::playerId
int32 playerId
プレイヤーID.
Definition: MunStream.hpp:5088
STREAM::RESOLVER_FUNCID_MAX
未使用（RESOLVER_FUNCID の最大値閾値）.
Definition: MunStream.hpp:31
STREAM::RoomLoginPlayerResponse::playersLen
uint32 playersLen
ルーム内プレイヤー情報の数.
Definition: MunStream.hpp:5535
STREAM::PROXYRESOLVER_FUNCID_QUERYCONNECTPROXYRESOLVERRESULT
未使用（MUN1.x互換のために残している情報）.
Definition: MunStream.hpp:38
STREAM::MasterRoomCreateRequest::lobbyInfo
CreateLobbyInfo lobbyInfo
ルームを所属させるロビーの情報.
Definition: MunStream.hpp:2640
STREAM::MasterSearchPlayersResponse::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:4294
STREAM::Text::text
std::string text
可変長テキスト実体.
Definition: MunStream.hpp:335
STREAM::RESOLVER_FUNCID_QUERYCONNECTRESOLVERRESULT
未使用（MUN1.x互換のために残している情報）.
Definition: MunStream.hpp:25
STREAM::RoomMasterLoginPlayerResponse::clientUidForMasterServer
uint32 clientUidForMasterServer
mun_masterサーバ側におけるクライアント識別ユニークID.
Definition: MunStream.hpp:4910
STREAM::PlayerInfo::parameters
KeyValue parameters[PLAYER_PARAMETERS_MAX]
プレイヤーパラメータ.
Definition: MunStream.hpp:1068
STREAM::MasterRoomForceJoinResponse::roomAddressInfo
AddressInfo roomAddressInfo
mun_roomサーバのアドレス情報.
Definition: MunStream.hpp:2853
STREAM::RoomRPCResponse
mun_roomサーバからMUNクライアントに対して送信される、汎用的なRPC送信処理結果.
Definition: MunStream.hpp:6001
STREAM::ROOM_TRANS_RPC
クライアントから送信される、RPCメッセージ情報（MonobitView）.
Definition: MunStream.hpp:252
STREAM::ProxyCheckResponse::ProxyCheckResponse
ProxyCheckResponse(uint64 _clientUid, int32 _result, Text &_authServerRawData)
コンストラクタ.
Definition: MunStream.hpp:2167
STREAM::MasterRoomUpdateResponse::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:4139
STREAM::CreateRoomInfo::name
Text name
ルーム名.
Definition: MunStream.hpp:869
STREAM::PlayerInfo::PlayerInfo
PlayerInfo()
コンストラクタ.
Definition: MunStream.hpp:1074
STREAM::RoomRPCRequest::senderId
int32 senderId
送信者のプレイヤーID.
Definition: MunStream.hpp:5889
STREAM::MasterRoomForceJoinRequest::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:2827
STREAM::MasterRoomForceJoinRequest::lobbyInfo
CreateLobbyInfo lobbyInfo
強制入室するルームが所属するロビー情報.
Definition: MunStream.hpp:2784
STREAM::MasterCheckResponse::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:2404
STREAM::RoomInfo::lobbyParametersLen
uint16 lobbyParametersLen
ロビー通知パラメータの登録数.
Definition: MunStream.hpp:1304
STREAM::MasterLobbyUpdateResponse::lobbyInfo
SummaryLobbyInfo lobbyInfo
ロビー統計情報.
Definition: MunStream.hpp:2572
STREAM::MasterRoomRandomJoinRequest::maxPlayers
uint32 maxPlayers
ルーム内プレイヤー人数の上限.
Definition: MunStream.hpp:3099
STREAM::Text::operator=
Text & operator=(const Text &rRef)
代入処理.
Definition: MunStream.hpp:359
STREAM::MasterRoomUpdateLobbyParametersResponse::MasterRoomUpdateLobbyParametersResponse
MasterRoomUpdateLobbyParametersResponse(Text *_lobbyParameters, uint16 _lobbyParametersLen)
コンストラクタ.
Definition: MunStream.hpp:4029
STREAM::UNIONTYPE_ARRAY_VECTOR3
UnityEngine.Vector3[] 型.
Definition: MunStream.hpp:304
STREAM::ProxyResolverSetWeightRequest::weight
int32 weight
サーバ負荷情報.
Definition: MunStream.hpp:1973
STREAM::RoomMasterLoginPlayerResponse::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:4985
STREAM::MasterCheckResponse
mun_masterサーバからMUNクライアントに対して送信される、mun_masterサーバ認証結果.
Definition: MunStream.hpp:2312
STREAM::UNIONTYPE_ARRAY_VECTOR2
UnityEngine.Vector2[] 型.
Definition: MunStream.hpp:303
STREAM::RoomMasterLoginPlayerResponse::clientUidForProxyServer
uint64 clientUidForProxyServer
mun_proxyサーバ側におけるクライアント識別ユニークID.
Definition: MunStream.hpp:4912
STREAM::UNIONTYPE_ARRAY_DOUBLE
System.Double[] 型.
Definition: MunStream.hpp:320
STREAM::MasterRoomRandomJoinRequest::playerParameters
KeyValue playerParameters[PLAYER_PARAMETERS_MAX]
プレイヤーパラメータ.
Definition: MunStream.hpp:3111
STREAM::MasterRoomForceJoinResponse::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:2908
STREAM::RoomLoginPlayerRequest::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:5492
STREAM::ROOM_LIST_MAX
ロビー内に設置できるルームの最大数.
Definition: MunStream.hpp:270
STREAM::MasterRoomUpdateLobbyParametersRequest
MUNクライアントからmun_masterサーバに対して送信される、ロビー通知パラメータ変更要求.
Definition: MunStream.hpp:3926
STREAM::RoomMasterSetWeightRequest::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:4822
STREAM::LOBBY_PARAMETERS_MAX
１つのルームに対して設定可能な、ロビー通知カスタムパラメータの最大数.
Definition: MunStream.hpp:274
STREAM::TARGETS_TYPE
TARGETS_TYPE
送信先の指定.
Definition: MunStream.hpp:216
STREAM::KeyValue::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:645
STREAM::RESULT_FAILURE
汎用的な処理失敗.
Definition: MunStream.hpp:161
STREAM::LobbyInfo::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:768
STREAM::MasterRoomUpdateIsVisibleResponse::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:3640
STREAM::MasterRoomRandomJoinRequest::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:3200
STREAM
MUNにおける通信データ情報.
Definition: MunStream.hpp:19
STREAM::RoomInfo::lobbyParameters
Text lobbyParameters[LOBBY_PARAMETERS_MAX]
ロビー通知パラメータ.
Definition: MunStream.hpp:1302
STREAM::CreateRoomInfo::roomParameters
KeyValue roomParameters[ROOM_PARAMETERS_MAX]
ルームパラメータ.
Definition: MunStream.hpp:877
STREAM::RoomLeftPlayerResponse
mun_roomサーバからMUNクライアントに対して送信される、誰かがルームからログアウトした結果.
Definition: MunStream.hpp:5702
STREAM::RoomUpdateHostIdResponse::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:5855
STREAM::RoomMasterLogoutPlayerResponse
mun_roomサーバからmun_masterサーバに対して送信される、プレイヤーのルームログアウト処理結果.
Definition: MunStream.hpp:5078
STREAM::RoomMasterUpdatePlayerNameRequest::playerId
int32 playerId
プレイヤーID.
Definition: MunStream.hpp:5388
STREAM::RoomMasterUpdatePlayerParametersRequest::RoomMasterUpdatePlayerParametersRequest
RoomMasterUpdatePlayerParametersRequest()
コンストラクタ.
Definition: MunStream.hpp:5297
STREAM::RoomRPCResponse::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:6046
STREAM::RoomKickPlayerResponse::RoomKickPlayerResponse
RoomKickPlayerResponse(int32 _playerId)
コンストラクタ.
Definition: MunStream.hpp:6134
STREAM::RoomMasterUpdatePlayerNameRequest
mun_masterサーバからmun_roomサーバに対して送信される、プレイヤーパラメータの変更通知.
Definition: MunStream.hpp:5380
STREAM::MASTER_FUNCID
MASTER_FUNCID
MasterRPC における payload_type の ID.
Definition: MunStream.hpp:49
STREAM::ProxyCheckResponse::clientUid
uint64 clientUid
mun_proxy が管理している、MUNクライアント自身の識別用ユニークID.
Definition: MunStream.hpp:2150
STREAM::MasterRoomRandomJoinResponse::roomUid
uint64 roomUid
mun_roomサーバ識別用ユニークID.
Definition: MunStream.hpp:3264
STREAM::MasterRoomUpdateIsOpenRequest::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:3689
STREAM::ProxyCheckResponse::ProxyCheckResponse
ProxyCheckResponse()
コンストラクタ.
Definition: MunStream.hpp:2158
STREAM::RoomMasterSetAddressRequest
mun_roomサーバからmun_masterサーバに対して送信される、mun_roomサーバのアドレス情報.
Definition: MunStream.hpp:4672
STREAM::ROOM_FUNCID_ROOM_JOINEDPLAYERRESULT
mun_room サーバから送信される、ルームに別の MUN クライアントが入室してきたことへの通知.
Definition: MunStream.hpp:128
STREAM::RoomLoginPlayerResponse::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:5604
STREAM::RoomRPCRequest::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:5984
STREAM::RoomMasterUpdateHostIdRequest::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:5189
STREAM::ROOMMASTER_FUNCID_QUERYCONNECTROOMMASTER
未使用（MUN1.x互換のために残している情報）.
Definition: MunStream.hpp:100
STREAM::RoomLoginPlayerResponse::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:5587
STREAM::RoomMasterSetWeightRequest::weight
int32 weight
サーバ負荷情報.
Definition: MunStream.hpp:4782
STREAM::RESULT_FAILURE_MASTER_UNCREATED_MATCHING_DATABASE
mun_master サーバにおいて、マッチングデータベースの構築に失敗した.
Definition: MunStream.hpp:177
STREAM::MasterLobbyForceJoinResponse::roomInfoLen
uint16 roomInfoLen
ルーム統計の登録数.
Definition: MunStream.hpp:2484
STREAM::RoomJoinedPlayerResponse::playerInfo
PlayerInfo playerInfo
プレイヤー情報.
Definition: MunStream.hpp:5647
STREAM::RoomLoginPlayerRequest
MUNクライアントからmun_roomサーバに対して送信される、ルームログイン要求.
Definition: MunStream.hpp:5454
STREAM::MasterRoomJoinResponse::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:3061
STREAM::ProxyResolverSetWeightRequest::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:2021
STREAM::MasterUpdatePlayerNameRequest::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:4582
STREAM::ProxyResolverSetAddressRequest::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:1952
STREAM::MasterSearchPlayersResponse
mun_masterサーバからMUNクライアントに対して送信される、プレイヤー検索処理結果.
Definition: MunStream.hpp:4239
STREAM::MasterRoomCreateResponse
mun_masterサーバからMUNクライアントに対して送信される、ルーム作成処理結果.
Definition: MunStream.hpp:2701
STREAM::Union::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:572
STREAM::SearchedPlayerInfo::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:1256
STREAM::MasterRoomRandomJoinResponse::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:3311
STREAM::MasterRoomJoinResponse::MasterRoomJoinResponse
MasterRoomJoinResponse(int32 _result, AddressInfo &_roomAddressInfo, uint64 _roomUid)
コンストラクタ.
Definition: MunStream.hpp:3042
STREAM::MonitoringPullRequest::MonitoringPullRequest
MonitoringPullRequest()
コンストラクタ.
Definition: MunStream.hpp:6182
STREAM::CreateRoomInfo::CreateRoomInfo
CreateRoomInfo()
コンストラクタ.
Definition: MunStream.hpp:893
STREAM::RESULT_FAILURE_PROXY_MISMATCH_MUN_VERSION
MUN クライアントと mun_proxy サーバとの MUN バージョンが不一致.
Definition: MunStream.hpp:170
STREAM::RESULT_FAILURE_RESOLVER
未使用（mun_resolver サーバからのエラーコードの最小値閾値）.
Definition: MunStream.hpp:163
STREAM::MasterUpdatePlayerNameRequest::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:4591
STREAM::MasterRoomJoinResponse::roomUid
uint64 roomUid
mun_roomサーバ識別用ユニークID.
Definition: MunStream.hpp:3028
STREAM::MasterSearchPlayersResponse::playerInfo
SearchedPlayerInfo playerInfo[PLAYER_MAX]
プレイヤー検索結果リスト.
Definition: MunStream.hpp:4245
STREAM::UNIONTYPE_ARRAY_OBJECT
System.Object[] 型.
Definition: MunStream.hpp:309
STREAM::MasterRoomForceJoinRequest::protocol
uint8 protocol
問い合わせするルームサーバの接続プロトコルの要求について。0 なら TCP, 1なら UDP.
Definition: MunStream.hpp:2780
STREAM::ROOM_TRANS_STREAM
クライアントから送信される、オブジェクト同期などで使用するストリーム情報（MonobitView, MonobitTransformView, MonobitAnimatorView）.
Definition: MunStream.hpp:253
STREAM::ROOM_FUNCID_MAX
未使用（ROOMMASTER_FUNCID の最大値閾値）.
Definition: MunStream.hpp:141
STREAM::MASTER_FUNCID_PROXY_CHECKRESULT
mun_proxy サーバから送信される、クライアント識別用ユニークIDの発行.
Definition: MunStream.hpp:55
STREAM::RoomUpdateHostIdResponse::hostId
int32 hostId
ホストID.
Definition: MunStream.hpp:5829
STREAM::ROOMMASTER_FUNCID_ROOMMASTER_UPDATEHOSTID
mun_room サーバから送信される、ルームホスト変更要求.
Definition: MunStream.hpp:110
STREAM::MasterRoomCreateResponse::roomAddressInfo
AddressInfo roomAddressInfo
mun_roomサーバのアドレス情報.
Definition: MunStream.hpp:2709
STREAM::RoomLeftPlayerResponse::playerId
int32 playerId
ログアウトしたプレイヤーID.
Definition: MunStream.hpp:5710
STREAM::MASTER_FUNCID_QUERYHEALTHCHECKMASTER
未使用（MUN1.x互換のために残している情報）.
Definition: MunStream.hpp:52
STREAM::ROOM_FUNCID_ROOM_LOGINPLAYERRESULT
mun_room サーバから送信される、MUN クライアントのログイン処理結果の通知.
Definition: MunStream.hpp:126
STREAM::ProxyCheckRequest::ProxyCheckRequest
ProxyCheckRequest(uint8 _isUseCustomAuth, uint8 _isUseClientCustomAuthServerAddress, Text &_customAuthServerAddress, uint8 _isIgnoreCustomAuthError, KeyValue *_customAuthParameters, uint16 _customAuthParametersLen)
コンストラクタ.
Definition: MunStream.hpp:2065
STREAM::MasterRoomUpdateIsVisibleRequest
MUNクライアントからmun_masterサーバに対して送信される、ルーム情報可視化設定変更要求.
Definition: MunStream.hpp:3536
STREAM::RESOLVER_FUNCID_QUERYCONNECTRESOLVER
未使用（MUN1.x互換のために残している情報）.
Definition: MunStream.hpp:24
STREAM::MASTER_FUNCID_MASTER_ROOM_UPDATEISOPEN
MUN クライアントから送信される、ルーム入室可否設定の変更要求.
Definition: MunStream.hpp:77
STREAM::CreateRoomInfo::CreateRoomInfo
CreateRoomInfo(Text &_name, uint32 _maxPlayers, uint8 _isVisible, uint8 _isOpen, KeyValue *_roomParameters, uint16 _roomParametersLen, Text *_lobbyParameters, uint16 _lobbyParametersLen, KeyValue *_playerParameters, uint16 _playerParametersLen, uint8 _isNeedHostPlayer)
コンストラクタ.
Definition: MunStream.hpp:916
STREAM::MasterRoomUpdateLobbyParametersResponse::lobbyParameters
Text lobbyParameters[LOBBY_PARAMETERS_MAX]
ロビー通知パラメータ.
Definition: MunStream.hpp:4015
STREAM::RoomMasterLoginPlayerRequest::RoomMasterLoginPlayerRequest
RoomMasterLoginPlayerRequest()
コンストラクタ.
Definition: MunStream.hpp:4851
STREAM::UNIONTYPE_STRING
System.String 型.
Definition: MunStream.hpp:301
STREAM::RoomLoginPlayerResponse::RoomLoginPlayerResponse
RoomLoginPlayerResponse(int32 _result, uint64 _roomId, RoomInfo &_roomInfo, int32 _playerId, PlayerInfo *_players, uint32 _playersLen)
コンストラクタ.
Definition: MunStream.hpp:5554
STREAM::RoomJoinedPlayerResponse::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:5694
STREAM::MASTER_FUNCID_MASTER_ROOM_JOINRESULT
mun_master サーバから送信される、ルーム強制入室結果の通知.
Definition: MunStream.hpp:68
STREAM::UNIONTYPE_UINT32
System.UInt32 型.
Definition: MunStream.hpp:297
STREAM::MasterLobbyForceJoinResponse::MasterLobbyForceJoinResponse
MasterLobbyForceJoinResponse()
コンストラクタ.
Definition: MunStream.hpp:2488
STREAM::RESULT_FAILURE_MASTER_UNCREATED_CLIENT_DATABASE
mun_master サーバにおいて、クライアントデータベースの構築に失敗した.
Definition: MunStream.hpp:179
STREAM::ProxyCheckResponse::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:2186
STREAM::MasterRoomUpdateIsOpenResponse::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:3736
STREAM::UNIONTYPE_ARRAY_UINT8
System.Byte[] 型.
Definition: MunStream.hpp:315
STREAM::RoomLoginPlayerResponse::roomInfo
RoomInfo roomInfo
ルーム情報.
Definition: MunStream.hpp:5529
STREAM::StatsInfo
サーバ統計情報.
Definition: MunStream.hpp:1601
STREAM::MasterRoomJoinRequest
MUNクライアントからmun_masterサーバに対して送信される、ルーム入室要求.
Definition: MunStream.hpp:2918
STREAM::MasterLobbyForceJoinResponse::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:2551
STREAM::MonitoringPullRequest::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:6188
STREAM::MasterRoomCreateRequest::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:2672
STREAM::MasterUpdatePlayerNameResponse::MasterUpdatePlayerNameResponse
MasterUpdatePlayerNameResponse(int32 _playerId, Text &_playerName)
コンストラクタ.
Definition: MunStream.hpp:4627
STREAM::SearchedPlayerInfo::SearchedPlayerInfo
SearchedPlayerInfo(uint8 _isOnline, Text &_roomName)
コンストラクタ.
Definition: MunStream.hpp:1239
STREAM::Union::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:582
STREAM::MASTERPROXY_FUNCID
MASTERPROXY_FUNCID
mun_masterサーバ⇔mun_proxyサーバ間 における payload_type の ID.
Definition: MunStream.hpp:146
STREAM::MasterUpdatePlayerNameResponse::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:4654
STREAM::MonitoringPullResponse::MonitoringPullResponse
MonitoringPullResponse()
コンストラクタ.
Definition: MunStream.hpp:6220
STREAM::SearchedPlayerInfo
プレイヤー検索結果情報.
Definition: MunStream.hpp:1221
STREAM::MonitoringPullRequest
mun_monitorに対して送信する、モニタリング情報取得要求.
Definition: MunStream.hpp:6174
STREAM::ProxyResolverSetAddressRequest::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:1925
STREAM::LobbyInfo::lobbyKind
uint8 lobbyKind
ロビーの属性.
Definition: MunStream.hpp:729
STREAM::MasterCheckResponse::lobbyInfoLen
uint16 lobbyInfoLen
ロビー統計情報の登録数.
Definition: MunStream.hpp:2326
STREAM::MasterRoomJoinRequest::protocol
uint8 protocol
問い合わせするルームサーバの接続プロトコルの要求について。0 なら TCP, 1なら UDP.
Definition: MunStream.hpp:2924
STREAM::PROTOCOL_ID
PROTOCOL_ID
接続プロトコル.
Definition: MunStream.hpp:206
STREAM::ResolverResolveAddressResponse
mun_resolverサーバからMUNクライアントに対して送信される、mun_proxyサーバのアドレス情報取得結果.
Definition: MunStream.hpp:1800
STREAM::MasterLobbyForceJoinRequest::MasterLobbyForceJoinRequest
MasterLobbyForceJoinRequest()
コンストラクタ.
Definition: MunStream.hpp:2431
STREAM::ROOMMASTER_FUNCID_ROOMMASTER_SETWEIGHT
mun_room サーバから送信される、mun_room サーバのクライアント接続負荷情報の通知.
Definition: MunStream.hpp:105
STREAM::MasterUpdatePlayerNameResponse::playerId
int32 playerId
プレイヤーID.
Definition: MunStream.hpp:4613
STREAM::RESULT_FAILURE_ROOM_MISMATCH_MRS_VERSION
MUN クライアントと mun_room サーバとの MRS バージョンが不一致.
Definition: MunStream.hpp:200
STREAM::RESOLVER_FUNCID_QUERYDISCONNECTRESOLVER
未使用（MUN1.x互換のために残している情報）.
Definition: MunStream.hpp:30
STREAM::Binary::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:519
STREAM::ROOMMASTER_FUNCID_ROOMMASTER_UPDATEHOSTIDRESULT
mun_master サーバから送信される、ルームホスト変更結果の通知.
Definition: MunStream.hpp:111
STREAM::ProxyResolverSetAddressRequest::proxyUid
uint64 proxyUid
プロキシサーバ自身のユニークID.
Definition: MunStream.hpp:1869
STREAM::ProxyResolverSetWeightRequest::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:2003
STREAM::MasterCheckResponse::lobbyInfo
SummaryLobbyInfo lobbyInfo[LOBBY_LIST_MAX]
ロビー統計情報.
Definition: MunStream.hpp:2324
STREAM::UNIONTYPE_INT64
System.Int64 型.
Definition: MunStream.hpp:294
STREAM::MasterCheckResponse::clientUid
uint32 clientUid
mun_master が管理している、MUNクライアント自身の識別用ユニークID.
Definition: MunStream.hpp:2322
STREAM::RoomMasterSetAddressRequest::roomUid
uint64 roomUid
ルームサーバ自身のユニークID.
Definition: MunStream.hpp:4678
STREAM::MASTER_FUNCID_MASTER_ROOM_RANDOMJOIN
MUN クライアントから送信される、ルームランダム入室要求.
Definition: MunStream.hpp:69
STREAM::ROOM_FUNCID_SERVERSVC_INSTANTIATE
mun_room サーバから送信される、シーン静的オブジェクトの生成要求.
Definition: MunStream.hpp:138
STREAM::MasterRoomRandomJoinResponse::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:3299
STREAM::Binary::Clear
virtual void Clear()
バイナリデータの消去.
Definition: MunStream.hpp:451
STREAM::ROOMMASTER_FUNCID_QUERYHEALTHCHECKROOMMASTERRESULT
未使用（MUN1.x互換のために残している情報）.
Definition: MunStream.hpp:103
STREAM::RESULT_FAILURE_PROXY_DENYED_CUSTOM_AUTH
mun_proxy サーバにおいて、MUN クライアントのカスタム認証処理に失敗した.
Definition: MunStream.hpp:171
STREAM::RoomInfo::roomParametersLen
uint16 roomParametersLen
ルームパラメータの登録数.
Definition: MunStream.hpp:1300
STREAM::MasterStatsUpdateResponse
mun_masterサーバからMUNクライアントに対して送信される、サーバ統計情報.
Definition: MunStream.hpp:4322
STREAM::RoomMasterSetAddressRequest::address
Text address
IPアドレス.
Definition: MunStream.hpp:4680
STREAM::ResolverResolveAddressResponse::result
int32 result
アドレス情報取得結果（列挙型ERRORCODE_IDの定数）.
Definition: MunStream.hpp:1806
STREAM::MasterRoomUpdateIsOpenResponse::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:3752
STREAM::MasterRoomUpdateRoomParametersResponse::MasterRoomUpdateRoomParametersResponse
MasterRoomUpdateRoomParametersResponse()
コンストラクタ.
Definition: MunStream.hpp:3855
STREAM::MASTER_FUNCID_MASTER_LOBBY_LEAVE
MUN クライアントから送信される、ロビー退室要求.
Definition: MunStream.hpp:60
STREAM::LOBBYKIND_ID
LOBBYKIND_ID
ロビー属性値.
Definition: MunStream.hpp:224
STREAM::ProxyResolverSetAddressRequest::address
Text address
IPアドレス.
Definition: MunStream.hpp:1871
STREAM::Text::~Text
virtual ~Text()
デストラクタ.
Definition: MunStream.hpp:373
STREAM::RoomMasterLoginPlayerResponse::isNeedHostPlayer
uint8 isNeedHostPlayer
ホストプレイヤーが必要かどうかのフラグ.
Definition: MunStream.hpp:4922
STREAM::CreateRoomInfo::isVisible
uint8 isVisible
ルーム情報をロビーに通知するかどうかのフラグ.
Definition: MunStream.hpp:873
STREAM::CreateRoomInfo::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:969
STREAM::MasterRoomJoinRequest::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:3002
STREAM::Union::data
Binary data
変数データ本体.
Definition: MunStream.hpp:537
STREAM::SearchedPlayerInfo::roomName
Text roomName
プレイヤーがルームに入室している場合、そのルーム名.
Definition: MunStream.hpp:1227
STREAM::RoomMasterSetWeightRequest::RoomMasterSetWeightRequest
RoomMasterSetWeightRequest(uint64 _roomUid, int32 _weight)
コンストラクタ.
Definition: MunStream.hpp:4795
STREAM::Binary::Binary
Binary(const Binary &binary)
コンストラクタ.
Definition: MunStream.hpp:443
STREAM::MasterRoomJoinResponse::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:3081
STREAM::LOBBYKIND_DEFAULT
デフォルトロビーを含む、標準的なロビー。ロビー属性の中で、最もサーバへの負荷が低い.
Definition: MunStream.hpp:225
STREAM::MasterRoomForceJoinResponse
mun_masterサーバからMUNクライアントに対して送信される、ルーム強制入室処理結果.
Definition: MunStream.hpp:2845
STREAM::MasterRoomRandomJoinRequest::protocol
uint8 protocol
問い合わせするルームサーバの接続プロトコルの要求について。0 なら TCP, 1なら UDP.
Definition: MunStream.hpp:3097
STREAM::MasterRoomUpdateIsVisibleRequest::MasterRoomUpdateIsVisibleRequest
MasterRoomUpdateIsVisibleRequest()
コンストラクタ.
Definition: MunStream.hpp:3546
STREAM::SummaryRoomInfo
ルーム統計情報.
Definition: MunStream.hpp:1459
STREAM::MasterRoomForceJoinResponse::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:2899
STREAM::ROOM_FUNCID
ROOM_FUNCID
RoomRPC における payload_type の ID.
Definition: MunStream.hpp:120
STREAM::UNIONTYPE_MONOBIT_PLAYER
MonobitEngine.MonobitPlayer 型.
Definition: MunStream.hpp:288
STREAM::RoomMasterUpdatePlayerNameRequest::playerParametersLen
uint16 playerParametersLen
プレイヤーパラメータの登録数.
Definition: MunStream.hpp:5392
STREAM::Binary::data
uint8 * data
可変長バイナリ実体.
Definition: MunStream.hpp:419
STREAM::LobbyInfo::lobbyName
Text lobbyName
ロビー名.
Definition: MunStream.hpp:727
STREAM::MasterRoomUpdateLobbyParametersRequest::lobbyParameters
Text lobbyParameters[LOBBY_PARAMETERS_MAX]
ロビー通知パラメータ.
Definition: MunStream.hpp:3932
STREAM::MasterRoomUpdateIsVisibleResponse::isVisible
uint8 isVisible
ルーム情報をロビーに通知するかどうかのフラグ.
Definition: MunStream.hpp:3598
STREAM::PlayerInfo::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:1112
STREAM::MasterRoomJoinRequest::MasterRoomJoinRequest
MasterRoomJoinRequest(uint8 _protocol, Text &_roomName, KeyValue *_playerParameters, uint16 _playerParametersLen)
コンストラクタ.
Definition: MunStream.hpp:2945
STREAM::ProxyCheckRequest::ProxyCheckRequest
ProxyCheckRequest()
コンストラクタ.
Definition: MunStream.hpp:2050
STREAM::MASTER_FUNCID_MASTER_SEARCHPLAYERSRESULT
mun_master サーバから送信される、プレイヤー検索結果の通知.
Definition: MunStream.hpp:86
STREAM::MasterRoomUpdateLobbyParametersRequest::MasterRoomUpdateLobbyParametersRequest
MasterRoomUpdateLobbyParametersRequest(Text *_lobbyParameters, uint16 _lobbyParametersLen)
コンストラクタ.
Definition: MunStream.hpp:3946
STREAM::MONITOR_FUNCID
MONITOR_FUNCID
MonitorRPC における payload_type の ID.
Definition: MunStream.hpp:152
STREAM::RoomJoinedPlayerResponse::hostId
int32 hostId
ルームホストとなるプレイヤーID.
Definition: MunStream.hpp:5645
STREAM::RoomMasterUpdateHostIdResponse::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:5254
STREAM::Text::Text
Text()
コンストラクタ.
Definition: MunStream.hpp:339
STREAM::CreateRoomInfo
ルーム作成情報.
Definition: MunStream.hpp:865
STREAM::MasterUpdatePlayerNameRequest::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:4599
STREAM::MasterRoomUpdatePlayerParametersResponse::MasterRoomUpdatePlayerParametersResponse
MasterRoomUpdatePlayerParametersResponse(int32 _playerId, KeyValue *_playerParameters, uint16 _playerParametersLen)
コンストラクタ.
Definition: MunStream.hpp:4483
STREAM::MasterRoomRandomJoinRequest::MasterRoomRandomJoinRequest
MasterRoomRandomJoinRequest()
コンストラクタ.
Definition: MunStream.hpp:3117
STREAM::Union::type
uint8 type
変数型（列挙型UNIONTYPEの定数）.
Definition: MunStream.hpp:535
STREAM::SummaryRoomInfo::maxPlayers
uint32 maxPlayers
ルーム内プレイヤー人数の上限.
Definition: MunStream.hpp:1465
STREAM::MasterRoomUpdateMaxPlayersResponse::MasterRoomUpdateMaxPlayersResponse
MasterRoomUpdateMaxPlayersResponse()
コンストラクタ.
Definition: MunStream.hpp:3490
STREAM::RoomRPCRequest::targetIdsLen
uint32 targetIdsLen
送信相手となるプレイヤーIDの数.
Definition: MunStream.hpp:5893
STREAM::MasterRoomRandomJoinResponse::msg
Text msg
条件付きランダムルーム入室処理結果（メッセージ文字列）.
Definition: MunStream.hpp:3260
STREAM::MasterRoomUpdateRoomParametersResponse::roomParameters
KeyValue roomParameters[ROOM_PARAMETERS_MAX]
ルームパラメータ.
Definition: MunStream.hpp:3849
STREAM::RoomLeftPlayerResponse::hostId
int32 hostId
ルームホストとなるプレイヤーID.
Definition: MunStream.hpp:5708
STREAM::MasterRoomUpdateResponse::MasterRoomUpdateResponse
MasterRoomUpdateResponse(SummaryRoomInfo &_roomInfo, uint8 _isRemove)
コンストラクタ.
Definition: MunStream.hpp:4112
STREAM::RESOLVER_FUNCID_RESOLVER_RESOLVEADDRESSRESULT
mun_resolver サーバから送信される、mun_proxy サーバのクライアントリスニングアドレス情報の取得結果通知...
Definition: MunStream.hpp:29
STREAM::TARGETS_ALL
送信元の MUN クライアントを含む、ルーム所属クライアント全員に対して broadcast で配信する.
Definition: MunStream.hpp:217
STREAM::MasterRoomForceJoinResponse::MasterRoomForceJoinResponse
MasterRoomForceJoinResponse()
コンストラクタ.
Definition: MunStream.hpp:2859
STREAM::SummaryLobbyInfo::lobbyName
Text lobbyName
ロビー名.
Definition: MunStream.hpp:789
STREAM::MasterLobbyForceJoinRequest::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:2451
STREAM::MASTER_FUNCID_MAX
未使用（MASTER_FUNCID の最大値閾値）.
Definition: MunStream.hpp:94
STREAM::AddressInfo::port
uint16 port
ポート番号.
Definition: MunStream.hpp:1688
STREAM::LOBBYKIND_SQL
ランダム入室において、「条件に適合する、最も古いルーム」を自動選択します.
Definition: MunStream.hpp:226
STREAM::MasterRoomJoinRequest::MasterRoomJoinRequest
MasterRoomJoinRequest()
コンストラクタ.
Definition: MunStream.hpp:2934
STREAM::MasterLobbyForceJoinResponse::MasterLobbyForceJoinResponse
MasterLobbyForceJoinResponse(int32 _result, SummaryRoomInfo *_roomInfo, uint16 _roomInfoLen)
コンストラクタ.
Definition: MunStream.hpp:2498
STREAM::SEARCHPLAYER_IS_IN_ROOM
検索対象のプレイヤーは接続中で、かつ、ルームに入室中である.
Definition: MunStream.hpp:243
STREAM::StatsInfo::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:1671
STREAM::RoomKickPlayerResponse::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:6149
STREAM::RoomMasterSetWeightRequest::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:4830
STREAM::MasterRoomForceJoinRequest::MasterRoomForceJoinRequest
MasterRoomForceJoinRequest(uint8 _protocol, CreateRoomInfo &_roomInfo, CreateLobbyInfo &_lobbyInfo)
コンストラクタ.
Definition: MunStream.hpp:2797
STREAM::MasterRoomCreateResponse::roomUid
uint64 roomUid
mun_roomサーバ識別用ユニークID.
Definition: MunStream.hpp:2711
STREAM::RoomMasterLoginPlayerResponse::roomInfo
RoomInfo roomInfo
ルーム情報.
Definition: MunStream.hpp:4918
STREAM::RoomLoginPlayerResponse::roomId
uint64 roomId
ルームID.
Definition: MunStream.hpp:5527
STREAM::MASTER_FUNCID_MASTER_ROOM_UPDATEPLAYERPARAMETERSRESULT
mun_master サーバから送信される、プレイヤーパラメータ変更結果の通知.
Definition: MunStream.hpp:90
STREAM::MasterRoomCreateRequest::roomInfo
CreateRoomInfo roomInfo
作成するルームの情報.
Definition: MunStream.hpp:2638
STREAM::PLAYER_MAX
ルーム内に入室可能なプレイヤーの最大数.
Definition: MunStream.hpp:271
STREAM::UNIONTYPE_ARRAY_BOOL
System.Bool[] 型.
Definition: MunStream.hpp:310
STREAM::ResolverResolveAddressResponse::proxyAddressInfo
AddressInfo proxyAddressInfo
アドレス情報.
Definition: MunStream.hpp:1808
STREAM::CreateRoomInfo::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:994
STREAM::MASTER_FUNCID_MASTER_UPDATEPLAYERNAME
MUN クライアントから送信される、プレイヤー名変更要求.
Definition: MunStream.hpp:91
STREAM::Binary::Binary
Binary()
コンストラクタ.
Definition: MunStream.hpp:425
STREAM::ROOMMASTER_FUNCID_ROOMMASTER_LOGINPLAYER
mun_room サーバから送信される、ルームに対するプレイヤーのログイン要求.
Definition: MunStream.hpp:106
STREAM::RoomMasterSetWeightRequest::roomUid
uint64 roomUid
ルームサーバ自身のユニークID.
Definition: MunStream.hpp:4780
STREAM::MASTER_FUNCID_QUERYHEALTHCHECKMASTERRESULT
未使用（MUN1.x互換のために残している情報）.
Definition: MunStream.hpp:53
STREAM::MasterRoomLeaveResponse::MasterRoomLeaveResponse
MasterRoomLeaveResponse()
コンストラクタ.
Definition: MunStream.hpp:3346
STREAM::RoomLoginPlayerRequest::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:5510
STREAM::MasterUpdatePlayerNameRequest::playerName
Text playerName
プレイヤー名.
Definition: MunStream.hpp:4557
STREAM::AddressInfo::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:1717
STREAM::MasterRoomCreateRequest::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:2683
STREAM::RESULT_FAILURE_MASTER_MISMATCH_MRS_VERSION
MUN クライアントと mun_master サーバとの MRS バージョンが不一致.
Definition: MunStream.hpp:175
STREAM::PROXYRESOLVER_FUNCID_QUERYHEALTHCHECKPROXYRESOLVERRESULT
未使用（MUN1.x互換のために残している情報）.
Definition: MunStream.hpp:40
STREAM::SummaryLobbyInfo::playerCount
int32 playerCount
ロビー内プレイヤー数.
Definition: MunStream.hpp:795
STREAM::CreateLobbyInfo::lobbyName
Text lobbyName
ロビー名.
Definition: MunStream.hpp:665
STREAM::PlayerInfo::name
Text name
プレイヤー名.
Definition: MunStream.hpp:1066
STREAM::SearchedPlayerInfo::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:1274
STREAM::MasterRoomJoinResponse::MasterRoomJoinResponse
MasterRoomJoinResponse()
コンストラクタ.
Definition: MunStream.hpp:3032
STREAM::PLAYER_PARAMETERS_MAX
１つのプレイヤーに対して設定可能な、プレイヤーカスタムパラメータの最大数.
Definition: MunStream.hpp:272
STREAM::ROOM_FUNCID_ROOM_KICKPLAYER
MUN クライアントから送信される、対象プレイヤーの強制退室要求.
Definition: MunStream.hpp:135
STREAM::MasterRoomForceJoinResponse::MasterRoomForceJoinResponse
MasterRoomForceJoinResponse(int32 _result, AddressInfo &_roomAddressInfo, uint64 _roomUid)
コンストラクタ.
Definition: MunStream.hpp:2869
STREAM::RoomLoginPlayerResponse
mun_roomサーバからMUNクライアントに対して送信される、ルームログイン処理結果.
Definition: MunStream.hpp:5519
STREAM::CreateLobbyInfo::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:714
STREAM::MasterLobbyForceJoinRequest::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:2467
STREAM::ROOMMASTER_FUNCID_ROOMMASTER_LOGOUTPLAYER
mun_room サーバから送信される、ルームに対するプレイヤーのログアウト要求.
Definition: MunStream.hpp:108
STREAM::MasterLobbyForceJoinResponse::roomInfo
SummaryRoomInfo roomInfo[ROOM_LIST_MAX]
ルーム統計情報.
Definition: MunStream.hpp:2482
STREAM::ROOM_RPC_BUFFER_MAX
MUN クライアントからまとめて送信することが可能な RPC メッセージ群の最大値.
Definition: MunStream.hpp:275
STREAM::SummaryPlayerInfo::SummaryPlayerInfo
SummaryPlayerInfo(int32 _id, Text &_name)
コンストラクタ.
Definition: MunStream.hpp:1176
STREAM::MasterRoomUpdateLobbyParametersResponse::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:4078
STREAM::ResolverResolveAddressResponse::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:1837
STREAM::ROOM_FUNCID_ROOM_RPCRESULT
mun_room サーバから送信される、RPC メッセージの unicast 配信、または broadcast 配信.
Definition: MunStream.hpp:134
STREAM::MasterRoomCreateRequest::MasterRoomCreateRequest
MasterRoomCreateRequest(uint8 _protocol, CreateRoomInfo &_roomInfo, CreateLobbyInfo &_lobbyInfo)
コンストラクタ.
Definition: MunStream.hpp:2653
STREAM::RoomLoginPlayerResponse::RoomLoginPlayerResponse
RoomLoginPlayerResponse()
コンストラクタ.
Definition: MunStream.hpp:5539
STREAM::MasterCheckRequest::isUpdateLobbyInfo
uint8 isUpdateLobbyInfo
ロビー情報を更新するかどうかのフラグ.
Definition: MunStream.hpp:2231
STREAM::MasterRoomUpdateLobbyParametersRequest::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:3995
STREAM::SummaryPlayerInfo::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:1193
STREAM::MasterRoomUpdateIsVisibleRequest::MasterRoomUpdateIsVisibleRequest
MasterRoomUpdateIsVisibleRequest(uint8 _isVisible)
コンストラクタ.
Definition: MunStream.hpp:3553
STREAM::MasterRoomUpdateIsOpenRequest::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:3696
STREAM::RESULT_FAILURE_MASTER
未使用（mun_master サーバからのエラーコードの最小値閾値）.
Definition: MunStream.hpp:174
STREAM::RESOLVER_FUNCID
RESOLVER_FUNCID
ResolverRPC における payload_type の ID.
Definition: MunStream.hpp:23
STREAM::RESULT_FAILURE_MASTER_CLOSED_ROOM
MUN クライアントから入室要求を受けたルームが、入室拒否に設定されている.
Definition: MunStream.hpp:194
STREAM::RoomMasterLogoutPlayerRequest::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:5051
STREAM::PlayerInfo::parametersLen
uint16 parametersLen
プレイヤーパラメータの登録数.
Definition: MunStream.hpp:1070
STREAM::Text
可変長テキスト.
Definition: MunStream.hpp:331
STREAM::LobbyInfo::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:776
STREAM::UNIONTYPE_ARRAY_UINT32
System.UInt32[] 型.
Definition: MunStream.hpp:317
STREAM::RESULT_FAILURE_MASTER_FAILED_FORCEJOIN_LOBBY
mun_master サーバにおいて、ロビーへの強制入室に失敗した.
Definition: MunStream.hpp:189
STREAM::MasterRoomUpdateLobbyParametersResponse::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:4052
STREAM::MasterRoomRandomJoinRequest::keyValueFilter
Text keyValueFilter
範囲検索用クエリー.
Definition: MunStream.hpp:3105
STREAM::RoomUpdateHostIdResponse::RoomUpdateHostIdResponse
RoomUpdateHostIdResponse()
コンストラクタ.
Definition: MunStream.hpp:5833
STREAM::KeyValue::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:653
STREAM::MasterSearchPlayersResponse::MasterSearchPlayersResponse
MasterSearchPlayersResponse(SearchedPlayerInfo *_playerInfo, uint32 _playerInfoLen)
コンストラクタ.
Definition: MunStream.hpp:4259
STREAM::MasterRoomForceJoinResponse::roomUid
uint64 roomUid
mun_roomサーバ識別用ユニークID.
Definition: MunStream.hpp:2855
STREAM::MASTER_FUNCID_MASTER_ROOM_UPDATEROOMPARAMETERSRESULT
mun_master サーバから送信される、ルームパラメータ変更結果の通知.
Definition: MunStream.hpp:80
STREAM::MonitoringPullRequest::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:6196
STREAM::UNIONTYPE_VECTOR3
UnityEngine.Vector3 型.
Definition: MunStream.hpp:285
STREAM::UNIONTYPE_ARRAY_INT8
System.SByte[] 型.
Definition: MunStream.hpp:311
STREAM::MasterRoomJoinRequest::roomName
Text roomName
ルーム名.
Definition: MunStream.hpp:2926
STREAM::MASTER_FUNCID_MASTER_ROOM_LEAVE
MUN クライアントから送信される、ルーム退室要求.
Definition: MunStream.hpp:71
STREAM::Binary
可変長バイナリ.
Definition: MunStream.hpp:415
STREAM::MasterRoomUpdateIsVisibleResponse::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:3624
STREAM::ROOM_PARAMETERS_MAX
１つのルームに対して設定可能な、ルームカスタムパラメータの最大数.
Definition: MunStream.hpp:273
STREAM::MasterRoomUpdateIsOpenResponse::isOpen
uint8 isOpen
他プレイヤーのルーム入室を許可するかどうかのフラグ.
Definition: MunStream.hpp:3710
STREAM::ProxyResolverSetWeightRequest::proxyUid
uint64 proxyUid
プロキシサーバ自身のユニークID.
Definition: MunStream.hpp:1971
STREAM::UNIONTYPE_QUATERNION
UnityEngine.Quatenion 型.
Definition: MunStream.hpp:287
STREAM::PROTOCOL_NONE
接続タイプなし.
Definition: MunStream.hpp:207
STREAM::RoomMasterLoginPlayerResponse::result
int32 result
ログイン許可処理結果（列挙型ERRORCODE_IDの定数）.
Definition: MunStream.hpp:4914
STREAM::StatsInfo::clientCountInLobby
int32 clientCountInLobby
ロビーに入室しているプレイヤーの人数.
Definition: MunStream.hpp:1607
STREAM::ROOM_FUNCID_ROOM_LEFTPLAYER
未使用.
Definition: MunStream.hpp:129
STREAM::CreateRoomInfo::isNeedHostPlayer
uint8 isNeedHostPlayer
ホストプレイヤーが必要かどうかのフラグ.
Definition: MunStream.hpp:889
STREAM::RoomLoginPlayerResponse::playerId
int32 playerId
プレイヤーID.
Definition: MunStream.hpp:5531
STREAM::MasterCheckResponse::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:2372
STREAM::ProxyCheckRequest::isIgnoreCustomAuthError
uint8 isIgnoreCustomAuthError
カスタム認証サーバへの認証処理でエラーが発生した場合無視するかどうかのフラグ.
Definition: MunStream.hpp:2042
STREAM::MonitoringPullResponse::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:6258
STREAM::RoomUpdateHostIdRequest::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:5799
STREAM::RoomMasterLogoutPlayerResponse::RoomMasterLogoutPlayerResponse
RoomMasterLogoutPlayerResponse()
コンストラクタ.
Definition: MunStream.hpp:5092
STREAM::MAX_LIMIT
MAX_LIMIT
各種上限値.
Definition: MunStream.hpp:268
STREAM::MasterRoomUpdateIsOpenResponse::MasterRoomUpdateIsOpenResponse
MasterRoomUpdateIsOpenResponse(uint8 _isOpen)
コンストラクタ.
Definition: MunStream.hpp:3721
STREAM::ROOMMASTER_FUNCID_QUERYHEALTHCHECKROOMMASTER
未使用（MUN1.x互換のために残している情報）.
Definition: MunStream.hpp:102
STREAM::RoomRPCResponse::RoomRPCResponse
RoomRPCResponse()
コンストラクタ.
Definition: MunStream.hpp:6011
STREAM::RoomKickPlayerRequest::RoomKickPlayerRequest
RoomKickPlayerRequest(int32 _playerId)
コンストラクタ.
Definition: MunStream.hpp:6077
STREAM::SummaryLobbyInfo::lobbyKind
uint8 lobbyKind
ロビーの属性.
Definition: MunStream.hpp:791
STREAM::RoomMasterLoginPlayerRequest
mun_roomサーバからmun_masterサーバに対して送信される、プレイヤーのルームログイン要求.
Definition: MunStream.hpp:4839
STREAM::MasterRoomRandomJoinResponse::roomAddressInfo
AddressInfo roomAddressInfo
mun_roomサーバのアドレス情報.
Definition: MunStream.hpp:3262
STREAM::MasterSearchPlayersRequest::MasterSearchPlayersRequest
MasterSearchPlayersRequest(Text *_playerNames, uint32 _playerNamesLen)
コンストラクタ.
Definition: MunStream.hpp:4176
STREAM::RoomRPCRequest::~RoomRPCRequest
virtual ~RoomRPCRequest()
デストラクタ.
Definition: MunStream.hpp:5908
STREAM::MasterRoomCreateResponse::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:2755
STREAM::ProxyResolverSetAddressRequest::wss_port
uint16 wss_port
WebSocketSecureポート番号.
Definition: MunStream.hpp:1879
STREAM::LOBBY_LIST_MAX
ロビーの最大数.
Definition: MunStream.hpp:269
STREAM::MASTER_FUNCID_MASTER_ROOM_UPDATEPLAYERPARAMETERS
MUN クライアントから送信される、プレイヤーパラメータ変更要求.
Definition: MunStream.hpp:89
STREAM::MasterRoomUpdateMaxPlayersRequest
MUNクライアントからmun_masterサーバに対して送信される、ルーム内プレイヤー人数の上限変更要求.
Definition: MunStream.hpp:3424
STREAM::RoomMasterLogoutPlayerRequest::roomId
uint64 roomId
ルームID.
Definition: MunStream.hpp:5019
STREAM::MasterCheckResponse::result
int32 result
認証結果（列挙型ERRORCODE_IDの定数）.
Definition: MunStream.hpp:2318
STREAM::RoomInfo
ルーム情報.
Definition: MunStream.hpp:1282
STREAM::MasterRoomRandomJoinResponse
mun_masterサーバからMUNクライアントに対して送信される、条件付きランダムルーム入室処理結果.
Definition: MunStream.hpp:3252
STREAM::AddressInfo::AddressInfo
AddressInfo(Text &_address, uint16 _port)
コンストラクタ.
Definition: MunStream.hpp:1700
STREAM::ProxyCheckRequest::isUseClientCustomAuthServerAddress
uint8 isUseClientCustomAuthServerAddress
カスタム認証サーバのアドレスについて、MUN クライアント側から設定したものを使用尾するかどうかのフラグ...
Definition: MunStream.hpp:2038
STREAM::MasterRoomUpdateLobbyParametersRequest::lobbyParametersLen
uint16 lobbyParametersLen
ロビー通知パラメータの登録数.
Definition: MunStream.hpp:3934
STREAM::MasterRoomJoinResponse::roomAddressInfo
AddressInfo roomAddressInfo
mun_roomサーバのアドレス情報.
Definition: MunStream.hpp:3026
STREAM::MasterRoomUpdateIsOpenResponse::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:3745
STREAM::RESOLVER_FUNCID_QUERYHEALTHCHECKRESOLVER
未使用（MUN1.x互換のために残している情報）.
Definition: MunStream.hpp:26
STREAM::ProxyResolverSetWeightRequest
mun_proxyサーバからmun_resolverサーバに対して送信される、mun_proxyサーバの負荷情報.
Definition: MunStream.hpp:1965
STREAM::MasterSearchPlayersRequest::playerNames
Text playerNames[PLAYER_MAX]
検索対象となるプレイヤー名リスト.
Definition: MunStream.hpp:4162
STREAM::MasterStatsUpdateResponse::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:4362
STREAM::RoomMasterLoginPlayerRequest::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:4877
STREAM::MasterRoomUpdateLobbyParametersResponse::MasterRoomUpdateLobbyParametersResponse
MasterRoomUpdateLobbyParametersResponse()
コンストラクタ.
Definition: MunStream.hpp:4021
STREAM::MasterRoomUpdateLobbyParametersRequest::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:3969
STREAM::MasterRoomForceJoinRequest::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:2816
STREAM::PlayerInfo
プレイヤー情報.
Definition: MunStream.hpp:1060
STREAM::RoomMasterUpdateHostIdResponse::RoomMasterUpdateHostIdResponse
RoomMasterUpdateHostIdResponse(uint64 _roomId, int32 _hostId)
コンストラクタ.
Definition: MunStream.hpp:5237
STREAM::PROTOCOL_UDP
UDP 接続.
Definition: MunStream.hpp:209
STREAM::MasterLobbyForceJoinResponse::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:2536
STREAM::UNIONTYPE_ARRAY_QUATERNION
UnityEngine.Quatenion[] 型.
Definition: MunStream.hpp:306
STREAM::RESULT_FAILURE_MASTER_UNUPDATE_ROOM_DATABASE
mun_master サーバにおいて、ルームデータベースへの更新に失敗した.
Definition: MunStream.hpp:182
STREAM::ProxyCheckRequest::Unpack
bool Unpack(MunBuffer &buffer)
MunBufferからのアンパッキング.
Definition: MunStream.hpp:2128
STREAM::MASTER_FUNCID_MASTER_CHECKRESULT
mun_master サーバから送信される、アプリケーション認証結果の通知.
Definition: MunStream.hpp:57
STREAM::RoomRPCResponse::~RoomRPCResponse
virtual ~RoomRPCResponse()
デストラクタ.
Definition: MunStream.hpp:6015
STREAM::SummaryRoomInfo::hostId
int32 hostId
ホストID.
Definition: MunStream.hpp:1471
STREAM::RESOLVER_FUNCID_RESOLVER_RESOLVEADDRESS
MUN クライアントから送信される、mun_proxy サーバのクライアントリスニングアドレス情報の取得要求.
Definition: MunStream.hpp:28
STREAM::RESULT_FAILURE_MASTER_ROOM_MAX_OVER
mun_master サーバにおいて、管理可能なルームの上限数を超えてルームを作成しようとした.
Definition: MunStream.hpp:186
STREAM::SEARCHPLAYER_RESULT_STATUS
SEARCHPLAYER_RESULT_STATUS
プレイヤー検索結果のステータスID.
Definition: MunStream.hpp:240
STREAM::Binary::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:509
STREAM::UNIONTYPE_UINT16
System.UInt16 型.
Definition: MunStream.hpp:296
STREAM::MASTER_FUNCID_QUERYDISCONNECTMASTER
未使用（MUN1.x互換のために残している情報）.
Definition: MunStream.hpp:93
STREAM::MasterRoomUpdateRoomParametersRequest::MasterRoomUpdateRoomParametersRequest
MasterRoomUpdateRoomParametersRequest()
コンストラクタ.
Definition: MunStream.hpp:3772
STREAM::StatsInfo::StatsInfo
StatsInfo()
コンストラクタ.
Definition: MunStream.hpp:1615
STREAM::Union
任意の変数.
Definition: MunStream.hpp:531
STREAM::MasterLobbyForceJoinRequest::Pack
bool Pack(MunBuffer &buffer)
MunBufferへのパッキング.
Definition: MunStream.hpp:2460
STREAM::MasterSearchPlayersResponse::playerInfoLen
uint32 playerInfoLen
プレイヤー検索結果リストの登録数.
Definition: MunStream.hpp:4247
STREAM::ROOM_FUNCID_ROOM_UPDATEHOSTIDRESULT
mun_room サーバから送信される、ルームホスト変更結果の通知.
Definition: MunStream.hpp:132
STREAM::MasterSearchPlayersResponse::Size
uint32 Size()
データサイズの取得.
Definition: MunStream.hpp:4282