diff --git a/gocode/src/gameserver/dispatcher.go b/gocode/src/gameserver/dispatcher.go new file mode 100644 index 00000000..55f1e348 --- /dev/null +++ b/gocode/src/gameserver/dispatcher.go @@ -0,0 +1,65 @@ +/***************************************************************************** + * PokerTH dedicated server * + * Copyright (C) 2014 Lothar May * + * * + * This program is free software: you can redistribute it and/or modify * + * it under the terms of the GNU Affero General Public License as * + * published by the Free Software Foundation, either version 3 of the * + * License, or (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU Affero General Public License for more details. * + * * + * You should have received a copy of the GNU Affero General Public License * + * along with this program. If not, see . * + * * + * * + * Additional permission under GNU AGPL version 3 section 7 * + * * + * If you modify this program, or any covered work, by linking or * + * combining it with the OpenSSL project's OpenSSL library (or a * + * modified version of that library), containing parts covered by the * + * terms of the OpenSSL or SSLeay licenses, the authors of PokerTH * + * (Felix Hammer, Florian Thauer, Lothar May) grant you additional * + * permission to convey the resulting work. * + * Corresponding Source for a non-source form of such a combination * + * shall include the source code for the parts of OpenSSL used as well * + * as that of the covered work. * + *****************************************************************************/ +package gameserver + +import ( + "log" + "sync/atomic" +) + +type Dispatcher struct { + handler PacketHandler + receiver chan SessionPacket + lastSessionId uint32 +} + +func NewDispatcher(handler PacketHandler) *Dispatcher { + return &Dispatcher{handler, make(chan SessionPacket, RECV_DISPATCHER_NUM_PACKET_BUF), 0} +} + +func (d *Dispatcher) GetReceiver() *chan SessionPacket { + return &d.receiver +} + +func (d *Dispatcher) GetNextSessionId() uint32 { + return atomic.AddUint32(&d.lastSessionId, 1) +} + +func (d *Dispatcher) Run() { + var sessionPacket SessionPacket + for { + select { + case sessionPacket = <-d.receiver: + log.Printf("Packet in dispatcher session %d type %d", sessionPacket.session.id, sessionPacket.packet.GetMessageType()) + d.handler.HandlePacket(sessionPacket.session, sessionPacket.packet) + } + } +} diff --git a/gocode/src/gameserver/lobby.go b/gocode/src/gameserver/lobby.go new file mode 100644 index 00000000..f8784209 --- /dev/null +++ b/gocode/src/gameserver/lobby.go @@ -0,0 +1,76 @@ +/***************************************************************************** + * PokerTH dedicated server * + * Copyright (C) 2014 Lothar May * + * * + * This program is free software: you can redistribute it and/or modify * + * it under the terms of the GNU Affero General Public License as * + * published by the Free Software Foundation, either version 3 of the * + * License, or (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU Affero General Public License for more details. * + * * + * You should have received a copy of the GNU Affero General Public License * + * along with this program. If not, see . * + * * + * * + * Additional permission under GNU AGPL version 3 section 7 * + * * + * If you modify this program, or any covered work, by linking or * + * combining it with the OpenSSL project's OpenSSL library (or a * + * modified version of that library), containing parts covered by the * + * terms of the OpenSSL or SSLeay licenses, the authors of PokerTH * + * (Felix Hammer, Florian Thauer, Lothar May) grant you additional * + * permission to convey the resulting work. * + * Corresponding Source for a non-source form of such a combination * + * shall include the source code for the parts of OpenSSL used as well * + * as that of the covered work. * + *****************************************************************************/ +package gameserver + +import ( + "code.google.com/p/goprotobuf/proto" + "container/list" + "log" + "pokerth" +) + +type PacketHandler interface { + HandlePacket(session *Session, packet *pokerth.PokerTHMessage) +} + +type Lobby struct { + sessions *list.List +} + +func NewLobby() *Lobby { + return &Lobby{list.New()} +} + +func (l *Lobby) AddSession(session *Session) { + log.Print("New session") + l.sessions.PushBack(session) + announce := &pokerth.PokerTHMessage{ + MessageType: pokerth.PokerTHMessage_PokerTHMessageType.Enum(pokerth.PokerTHMessage_Type_AnnounceMessage), + AnnounceMessage: &pokerth.AnnounceMessage{ + ProtocolVersion: &pokerth.AnnounceMessage_Version{ + MajorVersion: proto.Uint32(NET_VERSION_MAJOR), + MinorVersion: proto.Uint32(NET_VERSION_MINOR), + }, + LatestGameVersion: &pokerth.AnnounceMessage_Version{ + MajorVersion: proto.Uint32(POKERTH_VERSION_MAJOR), + MinorVersion: proto.Uint32(POKERTH_VERSION_MINOR), + }, + LatestBetaRevision: proto.Uint32(0), + ServerType: pokerth.AnnounceMessage_ServerType.Enum(pokerth.AnnounceMessage_serverTypeInternetAuth), + NumPlayersOnServer: proto.Uint32(0), + }, + } + session.sender <- announce +} + +func (l *Lobby) HandlePacket(session *Session, packet *pokerth.PokerTHMessage) { + log.Print("packet") +} diff --git a/gocode/src/gameserver/packetserializer.go b/gocode/src/gameserver/packetserializer.go new file mode 100644 index 00000000..c7fcaf80 --- /dev/null +++ b/gocode/src/gameserver/packetserializer.go @@ -0,0 +1,103 @@ +/***************************************************************************** + * PokerTH dedicated server * + * Copyright (C) 2014 Lothar May * + * * + * This program is free software: you can redistribute it and/or modify * + * it under the terms of the GNU Affero General Public License as * + * published by the Free Software Foundation, either version 3 of the * + * License, or (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU Affero General Public License for more details. * + * * + * You should have received a copy of the GNU Affero General Public License * + * along with this program. If not, see . * + * * + * * + * Additional permission under GNU AGPL version 3 section 7 * + * * + * If you modify this program, or any covered work, by linking or * + * combining it with the OpenSSL project's OpenSSL library (or a * + * modified version of that library), containing parts covered by the * + * terms of the OpenSSL or SSLeay licenses, the authors of PokerTH * + * (Felix Hammer, Florian Thauer, Lothar May) grant you additional * + * permission to convey the resulting work. * + * Corresponding Source for a non-source form of such a combination * + * shall include the source code for the parts of OpenSSL used as well * + * as that of the covered work. * + *****************************************************************************/ +package gameserver + +import ( + "encoding/binary" + "pokerth" +) + +const NET_HEADER_SIZE uint32 = 4 + +type PacketSerializer interface { + ReadPacket(buf []byte, num uint32) (uint32, *pokerth.PokerTHMessage) + WritePacket(buf []byte, packet *pokerth.PokerTHMessage) uint32 +} + +func readPacketRaw(buf []byte, num uint32) (uint32, *pokerth.PokerTHMessage) { + packet := &pokerth.PokerTHMessage{} + err := packet.Unmarshal(buf[0:num]) + if err != nil { + packet = nil + } + return num, packet +} + +func readPacketWithHeader(buf []byte, num uint32) (uint32, *pokerth.PokerTHMessage) { + var bytesScanned uint32 = 0 + var packetSize uint32 = 0 + packet := &pokerth.PokerTHMessage{} + if num >= NET_HEADER_SIZE { + packetSize = binary.BigEndian.Uint32(buf[0:NET_HEADER_SIZE]) + if packetSize <= 0 { + bytesScanned = NET_HEADER_SIZE + } else if num >= NET_HEADER_SIZE+packetSize { + bytesScanned, packet = readPacketRaw(buf[NET_HEADER_SIZE:], NET_HEADER_SIZE+packetSize) + } + } + return bytesScanned, packet +} + +func writePacketGeneric(buf []byte, packet *pokerth.PokerTHMessage, headerSize uint32) uint32 { + var bytesWritten uint32 = 0 + num, err := packet.MarshalTo(buf[headerSize:]) + if err == nil { + if headerSize > 0 { + binary.BigEndian.PutUint32(buf[0:headerSize], uint32(num)) + bytesWritten = uint32(num) + headerSize + } else { + bytesWritten = uint32(num) + } + } + return bytesWritten +} + +type RawPacketSerializer struct { +} + +func (RawPacketSerializer) ReadPacket(buf []byte, num uint32) (uint32, *pokerth.PokerTHMessage) { + return readPacketRaw(buf, num) +} + +func (RawPacketSerializer) WritePacket(buf []byte, packet *pokerth.PokerTHMessage) uint32 { + return writePacketGeneric(buf, packet, 0) +} + +type HeaderPacketSerializer struct { +} + +func (HeaderPacketSerializer) ReadPacket(buf []byte, num uint32) (uint32, *pokerth.PokerTHMessage) { + return readPacketWithHeader(buf, num) +} + +func (HeaderPacketSerializer) WritePacket(buf []byte, packet *pokerth.PokerTHMessage) uint32 { + return writePacketGeneric(buf, packet, NET_HEADER_SIZE) +} diff --git a/gocode/src/gameserver/session.go b/gocode/src/gameserver/session.go new file mode 100644 index 00000000..20674b5e --- /dev/null +++ b/gocode/src/gameserver/session.go @@ -0,0 +1,130 @@ +/***************************************************************************** + * PokerTH dedicated server * + * Copyright (C) 2014 Lothar May * + * * + * This program is free software: you can redistribute it and/or modify * + * it under the terms of the GNU Affero General Public License as * + * published by the Free Software Foundation, either version 3 of the * + * License, or (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU Affero General Public License for more details. * + * * + * You should have received a copy of the GNU Affero General Public License * + * along with this program. If not, see . * + * * + * * + * Additional permission under GNU AGPL version 3 section 7 * + * * + * If you modify this program, or any covered work, by linking or * + * combining it with the OpenSSL project's OpenSSL library (or a * + * modified version of that library), containing parts covered by the * + * terms of the OpenSSL or SSLeay licenses, the authors of PokerTH * + * (Felix Hammer, Florian Thauer, Lothar May) grant you additional * + * permission to convey the resulting work. * + * Corresponding Source for a non-source form of such a combination * + * shall include the source code for the parts of OpenSSL used as well * + * as that of the covered work. * + *****************************************************************************/ +package gameserver + +import ( + "log" + "net" + "pokerth" +) + +const POKERTH_VERSION_MAJOR = 1 +const POKERTH_VERSION_MINOR = 11 + +const NET_VERSION_MAJOR = 5 +const NET_VERSION_MINOR = 1 + +const MAX_PACKET_SIZE uint32 = 384 +const RECV_BUF_SIZE uint32 = 4 * MAX_PACKET_SIZE +const SEND_BUF_SIZE uint32 = 2 * MAX_PACKET_SIZE +const SEND_NUM_PACKET_BUF = 2048 +const RECV_DISPATCHER_NUM_PACKET_BUF = 2048 + +type Session struct { + id uint32 + PacketSerializer + Connection net.Conn + sender chan *pokerth.PokerTHMessage + receiver *chan SessionPacket +} + +type SessionPacket struct { + session *Session + packet *pokerth.PokerTHMessage +} + +func NewSession(id uint32, serializer PacketSerializer, conn net.Conn, receiver *chan SessionPacket) *Session { + return &Session{id, serializer, conn, make(chan *pokerth.PokerTHMessage, SEND_NUM_PACKET_BUF), receiver} +} + +func (s *Session) Run() { + // run sender as separate goroutine + go s.handleSend() + s.handleReceive() +} + +func (s *Session) handleReceive() { + // close connection on exit + defer s.Connection.Close() + + var buf [RECV_BUF_SIZE]byte + var bufPos uint32 = 0 + for { + // read upto RECV_BUF_SIZE bytes + num, err := s.Connection.Read(buf[bufPos:]) + bufPos += uint32(num) + if err != nil { + log.Printf("Read error: %s\n", err.Error()) + return + } + + bytesScanned, packet := s.ReadPacket(buf[0:bufPos], bufPos) + + if bytesScanned > 0 { + if packet == nil { + log.Print("Invalid packet") + } else { + log.Printf("Packet in: %d\n", packet.GetMessageType()) + *s.receiver <- SessionPacket{s, packet} + remainingBytes := bufPos - bytesScanned + if remainingBytes > 0 { + copy(buf[0:], buf[bytesScanned:remainingBytes]) + bufPos = remainingBytes + } else { + bufPos = 0 + } + } + } + } +} + +func (s *Session) handleSend() { + var buf [RECV_BUF_SIZE]byte + var packet *pokerth.PokerTHMessage + for { + select { + case packet = <-s.sender: + packetSize := s.WritePacket(buf[0:RECV_BUF_SIZE], packet) + if packetSize > 0 { + var bufStart uint32 = 0 + for bufStart < packetSize { + num, err := s.Connection.Write(buf[bufStart:packetSize]) + if err != nil { + log.Printf("Write error: %s\n", err.Error()) + return + } + bufStart += uint32(num) + } + log.Printf("Packet out: %d, size: %d\n", packet.GetMessageType(), packetSize) + } + } + } +} diff --git a/gocode/src/main/main.go b/gocode/src/main/main.go new file mode 100644 index 00000000..8ae5d17e --- /dev/null +++ b/gocode/src/main/main.go @@ -0,0 +1,77 @@ +/***************************************************************************** + * PokerTH dedicated server * + * Copyright (C) 2014 Lothar May * + * * + * This program is free software: you can redistribute it and/or modify * + * it under the terms of the GNU Affero General Public License as * + * published by the Free Software Foundation, either version 3 of the * + * License, or (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU Affero General Public License for more details. * + * * + * You should have received a copy of the GNU Affero General Public License * + * along with this program. If not, see . * + * * + * * + * Additional permission under GNU AGPL version 3 section 7 * + * * + * If you modify this program, or any covered work, by linking or * + * combining it with the OpenSSL project's OpenSSL library (or a * + * modified version of that library), containing parts covered by the * + * terms of the OpenSSL or SSLeay licenses, the authors of PokerTH * + * (Felix Hammer, Florian Thauer, Lothar May) grant you additional * + * permission to convey the resulting work. * + * Corresponding Source for a non-source form of such a combination * + * shall include the source code for the parts of OpenSSL used as well * + * as that of the covered work. * + *****************************************************************************/ +package main + +import ( + "code.google.com/p/go.net/websocket" + "gameserver" + "log" + "net" + "net/http" +) + +var lobby *gameserver.Lobby +var dispatcher *gameserver.Dispatcher + +func main() { + lobby = gameserver.NewLobby() + dispatcher = gameserver.NewDispatcher(lobby) + go dispatcher.Run() + + listener, err := net.Listen("tcp", ":7234") + if err != nil { + log.Fatalf("Listen error: %s", err.Error()) + } + go acceptSockets(listener) + + server := websocket.Server{Handler: handleWebsocketConn} + http.Handle("/pokerthwebsocket", server) + http.ListenAndServe(":7233", nil) +} + +func acceptSockets(listener net.Listener) { + for { + conn, err := listener.Accept() + if err != nil { + log.Fatalf("Accept error: %s\n", err.Error()) + } + s := gameserver.NewSession(dispatcher.GetNextSessionId(), gameserver.HeaderPacketSerializer{}, conn, dispatcher.GetReceiver()) + lobby.AddSession(s) + go s.Run() + } +} + +func handleWebsocketConn(ws *websocket.Conn) { + ws.PayloadType = websocket.BinaryFrame + s := gameserver.NewSession(dispatcher.GetNextSessionId(), gameserver.RawPacketSerializer{}, ws, dispatcher.GetReceiver()) + lobby.AddSession(s) + s.Run() +} diff --git a/gocode/src/pokerth/pokerth.pb.go b/gocode/src/pokerth/pokerth.pb.go new file mode 100644 index 00000000..6da5fdb4 --- /dev/null +++ b/gocode/src/pokerth/pokerth.pb.go @@ -0,0 +1,22427 @@ +// Code generated by protoc-gen-gogo. +// source: pokerth.proto +// DO NOT EDIT! + +/* + Package pokerth is a generated protocol buffer package. + + It is generated from these files: + pokerth.proto + + It has these top-level messages: + NetGameInfo + PlayerResult + AnnounceMessage + AuthClientRequestMessage + AuthServerChallengeMessage + AuthClientResponseMessage + AuthServerVerificationMessage + InitMessage + InitAckMessage + AvatarRequestMessage + AvatarHeaderMessage + AvatarDataMessage + AvatarEndMessage + UnknownAvatarMessage + PlayerListMessage + GameListNewMessage + GameListUpdateMessage + GameListPlayerJoinedMessage + GameListPlayerLeftMessage + GameListSpectatorJoinedMessage + GameListSpectatorLeftMessage + GameListAdminChangedMessage + PlayerInfoRequestMessage + PlayerInfoReplyMessage + SubscriptionRequestMessage + SubscriptionReplyMessage + CreateGameMessage + CreateGameFailedMessage + JoinGameMessage + RejoinGameMessage + JoinGameAckMessage + JoinGameFailedMessage + GamePlayerJoinedMessage + GamePlayerLeftMessage + GameSpectatorJoinedMessage + GameSpectatorLeftMessage + GameAdminChangedMessage + RemovedFromGameMessage + KickPlayerRequestMessage + LeaveGameRequestMessage + InvitePlayerToGameMessage + InviteNotifyMessage + RejectGameInvitationMessage + RejectInvNotifyMessage + StartEventMessage + StartEventAckMessage + GameStartInitialMessage + GameStartRejoinMessage + HandStartMessage + PlayersTurnMessage + MyActionRequestMessage + YourActionRejectedMessage + PlayersActionDoneMessage + DealFlopCardsMessage + DealTurnCardMessage + DealRiverCardMessage + AllInShowCardsMessage + EndOfHandShowCardsMessage + EndOfHandHideCardsMessage + ShowMyCardsRequestMessage + AfterHandShowCardsMessage + EndOfGameMessage + PlayerIdChangedMessage + AskKickPlayerMessage + AskKickDeniedMessage + StartKickPetitionMessage + VoteKickRequestMessage + VoteKickReplyMessage + KickPetitionUpdateMessage + EndKickPetitionMessage + StatisticsMessage + ChatRequestMessage + ChatMessage + ChatRejectMessage + DialogMessage + TimeoutWarningMessage + ResetTimeoutMessage + ReportAvatarMessage + ReportAvatarAckMessage + ReportGameMessage + ReportGameAckMessage + ErrorMessage + AdminRemoveGameMessage + AdminRemoveGameAckMessage + AdminBanPlayerMessage + AdminBanPlayerAckMessage + AuthMessage + LobbyMessage + GameManagementMessage + GameEngineMessage + GameMessage + PokerTHMessage +*/ +package pokerth + +import proto "code.google.com/p/gogoprotobuf/proto" +import json "encoding/json" +import math "math" + +// discarding unused import gogoproto "src/third_party/gogoprotobuf/gogo.pb" + +import io "io" +import code_google_com_p_gogoprotobuf_proto "code.google.com/p/gogoprotobuf/proto" + +// Reference proto, json, and math imports to suppress error if they are not otherwise used. +var _ = proto.Marshal +var _ = &json.SyntaxError{} +var _ = math.Inf + +type NetGameMode int32 + +const ( + NetGameMode_netGameCreated NetGameMode = 1 + NetGameMode_netGameStarted NetGameMode = 2 + NetGameMode_netGameClosed NetGameMode = 3 +) + +var NetGameMode_name = map[int32]string{ + 1: "netGameCreated", + 2: "netGameStarted", + 3: "netGameClosed", +} +var NetGameMode_value = map[string]int32{ + "netGameCreated": 1, + "netGameStarted": 2, + "netGameClosed": 3, +} + +func (x NetGameMode) Enum() *NetGameMode { + p := new(NetGameMode) + *p = x + return p +} +func (x NetGameMode) String() string { + return proto.EnumName(NetGameMode_name, int32(x)) +} +func (x *NetGameMode) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(NetGameMode_value, data, "NetGameMode") + if err != nil { + return err + } + *x = NetGameMode(value) + return nil +} + +type NetGameState int32 + +const ( + NetGameState_netStatePreflop NetGameState = 0 + NetGameState_netStateFlop NetGameState = 1 + NetGameState_netStateTurn NetGameState = 2 + NetGameState_netStateRiver NetGameState = 3 + NetGameState_netStatePreflopSmallBlind NetGameState = 4 + NetGameState_netStatePreflopBigBlind NetGameState = 5 +) + +var NetGameState_name = map[int32]string{ + 0: "netStatePreflop", + 1: "netStateFlop", + 2: "netStateTurn", + 3: "netStateRiver", + 4: "netStatePreflopSmallBlind", + 5: "netStatePreflopBigBlind", +} +var NetGameState_value = map[string]int32{ + "netStatePreflop": 0, + "netStateFlop": 1, + "netStateTurn": 2, + "netStateRiver": 3, + "netStatePreflopSmallBlind": 4, + "netStatePreflopBigBlind": 5, +} + +func (x NetGameState) Enum() *NetGameState { + p := new(NetGameState) + *p = x + return p +} +func (x NetGameState) String() string { + return proto.EnumName(NetGameState_name, int32(x)) +} +func (x *NetGameState) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(NetGameState_value, data, "NetGameState") + if err != nil { + return err + } + *x = NetGameState(value) + return nil +} + +type NetPlayerAction int32 + +const ( + NetPlayerAction_netActionNone NetPlayerAction = 0 + NetPlayerAction_netActionFold NetPlayerAction = 1 + NetPlayerAction_netActionCheck NetPlayerAction = 2 + NetPlayerAction_netActionCall NetPlayerAction = 3 + NetPlayerAction_netActionBet NetPlayerAction = 4 + NetPlayerAction_netActionRaise NetPlayerAction = 5 + NetPlayerAction_netActionAllIn NetPlayerAction = 6 +) + +var NetPlayerAction_name = map[int32]string{ + 0: "netActionNone", + 1: "netActionFold", + 2: "netActionCheck", + 3: "netActionCall", + 4: "netActionBet", + 5: "netActionRaise", + 6: "netActionAllIn", +} +var NetPlayerAction_value = map[string]int32{ + "netActionNone": 0, + "netActionFold": 1, + "netActionCheck": 2, + "netActionCall": 3, + "netActionBet": 4, + "netActionRaise": 5, + "netActionAllIn": 6, +} + +func (x NetPlayerAction) Enum() *NetPlayerAction { + p := new(NetPlayerAction) + *p = x + return p +} +func (x NetPlayerAction) String() string { + return proto.EnumName(NetPlayerAction_name, int32(x)) +} +func (x *NetPlayerAction) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(NetPlayerAction_value, data, "NetPlayerAction") + if err != nil { + return err + } + *x = NetPlayerAction(value) + return nil +} + +type NetPlayerState int32 + +const ( + NetPlayerState_netPlayerStateNormal NetPlayerState = 0 + NetPlayerState_netPlayerStateSessionInactive NetPlayerState = 1 + NetPlayerState_netPlayerStateNoMoney NetPlayerState = 2 +) + +var NetPlayerState_name = map[int32]string{ + 0: "netPlayerStateNormal", + 1: "netPlayerStateSessionInactive", + 2: "netPlayerStateNoMoney", +} +var NetPlayerState_value = map[string]int32{ + "netPlayerStateNormal": 0, + "netPlayerStateSessionInactive": 1, + "netPlayerStateNoMoney": 2, +} + +func (x NetPlayerState) Enum() *NetPlayerState { + p := new(NetPlayerState) + *p = x + return p +} +func (x NetPlayerState) String() string { + return proto.EnumName(NetPlayerState_name, int32(x)) +} +func (x *NetPlayerState) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(NetPlayerState_value, data, "NetPlayerState") + if err != nil { + return err + } + *x = NetPlayerState(value) + return nil +} + +type NetPlayerInfoRights int32 + +const ( + NetPlayerInfoRights_netPlayerRightsGuest NetPlayerInfoRights = 1 + NetPlayerInfoRights_netPlayerRightsNormal NetPlayerInfoRights = 2 + NetPlayerInfoRights_netPlayerRightsAdmin NetPlayerInfoRights = 3 +) + +var NetPlayerInfoRights_name = map[int32]string{ + 1: "netPlayerRightsGuest", + 2: "netPlayerRightsNormal", + 3: "netPlayerRightsAdmin", +} +var NetPlayerInfoRights_value = map[string]int32{ + "netPlayerRightsGuest": 1, + "netPlayerRightsNormal": 2, + "netPlayerRightsAdmin": 3, +} + +func (x NetPlayerInfoRights) Enum() *NetPlayerInfoRights { + p := new(NetPlayerInfoRights) + *p = x + return p +} +func (x NetPlayerInfoRights) String() string { + return proto.EnumName(NetPlayerInfoRights_name, int32(x)) +} +func (x *NetPlayerInfoRights) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(NetPlayerInfoRights_value, data, "NetPlayerInfoRights") + if err != nil { + return err + } + *x = NetPlayerInfoRights(value) + return nil +} + +type NetAvatarType int32 + +const ( + NetAvatarType_netAvatarImagePng NetAvatarType = 1 + NetAvatarType_netAvatarImageJpg NetAvatarType = 2 + NetAvatarType_netAvatarImageGif NetAvatarType = 3 +) + +var NetAvatarType_name = map[int32]string{ + 1: "netAvatarImagePng", + 2: "netAvatarImageJpg", + 3: "netAvatarImageGif", +} +var NetAvatarType_value = map[string]int32{ + "netAvatarImagePng": 1, + "netAvatarImageJpg": 2, + "netAvatarImageGif": 3, +} + +func (x NetAvatarType) Enum() *NetAvatarType { + p := new(NetAvatarType) + *p = x + return p +} +func (x NetAvatarType) String() string { + return proto.EnumName(NetAvatarType_name, int32(x)) +} +func (x *NetAvatarType) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(NetAvatarType_value, data, "NetAvatarType") + if err != nil { + return err + } + *x = NetAvatarType(value) + return nil +} + +type NetGameInfo_NetGameType int32 + +const ( + NetGameInfo_normalGame NetGameInfo_NetGameType = 1 + NetGameInfo_registeredOnlyGame NetGameInfo_NetGameType = 2 + NetGameInfo_inviteOnlyGame NetGameInfo_NetGameType = 3 + NetGameInfo_rankingGame NetGameInfo_NetGameType = 4 +) + +var NetGameInfo_NetGameType_name = map[int32]string{ + 1: "normalGame", + 2: "registeredOnlyGame", + 3: "inviteOnlyGame", + 4: "rankingGame", +} +var NetGameInfo_NetGameType_value = map[string]int32{ + "normalGame": 1, + "registeredOnlyGame": 2, + "inviteOnlyGame": 3, + "rankingGame": 4, +} + +func (x NetGameInfo_NetGameType) Enum() *NetGameInfo_NetGameType { + p := new(NetGameInfo_NetGameType) + *p = x + return p +} +func (x NetGameInfo_NetGameType) String() string { + return proto.EnumName(NetGameInfo_NetGameType_name, int32(x)) +} +func (x *NetGameInfo_NetGameType) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(NetGameInfo_NetGameType_value, data, "NetGameInfo_NetGameType") + if err != nil { + return err + } + *x = NetGameInfo_NetGameType(value) + return nil +} + +type NetGameInfo_RaiseIntervalMode int32 + +const ( + NetGameInfo_raiseOnHandNum NetGameInfo_RaiseIntervalMode = 1 + NetGameInfo_raiseOnMinutes NetGameInfo_RaiseIntervalMode = 2 +) + +var NetGameInfo_RaiseIntervalMode_name = map[int32]string{ + 1: "raiseOnHandNum", + 2: "raiseOnMinutes", +} +var NetGameInfo_RaiseIntervalMode_value = map[string]int32{ + "raiseOnHandNum": 1, + "raiseOnMinutes": 2, +} + +func (x NetGameInfo_RaiseIntervalMode) Enum() *NetGameInfo_RaiseIntervalMode { + p := new(NetGameInfo_RaiseIntervalMode) + *p = x + return p +} +func (x NetGameInfo_RaiseIntervalMode) String() string { + return proto.EnumName(NetGameInfo_RaiseIntervalMode_name, int32(x)) +} +func (x *NetGameInfo_RaiseIntervalMode) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(NetGameInfo_RaiseIntervalMode_value, data, "NetGameInfo_RaiseIntervalMode") + if err != nil { + return err + } + *x = NetGameInfo_RaiseIntervalMode(value) + return nil +} + +type NetGameInfo_EndRaiseMode int32 + +const ( + NetGameInfo_doubleBlinds NetGameInfo_EndRaiseMode = 1 + NetGameInfo_raiseByEndValue NetGameInfo_EndRaiseMode = 2 + NetGameInfo_keepLastBlind NetGameInfo_EndRaiseMode = 3 +) + +var NetGameInfo_EndRaiseMode_name = map[int32]string{ + 1: "doubleBlinds", + 2: "raiseByEndValue", + 3: "keepLastBlind", +} +var NetGameInfo_EndRaiseMode_value = map[string]int32{ + "doubleBlinds": 1, + "raiseByEndValue": 2, + "keepLastBlind": 3, +} + +func (x NetGameInfo_EndRaiseMode) Enum() *NetGameInfo_EndRaiseMode { + p := new(NetGameInfo_EndRaiseMode) + *p = x + return p +} +func (x NetGameInfo_EndRaiseMode) String() string { + return proto.EnumName(NetGameInfo_EndRaiseMode_name, int32(x)) +} +func (x *NetGameInfo_EndRaiseMode) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(NetGameInfo_EndRaiseMode_value, data, "NetGameInfo_EndRaiseMode") + if err != nil { + return err + } + *x = NetGameInfo_EndRaiseMode(value) + return nil +} + +type AnnounceMessage_ServerType int32 + +const ( + AnnounceMessage_serverTypeLAN AnnounceMessage_ServerType = 0 + AnnounceMessage_serverTypeInternetNoAuth AnnounceMessage_ServerType = 1 + AnnounceMessage_serverTypeInternetAuth AnnounceMessage_ServerType = 2 +) + +var AnnounceMessage_ServerType_name = map[int32]string{ + 0: "serverTypeLAN", + 1: "serverTypeInternetNoAuth", + 2: "serverTypeInternetAuth", +} +var AnnounceMessage_ServerType_value = map[string]int32{ + "serverTypeLAN": 0, + "serverTypeInternetNoAuth": 1, + "serverTypeInternetAuth": 2, +} + +func (x AnnounceMessage_ServerType) Enum() *AnnounceMessage_ServerType { + p := new(AnnounceMessage_ServerType) + *p = x + return p +} +func (x AnnounceMessage_ServerType) String() string { + return proto.EnumName(AnnounceMessage_ServerType_name, int32(x)) +} +func (x *AnnounceMessage_ServerType) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(AnnounceMessage_ServerType_value, data, "AnnounceMessage_ServerType") + if err != nil { + return err + } + *x = AnnounceMessage_ServerType(value) + return nil +} + +type AuthClientRequestMessage_LoginType int32 + +const ( + AuthClientRequestMessage_guestLogin AuthClientRequestMessage_LoginType = 0 + AuthClientRequestMessage_authenticatedLogin AuthClientRequestMessage_LoginType = 1 + AuthClientRequestMessage_unauthenticatedLogin AuthClientRequestMessage_LoginType = 2 +) + +var AuthClientRequestMessage_LoginType_name = map[int32]string{ + 0: "guestLogin", + 1: "authenticatedLogin", + 2: "unauthenticatedLogin", +} +var AuthClientRequestMessage_LoginType_value = map[string]int32{ + "guestLogin": 0, + "authenticatedLogin": 1, + "unauthenticatedLogin": 2, +} + +func (x AuthClientRequestMessage_LoginType) Enum() *AuthClientRequestMessage_LoginType { + p := new(AuthClientRequestMessage_LoginType) + *p = x + return p +} +func (x AuthClientRequestMessage_LoginType) String() string { + return proto.EnumName(AuthClientRequestMessage_LoginType_name, int32(x)) +} +func (x *AuthClientRequestMessage_LoginType) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(AuthClientRequestMessage_LoginType_value, data, "AuthClientRequestMessage_LoginType") + if err != nil { + return err + } + *x = AuthClientRequestMessage_LoginType(value) + return nil +} + +type PlayerListMessage_PlayerListNotification int32 + +const ( + PlayerListMessage_playerListNew PlayerListMessage_PlayerListNotification = 0 + PlayerListMessage_playerListLeft PlayerListMessage_PlayerListNotification = 1 +) + +var PlayerListMessage_PlayerListNotification_name = map[int32]string{ + 0: "playerListNew", + 1: "playerListLeft", +} +var PlayerListMessage_PlayerListNotification_value = map[string]int32{ + "playerListNew": 0, + "playerListLeft": 1, +} + +func (x PlayerListMessage_PlayerListNotification) Enum() *PlayerListMessage_PlayerListNotification { + p := new(PlayerListMessage_PlayerListNotification) + *p = x + return p +} +func (x PlayerListMessage_PlayerListNotification) String() string { + return proto.EnumName(PlayerListMessage_PlayerListNotification_name, int32(x)) +} +func (x *PlayerListMessage_PlayerListNotification) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(PlayerListMessage_PlayerListNotification_value, data, "PlayerListMessage_PlayerListNotification") + if err != nil { + return err + } + *x = PlayerListMessage_PlayerListNotification(value) + return nil +} + +type SubscriptionRequestMessage_SubscriptionAction int32 + +const ( + SubscriptionRequestMessage_unsubscribeGameList SubscriptionRequestMessage_SubscriptionAction = 1 + SubscriptionRequestMessage_resubscribeGameList SubscriptionRequestMessage_SubscriptionAction = 2 +) + +var SubscriptionRequestMessage_SubscriptionAction_name = map[int32]string{ + 1: "unsubscribeGameList", + 2: "resubscribeGameList", +} +var SubscriptionRequestMessage_SubscriptionAction_value = map[string]int32{ + "unsubscribeGameList": 1, + "resubscribeGameList": 2, +} + +func (x SubscriptionRequestMessage_SubscriptionAction) Enum() *SubscriptionRequestMessage_SubscriptionAction { + p := new(SubscriptionRequestMessage_SubscriptionAction) + *p = x + return p +} +func (x SubscriptionRequestMessage_SubscriptionAction) String() string { + return proto.EnumName(SubscriptionRequestMessage_SubscriptionAction_name, int32(x)) +} +func (x *SubscriptionRequestMessage_SubscriptionAction) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(SubscriptionRequestMessage_SubscriptionAction_value, data, "SubscriptionRequestMessage_SubscriptionAction") + if err != nil { + return err + } + *x = SubscriptionRequestMessage_SubscriptionAction(value) + return nil +} + +type CreateGameFailedMessage_CreateGameFailureReason int32 + +const ( + CreateGameFailedMessage_notAllowedAsGuest CreateGameFailedMessage_CreateGameFailureReason = 1 + CreateGameFailedMessage_gameNameInUse CreateGameFailedMessage_CreateGameFailureReason = 2 + CreateGameFailedMessage_badGameName CreateGameFailedMessage_CreateGameFailureReason = 3 + CreateGameFailedMessage_invalidSettings CreateGameFailedMessage_CreateGameFailureReason = 4 +) + +var CreateGameFailedMessage_CreateGameFailureReason_name = map[int32]string{ + 1: "notAllowedAsGuest", + 2: "gameNameInUse", + 3: "badGameName", + 4: "invalidSettings", +} +var CreateGameFailedMessage_CreateGameFailureReason_value = map[string]int32{ + "notAllowedAsGuest": 1, + "gameNameInUse": 2, + "badGameName": 3, + "invalidSettings": 4, +} + +func (x CreateGameFailedMessage_CreateGameFailureReason) Enum() *CreateGameFailedMessage_CreateGameFailureReason { + p := new(CreateGameFailedMessage_CreateGameFailureReason) + *p = x + return p +} +func (x CreateGameFailedMessage_CreateGameFailureReason) String() string { + return proto.EnumName(CreateGameFailedMessage_CreateGameFailureReason_name, int32(x)) +} +func (x *CreateGameFailedMessage_CreateGameFailureReason) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CreateGameFailedMessage_CreateGameFailureReason_value, data, "CreateGameFailedMessage_CreateGameFailureReason") + if err != nil { + return err + } + *x = CreateGameFailedMessage_CreateGameFailureReason(value) + return nil +} + +type JoinGameFailedMessage_JoinGameFailureReason int32 + +const ( + JoinGameFailedMessage_invalidGame JoinGameFailedMessage_JoinGameFailureReason = 1 + JoinGameFailedMessage_gameIsFull JoinGameFailedMessage_JoinGameFailureReason = 2 + JoinGameFailedMessage_gameIsRunning JoinGameFailedMessage_JoinGameFailureReason = 3 + JoinGameFailedMessage_invalidPassword JoinGameFailedMessage_JoinGameFailureReason = 4 + JoinGameFailedMessage_notInvited JoinGameFailedMessage_JoinGameFailureReason = 5 + JoinGameFailedMessage_ipAddressBlocked JoinGameFailedMessage_JoinGameFailureReason = 6 + JoinGameFailedMessage_rejoinFailed JoinGameFailedMessage_JoinGameFailureReason = 7 + JoinGameFailedMessage_noSpectatorsAllowed JoinGameFailedMessage_JoinGameFailureReason = 8 +) + +var JoinGameFailedMessage_JoinGameFailureReason_name = map[int32]string{ + 1: "invalidGame", + 2: "gameIsFull", + 3: "gameIsRunning", + 4: "invalidPassword", + 5: "notInvited", + 6: "ipAddressBlocked", + 7: "rejoinFailed", + 8: "noSpectatorsAllowed", +} +var JoinGameFailedMessage_JoinGameFailureReason_value = map[string]int32{ + "invalidGame": 1, + "gameIsFull": 2, + "gameIsRunning": 3, + "invalidPassword": 4, + "notInvited": 5, + "ipAddressBlocked": 6, + "rejoinFailed": 7, + "noSpectatorsAllowed": 8, +} + +func (x JoinGameFailedMessage_JoinGameFailureReason) Enum() *JoinGameFailedMessage_JoinGameFailureReason { + p := new(JoinGameFailedMessage_JoinGameFailureReason) + *p = x + return p +} +func (x JoinGameFailedMessage_JoinGameFailureReason) String() string { + return proto.EnumName(JoinGameFailedMessage_JoinGameFailureReason_name, int32(x)) +} +func (x *JoinGameFailedMessage_JoinGameFailureReason) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(JoinGameFailedMessage_JoinGameFailureReason_value, data, "JoinGameFailedMessage_JoinGameFailureReason") + if err != nil { + return err + } + *x = JoinGameFailedMessage_JoinGameFailureReason(value) + return nil +} + +type GamePlayerLeftMessage_GamePlayerLeftReason int32 + +const ( + GamePlayerLeftMessage_leftOnRequest GamePlayerLeftMessage_GamePlayerLeftReason = 0 + GamePlayerLeftMessage_leftKicked GamePlayerLeftMessage_GamePlayerLeftReason = 1 + GamePlayerLeftMessage_leftError GamePlayerLeftMessage_GamePlayerLeftReason = 2 +) + +var GamePlayerLeftMessage_GamePlayerLeftReason_name = map[int32]string{ + 0: "leftOnRequest", + 1: "leftKicked", + 2: "leftError", +} +var GamePlayerLeftMessage_GamePlayerLeftReason_value = map[string]int32{ + "leftOnRequest": 0, + "leftKicked": 1, + "leftError": 2, +} + +func (x GamePlayerLeftMessage_GamePlayerLeftReason) Enum() *GamePlayerLeftMessage_GamePlayerLeftReason { + p := new(GamePlayerLeftMessage_GamePlayerLeftReason) + *p = x + return p +} +func (x GamePlayerLeftMessage_GamePlayerLeftReason) String() string { + return proto.EnumName(GamePlayerLeftMessage_GamePlayerLeftReason_name, int32(x)) +} +func (x *GamePlayerLeftMessage_GamePlayerLeftReason) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(GamePlayerLeftMessage_GamePlayerLeftReason_value, data, "GamePlayerLeftMessage_GamePlayerLeftReason") + if err != nil { + return err + } + *x = GamePlayerLeftMessage_GamePlayerLeftReason(value) + return nil +} + +type RemovedFromGameMessage_RemovedFromGameReason int32 + +const ( + RemovedFromGameMessage_removedOnRequest RemovedFromGameMessage_RemovedFromGameReason = 0 + RemovedFromGameMessage_kickedFromGame RemovedFromGameMessage_RemovedFromGameReason = 1 + RemovedFromGameMessage_gameIsFull RemovedFromGameMessage_RemovedFromGameReason = 2 + RemovedFromGameMessage_gameIsRunning RemovedFromGameMessage_RemovedFromGameReason = 3 + RemovedFromGameMessage_gameTimeout RemovedFromGameMessage_RemovedFromGameReason = 4 + RemovedFromGameMessage_removedStartFailed RemovedFromGameMessage_RemovedFromGameReason = 5 + RemovedFromGameMessage_gameClosed RemovedFromGameMessage_RemovedFromGameReason = 6 +) + +var RemovedFromGameMessage_RemovedFromGameReason_name = map[int32]string{ + 0: "removedOnRequest", + 1: "kickedFromGame", + 2: "gameIsFull", + 3: "gameIsRunning", + 4: "gameTimeout", + 5: "removedStartFailed", + 6: "gameClosed", +} +var RemovedFromGameMessage_RemovedFromGameReason_value = map[string]int32{ + "removedOnRequest": 0, + "kickedFromGame": 1, + "gameIsFull": 2, + "gameIsRunning": 3, + "gameTimeout": 4, + "removedStartFailed": 5, + "gameClosed": 6, +} + +func (x RemovedFromGameMessage_RemovedFromGameReason) Enum() *RemovedFromGameMessage_RemovedFromGameReason { + p := new(RemovedFromGameMessage_RemovedFromGameReason) + *p = x + return p +} +func (x RemovedFromGameMessage_RemovedFromGameReason) String() string { + return proto.EnumName(RemovedFromGameMessage_RemovedFromGameReason_name, int32(x)) +} +func (x *RemovedFromGameMessage_RemovedFromGameReason) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(RemovedFromGameMessage_RemovedFromGameReason_value, data, "RemovedFromGameMessage_RemovedFromGameReason") + if err != nil { + return err + } + *x = RemovedFromGameMessage_RemovedFromGameReason(value) + return nil +} + +type RejectGameInvitationMessage_RejectGameInvReason int32 + +const ( + RejectGameInvitationMessage_rejectReasonNo RejectGameInvitationMessage_RejectGameInvReason = 0 + RejectGameInvitationMessage_rejectReasonBusy RejectGameInvitationMessage_RejectGameInvReason = 1 +) + +var RejectGameInvitationMessage_RejectGameInvReason_name = map[int32]string{ + 0: "rejectReasonNo", + 1: "rejectReasonBusy", +} +var RejectGameInvitationMessage_RejectGameInvReason_value = map[string]int32{ + "rejectReasonNo": 0, + "rejectReasonBusy": 1, +} + +func (x RejectGameInvitationMessage_RejectGameInvReason) Enum() *RejectGameInvitationMessage_RejectGameInvReason { + p := new(RejectGameInvitationMessage_RejectGameInvReason) + *p = x + return p +} +func (x RejectGameInvitationMessage_RejectGameInvReason) String() string { + return proto.EnumName(RejectGameInvitationMessage_RejectGameInvReason_name, int32(x)) +} +func (x *RejectGameInvitationMessage_RejectGameInvReason) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(RejectGameInvitationMessage_RejectGameInvReason_value, data, "RejectGameInvitationMessage_RejectGameInvReason") + if err != nil { + return err + } + *x = RejectGameInvitationMessage_RejectGameInvReason(value) + return nil +} + +type StartEventMessage_StartEventType int32 + +const ( + StartEventMessage_startEvent StartEventMessage_StartEventType = 0 + StartEventMessage_rejoinEvent StartEventMessage_StartEventType = 1 +) + +var StartEventMessage_StartEventType_name = map[int32]string{ + 0: "startEvent", + 1: "rejoinEvent", +} +var StartEventMessage_StartEventType_value = map[string]int32{ + "startEvent": 0, + "rejoinEvent": 1, +} + +func (x StartEventMessage_StartEventType) Enum() *StartEventMessage_StartEventType { + p := new(StartEventMessage_StartEventType) + *p = x + return p +} +func (x StartEventMessage_StartEventType) String() string { + return proto.EnumName(StartEventMessage_StartEventType_name, int32(x)) +} +func (x *StartEventMessage_StartEventType) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(StartEventMessage_StartEventType_value, data, "StartEventMessage_StartEventType") + if err != nil { + return err + } + *x = StartEventMessage_StartEventType(value) + return nil +} + +type YourActionRejectedMessage_RejectionReason int32 + +const ( + YourActionRejectedMessage_rejectedInvalidGameState YourActionRejectedMessage_RejectionReason = 1 + YourActionRejectedMessage_rejectedNotYourTurn YourActionRejectedMessage_RejectionReason = 2 + YourActionRejectedMessage_rejectedActionNotAllowed YourActionRejectedMessage_RejectionReason = 3 +) + +var YourActionRejectedMessage_RejectionReason_name = map[int32]string{ + 1: "rejectedInvalidGameState", + 2: "rejectedNotYourTurn", + 3: "rejectedActionNotAllowed", +} +var YourActionRejectedMessage_RejectionReason_value = map[string]int32{ + "rejectedInvalidGameState": 1, + "rejectedNotYourTurn": 2, + "rejectedActionNotAllowed": 3, +} + +func (x YourActionRejectedMessage_RejectionReason) Enum() *YourActionRejectedMessage_RejectionReason { + p := new(YourActionRejectedMessage_RejectionReason) + *p = x + return p +} +func (x YourActionRejectedMessage_RejectionReason) String() string { + return proto.EnumName(YourActionRejectedMessage_RejectionReason_name, int32(x)) +} +func (x *YourActionRejectedMessage_RejectionReason) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(YourActionRejectedMessage_RejectionReason_value, data, "YourActionRejectedMessage_RejectionReason") + if err != nil { + return err + } + *x = YourActionRejectedMessage_RejectionReason(value) + return nil +} + +type AskKickDeniedMessage_KickDeniedReason int32 + +const ( + AskKickDeniedMessage_kickDeniedInvalidGameState AskKickDeniedMessage_KickDeniedReason = 0 + AskKickDeniedMessage_kickDeniedNotPossible AskKickDeniedMessage_KickDeniedReason = 1 + AskKickDeniedMessage_kickDeniedTryAgainLater AskKickDeniedMessage_KickDeniedReason = 2 + AskKickDeniedMessage_kickDeniedAlreadyInProgress AskKickDeniedMessage_KickDeniedReason = 3 + AskKickDeniedMessage_kickDeniedInvalidPlayerId AskKickDeniedMessage_KickDeniedReason = 4 +) + +var AskKickDeniedMessage_KickDeniedReason_name = map[int32]string{ + 0: "kickDeniedInvalidGameState", + 1: "kickDeniedNotPossible", + 2: "kickDeniedTryAgainLater", + 3: "kickDeniedAlreadyInProgress", + 4: "kickDeniedInvalidPlayerId", +} +var AskKickDeniedMessage_KickDeniedReason_value = map[string]int32{ + "kickDeniedInvalidGameState": 0, + "kickDeniedNotPossible": 1, + "kickDeniedTryAgainLater": 2, + "kickDeniedAlreadyInProgress": 3, + "kickDeniedInvalidPlayerId": 4, +} + +func (x AskKickDeniedMessage_KickDeniedReason) Enum() *AskKickDeniedMessage_KickDeniedReason { + p := new(AskKickDeniedMessage_KickDeniedReason) + *p = x + return p +} +func (x AskKickDeniedMessage_KickDeniedReason) String() string { + return proto.EnumName(AskKickDeniedMessage_KickDeniedReason_name, int32(x)) +} +func (x *AskKickDeniedMessage_KickDeniedReason) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(AskKickDeniedMessage_KickDeniedReason_value, data, "AskKickDeniedMessage_KickDeniedReason") + if err != nil { + return err + } + *x = AskKickDeniedMessage_KickDeniedReason(value) + return nil +} + +type VoteKickReplyMessage_VoteKickReplyType int32 + +const ( + VoteKickReplyMessage_voteKickAck VoteKickReplyMessage_VoteKickReplyType = 0 + VoteKickReplyMessage_voteKickDeniedInvalid VoteKickReplyMessage_VoteKickReplyType = 1 + VoteKickReplyMessage_voteKickDeniedAlreadyVoted VoteKickReplyMessage_VoteKickReplyType = 2 +) + +var VoteKickReplyMessage_VoteKickReplyType_name = map[int32]string{ + 0: "voteKickAck", + 1: "voteKickDeniedInvalid", + 2: "voteKickDeniedAlreadyVoted", +} +var VoteKickReplyMessage_VoteKickReplyType_value = map[string]int32{ + "voteKickAck": 0, + "voteKickDeniedInvalid": 1, + "voteKickDeniedAlreadyVoted": 2, +} + +func (x VoteKickReplyMessage_VoteKickReplyType) Enum() *VoteKickReplyMessage_VoteKickReplyType { + p := new(VoteKickReplyMessage_VoteKickReplyType) + *p = x + return p +} +func (x VoteKickReplyMessage_VoteKickReplyType) String() string { + return proto.EnumName(VoteKickReplyMessage_VoteKickReplyType_name, int32(x)) +} +func (x *VoteKickReplyMessage_VoteKickReplyType) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(VoteKickReplyMessage_VoteKickReplyType_value, data, "VoteKickReplyMessage_VoteKickReplyType") + if err != nil { + return err + } + *x = VoteKickReplyMessage_VoteKickReplyType(value) + return nil +} + +type EndKickPetitionMessage_PetitionEndReason int32 + +const ( + EndKickPetitionMessage_petitionEndEnoughVotes EndKickPetitionMessage_PetitionEndReason = 0 + EndKickPetitionMessage_petitionEndTooFewPlayers EndKickPetitionMessage_PetitionEndReason = 1 + EndKickPetitionMessage_petitionEndPlayerLeft EndKickPetitionMessage_PetitionEndReason = 2 + EndKickPetitionMessage_petitionEndTimeout EndKickPetitionMessage_PetitionEndReason = 3 +) + +var EndKickPetitionMessage_PetitionEndReason_name = map[int32]string{ + 0: "petitionEndEnoughVotes", + 1: "petitionEndTooFewPlayers", + 2: "petitionEndPlayerLeft", + 3: "petitionEndTimeout", +} +var EndKickPetitionMessage_PetitionEndReason_value = map[string]int32{ + "petitionEndEnoughVotes": 0, + "petitionEndTooFewPlayers": 1, + "petitionEndPlayerLeft": 2, + "petitionEndTimeout": 3, +} + +func (x EndKickPetitionMessage_PetitionEndReason) Enum() *EndKickPetitionMessage_PetitionEndReason { + p := new(EndKickPetitionMessage_PetitionEndReason) + *p = x + return p +} +func (x EndKickPetitionMessage_PetitionEndReason) String() string { + return proto.EnumName(EndKickPetitionMessage_PetitionEndReason_name, int32(x)) +} +func (x *EndKickPetitionMessage_PetitionEndReason) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(EndKickPetitionMessage_PetitionEndReason_value, data, "EndKickPetitionMessage_PetitionEndReason") + if err != nil { + return err + } + *x = EndKickPetitionMessage_PetitionEndReason(value) + return nil +} + +type StatisticsMessage_StatisticsData_StatisticsType int32 + +const ( + StatisticsMessage_StatisticsData_statNumberOfPlayers StatisticsMessage_StatisticsData_StatisticsType = 1 +) + +var StatisticsMessage_StatisticsData_StatisticsType_name = map[int32]string{ + 1: "statNumberOfPlayers", +} +var StatisticsMessage_StatisticsData_StatisticsType_value = map[string]int32{ + "statNumberOfPlayers": 1, +} + +func (x StatisticsMessage_StatisticsData_StatisticsType) Enum() *StatisticsMessage_StatisticsData_StatisticsType { + p := new(StatisticsMessage_StatisticsData_StatisticsType) + *p = x + return p +} +func (x StatisticsMessage_StatisticsData_StatisticsType) String() string { + return proto.EnumName(StatisticsMessage_StatisticsData_StatisticsType_name, int32(x)) +} +func (x *StatisticsMessage_StatisticsData_StatisticsType) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(StatisticsMessage_StatisticsData_StatisticsType_value, data, "StatisticsMessage_StatisticsData_StatisticsType") + if err != nil { + return err + } + *x = StatisticsMessage_StatisticsData_StatisticsType(value) + return nil +} + +type ChatMessage_ChatType int32 + +const ( + ChatMessage_chatTypeStandard ChatMessage_ChatType = 0 + ChatMessage_chatTypeBot ChatMessage_ChatType = 1 + ChatMessage_chatTypeBroadcast ChatMessage_ChatType = 2 + ChatMessage_chatTypePrivate ChatMessage_ChatType = 3 +) + +var ChatMessage_ChatType_name = map[int32]string{ + 0: "chatTypeStandard", + 1: "chatTypeBot", + 2: "chatTypeBroadcast", + 3: "chatTypePrivate", +} +var ChatMessage_ChatType_value = map[string]int32{ + "chatTypeStandard": 0, + "chatTypeBot": 1, + "chatTypeBroadcast": 2, + "chatTypePrivate": 3, +} + +func (x ChatMessage_ChatType) Enum() *ChatMessage_ChatType { + p := new(ChatMessage_ChatType) + *p = x + return p +} +func (x ChatMessage_ChatType) String() string { + return proto.EnumName(ChatMessage_ChatType_name, int32(x)) +} +func (x *ChatMessage_ChatType) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(ChatMessage_ChatType_value, data, "ChatMessage_ChatType") + if err != nil { + return err + } + *x = ChatMessage_ChatType(value) + return nil +} + +type TimeoutWarningMessage_TimeoutReason int32 + +const ( + TimeoutWarningMessage_timeoutNoDataReceived TimeoutWarningMessage_TimeoutReason = 0 + TimeoutWarningMessage_timeoutInactiveGame TimeoutWarningMessage_TimeoutReason = 1 + TimeoutWarningMessage_timeoutKickAfterAutofold TimeoutWarningMessage_TimeoutReason = 2 +) + +var TimeoutWarningMessage_TimeoutReason_name = map[int32]string{ + 0: "timeoutNoDataReceived", + 1: "timeoutInactiveGame", + 2: "timeoutKickAfterAutofold", +} +var TimeoutWarningMessage_TimeoutReason_value = map[string]int32{ + "timeoutNoDataReceived": 0, + "timeoutInactiveGame": 1, + "timeoutKickAfterAutofold": 2, +} + +func (x TimeoutWarningMessage_TimeoutReason) Enum() *TimeoutWarningMessage_TimeoutReason { + p := new(TimeoutWarningMessage_TimeoutReason) + *p = x + return p +} +func (x TimeoutWarningMessage_TimeoutReason) String() string { + return proto.EnumName(TimeoutWarningMessage_TimeoutReason_name, int32(x)) +} +func (x *TimeoutWarningMessage_TimeoutReason) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(TimeoutWarningMessage_TimeoutReason_value, data, "TimeoutWarningMessage_TimeoutReason") + if err != nil { + return err + } + *x = TimeoutWarningMessage_TimeoutReason(value) + return nil +} + +type ReportAvatarAckMessage_ReportAvatarResult int32 + +const ( + ReportAvatarAckMessage_avatarReportAccepted ReportAvatarAckMessage_ReportAvatarResult = 0 + ReportAvatarAckMessage_avatarReportDuplicate ReportAvatarAckMessage_ReportAvatarResult = 1 + ReportAvatarAckMessage_avatarReportInvalid ReportAvatarAckMessage_ReportAvatarResult = 2 +) + +var ReportAvatarAckMessage_ReportAvatarResult_name = map[int32]string{ + 0: "avatarReportAccepted", + 1: "avatarReportDuplicate", + 2: "avatarReportInvalid", +} +var ReportAvatarAckMessage_ReportAvatarResult_value = map[string]int32{ + "avatarReportAccepted": 0, + "avatarReportDuplicate": 1, + "avatarReportInvalid": 2, +} + +func (x ReportAvatarAckMessage_ReportAvatarResult) Enum() *ReportAvatarAckMessage_ReportAvatarResult { + p := new(ReportAvatarAckMessage_ReportAvatarResult) + *p = x + return p +} +func (x ReportAvatarAckMessage_ReportAvatarResult) String() string { + return proto.EnumName(ReportAvatarAckMessage_ReportAvatarResult_name, int32(x)) +} +func (x *ReportAvatarAckMessage_ReportAvatarResult) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(ReportAvatarAckMessage_ReportAvatarResult_value, data, "ReportAvatarAckMessage_ReportAvatarResult") + if err != nil { + return err + } + *x = ReportAvatarAckMessage_ReportAvatarResult(value) + return nil +} + +type ReportGameAckMessage_ReportGameResult int32 + +const ( + ReportGameAckMessage_gameReportAccepted ReportGameAckMessage_ReportGameResult = 0 + ReportGameAckMessage_gameReportDuplicate ReportGameAckMessage_ReportGameResult = 1 + ReportGameAckMessage_gameReportInvalid ReportGameAckMessage_ReportGameResult = 2 +) + +var ReportGameAckMessage_ReportGameResult_name = map[int32]string{ + 0: "gameReportAccepted", + 1: "gameReportDuplicate", + 2: "gameReportInvalid", +} +var ReportGameAckMessage_ReportGameResult_value = map[string]int32{ + "gameReportAccepted": 0, + "gameReportDuplicate": 1, + "gameReportInvalid": 2, +} + +func (x ReportGameAckMessage_ReportGameResult) Enum() *ReportGameAckMessage_ReportGameResult { + p := new(ReportGameAckMessage_ReportGameResult) + *p = x + return p +} +func (x ReportGameAckMessage_ReportGameResult) String() string { + return proto.EnumName(ReportGameAckMessage_ReportGameResult_name, int32(x)) +} +func (x *ReportGameAckMessage_ReportGameResult) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(ReportGameAckMessage_ReportGameResult_value, data, "ReportGameAckMessage_ReportGameResult") + if err != nil { + return err + } + *x = ReportGameAckMessage_ReportGameResult(value) + return nil +} + +type ErrorMessage_ErrorReason int32 + +const ( + ErrorMessage_reserved ErrorMessage_ErrorReason = 0 + ErrorMessage_initVersionNotSupported ErrorMessage_ErrorReason = 1 + ErrorMessage_initServerFull ErrorMessage_ErrorReason = 2 + ErrorMessage_initAuthFailure ErrorMessage_ErrorReason = 3 + ErrorMessage_initPlayerNameInUse ErrorMessage_ErrorReason = 4 + ErrorMessage_initInvalidPlayerName ErrorMessage_ErrorReason = 5 + ErrorMessage_initServerMaintenance ErrorMessage_ErrorReason = 6 + ErrorMessage_initBlocked ErrorMessage_ErrorReason = 7 + ErrorMessage_avatarTooLarge ErrorMessage_ErrorReason = 8 + ErrorMessage_invalidPacket ErrorMessage_ErrorReason = 9 + ErrorMessage_invalidState ErrorMessage_ErrorReason = 10 + ErrorMessage_kickedFromServer ErrorMessage_ErrorReason = 11 + ErrorMessage_bannedFromServer ErrorMessage_ErrorReason = 12 + ErrorMessage_blockedByServer ErrorMessage_ErrorReason = 13 + ErrorMessage_sessionTimeout ErrorMessage_ErrorReason = 14 +) + +var ErrorMessage_ErrorReason_name = map[int32]string{ + 0: "reserved", + 1: "initVersionNotSupported", + 2: "initServerFull", + 3: "initAuthFailure", + 4: "initPlayerNameInUse", + 5: "initInvalidPlayerName", + 6: "initServerMaintenance", + 7: "initBlocked", + 8: "avatarTooLarge", + 9: "invalidPacket", + 10: "invalidState", + 11: "kickedFromServer", + 12: "bannedFromServer", + 13: "blockedByServer", + 14: "sessionTimeout", +} +var ErrorMessage_ErrorReason_value = map[string]int32{ + "reserved": 0, + "initVersionNotSupported": 1, + "initServerFull": 2, + "initAuthFailure": 3, + "initPlayerNameInUse": 4, + "initInvalidPlayerName": 5, + "initServerMaintenance": 6, + "initBlocked": 7, + "avatarTooLarge": 8, + "invalidPacket": 9, + "invalidState": 10, + "kickedFromServer": 11, + "bannedFromServer": 12, + "blockedByServer": 13, + "sessionTimeout": 14, +} + +func (x ErrorMessage_ErrorReason) Enum() *ErrorMessage_ErrorReason { + p := new(ErrorMessage_ErrorReason) + *p = x + return p +} +func (x ErrorMessage_ErrorReason) String() string { + return proto.EnumName(ErrorMessage_ErrorReason_name, int32(x)) +} +func (x *ErrorMessage_ErrorReason) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(ErrorMessage_ErrorReason_value, data, "ErrorMessage_ErrorReason") + if err != nil { + return err + } + *x = ErrorMessage_ErrorReason(value) + return nil +} + +type AdminRemoveGameAckMessage_AdminRemoveGameResult int32 + +const ( + AdminRemoveGameAckMessage_gameRemoveAccepted AdminRemoveGameAckMessage_AdminRemoveGameResult = 0 + AdminRemoveGameAckMessage_gameRemoveInvalid AdminRemoveGameAckMessage_AdminRemoveGameResult = 1 +) + +var AdminRemoveGameAckMessage_AdminRemoveGameResult_name = map[int32]string{ + 0: "gameRemoveAccepted", + 1: "gameRemoveInvalid", +} +var AdminRemoveGameAckMessage_AdminRemoveGameResult_value = map[string]int32{ + "gameRemoveAccepted": 0, + "gameRemoveInvalid": 1, +} + +func (x AdminRemoveGameAckMessage_AdminRemoveGameResult) Enum() *AdminRemoveGameAckMessage_AdminRemoveGameResult { + p := new(AdminRemoveGameAckMessage_AdminRemoveGameResult) + *p = x + return p +} +func (x AdminRemoveGameAckMessage_AdminRemoveGameResult) String() string { + return proto.EnumName(AdminRemoveGameAckMessage_AdminRemoveGameResult_name, int32(x)) +} +func (x *AdminRemoveGameAckMessage_AdminRemoveGameResult) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(AdminRemoveGameAckMessage_AdminRemoveGameResult_value, data, "AdminRemoveGameAckMessage_AdminRemoveGameResult") + if err != nil { + return err + } + *x = AdminRemoveGameAckMessage_AdminRemoveGameResult(value) + return nil +} + +type AdminBanPlayerAckMessage_AdminBanPlayerResult int32 + +const ( + AdminBanPlayerAckMessage_banPlayerAccepted AdminBanPlayerAckMessage_AdminBanPlayerResult = 0 + AdminBanPlayerAckMessage_banPlayerPending AdminBanPlayerAckMessage_AdminBanPlayerResult = 1 + AdminBanPlayerAckMessage_banPlayerNoDB AdminBanPlayerAckMessage_AdminBanPlayerResult = 2 + AdminBanPlayerAckMessage_banPlayerDBError AdminBanPlayerAckMessage_AdminBanPlayerResult = 3 + AdminBanPlayerAckMessage_banPlayerInvalid AdminBanPlayerAckMessage_AdminBanPlayerResult = 4 +) + +var AdminBanPlayerAckMessage_AdminBanPlayerResult_name = map[int32]string{ + 0: "banPlayerAccepted", + 1: "banPlayerPending", + 2: "banPlayerNoDB", + 3: "banPlayerDBError", + 4: "banPlayerInvalid", +} +var AdminBanPlayerAckMessage_AdminBanPlayerResult_value = map[string]int32{ + "banPlayerAccepted": 0, + "banPlayerPending": 1, + "banPlayerNoDB": 2, + "banPlayerDBError": 3, + "banPlayerInvalid": 4, +} + +func (x AdminBanPlayerAckMessage_AdminBanPlayerResult) Enum() *AdminBanPlayerAckMessage_AdminBanPlayerResult { + p := new(AdminBanPlayerAckMessage_AdminBanPlayerResult) + *p = x + return p +} +func (x AdminBanPlayerAckMessage_AdminBanPlayerResult) String() string { + return proto.EnumName(AdminBanPlayerAckMessage_AdminBanPlayerResult_name, int32(x)) +} +func (x *AdminBanPlayerAckMessage_AdminBanPlayerResult) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(AdminBanPlayerAckMessage_AdminBanPlayerResult_value, data, "AdminBanPlayerAckMessage_AdminBanPlayerResult") + if err != nil { + return err + } + *x = AdminBanPlayerAckMessage_AdminBanPlayerResult(value) + return nil +} + +type AuthMessage_AuthMessageType int32 + +const ( + AuthMessage_Type_AuthClientRequestMessage AuthMessage_AuthMessageType = 1 + AuthMessage_Type_AuthServerChallengeMessage AuthMessage_AuthMessageType = 2 + AuthMessage_Type_AuthClientResponseMessage AuthMessage_AuthMessageType = 3 + AuthMessage_Type_AuthServerVerificationMessage AuthMessage_AuthMessageType = 4 + AuthMessage_Type_ErrorMessage AuthMessage_AuthMessageType = 1024 +) + +var AuthMessage_AuthMessageType_name = map[int32]string{ + 1: "Type_AuthClientRequestMessage", + 2: "Type_AuthServerChallengeMessage", + 3: "Type_AuthClientResponseMessage", + 4: "Type_AuthServerVerificationMessage", + 1024: "Type_ErrorMessage", +} +var AuthMessage_AuthMessageType_value = map[string]int32{ + "Type_AuthClientRequestMessage": 1, + "Type_AuthServerChallengeMessage": 2, + "Type_AuthClientResponseMessage": 3, + "Type_AuthServerVerificationMessage": 4, + "Type_ErrorMessage": 1024, +} + +func (x AuthMessage_AuthMessageType) Enum() *AuthMessage_AuthMessageType { + p := new(AuthMessage_AuthMessageType) + *p = x + return p +} +func (x AuthMessage_AuthMessageType) String() string { + return proto.EnumName(AuthMessage_AuthMessageType_name, int32(x)) +} +func (x *AuthMessage_AuthMessageType) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(AuthMessage_AuthMessageType_value, data, "AuthMessage_AuthMessageType") + if err != nil { + return err + } + *x = AuthMessage_AuthMessageType(value) + return nil +} + +type LobbyMessage_LobbyMessageType int32 + +const ( + LobbyMessage_Type_InitMessage LobbyMessage_LobbyMessageType = 1 + LobbyMessage_Type_InitAckMessage LobbyMessage_LobbyMessageType = 2 + LobbyMessage_Type_AvatarRequestMessage LobbyMessage_LobbyMessageType = 3 + LobbyMessage_Type_AvatarHeaderMessage LobbyMessage_LobbyMessageType = 4 + LobbyMessage_Type_AvatarDataMessage LobbyMessage_LobbyMessageType = 5 + LobbyMessage_Type_AvatarEndMessage LobbyMessage_LobbyMessageType = 6 + LobbyMessage_Type_UnknownAvatarMessage LobbyMessage_LobbyMessageType = 7 + LobbyMessage_Type_PlayerListMessage LobbyMessage_LobbyMessageType = 8 + LobbyMessage_Type_GameListNewMessage LobbyMessage_LobbyMessageType = 9 + LobbyMessage_Type_GameListUpdateMessage LobbyMessage_LobbyMessageType = 10 + LobbyMessage_Type_GameListPlayerJoinedMessage LobbyMessage_LobbyMessageType = 11 + LobbyMessage_Type_GameListPlayerLeftMessage LobbyMessage_LobbyMessageType = 12 + LobbyMessage_Type_GameListSpectatorJoinedMessage LobbyMessage_LobbyMessageType = 13 + LobbyMessage_Type_GameListSpectatorLeftMessage LobbyMessage_LobbyMessageType = 14 + LobbyMessage_Type_GameListAdminChangedMessage LobbyMessage_LobbyMessageType = 15 + LobbyMessage_Type_PlayerInfoRequestMessage LobbyMessage_LobbyMessageType = 16 + LobbyMessage_Type_PlayerInfoReplyMessage LobbyMessage_LobbyMessageType = 17 + LobbyMessage_Type_SubscriptionRequestMessage LobbyMessage_LobbyMessageType = 18 + LobbyMessage_Type_SubscriptionReplyMessage LobbyMessage_LobbyMessageType = 19 + LobbyMessage_Type_CreateGameMessage LobbyMessage_LobbyMessageType = 20 + LobbyMessage_Type_CreateGameFailedMessage LobbyMessage_LobbyMessageType = 21 + LobbyMessage_Type_InvitePlayerToGameMessage LobbyMessage_LobbyMessageType = 22 + LobbyMessage_Type_InviteNotifyMessage LobbyMessage_LobbyMessageType = 23 + LobbyMessage_Type_RejectGameInvitationMessage LobbyMessage_LobbyMessageType = 24 + LobbyMessage_Type_RejectInvNotifyMessage LobbyMessage_LobbyMessageType = 25 + LobbyMessage_Type_StatisticsMessage LobbyMessage_LobbyMessageType = 26 + LobbyMessage_Type_ChatRequestMessage LobbyMessage_LobbyMessageType = 27 + LobbyMessage_Type_ChatMessage LobbyMessage_LobbyMessageType = 28 + LobbyMessage_Type_ChatRejectMessage LobbyMessage_LobbyMessageType = 29 + LobbyMessage_Type_DialogMessage LobbyMessage_LobbyMessageType = 30 + LobbyMessage_Type_TimeoutWarningMessage LobbyMessage_LobbyMessageType = 31 + LobbyMessage_Type_ResetTimeoutMessage LobbyMessage_LobbyMessageType = 32 + LobbyMessage_Type_ReportAvatarMessage LobbyMessage_LobbyMessageType = 33 + LobbyMessage_Type_ReportAvatarAckMessage LobbyMessage_LobbyMessageType = 34 + LobbyMessage_Type_ReportGameMessage LobbyMessage_LobbyMessageType = 35 + LobbyMessage_Type_ReportGameAckMessage LobbyMessage_LobbyMessageType = 36 + LobbyMessage_Type_AdminRemoveGameMessage LobbyMessage_LobbyMessageType = 37 + LobbyMessage_Type_AdminRemoveGameAckMessage LobbyMessage_LobbyMessageType = 38 + LobbyMessage_Type_AdminBanPlayerMessage LobbyMessage_LobbyMessageType = 39 + LobbyMessage_Type_AdminBanPlayerAckMessage LobbyMessage_LobbyMessageType = 40 + LobbyMessage_Type_ErrorMessage LobbyMessage_LobbyMessageType = 1024 +) + +var LobbyMessage_LobbyMessageType_name = map[int32]string{ + 1: "Type_InitMessage", + 2: "Type_InitAckMessage", + 3: "Type_AvatarRequestMessage", + 4: "Type_AvatarHeaderMessage", + 5: "Type_AvatarDataMessage", + 6: "Type_AvatarEndMessage", + 7: "Type_UnknownAvatarMessage", + 8: "Type_PlayerListMessage", + 9: "Type_GameListNewMessage", + 10: "Type_GameListUpdateMessage", + 11: "Type_GameListPlayerJoinedMessage", + 12: "Type_GameListPlayerLeftMessage", + 13: "Type_GameListSpectatorJoinedMessage", + 14: "Type_GameListSpectatorLeftMessage", + 15: "Type_GameListAdminChangedMessage", + 16: "Type_PlayerInfoRequestMessage", + 17: "Type_PlayerInfoReplyMessage", + 18: "Type_SubscriptionRequestMessage", + 19: "Type_SubscriptionReplyMessage", + 20: "Type_CreateGameMessage", + 21: "Type_CreateGameFailedMessage", + 22: "Type_InvitePlayerToGameMessage", + 23: "Type_InviteNotifyMessage", + 24: "Type_RejectGameInvitationMessage", + 25: "Type_RejectInvNotifyMessage", + 26: "Type_StatisticsMessage", + 27: "Type_ChatRequestMessage", + 28: "Type_ChatMessage", + 29: "Type_ChatRejectMessage", + 30: "Type_DialogMessage", + 31: "Type_TimeoutWarningMessage", + 32: "Type_ResetTimeoutMessage", + 33: "Type_ReportAvatarMessage", + 34: "Type_ReportAvatarAckMessage", + 35: "Type_ReportGameMessage", + 36: "Type_ReportGameAckMessage", + 37: "Type_AdminRemoveGameMessage", + 38: "Type_AdminRemoveGameAckMessage", + 39: "Type_AdminBanPlayerMessage", + 40: "Type_AdminBanPlayerAckMessage", + 1024: "Type_ErrorMessage", +} +var LobbyMessage_LobbyMessageType_value = map[string]int32{ + "Type_InitMessage": 1, + "Type_InitAckMessage": 2, + "Type_AvatarRequestMessage": 3, + "Type_AvatarHeaderMessage": 4, + "Type_AvatarDataMessage": 5, + "Type_AvatarEndMessage": 6, + "Type_UnknownAvatarMessage": 7, + "Type_PlayerListMessage": 8, + "Type_GameListNewMessage": 9, + "Type_GameListUpdateMessage": 10, + "Type_GameListPlayerJoinedMessage": 11, + "Type_GameListPlayerLeftMessage": 12, + "Type_GameListSpectatorJoinedMessage": 13, + "Type_GameListSpectatorLeftMessage": 14, + "Type_GameListAdminChangedMessage": 15, + "Type_PlayerInfoRequestMessage": 16, + "Type_PlayerInfoReplyMessage": 17, + "Type_SubscriptionRequestMessage": 18, + "Type_SubscriptionReplyMessage": 19, + "Type_CreateGameMessage": 20, + "Type_CreateGameFailedMessage": 21, + "Type_InvitePlayerToGameMessage": 22, + "Type_InviteNotifyMessage": 23, + "Type_RejectGameInvitationMessage": 24, + "Type_RejectInvNotifyMessage": 25, + "Type_StatisticsMessage": 26, + "Type_ChatRequestMessage": 27, + "Type_ChatMessage": 28, + "Type_ChatRejectMessage": 29, + "Type_DialogMessage": 30, + "Type_TimeoutWarningMessage": 31, + "Type_ResetTimeoutMessage": 32, + "Type_ReportAvatarMessage": 33, + "Type_ReportAvatarAckMessage": 34, + "Type_ReportGameMessage": 35, + "Type_ReportGameAckMessage": 36, + "Type_AdminRemoveGameMessage": 37, + "Type_AdminRemoveGameAckMessage": 38, + "Type_AdminBanPlayerMessage": 39, + "Type_AdminBanPlayerAckMessage": 40, + "Type_ErrorMessage": 1024, +} + +func (x LobbyMessage_LobbyMessageType) Enum() *LobbyMessage_LobbyMessageType { + p := new(LobbyMessage_LobbyMessageType) + *p = x + return p +} +func (x LobbyMessage_LobbyMessageType) String() string { + return proto.EnumName(LobbyMessage_LobbyMessageType_name, int32(x)) +} +func (x *LobbyMessage_LobbyMessageType) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(LobbyMessage_LobbyMessageType_value, data, "LobbyMessage_LobbyMessageType") + if err != nil { + return err + } + *x = LobbyMessage_LobbyMessageType(value) + return nil +} + +type GameManagementMessage_GameManagementMessageType int32 + +const ( + GameManagementMessage_Type_JoinGameMessage GameManagementMessage_GameManagementMessageType = 1 + GameManagementMessage_Type_RejoinGameMessage GameManagementMessage_GameManagementMessageType = 2 + GameManagementMessage_Type_JoinGameAckMessage GameManagementMessage_GameManagementMessageType = 3 + GameManagementMessage_Type_JoinGameFailedMessage GameManagementMessage_GameManagementMessageType = 4 + GameManagementMessage_Type_GamePlayerJoinedMessage GameManagementMessage_GameManagementMessageType = 5 + GameManagementMessage_Type_GamePlayerLeftMessage GameManagementMessage_GameManagementMessageType = 6 + GameManagementMessage_Type_GameSpectatorJoinedMessage GameManagementMessage_GameManagementMessageType = 7 + GameManagementMessage_Type_GameSpectatorLeftMessage GameManagementMessage_GameManagementMessageType = 8 + GameManagementMessage_Type_GameAdminChangedMessage GameManagementMessage_GameManagementMessageType = 9 + GameManagementMessage_Type_RemovedFromGameMessage GameManagementMessage_GameManagementMessageType = 10 + GameManagementMessage_Type_KickPlayerRequestMessage GameManagementMessage_GameManagementMessageType = 11 + GameManagementMessage_Type_LeaveGameRequestMessage GameManagementMessage_GameManagementMessageType = 12 + GameManagementMessage_Type_StartEventMessage GameManagementMessage_GameManagementMessageType = 13 + GameManagementMessage_Type_StartEventAckMessage GameManagementMessage_GameManagementMessageType = 14 + GameManagementMessage_Type_GameStartInitialMessage GameManagementMessage_GameManagementMessageType = 15 + GameManagementMessage_Type_GameStartRejoinMessage GameManagementMessage_GameManagementMessageType = 16 + GameManagementMessage_Type_EndOfGameMessage GameManagementMessage_GameManagementMessageType = 17 + GameManagementMessage_Type_PlayerIdChangedMessage GameManagementMessage_GameManagementMessageType = 18 + GameManagementMessage_Type_AskKickPlayerMessage GameManagementMessage_GameManagementMessageType = 19 + GameManagementMessage_Type_AskKickDeniedMessage GameManagementMessage_GameManagementMessageType = 20 + GameManagementMessage_Type_StartKickPetitionMessage GameManagementMessage_GameManagementMessageType = 21 + GameManagementMessage_Type_VoteKickRequestMessage GameManagementMessage_GameManagementMessageType = 22 + GameManagementMessage_Type_VoteKickReplyMessage GameManagementMessage_GameManagementMessageType = 23 + GameManagementMessage_Type_KickPetitionUpdateMessage GameManagementMessage_GameManagementMessageType = 24 + GameManagementMessage_Type_EndKickPetitionMessage GameManagementMessage_GameManagementMessageType = 25 + GameManagementMessage_Type_ChatRequestMessage GameManagementMessage_GameManagementMessageType = 26 + GameManagementMessage_Type_ChatMessage GameManagementMessage_GameManagementMessageType = 27 + GameManagementMessage_Type_ChatRejectMessage GameManagementMessage_GameManagementMessageType = 28 + GameManagementMessage_Type_ErrorMessage GameManagementMessage_GameManagementMessageType = 1024 +) + +var GameManagementMessage_GameManagementMessageType_name = map[int32]string{ + 1: "Type_JoinGameMessage", + 2: "Type_RejoinGameMessage", + 3: "Type_JoinGameAckMessage", + 4: "Type_JoinGameFailedMessage", + 5: "Type_GamePlayerJoinedMessage", + 6: "Type_GamePlayerLeftMessage", + 7: "Type_GameSpectatorJoinedMessage", + 8: "Type_GameSpectatorLeftMessage", + 9: "Type_GameAdminChangedMessage", + 10: "Type_RemovedFromGameMessage", + 11: "Type_KickPlayerRequestMessage", + 12: "Type_LeaveGameRequestMessage", + 13: "Type_StartEventMessage", + 14: "Type_StartEventAckMessage", + 15: "Type_GameStartInitialMessage", + 16: "Type_GameStartRejoinMessage", + 17: "Type_EndOfGameMessage", + 18: "Type_PlayerIdChangedMessage", + 19: "Type_AskKickPlayerMessage", + 20: "Type_AskKickDeniedMessage", + 21: "Type_StartKickPetitionMessage", + 22: "Type_VoteKickRequestMessage", + 23: "Type_VoteKickReplyMessage", + 24: "Type_KickPetitionUpdateMessage", + 25: "Type_EndKickPetitionMessage", + 26: "Type_ChatRequestMessage", + 27: "Type_ChatMessage", + 28: "Type_ChatRejectMessage", + 1024: "Type_ErrorMessage", +} +var GameManagementMessage_GameManagementMessageType_value = map[string]int32{ + "Type_JoinGameMessage": 1, + "Type_RejoinGameMessage": 2, + "Type_JoinGameAckMessage": 3, + "Type_JoinGameFailedMessage": 4, + "Type_GamePlayerJoinedMessage": 5, + "Type_GamePlayerLeftMessage": 6, + "Type_GameSpectatorJoinedMessage": 7, + "Type_GameSpectatorLeftMessage": 8, + "Type_GameAdminChangedMessage": 9, + "Type_RemovedFromGameMessage": 10, + "Type_KickPlayerRequestMessage": 11, + "Type_LeaveGameRequestMessage": 12, + "Type_StartEventMessage": 13, + "Type_StartEventAckMessage": 14, + "Type_GameStartInitialMessage": 15, + "Type_GameStartRejoinMessage": 16, + "Type_EndOfGameMessage": 17, + "Type_PlayerIdChangedMessage": 18, + "Type_AskKickPlayerMessage": 19, + "Type_AskKickDeniedMessage": 20, + "Type_StartKickPetitionMessage": 21, + "Type_VoteKickRequestMessage": 22, + "Type_VoteKickReplyMessage": 23, + "Type_KickPetitionUpdateMessage": 24, + "Type_EndKickPetitionMessage": 25, + "Type_ChatRequestMessage": 26, + "Type_ChatMessage": 27, + "Type_ChatRejectMessage": 28, + "Type_ErrorMessage": 1024, +} + +func (x GameManagementMessage_GameManagementMessageType) Enum() *GameManagementMessage_GameManagementMessageType { + p := new(GameManagementMessage_GameManagementMessageType) + *p = x + return p +} +func (x GameManagementMessage_GameManagementMessageType) String() string { + return proto.EnumName(GameManagementMessage_GameManagementMessageType_name, int32(x)) +} +func (x *GameManagementMessage_GameManagementMessageType) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(GameManagementMessage_GameManagementMessageType_value, data, "GameManagementMessage_GameManagementMessageType") + if err != nil { + return err + } + *x = GameManagementMessage_GameManagementMessageType(value) + return nil +} + +type GameEngineMessage_GameEngineMessageType int32 + +const ( + GameEngineMessage_Type_HandStartMessage GameEngineMessage_GameEngineMessageType = 1 + GameEngineMessage_Type_PlayersTurnMessage GameEngineMessage_GameEngineMessageType = 2 + GameEngineMessage_Type_MyActionRequestMessage GameEngineMessage_GameEngineMessageType = 3 + GameEngineMessage_Type_YourActionRejectedMessage GameEngineMessage_GameEngineMessageType = 4 + GameEngineMessage_Type_PlayersActionDoneMessage GameEngineMessage_GameEngineMessageType = 5 + GameEngineMessage_Type_DealFlopCardsMessage GameEngineMessage_GameEngineMessageType = 6 + GameEngineMessage_Type_DealTurnCardMessage GameEngineMessage_GameEngineMessageType = 7 + GameEngineMessage_Type_DealRiverCardMessage GameEngineMessage_GameEngineMessageType = 8 + GameEngineMessage_Type_AllInShowCardsMessage GameEngineMessage_GameEngineMessageType = 9 + GameEngineMessage_Type_EndOfHandShowCardsMessage GameEngineMessage_GameEngineMessageType = 10 + GameEngineMessage_Type_EndOfHandHideCardsMessage GameEngineMessage_GameEngineMessageType = 11 + GameEngineMessage_Type_ShowMyCardsRequestMessage GameEngineMessage_GameEngineMessageType = 12 + GameEngineMessage_Type_AfterHandShowCardsMessage GameEngineMessage_GameEngineMessageType = 13 +) + +var GameEngineMessage_GameEngineMessageType_name = map[int32]string{ + 1: "Type_HandStartMessage", + 2: "Type_PlayersTurnMessage", + 3: "Type_MyActionRequestMessage", + 4: "Type_YourActionRejectedMessage", + 5: "Type_PlayersActionDoneMessage", + 6: "Type_DealFlopCardsMessage", + 7: "Type_DealTurnCardMessage", + 8: "Type_DealRiverCardMessage", + 9: "Type_AllInShowCardsMessage", + 10: "Type_EndOfHandShowCardsMessage", + 11: "Type_EndOfHandHideCardsMessage", + 12: "Type_ShowMyCardsRequestMessage", + 13: "Type_AfterHandShowCardsMessage", +} +var GameEngineMessage_GameEngineMessageType_value = map[string]int32{ + "Type_HandStartMessage": 1, + "Type_PlayersTurnMessage": 2, + "Type_MyActionRequestMessage": 3, + "Type_YourActionRejectedMessage": 4, + "Type_PlayersActionDoneMessage": 5, + "Type_DealFlopCardsMessage": 6, + "Type_DealTurnCardMessage": 7, + "Type_DealRiverCardMessage": 8, + "Type_AllInShowCardsMessage": 9, + "Type_EndOfHandShowCardsMessage": 10, + "Type_EndOfHandHideCardsMessage": 11, + "Type_ShowMyCardsRequestMessage": 12, + "Type_AfterHandShowCardsMessage": 13, +} + +func (x GameEngineMessage_GameEngineMessageType) Enum() *GameEngineMessage_GameEngineMessageType { + p := new(GameEngineMessage_GameEngineMessageType) + *p = x + return p +} +func (x GameEngineMessage_GameEngineMessageType) String() string { + return proto.EnumName(GameEngineMessage_GameEngineMessageType_name, int32(x)) +} +func (x *GameEngineMessage_GameEngineMessageType) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(GameEngineMessage_GameEngineMessageType_value, data, "GameEngineMessage_GameEngineMessageType") + if err != nil { + return err + } + *x = GameEngineMessage_GameEngineMessageType(value) + return nil +} + +type GameMessage_GameMessageType int32 + +const ( + GameMessage_Type_GameManagementMessage GameMessage_GameMessageType = 1 + GameMessage_Type_GameEngineMessage GameMessage_GameMessageType = 2 +) + +var GameMessage_GameMessageType_name = map[int32]string{ + 1: "Type_GameManagementMessage", + 2: "Type_GameEngineMessage", +} +var GameMessage_GameMessageType_value = map[string]int32{ + "Type_GameManagementMessage": 1, + "Type_GameEngineMessage": 2, +} + +func (x GameMessage_GameMessageType) Enum() *GameMessage_GameMessageType { + p := new(GameMessage_GameMessageType) + *p = x + return p +} +func (x GameMessage_GameMessageType) String() string { + return proto.EnumName(GameMessage_GameMessageType_name, int32(x)) +} +func (x *GameMessage_GameMessageType) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(GameMessage_GameMessageType_value, data, "GameMessage_GameMessageType") + if err != nil { + return err + } + *x = GameMessage_GameMessageType(value) + return nil +} + +type PokerTHMessage_PokerTHMessageType int32 + +const ( + PokerTHMessage_Type_AnnounceMessage PokerTHMessage_PokerTHMessageType = 1 + PokerTHMessage_Type_AuthMessage PokerTHMessage_PokerTHMessageType = 2 + PokerTHMessage_Type_LobbyMessage PokerTHMessage_PokerTHMessageType = 3 + PokerTHMessage_Type_GameMessage PokerTHMessage_PokerTHMessageType = 4 +) + +var PokerTHMessage_PokerTHMessageType_name = map[int32]string{ + 1: "Type_AnnounceMessage", + 2: "Type_AuthMessage", + 3: "Type_LobbyMessage", + 4: "Type_GameMessage", +} +var PokerTHMessage_PokerTHMessageType_value = map[string]int32{ + "Type_AnnounceMessage": 1, + "Type_AuthMessage": 2, + "Type_LobbyMessage": 3, + "Type_GameMessage": 4, +} + +func (x PokerTHMessage_PokerTHMessageType) Enum() *PokerTHMessage_PokerTHMessageType { + p := new(PokerTHMessage_PokerTHMessageType) + *p = x + return p +} +func (x PokerTHMessage_PokerTHMessageType) String() string { + return proto.EnumName(PokerTHMessage_PokerTHMessageType_name, int32(x)) +} +func (x *PokerTHMessage_PokerTHMessageType) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(PokerTHMessage_PokerTHMessageType_value, data, "PokerTHMessage_PokerTHMessageType") + if err != nil { + return err + } + *x = PokerTHMessage_PokerTHMessageType(value) + return nil +} + +type NetGameInfo struct { + GameName *string `protobuf:"bytes,1,req,name=gameName" json:"gameName,omitempty"` + NetGameType *NetGameInfo_NetGameType `protobuf:"varint,2,req,name=netGameType,enum=NetGameInfo_NetGameType" json:"netGameType,omitempty"` + MaxNumPlayers *uint32 `protobuf:"varint,3,req,name=maxNumPlayers" json:"maxNumPlayers,omitempty"` + RaiseIntervalMode *NetGameInfo_RaiseIntervalMode `protobuf:"varint,4,req,name=raiseIntervalMode,enum=NetGameInfo_RaiseIntervalMode" json:"raiseIntervalMode,omitempty"` + RaiseEveryHands *uint32 `protobuf:"varint,5,opt,name=raiseEveryHands" json:"raiseEveryHands,omitempty"` + RaiseEveryMinutes *uint32 `protobuf:"varint,6,opt,name=raiseEveryMinutes" json:"raiseEveryMinutes,omitempty"` + EndRaiseMode *NetGameInfo_EndRaiseMode `protobuf:"varint,7,req,name=endRaiseMode,enum=NetGameInfo_EndRaiseMode" json:"endRaiseMode,omitempty"` + EndRaiseSmallBlindValue *uint32 `protobuf:"varint,8,opt,name=endRaiseSmallBlindValue" json:"endRaiseSmallBlindValue,omitempty"` + ProposedGuiSpeed *uint32 `protobuf:"varint,9,req,name=proposedGuiSpeed" json:"proposedGuiSpeed,omitempty"` + DelayBetweenHands *uint32 `protobuf:"varint,10,req,name=delayBetweenHands" json:"delayBetweenHands,omitempty"` + PlayerActionTimeout *uint32 `protobuf:"varint,11,req,name=playerActionTimeout" json:"playerActionTimeout,omitempty"` + FirstSmallBlind *uint32 `protobuf:"varint,12,req,name=firstSmallBlind" json:"firstSmallBlind,omitempty"` + StartMoney *uint32 `protobuf:"varint,13,req,name=startMoney" json:"startMoney,omitempty"` + ManualBlinds []uint32 `protobuf:"varint,14,rep,packed,name=manualBlinds" json:"manualBlinds,omitempty"` + AllowSpectators *bool `protobuf:"varint,15,opt,name=allowSpectators,def=1" json:"allowSpectators,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NetGameInfo) Reset() { *m = NetGameInfo{} } +func (m *NetGameInfo) String() string { return proto.CompactTextString(m) } +func (*NetGameInfo) ProtoMessage() {} + +const Default_NetGameInfo_AllowSpectators bool = true + +func (m *NetGameInfo) GetGameName() string { + if m != nil && m.GameName != nil { + return *m.GameName + } + return "" +} + +func (m *NetGameInfo) GetNetGameType() NetGameInfo_NetGameType { + if m != nil && m.NetGameType != nil { + return *m.NetGameType + } + return NetGameInfo_normalGame +} + +func (m *NetGameInfo) GetMaxNumPlayers() uint32 { + if m != nil && m.MaxNumPlayers != nil { + return *m.MaxNumPlayers + } + return 0 +} + +func (m *NetGameInfo) GetRaiseIntervalMode() NetGameInfo_RaiseIntervalMode { + if m != nil && m.RaiseIntervalMode != nil { + return *m.RaiseIntervalMode + } + return NetGameInfo_raiseOnHandNum +} + +func (m *NetGameInfo) GetRaiseEveryHands() uint32 { + if m != nil && m.RaiseEveryHands != nil { + return *m.RaiseEveryHands + } + return 0 +} + +func (m *NetGameInfo) GetRaiseEveryMinutes() uint32 { + if m != nil && m.RaiseEveryMinutes != nil { + return *m.RaiseEveryMinutes + } + return 0 +} + +func (m *NetGameInfo) GetEndRaiseMode() NetGameInfo_EndRaiseMode { + if m != nil && m.EndRaiseMode != nil { + return *m.EndRaiseMode + } + return NetGameInfo_doubleBlinds +} + +func (m *NetGameInfo) GetEndRaiseSmallBlindValue() uint32 { + if m != nil && m.EndRaiseSmallBlindValue != nil { + return *m.EndRaiseSmallBlindValue + } + return 0 +} + +func (m *NetGameInfo) GetProposedGuiSpeed() uint32 { + if m != nil && m.ProposedGuiSpeed != nil { + return *m.ProposedGuiSpeed + } + return 0 +} + +func (m *NetGameInfo) GetDelayBetweenHands() uint32 { + if m != nil && m.DelayBetweenHands != nil { + return *m.DelayBetweenHands + } + return 0 +} + +func (m *NetGameInfo) GetPlayerActionTimeout() uint32 { + if m != nil && m.PlayerActionTimeout != nil { + return *m.PlayerActionTimeout + } + return 0 +} + +func (m *NetGameInfo) GetFirstSmallBlind() uint32 { + if m != nil && m.FirstSmallBlind != nil { + return *m.FirstSmallBlind + } + return 0 +} + +func (m *NetGameInfo) GetStartMoney() uint32 { + if m != nil && m.StartMoney != nil { + return *m.StartMoney + } + return 0 +} + +func (m *NetGameInfo) GetManualBlinds() []uint32 { + if m != nil { + return m.ManualBlinds + } + return nil +} + +func (m *NetGameInfo) GetAllowSpectators() bool { + if m != nil && m.AllowSpectators != nil { + return *m.AllowSpectators + } + return Default_NetGameInfo_AllowSpectators +} + +type PlayerResult struct { + PlayerId *uint32 `protobuf:"varint,1,req,name=playerId" json:"playerId,omitempty"` + ResultCard1 *uint32 `protobuf:"varint,2,req,name=resultCard1" json:"resultCard1,omitempty"` + ResultCard2 *uint32 `protobuf:"varint,3,req,name=resultCard2" json:"resultCard2,omitempty"` + BestHandPosition []uint32 `protobuf:"varint,4,rep,packed,name=bestHandPosition" json:"bestHandPosition,omitempty"` + MoneyWon *uint32 `protobuf:"varint,5,req,name=moneyWon" json:"moneyWon,omitempty"` + PlayerMoney *uint32 `protobuf:"varint,6,req,name=playerMoney" json:"playerMoney,omitempty"` + CardsValue *uint32 `protobuf:"varint,7,opt,name=cardsValue" json:"cardsValue,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *PlayerResult) Reset() { *m = PlayerResult{} } +func (m *PlayerResult) String() string { return proto.CompactTextString(m) } +func (*PlayerResult) ProtoMessage() {} + +func (m *PlayerResult) GetPlayerId() uint32 { + if m != nil && m.PlayerId != nil { + return *m.PlayerId + } + return 0 +} + +func (m *PlayerResult) GetResultCard1() uint32 { + if m != nil && m.ResultCard1 != nil { + return *m.ResultCard1 + } + return 0 +} + +func (m *PlayerResult) GetResultCard2() uint32 { + if m != nil && m.ResultCard2 != nil { + return *m.ResultCard2 + } + return 0 +} + +func (m *PlayerResult) GetBestHandPosition() []uint32 { + if m != nil { + return m.BestHandPosition + } + return nil +} + +func (m *PlayerResult) GetMoneyWon() uint32 { + if m != nil && m.MoneyWon != nil { + return *m.MoneyWon + } + return 0 +} + +func (m *PlayerResult) GetPlayerMoney() uint32 { + if m != nil && m.PlayerMoney != nil { + return *m.PlayerMoney + } + return 0 +} + +func (m *PlayerResult) GetCardsValue() uint32 { + if m != nil && m.CardsValue != nil { + return *m.CardsValue + } + return 0 +} + +type AnnounceMessage struct { + ProtocolVersion *AnnounceMessage_Version `protobuf:"bytes,1,req,name=protocolVersion" json:"protocolVersion,omitempty"` + LatestGameVersion *AnnounceMessage_Version `protobuf:"bytes,2,req,name=latestGameVersion" json:"latestGameVersion,omitempty"` + LatestBetaRevision *uint32 `protobuf:"varint,3,req,name=latestBetaRevision" json:"latestBetaRevision,omitempty"` + ServerType *AnnounceMessage_ServerType `protobuf:"varint,4,req,name=serverType,enum=AnnounceMessage_ServerType" json:"serverType,omitempty"` + NumPlayersOnServer *uint32 `protobuf:"varint,5,req,name=numPlayersOnServer" json:"numPlayersOnServer,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AnnounceMessage) Reset() { *m = AnnounceMessage{} } +func (m *AnnounceMessage) String() string { return proto.CompactTextString(m) } +func (*AnnounceMessage) ProtoMessage() {} + +func (m *AnnounceMessage) GetProtocolVersion() *AnnounceMessage_Version { + if m != nil { + return m.ProtocolVersion + } + return nil +} + +func (m *AnnounceMessage) GetLatestGameVersion() *AnnounceMessage_Version { + if m != nil { + return m.LatestGameVersion + } + return nil +} + +func (m *AnnounceMessage) GetLatestBetaRevision() uint32 { + if m != nil && m.LatestBetaRevision != nil { + return *m.LatestBetaRevision + } + return 0 +} + +func (m *AnnounceMessage) GetServerType() AnnounceMessage_ServerType { + if m != nil && m.ServerType != nil { + return *m.ServerType + } + return AnnounceMessage_serverTypeLAN +} + +func (m *AnnounceMessage) GetNumPlayersOnServer() uint32 { + if m != nil && m.NumPlayersOnServer != nil { + return *m.NumPlayersOnServer + } + return 0 +} + +type AnnounceMessage_Version struct { + MajorVersion *uint32 `protobuf:"varint,1,req,name=majorVersion" json:"majorVersion,omitempty"` + MinorVersion *uint32 `protobuf:"varint,2,req,name=minorVersion" json:"minorVersion,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AnnounceMessage_Version) Reset() { *m = AnnounceMessage_Version{} } +func (m *AnnounceMessage_Version) String() string { return proto.CompactTextString(m) } +func (*AnnounceMessage_Version) ProtoMessage() {} + +func (m *AnnounceMessage_Version) GetMajorVersion() uint32 { + if m != nil && m.MajorVersion != nil { + return *m.MajorVersion + } + return 0 +} + +func (m *AnnounceMessage_Version) GetMinorVersion() uint32 { + if m != nil && m.MinorVersion != nil { + return *m.MinorVersion + } + return 0 +} + +type AuthClientRequestMessage struct { + RequestedVersion *AnnounceMessage_Version `protobuf:"bytes,1,req,name=requestedVersion" json:"requestedVersion,omitempty"` + // buildId contains a constant build id (specific for Windows/Linux/Mac builds) + BuildId *uint32 `protobuf:"varint,2,req,name=buildId" json:"buildId,omitempty"` + Login *AuthClientRequestMessage_LoginType `protobuf:"varint,3,req,name=login,enum=AuthClientRequestMessage_LoginType" json:"login,omitempty"` + AuthServerPassword *string `protobuf:"bytes,4,opt,name=authServerPassword" json:"authServerPassword,omitempty"` + // Only used for guest login or unauthenticated login. + NickName *string `protobuf:"bytes,5,opt,name=nickName" json:"nickName,omitempty"` + // Authenticated login data is according to SCRAM SHA-1 + ClientUserData []byte `protobuf:"bytes,6,opt,name=clientUserData" json:"clientUserData,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AuthClientRequestMessage) Reset() { *m = AuthClientRequestMessage{} } +func (m *AuthClientRequestMessage) String() string { return proto.CompactTextString(m) } +func (*AuthClientRequestMessage) ProtoMessage() {} + +func (m *AuthClientRequestMessage) GetRequestedVersion() *AnnounceMessage_Version { + if m != nil { + return m.RequestedVersion + } + return nil +} + +func (m *AuthClientRequestMessage) GetBuildId() uint32 { + if m != nil && m.BuildId != nil { + return *m.BuildId + } + return 0 +} + +func (m *AuthClientRequestMessage) GetLogin() AuthClientRequestMessage_LoginType { + if m != nil && m.Login != nil { + return *m.Login + } + return AuthClientRequestMessage_guestLogin +} + +func (m *AuthClientRequestMessage) GetAuthServerPassword() string { + if m != nil && m.AuthServerPassword != nil { + return *m.AuthServerPassword + } + return "" +} + +func (m *AuthClientRequestMessage) GetNickName() string { + if m != nil && m.NickName != nil { + return *m.NickName + } + return "" +} + +func (m *AuthClientRequestMessage) GetClientUserData() []byte { + if m != nil { + return m.ClientUserData + } + return nil +} + +type AuthServerChallengeMessage struct { + ServerChallenge []byte `protobuf:"bytes,1,req,name=serverChallenge" json:"serverChallenge,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AuthServerChallengeMessage) Reset() { *m = AuthServerChallengeMessage{} } +func (m *AuthServerChallengeMessage) String() string { return proto.CompactTextString(m) } +func (*AuthServerChallengeMessage) ProtoMessage() {} + +func (m *AuthServerChallengeMessage) GetServerChallenge() []byte { + if m != nil { + return m.ServerChallenge + } + return nil +} + +type AuthClientResponseMessage struct { + ClientResponse []byte `protobuf:"bytes,1,req,name=clientResponse" json:"clientResponse,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AuthClientResponseMessage) Reset() { *m = AuthClientResponseMessage{} } +func (m *AuthClientResponseMessage) String() string { return proto.CompactTextString(m) } +func (*AuthClientResponseMessage) ProtoMessage() {} + +func (m *AuthClientResponseMessage) GetClientResponse() []byte { + if m != nil { + return m.ClientResponse + } + return nil +} + +type AuthServerVerificationMessage struct { + YourSessionId []byte `protobuf:"bytes,1,req,name=yourSessionId" json:"yourSessionId,omitempty"` + YourPlayerId *uint32 `protobuf:"varint,2,req,name=yourPlayerId" json:"yourPlayerId,omitempty"` + ServerVerification []byte `protobuf:"bytes,3,opt,name=serverVerification" json:"serverVerification,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AuthServerVerificationMessage) Reset() { *m = AuthServerVerificationMessage{} } +func (m *AuthServerVerificationMessage) String() string { return proto.CompactTextString(m) } +func (*AuthServerVerificationMessage) ProtoMessage() {} + +func (m *AuthServerVerificationMessage) GetYourSessionId() []byte { + if m != nil { + return m.YourSessionId + } + return nil +} + +func (m *AuthServerVerificationMessage) GetYourPlayerId() uint32 { + if m != nil && m.YourPlayerId != nil { + return *m.YourPlayerId + } + return 0 +} + +func (m *AuthServerVerificationMessage) GetServerVerification() []byte { + if m != nil { + return m.ServerVerification + } + return nil +} + +type InitMessage struct { + MyLastSessionId []byte `protobuf:"bytes,1,opt,name=myLastSessionId" json:"myLastSessionId,omitempty"` + // Ignored for guest login. + AvatarHash []byte `protobuf:"bytes,2,opt,name=avatarHash" json:"avatarHash,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *InitMessage) Reset() { *m = InitMessage{} } +func (m *InitMessage) String() string { return proto.CompactTextString(m) } +func (*InitMessage) ProtoMessage() {} + +func (m *InitMessage) GetMyLastSessionId() []byte { + if m != nil { + return m.MyLastSessionId + } + return nil +} + +func (m *InitMessage) GetAvatarHash() []byte { + if m != nil { + return m.AvatarHash + } + return nil +} + +type InitAckMessage struct { + YourAvatarHash []byte `protobuf:"bytes,3,opt,name=yourAvatarHash" json:"yourAvatarHash,omitempty"` + RejoinGameId *uint32 `protobuf:"varint,4,opt,name=rejoinGameId" json:"rejoinGameId,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *InitAckMessage) Reset() { *m = InitAckMessage{} } +func (m *InitAckMessage) String() string { return proto.CompactTextString(m) } +func (*InitAckMessage) ProtoMessage() {} + +func (m *InitAckMessage) GetYourAvatarHash() []byte { + if m != nil { + return m.YourAvatarHash + } + return nil +} + +func (m *InitAckMessage) GetRejoinGameId() uint32 { + if m != nil && m.RejoinGameId != nil { + return *m.RejoinGameId + } + return 0 +} + +type AvatarRequestMessage struct { + RequestId *uint32 `protobuf:"varint,1,req,name=requestId" json:"requestId,omitempty"` + AvatarHash []byte `protobuf:"bytes,2,req,name=avatarHash" json:"avatarHash,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AvatarRequestMessage) Reset() { *m = AvatarRequestMessage{} } +func (m *AvatarRequestMessage) String() string { return proto.CompactTextString(m) } +func (*AvatarRequestMessage) ProtoMessage() {} + +func (m *AvatarRequestMessage) GetRequestId() uint32 { + if m != nil && m.RequestId != nil { + return *m.RequestId + } + return 0 +} + +func (m *AvatarRequestMessage) GetAvatarHash() []byte { + if m != nil { + return m.AvatarHash + } + return nil +} + +type AvatarHeaderMessage struct { + RequestId *uint32 `protobuf:"varint,1,req,name=requestId" json:"requestId,omitempty"` + AvatarType *NetAvatarType `protobuf:"varint,2,req,name=avatarType,enum=NetAvatarType" json:"avatarType,omitempty"` + AvatarSize *uint32 `protobuf:"varint,3,req,name=avatarSize" json:"avatarSize,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AvatarHeaderMessage) Reset() { *m = AvatarHeaderMessage{} } +func (m *AvatarHeaderMessage) String() string { return proto.CompactTextString(m) } +func (*AvatarHeaderMessage) ProtoMessage() {} + +func (m *AvatarHeaderMessage) GetRequestId() uint32 { + if m != nil && m.RequestId != nil { + return *m.RequestId + } + return 0 +} + +func (m *AvatarHeaderMessage) GetAvatarType() NetAvatarType { + if m != nil && m.AvatarType != nil { + return *m.AvatarType + } + return NetAvatarType_netAvatarImagePng +} + +func (m *AvatarHeaderMessage) GetAvatarSize() uint32 { + if m != nil && m.AvatarSize != nil { + return *m.AvatarSize + } + return 0 +} + +type AvatarDataMessage struct { + RequestId *uint32 `protobuf:"varint,1,req,name=requestId" json:"requestId,omitempty"` + AvatarBlock []byte `protobuf:"bytes,2,req,name=avatarBlock" json:"avatarBlock,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AvatarDataMessage) Reset() { *m = AvatarDataMessage{} } +func (m *AvatarDataMessage) String() string { return proto.CompactTextString(m) } +func (*AvatarDataMessage) ProtoMessage() {} + +func (m *AvatarDataMessage) GetRequestId() uint32 { + if m != nil && m.RequestId != nil { + return *m.RequestId + } + return 0 +} + +func (m *AvatarDataMessage) GetAvatarBlock() []byte { + if m != nil { + return m.AvatarBlock + } + return nil +} + +type AvatarEndMessage struct { + RequestId *uint32 `protobuf:"varint,1,req,name=requestId" json:"requestId,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AvatarEndMessage) Reset() { *m = AvatarEndMessage{} } +func (m *AvatarEndMessage) String() string { return proto.CompactTextString(m) } +func (*AvatarEndMessage) ProtoMessage() {} + +func (m *AvatarEndMessage) GetRequestId() uint32 { + if m != nil && m.RequestId != nil { + return *m.RequestId + } + return 0 +} + +type UnknownAvatarMessage struct { + RequestId *uint32 `protobuf:"varint,1,req,name=requestId" json:"requestId,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *UnknownAvatarMessage) Reset() { *m = UnknownAvatarMessage{} } +func (m *UnknownAvatarMessage) String() string { return proto.CompactTextString(m) } +func (*UnknownAvatarMessage) ProtoMessage() {} + +func (m *UnknownAvatarMessage) GetRequestId() uint32 { + if m != nil && m.RequestId != nil { + return *m.RequestId + } + return 0 +} + +type PlayerListMessage struct { + PlayerId *uint32 `protobuf:"varint,1,req,name=playerId" json:"playerId,omitempty"` + PlayerListNotification *PlayerListMessage_PlayerListNotification `protobuf:"varint,2,req,name=playerListNotification,enum=PlayerListMessage_PlayerListNotification" json:"playerListNotification,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *PlayerListMessage) Reset() { *m = PlayerListMessage{} } +func (m *PlayerListMessage) String() string { return proto.CompactTextString(m) } +func (*PlayerListMessage) ProtoMessage() {} + +func (m *PlayerListMessage) GetPlayerId() uint32 { + if m != nil && m.PlayerId != nil { + return *m.PlayerId + } + return 0 +} + +func (m *PlayerListMessage) GetPlayerListNotification() PlayerListMessage_PlayerListNotification { + if m != nil && m.PlayerListNotification != nil { + return *m.PlayerListNotification + } + return PlayerListMessage_playerListNew +} + +type GameListNewMessage struct { + GameId *uint32 `protobuf:"varint,1,req,name=gameId" json:"gameId,omitempty"` + GameMode *NetGameMode `protobuf:"varint,2,req,name=gameMode,enum=NetGameMode" json:"gameMode,omitempty"` + IsPrivate *bool `protobuf:"varint,3,req,name=isPrivate" json:"isPrivate,omitempty"` + PlayerIds []uint32 `protobuf:"varint,4,rep,packed,name=playerIds" json:"playerIds,omitempty"` + AdminPlayerId *uint32 `protobuf:"varint,5,req,name=adminPlayerId" json:"adminPlayerId,omitempty"` + GameInfo *NetGameInfo `protobuf:"bytes,6,req,name=gameInfo" json:"gameInfo,omitempty"` + SpectatorIds []uint32 `protobuf:"varint,7,rep,packed,name=spectatorIds" json:"spectatorIds,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GameListNewMessage) Reset() { *m = GameListNewMessage{} } +func (m *GameListNewMessage) String() string { return proto.CompactTextString(m) } +func (*GameListNewMessage) ProtoMessage() {} + +func (m *GameListNewMessage) GetGameId() uint32 { + if m != nil && m.GameId != nil { + return *m.GameId + } + return 0 +} + +func (m *GameListNewMessage) GetGameMode() NetGameMode { + if m != nil && m.GameMode != nil { + return *m.GameMode + } + return NetGameMode_netGameCreated +} + +func (m *GameListNewMessage) GetIsPrivate() bool { + if m != nil && m.IsPrivate != nil { + return *m.IsPrivate + } + return false +} + +func (m *GameListNewMessage) GetPlayerIds() []uint32 { + if m != nil { + return m.PlayerIds + } + return nil +} + +func (m *GameListNewMessage) GetAdminPlayerId() uint32 { + if m != nil && m.AdminPlayerId != nil { + return *m.AdminPlayerId + } + return 0 +} + +func (m *GameListNewMessage) GetGameInfo() *NetGameInfo { + if m != nil { + return m.GameInfo + } + return nil +} + +func (m *GameListNewMessage) GetSpectatorIds() []uint32 { + if m != nil { + return m.SpectatorIds + } + return nil +} + +type GameListUpdateMessage struct { + GameId *uint32 `protobuf:"varint,1,req,name=gameId" json:"gameId,omitempty"` + GameMode *NetGameMode `protobuf:"varint,2,req,name=gameMode,enum=NetGameMode" json:"gameMode,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GameListUpdateMessage) Reset() { *m = GameListUpdateMessage{} } +func (m *GameListUpdateMessage) String() string { return proto.CompactTextString(m) } +func (*GameListUpdateMessage) ProtoMessage() {} + +func (m *GameListUpdateMessage) GetGameId() uint32 { + if m != nil && m.GameId != nil { + return *m.GameId + } + return 0 +} + +func (m *GameListUpdateMessage) GetGameMode() NetGameMode { + if m != nil && m.GameMode != nil { + return *m.GameMode + } + return NetGameMode_netGameCreated +} + +type GameListPlayerJoinedMessage struct { + GameId *uint32 `protobuf:"varint,1,req,name=gameId" json:"gameId,omitempty"` + PlayerId *uint32 `protobuf:"varint,2,req,name=playerId" json:"playerId,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GameListPlayerJoinedMessage) Reset() { *m = GameListPlayerJoinedMessage{} } +func (m *GameListPlayerJoinedMessage) String() string { return proto.CompactTextString(m) } +func (*GameListPlayerJoinedMessage) ProtoMessage() {} + +func (m *GameListPlayerJoinedMessage) GetGameId() uint32 { + if m != nil && m.GameId != nil { + return *m.GameId + } + return 0 +} + +func (m *GameListPlayerJoinedMessage) GetPlayerId() uint32 { + if m != nil && m.PlayerId != nil { + return *m.PlayerId + } + return 0 +} + +type GameListPlayerLeftMessage struct { + GameId *uint32 `protobuf:"varint,1,req,name=gameId" json:"gameId,omitempty"` + PlayerId *uint32 `protobuf:"varint,2,req,name=playerId" json:"playerId,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GameListPlayerLeftMessage) Reset() { *m = GameListPlayerLeftMessage{} } +func (m *GameListPlayerLeftMessage) String() string { return proto.CompactTextString(m) } +func (*GameListPlayerLeftMessage) ProtoMessage() {} + +func (m *GameListPlayerLeftMessage) GetGameId() uint32 { + if m != nil && m.GameId != nil { + return *m.GameId + } + return 0 +} + +func (m *GameListPlayerLeftMessage) GetPlayerId() uint32 { + if m != nil && m.PlayerId != nil { + return *m.PlayerId + } + return 0 +} + +type GameListSpectatorJoinedMessage struct { + GameId *uint32 `protobuf:"varint,1,req,name=gameId" json:"gameId,omitempty"` + PlayerId *uint32 `protobuf:"varint,2,req,name=playerId" json:"playerId,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GameListSpectatorJoinedMessage) Reset() { *m = GameListSpectatorJoinedMessage{} } +func (m *GameListSpectatorJoinedMessage) String() string { return proto.CompactTextString(m) } +func (*GameListSpectatorJoinedMessage) ProtoMessage() {} + +func (m *GameListSpectatorJoinedMessage) GetGameId() uint32 { + if m != nil && m.GameId != nil { + return *m.GameId + } + return 0 +} + +func (m *GameListSpectatorJoinedMessage) GetPlayerId() uint32 { + if m != nil && m.PlayerId != nil { + return *m.PlayerId + } + return 0 +} + +type GameListSpectatorLeftMessage struct { + GameId *uint32 `protobuf:"varint,1,req,name=gameId" json:"gameId,omitempty"` + PlayerId *uint32 `protobuf:"varint,2,req,name=playerId" json:"playerId,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GameListSpectatorLeftMessage) Reset() { *m = GameListSpectatorLeftMessage{} } +func (m *GameListSpectatorLeftMessage) String() string { return proto.CompactTextString(m) } +func (*GameListSpectatorLeftMessage) ProtoMessage() {} + +func (m *GameListSpectatorLeftMessage) GetGameId() uint32 { + if m != nil && m.GameId != nil { + return *m.GameId + } + return 0 +} + +func (m *GameListSpectatorLeftMessage) GetPlayerId() uint32 { + if m != nil && m.PlayerId != nil { + return *m.PlayerId + } + return 0 +} + +type GameListAdminChangedMessage struct { + GameId *uint32 `protobuf:"varint,1,req,name=gameId" json:"gameId,omitempty"` + NewAdminPlayerId *uint32 `protobuf:"varint,2,req,name=newAdminPlayerId" json:"newAdminPlayerId,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GameListAdminChangedMessage) Reset() { *m = GameListAdminChangedMessage{} } +func (m *GameListAdminChangedMessage) String() string { return proto.CompactTextString(m) } +func (*GameListAdminChangedMessage) ProtoMessage() {} + +func (m *GameListAdminChangedMessage) GetGameId() uint32 { + if m != nil && m.GameId != nil { + return *m.GameId + } + return 0 +} + +func (m *GameListAdminChangedMessage) GetNewAdminPlayerId() uint32 { + if m != nil && m.NewAdminPlayerId != nil { + return *m.NewAdminPlayerId + } + return 0 +} + +type PlayerInfoRequestMessage struct { + PlayerId []uint32 `protobuf:"varint,1,rep,packed,name=playerId" json:"playerId,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *PlayerInfoRequestMessage) Reset() { *m = PlayerInfoRequestMessage{} } +func (m *PlayerInfoRequestMessage) String() string { return proto.CompactTextString(m) } +func (*PlayerInfoRequestMessage) ProtoMessage() {} + +func (m *PlayerInfoRequestMessage) GetPlayerId() []uint32 { + if m != nil { + return m.PlayerId + } + return nil +} + +type PlayerInfoReplyMessage struct { + PlayerId *uint32 `protobuf:"varint,1,req,name=playerId" json:"playerId,omitempty"` + PlayerInfoData *PlayerInfoReplyMessage_PlayerInfoData `protobuf:"bytes,2,opt,name=playerInfoData" json:"playerInfoData,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *PlayerInfoReplyMessage) Reset() { *m = PlayerInfoReplyMessage{} } +func (m *PlayerInfoReplyMessage) String() string { return proto.CompactTextString(m) } +func (*PlayerInfoReplyMessage) ProtoMessage() {} + +func (m *PlayerInfoReplyMessage) GetPlayerId() uint32 { + if m != nil && m.PlayerId != nil { + return *m.PlayerId + } + return 0 +} + +func (m *PlayerInfoReplyMessage) GetPlayerInfoData() *PlayerInfoReplyMessage_PlayerInfoData { + if m != nil { + return m.PlayerInfoData + } + return nil +} + +type PlayerInfoReplyMessage_PlayerInfoData struct { + PlayerName *string `protobuf:"bytes,1,req,name=playerName" json:"playerName,omitempty"` + IsHuman *bool `protobuf:"varint,2,req,name=isHuman" json:"isHuman,omitempty"` + PlayerRights *NetPlayerInfoRights `protobuf:"varint,3,req,name=playerRights,enum=NetPlayerInfoRights" json:"playerRights,omitempty"` + CountryCode *string `protobuf:"bytes,4,opt,name=countryCode" json:"countryCode,omitempty"` + AvatarData *PlayerInfoReplyMessage_PlayerInfoData_AvatarData `protobuf:"bytes,5,opt,name=avatarData" json:"avatarData,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *PlayerInfoReplyMessage_PlayerInfoData) Reset() { *m = PlayerInfoReplyMessage_PlayerInfoData{} } +func (m *PlayerInfoReplyMessage_PlayerInfoData) String() string { return proto.CompactTextString(m) } +func (*PlayerInfoReplyMessage_PlayerInfoData) ProtoMessage() {} + +func (m *PlayerInfoReplyMessage_PlayerInfoData) GetPlayerName() string { + if m != nil && m.PlayerName != nil { + return *m.PlayerName + } + return "" +} + +func (m *PlayerInfoReplyMessage_PlayerInfoData) GetIsHuman() bool { + if m != nil && m.IsHuman != nil { + return *m.IsHuman + } + return false +} + +func (m *PlayerInfoReplyMessage_PlayerInfoData) GetPlayerRights() NetPlayerInfoRights { + if m != nil && m.PlayerRights != nil { + return *m.PlayerRights + } + return NetPlayerInfoRights_netPlayerRightsGuest +} + +func (m *PlayerInfoReplyMessage_PlayerInfoData) GetCountryCode() string { + if m != nil && m.CountryCode != nil { + return *m.CountryCode + } + return "" +} + +func (m *PlayerInfoReplyMessage_PlayerInfoData) GetAvatarData() *PlayerInfoReplyMessage_PlayerInfoData_AvatarData { + if m != nil { + return m.AvatarData + } + return nil +} + +type PlayerInfoReplyMessage_PlayerInfoData_AvatarData struct { + AvatarType *NetAvatarType `protobuf:"varint,1,req,name=avatarType,enum=NetAvatarType" json:"avatarType,omitempty"` + AvatarHash []byte `protobuf:"bytes,2,req,name=avatarHash" json:"avatarHash,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *PlayerInfoReplyMessage_PlayerInfoData_AvatarData) Reset() { + *m = PlayerInfoReplyMessage_PlayerInfoData_AvatarData{} +} +func (m *PlayerInfoReplyMessage_PlayerInfoData_AvatarData) String() string { + return proto.CompactTextString(m) +} +func (*PlayerInfoReplyMessage_PlayerInfoData_AvatarData) ProtoMessage() {} + +func (m *PlayerInfoReplyMessage_PlayerInfoData_AvatarData) GetAvatarType() NetAvatarType { + if m != nil && m.AvatarType != nil { + return *m.AvatarType + } + return NetAvatarType_netAvatarImagePng +} + +func (m *PlayerInfoReplyMessage_PlayerInfoData_AvatarData) GetAvatarHash() []byte { + if m != nil { + return m.AvatarHash + } + return nil +} + +// The following request is used optionally to reduce server traffic. +type SubscriptionRequestMessage struct { + RequestId *uint32 `protobuf:"varint,1,req,name=requestId" json:"requestId,omitempty"` + SubscriptionAction *SubscriptionRequestMessage_SubscriptionAction `protobuf:"varint,2,req,name=subscriptionAction,enum=SubscriptionRequestMessage_SubscriptionAction" json:"subscriptionAction,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *SubscriptionRequestMessage) Reset() { *m = SubscriptionRequestMessage{} } +func (m *SubscriptionRequestMessage) String() string { return proto.CompactTextString(m) } +func (*SubscriptionRequestMessage) ProtoMessage() {} + +func (m *SubscriptionRequestMessage) GetRequestId() uint32 { + if m != nil && m.RequestId != nil { + return *m.RequestId + } + return 0 +} + +func (m *SubscriptionRequestMessage) GetSubscriptionAction() SubscriptionRequestMessage_SubscriptionAction { + if m != nil && m.SubscriptionAction != nil { + return *m.SubscriptionAction + } + return SubscriptionRequestMessage_unsubscribeGameList +} + +type SubscriptionReplyMessage struct { + RequestId *uint32 `protobuf:"varint,1,req,name=requestId" json:"requestId,omitempty"` + Ack *bool `protobuf:"varint,2,req,name=ack" json:"ack,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *SubscriptionReplyMessage) Reset() { *m = SubscriptionReplyMessage{} } +func (m *SubscriptionReplyMessage) String() string { return proto.CompactTextString(m) } +func (*SubscriptionReplyMessage) ProtoMessage() {} + +func (m *SubscriptionReplyMessage) GetRequestId() uint32 { + if m != nil && m.RequestId != nil { + return *m.RequestId + } + return 0 +} + +func (m *SubscriptionReplyMessage) GetAck() bool { + if m != nil && m.Ack != nil { + return *m.Ack + } + return false +} + +type CreateGameMessage struct { + RequestId *uint32 `protobuf:"varint,1,req,name=requestId" json:"requestId,omitempty"` + GameInfo *NetGameInfo `protobuf:"bytes,2,req,name=gameInfo" json:"gameInfo,omitempty"` + Password *string `protobuf:"bytes,3,opt,name=password" json:"password,omitempty"` + AutoLeave *bool `protobuf:"varint,4,opt,name=autoLeave" json:"autoLeave,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CreateGameMessage) Reset() { *m = CreateGameMessage{} } +func (m *CreateGameMessage) String() string { return proto.CompactTextString(m) } +func (*CreateGameMessage) ProtoMessage() {} + +func (m *CreateGameMessage) GetRequestId() uint32 { + if m != nil && m.RequestId != nil { + return *m.RequestId + } + return 0 +} + +func (m *CreateGameMessage) GetGameInfo() *NetGameInfo { + if m != nil { + return m.GameInfo + } + return nil +} + +func (m *CreateGameMessage) GetPassword() string { + if m != nil && m.Password != nil { + return *m.Password + } + return "" +} + +func (m *CreateGameMessage) GetAutoLeave() bool { + if m != nil && m.AutoLeave != nil { + return *m.AutoLeave + } + return false +} + +type CreateGameFailedMessage struct { + RequestId *uint32 `protobuf:"varint,1,req,name=requestId" json:"requestId,omitempty"` + CreateGameFailureReason *CreateGameFailedMessage_CreateGameFailureReason `protobuf:"varint,2,req,name=createGameFailureReason,enum=CreateGameFailedMessage_CreateGameFailureReason" json:"createGameFailureReason,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CreateGameFailedMessage) Reset() { *m = CreateGameFailedMessage{} } +func (m *CreateGameFailedMessage) String() string { return proto.CompactTextString(m) } +func (*CreateGameFailedMessage) ProtoMessage() {} + +func (m *CreateGameFailedMessage) GetRequestId() uint32 { + if m != nil && m.RequestId != nil { + return *m.RequestId + } + return 0 +} + +func (m *CreateGameFailedMessage) GetCreateGameFailureReason() CreateGameFailedMessage_CreateGameFailureReason { + if m != nil && m.CreateGameFailureReason != nil { + return *m.CreateGameFailureReason + } + return CreateGameFailedMessage_notAllowedAsGuest +} + +type JoinGameMessage struct { + Password *string `protobuf:"bytes,1,opt,name=password" json:"password,omitempty"` + AutoLeave *bool `protobuf:"varint,2,opt,name=autoLeave,def=0" json:"autoLeave,omitempty"` + SpectateOnly *bool `protobuf:"varint,3,opt,name=spectateOnly,def=0" json:"spectateOnly,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *JoinGameMessage) Reset() { *m = JoinGameMessage{} } +func (m *JoinGameMessage) String() string { return proto.CompactTextString(m) } +func (*JoinGameMessage) ProtoMessage() {} + +const Default_JoinGameMessage_AutoLeave bool = false +const Default_JoinGameMessage_SpectateOnly bool = false + +func (m *JoinGameMessage) GetPassword() string { + if m != nil && m.Password != nil { + return *m.Password + } + return "" +} + +func (m *JoinGameMessage) GetAutoLeave() bool { + if m != nil && m.AutoLeave != nil { + return *m.AutoLeave + } + return Default_JoinGameMessage_AutoLeave +} + +func (m *JoinGameMessage) GetSpectateOnly() bool { + if m != nil && m.SpectateOnly != nil { + return *m.SpectateOnly + } + return Default_JoinGameMessage_SpectateOnly +} + +type RejoinGameMessage struct { + AutoLeave *bool `protobuf:"varint,1,opt,name=autoLeave,def=0" json:"autoLeave,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *RejoinGameMessage) Reset() { *m = RejoinGameMessage{} } +func (m *RejoinGameMessage) String() string { return proto.CompactTextString(m) } +func (*RejoinGameMessage) ProtoMessage() {} + +const Default_RejoinGameMessage_AutoLeave bool = false + +func (m *RejoinGameMessage) GetAutoLeave() bool { + if m != nil && m.AutoLeave != nil { + return *m.AutoLeave + } + return Default_RejoinGameMessage_AutoLeave +} + +type JoinGameAckMessage struct { + AreYouGameAdmin *bool `protobuf:"varint,1,req,name=areYouGameAdmin" json:"areYouGameAdmin,omitempty"` + GameInfo *NetGameInfo `protobuf:"bytes,2,req,name=gameInfo" json:"gameInfo,omitempty"` + SpectateOnly *bool `protobuf:"varint,3,opt,name=spectateOnly" json:"spectateOnly,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *JoinGameAckMessage) Reset() { *m = JoinGameAckMessage{} } +func (m *JoinGameAckMessage) String() string { return proto.CompactTextString(m) } +func (*JoinGameAckMessage) ProtoMessage() {} + +func (m *JoinGameAckMessage) GetAreYouGameAdmin() bool { + if m != nil && m.AreYouGameAdmin != nil { + return *m.AreYouGameAdmin + } + return false +} + +func (m *JoinGameAckMessage) GetGameInfo() *NetGameInfo { + if m != nil { + return m.GameInfo + } + return nil +} + +func (m *JoinGameAckMessage) GetSpectateOnly() bool { + if m != nil && m.SpectateOnly != nil { + return *m.SpectateOnly + } + return false +} + +type JoinGameFailedMessage struct { + JoinGameFailureReason *JoinGameFailedMessage_JoinGameFailureReason `protobuf:"varint,1,req,name=joinGameFailureReason,enum=JoinGameFailedMessage_JoinGameFailureReason" json:"joinGameFailureReason,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *JoinGameFailedMessage) Reset() { *m = JoinGameFailedMessage{} } +func (m *JoinGameFailedMessage) String() string { return proto.CompactTextString(m) } +func (*JoinGameFailedMessage) ProtoMessage() {} + +func (m *JoinGameFailedMessage) GetJoinGameFailureReason() JoinGameFailedMessage_JoinGameFailureReason { + if m != nil && m.JoinGameFailureReason != nil { + return *m.JoinGameFailureReason + } + return JoinGameFailedMessage_invalidGame +} + +type GamePlayerJoinedMessage struct { + PlayerId *uint32 `protobuf:"varint,1,req,name=playerId" json:"playerId,omitempty"` + IsGameAdmin *bool `protobuf:"varint,2,req,name=isGameAdmin" json:"isGameAdmin,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GamePlayerJoinedMessage) Reset() { *m = GamePlayerJoinedMessage{} } +func (m *GamePlayerJoinedMessage) String() string { return proto.CompactTextString(m) } +func (*GamePlayerJoinedMessage) ProtoMessage() {} + +func (m *GamePlayerJoinedMessage) GetPlayerId() uint32 { + if m != nil && m.PlayerId != nil { + return *m.PlayerId + } + return 0 +} + +func (m *GamePlayerJoinedMessage) GetIsGameAdmin() bool { + if m != nil && m.IsGameAdmin != nil { + return *m.IsGameAdmin + } + return false +} + +type GamePlayerLeftMessage struct { + PlayerId *uint32 `protobuf:"varint,1,req,name=playerId" json:"playerId,omitempty"` + GamePlayerLeftReason *GamePlayerLeftMessage_GamePlayerLeftReason `protobuf:"varint,2,req,name=gamePlayerLeftReason,enum=GamePlayerLeftMessage_GamePlayerLeftReason" json:"gamePlayerLeftReason,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GamePlayerLeftMessage) Reset() { *m = GamePlayerLeftMessage{} } +func (m *GamePlayerLeftMessage) String() string { return proto.CompactTextString(m) } +func (*GamePlayerLeftMessage) ProtoMessage() {} + +func (m *GamePlayerLeftMessage) GetPlayerId() uint32 { + if m != nil && m.PlayerId != nil { + return *m.PlayerId + } + return 0 +} + +func (m *GamePlayerLeftMessage) GetGamePlayerLeftReason() GamePlayerLeftMessage_GamePlayerLeftReason { + if m != nil && m.GamePlayerLeftReason != nil { + return *m.GamePlayerLeftReason + } + return GamePlayerLeftMessage_leftOnRequest +} + +type GameSpectatorJoinedMessage struct { + PlayerId *uint32 `protobuf:"varint,1,req,name=playerId" json:"playerId,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GameSpectatorJoinedMessage) Reset() { *m = GameSpectatorJoinedMessage{} } +func (m *GameSpectatorJoinedMessage) String() string { return proto.CompactTextString(m) } +func (*GameSpectatorJoinedMessage) ProtoMessage() {} + +func (m *GameSpectatorJoinedMessage) GetPlayerId() uint32 { + if m != nil && m.PlayerId != nil { + return *m.PlayerId + } + return 0 +} + +type GameSpectatorLeftMessage struct { + PlayerId *uint32 `protobuf:"varint,1,req,name=playerId" json:"playerId,omitempty"` + GameSpectatorLeftReason *GamePlayerLeftMessage_GamePlayerLeftReason `protobuf:"varint,2,req,name=gameSpectatorLeftReason,enum=GamePlayerLeftMessage_GamePlayerLeftReason" json:"gameSpectatorLeftReason,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GameSpectatorLeftMessage) Reset() { *m = GameSpectatorLeftMessage{} } +func (m *GameSpectatorLeftMessage) String() string { return proto.CompactTextString(m) } +func (*GameSpectatorLeftMessage) ProtoMessage() {} + +func (m *GameSpectatorLeftMessage) GetPlayerId() uint32 { + if m != nil && m.PlayerId != nil { + return *m.PlayerId + } + return 0 +} + +func (m *GameSpectatorLeftMessage) GetGameSpectatorLeftReason() GamePlayerLeftMessage_GamePlayerLeftReason { + if m != nil && m.GameSpectatorLeftReason != nil { + return *m.GameSpectatorLeftReason + } + return GamePlayerLeftMessage_leftOnRequest +} + +type GameAdminChangedMessage struct { + NewAdminPlayerId *uint32 `protobuf:"varint,1,req,name=newAdminPlayerId" json:"newAdminPlayerId,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GameAdminChangedMessage) Reset() { *m = GameAdminChangedMessage{} } +func (m *GameAdminChangedMessage) String() string { return proto.CompactTextString(m) } +func (*GameAdminChangedMessage) ProtoMessage() {} + +func (m *GameAdminChangedMessage) GetNewAdminPlayerId() uint32 { + if m != nil && m.NewAdminPlayerId != nil { + return *m.NewAdminPlayerId + } + return 0 +} + +type RemovedFromGameMessage struct { + RemovedFromGameReason *RemovedFromGameMessage_RemovedFromGameReason `protobuf:"varint,1,req,name=removedFromGameReason,enum=RemovedFromGameMessage_RemovedFromGameReason" json:"removedFromGameReason,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *RemovedFromGameMessage) Reset() { *m = RemovedFromGameMessage{} } +func (m *RemovedFromGameMessage) String() string { return proto.CompactTextString(m) } +func (*RemovedFromGameMessage) ProtoMessage() {} + +func (m *RemovedFromGameMessage) GetRemovedFromGameReason() RemovedFromGameMessage_RemovedFromGameReason { + if m != nil && m.RemovedFromGameReason != nil { + return *m.RemovedFromGameReason + } + return RemovedFromGameMessage_removedOnRequest +} + +type KickPlayerRequestMessage struct { + PlayerId *uint32 `protobuf:"varint,1,req,name=playerId" json:"playerId,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *KickPlayerRequestMessage) Reset() { *m = KickPlayerRequestMessage{} } +func (m *KickPlayerRequestMessage) String() string { return proto.CompactTextString(m) } +func (*KickPlayerRequestMessage) ProtoMessage() {} + +func (m *KickPlayerRequestMessage) GetPlayerId() uint32 { + if m != nil && m.PlayerId != nil { + return *m.PlayerId + } + return 0 +} + +type LeaveGameRequestMessage struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *LeaveGameRequestMessage) Reset() { *m = LeaveGameRequestMessage{} } +func (m *LeaveGameRequestMessage) String() string { return proto.CompactTextString(m) } +func (*LeaveGameRequestMessage) ProtoMessage() {} + +type InvitePlayerToGameMessage struct { + GameId *uint32 `protobuf:"varint,1,req,name=gameId" json:"gameId,omitempty"` + PlayerId *uint32 `protobuf:"varint,2,req,name=playerId" json:"playerId,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *InvitePlayerToGameMessage) Reset() { *m = InvitePlayerToGameMessage{} } +func (m *InvitePlayerToGameMessage) String() string { return proto.CompactTextString(m) } +func (*InvitePlayerToGameMessage) ProtoMessage() {} + +func (m *InvitePlayerToGameMessage) GetGameId() uint32 { + if m != nil && m.GameId != nil { + return *m.GameId + } + return 0 +} + +func (m *InvitePlayerToGameMessage) GetPlayerId() uint32 { + if m != nil && m.PlayerId != nil { + return *m.PlayerId + } + return 0 +} + +type InviteNotifyMessage struct { + GameId *uint32 `protobuf:"varint,1,req,name=gameId" json:"gameId,omitempty"` + PlayerIdWho *uint32 `protobuf:"varint,2,req,name=playerIdWho" json:"playerIdWho,omitempty"` + PlayerIdByWhom *uint32 `protobuf:"varint,3,req,name=playerIdByWhom" json:"playerIdByWhom,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *InviteNotifyMessage) Reset() { *m = InviteNotifyMessage{} } +func (m *InviteNotifyMessage) String() string { return proto.CompactTextString(m) } +func (*InviteNotifyMessage) ProtoMessage() {} + +func (m *InviteNotifyMessage) GetGameId() uint32 { + if m != nil && m.GameId != nil { + return *m.GameId + } + return 0 +} + +func (m *InviteNotifyMessage) GetPlayerIdWho() uint32 { + if m != nil && m.PlayerIdWho != nil { + return *m.PlayerIdWho + } + return 0 +} + +func (m *InviteNotifyMessage) GetPlayerIdByWhom() uint32 { + if m != nil && m.PlayerIdByWhom != nil { + return *m.PlayerIdByWhom + } + return 0 +} + +type RejectGameInvitationMessage struct { + GameId *uint32 `protobuf:"varint,1,req,name=gameId" json:"gameId,omitempty"` + MyRejectReason *RejectGameInvitationMessage_RejectGameInvReason `protobuf:"varint,2,req,name=myRejectReason,enum=RejectGameInvitationMessage_RejectGameInvReason" json:"myRejectReason,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *RejectGameInvitationMessage) Reset() { *m = RejectGameInvitationMessage{} } +func (m *RejectGameInvitationMessage) String() string { return proto.CompactTextString(m) } +func (*RejectGameInvitationMessage) ProtoMessage() {} + +func (m *RejectGameInvitationMessage) GetGameId() uint32 { + if m != nil && m.GameId != nil { + return *m.GameId + } + return 0 +} + +func (m *RejectGameInvitationMessage) GetMyRejectReason() RejectGameInvitationMessage_RejectGameInvReason { + if m != nil && m.MyRejectReason != nil { + return *m.MyRejectReason + } + return RejectGameInvitationMessage_rejectReasonNo +} + +type RejectInvNotifyMessage struct { + GameId *uint32 `protobuf:"varint,1,req,name=gameId" json:"gameId,omitempty"` + PlayerId *uint32 `protobuf:"varint,2,req,name=playerId" json:"playerId,omitempty"` + PlayerRejectReason *RejectGameInvitationMessage_RejectGameInvReason `protobuf:"varint,3,req,name=playerRejectReason,enum=RejectGameInvitationMessage_RejectGameInvReason" json:"playerRejectReason,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *RejectInvNotifyMessage) Reset() { *m = RejectInvNotifyMessage{} } +func (m *RejectInvNotifyMessage) String() string { return proto.CompactTextString(m) } +func (*RejectInvNotifyMessage) ProtoMessage() {} + +func (m *RejectInvNotifyMessage) GetGameId() uint32 { + if m != nil && m.GameId != nil { + return *m.GameId + } + return 0 +} + +func (m *RejectInvNotifyMessage) GetPlayerId() uint32 { + if m != nil && m.PlayerId != nil { + return *m.PlayerId + } + return 0 +} + +func (m *RejectInvNotifyMessage) GetPlayerRejectReason() RejectGameInvitationMessage_RejectGameInvReason { + if m != nil && m.PlayerRejectReason != nil { + return *m.PlayerRejectReason + } + return RejectGameInvitationMessage_rejectReasonNo +} + +type StartEventMessage struct { + StartEventType *StartEventMessage_StartEventType `protobuf:"varint,1,req,name=startEventType,enum=StartEventMessage_StartEventType" json:"startEventType,omitempty"` + FillWithComputerPlayers *bool `protobuf:"varint,2,opt,name=fillWithComputerPlayers" json:"fillWithComputerPlayers,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *StartEventMessage) Reset() { *m = StartEventMessage{} } +func (m *StartEventMessage) String() string { return proto.CompactTextString(m) } +func (*StartEventMessage) ProtoMessage() {} + +func (m *StartEventMessage) GetStartEventType() StartEventMessage_StartEventType { + if m != nil && m.StartEventType != nil { + return *m.StartEventType + } + return StartEventMessage_startEvent +} + +func (m *StartEventMessage) GetFillWithComputerPlayers() bool { + if m != nil && m.FillWithComputerPlayers != nil { + return *m.FillWithComputerPlayers + } + return false +} + +type StartEventAckMessage struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *StartEventAckMessage) Reset() { *m = StartEventAckMessage{} } +func (m *StartEventAckMessage) String() string { return proto.CompactTextString(m) } +func (*StartEventAckMessage) ProtoMessage() {} + +type GameStartInitialMessage struct { + StartDealerPlayerId *uint32 `protobuf:"varint,1,req,name=startDealerPlayerId" json:"startDealerPlayerId,omitempty"` + PlayerSeats []uint32 `protobuf:"varint,2,rep,packed,name=playerSeats" json:"playerSeats,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GameStartInitialMessage) Reset() { *m = GameStartInitialMessage{} } +func (m *GameStartInitialMessage) String() string { return proto.CompactTextString(m) } +func (*GameStartInitialMessage) ProtoMessage() {} + +func (m *GameStartInitialMessage) GetStartDealerPlayerId() uint32 { + if m != nil && m.StartDealerPlayerId != nil { + return *m.StartDealerPlayerId + } + return 0 +} + +func (m *GameStartInitialMessage) GetPlayerSeats() []uint32 { + if m != nil { + return m.PlayerSeats + } + return nil +} + +type GameStartRejoinMessage struct { + StartDealerPlayerId *uint32 `protobuf:"varint,1,req,name=startDealerPlayerId" json:"startDealerPlayerId,omitempty"` + HandNum *uint32 `protobuf:"varint,2,req,name=handNum" json:"handNum,omitempty"` + RejoinPlayerData []*GameStartRejoinMessage_RejoinPlayerData `protobuf:"bytes,3,rep,name=rejoinPlayerData" json:"rejoinPlayerData,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GameStartRejoinMessage) Reset() { *m = GameStartRejoinMessage{} } +func (m *GameStartRejoinMessage) String() string { return proto.CompactTextString(m) } +func (*GameStartRejoinMessage) ProtoMessage() {} + +func (m *GameStartRejoinMessage) GetStartDealerPlayerId() uint32 { + if m != nil && m.StartDealerPlayerId != nil { + return *m.StartDealerPlayerId + } + return 0 +} + +func (m *GameStartRejoinMessage) GetHandNum() uint32 { + if m != nil && m.HandNum != nil { + return *m.HandNum + } + return 0 +} + +func (m *GameStartRejoinMessage) GetRejoinPlayerData() []*GameStartRejoinMessage_RejoinPlayerData { + if m != nil { + return m.RejoinPlayerData + } + return nil +} + +type GameStartRejoinMessage_RejoinPlayerData struct { + PlayerId *uint32 `protobuf:"varint,1,req,name=playerId" json:"playerId,omitempty"` + PlayerMoney *uint32 `protobuf:"varint,2,req,name=playerMoney" json:"playerMoney,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GameStartRejoinMessage_RejoinPlayerData) Reset() { + *m = GameStartRejoinMessage_RejoinPlayerData{} +} +func (m *GameStartRejoinMessage_RejoinPlayerData) String() string { return proto.CompactTextString(m) } +func (*GameStartRejoinMessage_RejoinPlayerData) ProtoMessage() {} + +func (m *GameStartRejoinMessage_RejoinPlayerData) GetPlayerId() uint32 { + if m != nil && m.PlayerId != nil { + return *m.PlayerId + } + return 0 +} + +func (m *GameStartRejoinMessage_RejoinPlayerData) GetPlayerMoney() uint32 { + if m != nil && m.PlayerMoney != nil { + return *m.PlayerMoney + } + return 0 +} + +type HandStartMessage struct { + PlainCards *HandStartMessage_PlainCards `protobuf:"bytes,1,opt,name=plainCards" json:"plainCards,omitempty"` + EncryptedCards []byte `protobuf:"bytes,2,opt,name=encryptedCards" json:"encryptedCards,omitempty"` + SmallBlind *uint32 `protobuf:"varint,3,req,name=smallBlind" json:"smallBlind,omitempty"` + SeatStates []NetPlayerState `protobuf:"varint,4,rep,name=seatStates,enum=NetPlayerState" json:"seatStates,omitempty"` + DealerPlayerId *uint32 `protobuf:"varint,5,opt,name=dealerPlayerId" json:"dealerPlayerId,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *HandStartMessage) Reset() { *m = HandStartMessage{} } +func (m *HandStartMessage) String() string { return proto.CompactTextString(m) } +func (*HandStartMessage) ProtoMessage() {} + +func (m *HandStartMessage) GetPlainCards() *HandStartMessage_PlainCards { + if m != nil { + return m.PlainCards + } + return nil +} + +func (m *HandStartMessage) GetEncryptedCards() []byte { + if m != nil { + return m.EncryptedCards + } + return nil +} + +func (m *HandStartMessage) GetSmallBlind() uint32 { + if m != nil && m.SmallBlind != nil { + return *m.SmallBlind + } + return 0 +} + +func (m *HandStartMessage) GetSeatStates() []NetPlayerState { + if m != nil { + return m.SeatStates + } + return nil +} + +func (m *HandStartMessage) GetDealerPlayerId() uint32 { + if m != nil && m.DealerPlayerId != nil { + return *m.DealerPlayerId + } + return 0 +} + +type HandStartMessage_PlainCards struct { + PlainCard1 *uint32 `protobuf:"varint,1,req,name=plainCard1" json:"plainCard1,omitempty"` + PlainCard2 *uint32 `protobuf:"varint,2,req,name=plainCard2" json:"plainCard2,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *HandStartMessage_PlainCards) Reset() { *m = HandStartMessage_PlainCards{} } +func (m *HandStartMessage_PlainCards) String() string { return proto.CompactTextString(m) } +func (*HandStartMessage_PlainCards) ProtoMessage() {} + +func (m *HandStartMessage_PlainCards) GetPlainCard1() uint32 { + if m != nil && m.PlainCard1 != nil { + return *m.PlainCard1 + } + return 0 +} + +func (m *HandStartMessage_PlainCards) GetPlainCard2() uint32 { + if m != nil && m.PlainCard2 != nil { + return *m.PlainCard2 + } + return 0 +} + +type PlayersTurnMessage struct { + PlayerId *uint32 `protobuf:"varint,1,req,name=playerId" json:"playerId,omitempty"` + GameState *NetGameState `protobuf:"varint,2,req,name=gameState,enum=NetGameState" json:"gameState,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *PlayersTurnMessage) Reset() { *m = PlayersTurnMessage{} } +func (m *PlayersTurnMessage) String() string { return proto.CompactTextString(m) } +func (*PlayersTurnMessage) ProtoMessage() {} + +func (m *PlayersTurnMessage) GetPlayerId() uint32 { + if m != nil && m.PlayerId != nil { + return *m.PlayerId + } + return 0 +} + +func (m *PlayersTurnMessage) GetGameState() NetGameState { + if m != nil && m.GameState != nil { + return *m.GameState + } + return NetGameState_netStatePreflop +} + +type MyActionRequestMessage struct { + HandNum *uint32 `protobuf:"varint,1,req,name=handNum" json:"handNum,omitempty"` + GameState *NetGameState `protobuf:"varint,2,req,name=gameState,enum=NetGameState" json:"gameState,omitempty"` + MyAction *NetPlayerAction `protobuf:"varint,3,req,name=myAction,enum=NetPlayerAction" json:"myAction,omitempty"` + MyRelativeBet *uint32 `protobuf:"varint,4,req,name=myRelativeBet" json:"myRelativeBet,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *MyActionRequestMessage) Reset() { *m = MyActionRequestMessage{} } +func (m *MyActionRequestMessage) String() string { return proto.CompactTextString(m) } +func (*MyActionRequestMessage) ProtoMessage() {} + +func (m *MyActionRequestMessage) GetHandNum() uint32 { + if m != nil && m.HandNum != nil { + return *m.HandNum + } + return 0 +} + +func (m *MyActionRequestMessage) GetGameState() NetGameState { + if m != nil && m.GameState != nil { + return *m.GameState + } + return NetGameState_netStatePreflop +} + +func (m *MyActionRequestMessage) GetMyAction() NetPlayerAction { + if m != nil && m.MyAction != nil { + return *m.MyAction + } + return NetPlayerAction_netActionNone +} + +func (m *MyActionRequestMessage) GetMyRelativeBet() uint32 { + if m != nil && m.MyRelativeBet != nil { + return *m.MyRelativeBet + } + return 0 +} + +type YourActionRejectedMessage struct { + GameState *NetGameState `protobuf:"varint,1,req,name=gameState,enum=NetGameState" json:"gameState,omitempty"` + YourAction *NetPlayerAction `protobuf:"varint,2,req,name=yourAction,enum=NetPlayerAction" json:"yourAction,omitempty"` + YourRelativeBet *uint32 `protobuf:"varint,3,req,name=yourRelativeBet" json:"yourRelativeBet,omitempty"` + RejectionReason *YourActionRejectedMessage_RejectionReason `protobuf:"varint,4,req,name=rejectionReason,enum=YourActionRejectedMessage_RejectionReason" json:"rejectionReason,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *YourActionRejectedMessage) Reset() { *m = YourActionRejectedMessage{} } +func (m *YourActionRejectedMessage) String() string { return proto.CompactTextString(m) } +func (*YourActionRejectedMessage) ProtoMessage() {} + +func (m *YourActionRejectedMessage) GetGameState() NetGameState { + if m != nil && m.GameState != nil { + return *m.GameState + } + return NetGameState_netStatePreflop +} + +func (m *YourActionRejectedMessage) GetYourAction() NetPlayerAction { + if m != nil && m.YourAction != nil { + return *m.YourAction + } + return NetPlayerAction_netActionNone +} + +func (m *YourActionRejectedMessage) GetYourRelativeBet() uint32 { + if m != nil && m.YourRelativeBet != nil { + return *m.YourRelativeBet + } + return 0 +} + +func (m *YourActionRejectedMessage) GetRejectionReason() YourActionRejectedMessage_RejectionReason { + if m != nil && m.RejectionReason != nil { + return *m.RejectionReason + } + return YourActionRejectedMessage_rejectedInvalidGameState +} + +type PlayersActionDoneMessage struct { + PlayerId *uint32 `protobuf:"varint,1,req,name=playerId" json:"playerId,omitempty"` + GameState *NetGameState `protobuf:"varint,2,req,name=gameState,enum=NetGameState" json:"gameState,omitempty"` + PlayerAction *NetPlayerAction `protobuf:"varint,3,req,name=playerAction,enum=NetPlayerAction" json:"playerAction,omitempty"` + TotalPlayerBet *uint32 `protobuf:"varint,4,req,name=totalPlayerBet" json:"totalPlayerBet,omitempty"` + PlayerMoney *uint32 `protobuf:"varint,5,req,name=playerMoney" json:"playerMoney,omitempty"` + HighestSet *uint32 `protobuf:"varint,6,req,name=highestSet" json:"highestSet,omitempty"` + MinimumRaise *uint32 `protobuf:"varint,7,req,name=minimumRaise" json:"minimumRaise,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *PlayersActionDoneMessage) Reset() { *m = PlayersActionDoneMessage{} } +func (m *PlayersActionDoneMessage) String() string { return proto.CompactTextString(m) } +func (*PlayersActionDoneMessage) ProtoMessage() {} + +func (m *PlayersActionDoneMessage) GetPlayerId() uint32 { + if m != nil && m.PlayerId != nil { + return *m.PlayerId + } + return 0 +} + +func (m *PlayersActionDoneMessage) GetGameState() NetGameState { + if m != nil && m.GameState != nil { + return *m.GameState + } + return NetGameState_netStatePreflop +} + +func (m *PlayersActionDoneMessage) GetPlayerAction() NetPlayerAction { + if m != nil && m.PlayerAction != nil { + return *m.PlayerAction + } + return NetPlayerAction_netActionNone +} + +func (m *PlayersActionDoneMessage) GetTotalPlayerBet() uint32 { + if m != nil && m.TotalPlayerBet != nil { + return *m.TotalPlayerBet + } + return 0 +} + +func (m *PlayersActionDoneMessage) GetPlayerMoney() uint32 { + if m != nil && m.PlayerMoney != nil { + return *m.PlayerMoney + } + return 0 +} + +func (m *PlayersActionDoneMessage) GetHighestSet() uint32 { + if m != nil && m.HighestSet != nil { + return *m.HighestSet + } + return 0 +} + +func (m *PlayersActionDoneMessage) GetMinimumRaise() uint32 { + if m != nil && m.MinimumRaise != nil { + return *m.MinimumRaise + } + return 0 +} + +type DealFlopCardsMessage struct { + FlopCard1 *uint32 `protobuf:"varint,1,req,name=flopCard1" json:"flopCard1,omitempty"` + FlopCard2 *uint32 `protobuf:"varint,2,req,name=flopCard2" json:"flopCard2,omitempty"` + FlopCard3 *uint32 `protobuf:"varint,3,req,name=flopCard3" json:"flopCard3,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *DealFlopCardsMessage) Reset() { *m = DealFlopCardsMessage{} } +func (m *DealFlopCardsMessage) String() string { return proto.CompactTextString(m) } +func (*DealFlopCardsMessage) ProtoMessage() {} + +func (m *DealFlopCardsMessage) GetFlopCard1() uint32 { + if m != nil && m.FlopCard1 != nil { + return *m.FlopCard1 + } + return 0 +} + +func (m *DealFlopCardsMessage) GetFlopCard2() uint32 { + if m != nil && m.FlopCard2 != nil { + return *m.FlopCard2 + } + return 0 +} + +func (m *DealFlopCardsMessage) GetFlopCard3() uint32 { + if m != nil && m.FlopCard3 != nil { + return *m.FlopCard3 + } + return 0 +} + +type DealTurnCardMessage struct { + TurnCard *uint32 `protobuf:"varint,1,req,name=turnCard" json:"turnCard,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *DealTurnCardMessage) Reset() { *m = DealTurnCardMessage{} } +func (m *DealTurnCardMessage) String() string { return proto.CompactTextString(m) } +func (*DealTurnCardMessage) ProtoMessage() {} + +func (m *DealTurnCardMessage) GetTurnCard() uint32 { + if m != nil && m.TurnCard != nil { + return *m.TurnCard + } + return 0 +} + +type DealRiverCardMessage struct { + RiverCard *uint32 `protobuf:"varint,1,req,name=riverCard" json:"riverCard,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *DealRiverCardMessage) Reset() { *m = DealRiverCardMessage{} } +func (m *DealRiverCardMessage) String() string { return proto.CompactTextString(m) } +func (*DealRiverCardMessage) ProtoMessage() {} + +func (m *DealRiverCardMessage) GetRiverCard() uint32 { + if m != nil && m.RiverCard != nil { + return *m.RiverCard + } + return 0 +} + +type AllInShowCardsMessage struct { + PlayersAllIn []*AllInShowCardsMessage_PlayerAllIn `protobuf:"bytes,1,rep,name=playersAllIn" json:"playersAllIn,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AllInShowCardsMessage) Reset() { *m = AllInShowCardsMessage{} } +func (m *AllInShowCardsMessage) String() string { return proto.CompactTextString(m) } +func (*AllInShowCardsMessage) ProtoMessage() {} + +func (m *AllInShowCardsMessage) GetPlayersAllIn() []*AllInShowCardsMessage_PlayerAllIn { + if m != nil { + return m.PlayersAllIn + } + return nil +} + +type AllInShowCardsMessage_PlayerAllIn struct { + PlayerId *uint32 `protobuf:"varint,1,req,name=playerId" json:"playerId,omitempty"` + AllInCard1 *uint32 `protobuf:"varint,2,req,name=allInCard1" json:"allInCard1,omitempty"` + AllInCard2 *uint32 `protobuf:"varint,3,req,name=allInCard2" json:"allInCard2,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AllInShowCardsMessage_PlayerAllIn) Reset() { *m = AllInShowCardsMessage_PlayerAllIn{} } +func (m *AllInShowCardsMessage_PlayerAllIn) String() string { return proto.CompactTextString(m) } +func (*AllInShowCardsMessage_PlayerAllIn) ProtoMessage() {} + +func (m *AllInShowCardsMessage_PlayerAllIn) GetPlayerId() uint32 { + if m != nil && m.PlayerId != nil { + return *m.PlayerId + } + return 0 +} + +func (m *AllInShowCardsMessage_PlayerAllIn) GetAllInCard1() uint32 { + if m != nil && m.AllInCard1 != nil { + return *m.AllInCard1 + } + return 0 +} + +func (m *AllInShowCardsMessage_PlayerAllIn) GetAllInCard2() uint32 { + if m != nil && m.AllInCard2 != nil { + return *m.AllInCard2 + } + return 0 +} + +type EndOfHandShowCardsMessage struct { + PlayerResults []*PlayerResult `protobuf:"bytes,1,rep,name=playerResults" json:"playerResults,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *EndOfHandShowCardsMessage) Reset() { *m = EndOfHandShowCardsMessage{} } +func (m *EndOfHandShowCardsMessage) String() string { return proto.CompactTextString(m) } +func (*EndOfHandShowCardsMessage) ProtoMessage() {} + +func (m *EndOfHandShowCardsMessage) GetPlayerResults() []*PlayerResult { + if m != nil { + return m.PlayerResults + } + return nil +} + +type EndOfHandHideCardsMessage struct { + PlayerId *uint32 `protobuf:"varint,1,req,name=playerId" json:"playerId,omitempty"` + MoneyWon *uint32 `protobuf:"varint,2,req,name=moneyWon" json:"moneyWon,omitempty"` + PlayerMoney *uint32 `protobuf:"varint,3,req,name=playerMoney" json:"playerMoney,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *EndOfHandHideCardsMessage) Reset() { *m = EndOfHandHideCardsMessage{} } +func (m *EndOfHandHideCardsMessage) String() string { return proto.CompactTextString(m) } +func (*EndOfHandHideCardsMessage) ProtoMessage() {} + +func (m *EndOfHandHideCardsMessage) GetPlayerId() uint32 { + if m != nil && m.PlayerId != nil { + return *m.PlayerId + } + return 0 +} + +func (m *EndOfHandHideCardsMessage) GetMoneyWon() uint32 { + if m != nil && m.MoneyWon != nil { + return *m.MoneyWon + } + return 0 +} + +func (m *EndOfHandHideCardsMessage) GetPlayerMoney() uint32 { + if m != nil && m.PlayerMoney != nil { + return *m.PlayerMoney + } + return 0 +} + +type ShowMyCardsRequestMessage struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *ShowMyCardsRequestMessage) Reset() { *m = ShowMyCardsRequestMessage{} } +func (m *ShowMyCardsRequestMessage) String() string { return proto.CompactTextString(m) } +func (*ShowMyCardsRequestMessage) ProtoMessage() {} + +type AfterHandShowCardsMessage struct { + PlayerResult *PlayerResult `protobuf:"bytes,1,req,name=playerResult" json:"playerResult,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AfterHandShowCardsMessage) Reset() { *m = AfterHandShowCardsMessage{} } +func (m *AfterHandShowCardsMessage) String() string { return proto.CompactTextString(m) } +func (*AfterHandShowCardsMessage) ProtoMessage() {} + +func (m *AfterHandShowCardsMessage) GetPlayerResult() *PlayerResult { + if m != nil { + return m.PlayerResult + } + return nil +} + +type EndOfGameMessage struct { + WinnerPlayerId *uint32 `protobuf:"varint,1,req,name=winnerPlayerId" json:"winnerPlayerId,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *EndOfGameMessage) Reset() { *m = EndOfGameMessage{} } +func (m *EndOfGameMessage) String() string { return proto.CompactTextString(m) } +func (*EndOfGameMessage) ProtoMessage() {} + +func (m *EndOfGameMessage) GetWinnerPlayerId() uint32 { + if m != nil && m.WinnerPlayerId != nil { + return *m.WinnerPlayerId + } + return 0 +} + +type PlayerIdChangedMessage struct { + OldPlayerId *uint32 `protobuf:"varint,1,req,name=oldPlayerId" json:"oldPlayerId,omitempty"` + NewPlayerId *uint32 `protobuf:"varint,2,req,name=newPlayerId" json:"newPlayerId,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *PlayerIdChangedMessage) Reset() { *m = PlayerIdChangedMessage{} } +func (m *PlayerIdChangedMessage) String() string { return proto.CompactTextString(m) } +func (*PlayerIdChangedMessage) ProtoMessage() {} + +func (m *PlayerIdChangedMessage) GetOldPlayerId() uint32 { + if m != nil && m.OldPlayerId != nil { + return *m.OldPlayerId + } + return 0 +} + +func (m *PlayerIdChangedMessage) GetNewPlayerId() uint32 { + if m != nil && m.NewPlayerId != nil { + return *m.NewPlayerId + } + return 0 +} + +type AskKickPlayerMessage struct { + PlayerId *uint32 `protobuf:"varint,1,req,name=playerId" json:"playerId,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AskKickPlayerMessage) Reset() { *m = AskKickPlayerMessage{} } +func (m *AskKickPlayerMessage) String() string { return proto.CompactTextString(m) } +func (*AskKickPlayerMessage) ProtoMessage() {} + +func (m *AskKickPlayerMessage) GetPlayerId() uint32 { + if m != nil && m.PlayerId != nil { + return *m.PlayerId + } + return 0 +} + +type AskKickDeniedMessage struct { + PlayerId *uint32 `protobuf:"varint,1,req,name=playerId" json:"playerId,omitempty"` + KickDeniedReason *AskKickDeniedMessage_KickDeniedReason `protobuf:"varint,2,req,name=kickDeniedReason,enum=AskKickDeniedMessage_KickDeniedReason" json:"kickDeniedReason,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AskKickDeniedMessage) Reset() { *m = AskKickDeniedMessage{} } +func (m *AskKickDeniedMessage) String() string { return proto.CompactTextString(m) } +func (*AskKickDeniedMessage) ProtoMessage() {} + +func (m *AskKickDeniedMessage) GetPlayerId() uint32 { + if m != nil && m.PlayerId != nil { + return *m.PlayerId + } + return 0 +} + +func (m *AskKickDeniedMessage) GetKickDeniedReason() AskKickDeniedMessage_KickDeniedReason { + if m != nil && m.KickDeniedReason != nil { + return *m.KickDeniedReason + } + return AskKickDeniedMessage_kickDeniedInvalidGameState +} + +type StartKickPetitionMessage struct { + PetitionId *uint32 `protobuf:"varint,1,req,name=petitionId" json:"petitionId,omitempty"` + ProposingPlayerId *uint32 `protobuf:"varint,2,req,name=proposingPlayerId" json:"proposingPlayerId,omitempty"` + KickPlayerId *uint32 `protobuf:"varint,3,req,name=kickPlayerId" json:"kickPlayerId,omitempty"` + KickTimeoutSec *uint32 `protobuf:"varint,4,req,name=kickTimeoutSec" json:"kickTimeoutSec,omitempty"` + NumVotesNeededToKick *uint32 `protobuf:"varint,5,req,name=numVotesNeededToKick" json:"numVotesNeededToKick,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *StartKickPetitionMessage) Reset() { *m = StartKickPetitionMessage{} } +func (m *StartKickPetitionMessage) String() string { return proto.CompactTextString(m) } +func (*StartKickPetitionMessage) ProtoMessage() {} + +func (m *StartKickPetitionMessage) GetPetitionId() uint32 { + if m != nil && m.PetitionId != nil { + return *m.PetitionId + } + return 0 +} + +func (m *StartKickPetitionMessage) GetProposingPlayerId() uint32 { + if m != nil && m.ProposingPlayerId != nil { + return *m.ProposingPlayerId + } + return 0 +} + +func (m *StartKickPetitionMessage) GetKickPlayerId() uint32 { + if m != nil && m.KickPlayerId != nil { + return *m.KickPlayerId + } + return 0 +} + +func (m *StartKickPetitionMessage) GetKickTimeoutSec() uint32 { + if m != nil && m.KickTimeoutSec != nil { + return *m.KickTimeoutSec + } + return 0 +} + +func (m *StartKickPetitionMessage) GetNumVotesNeededToKick() uint32 { + if m != nil && m.NumVotesNeededToKick != nil { + return *m.NumVotesNeededToKick + } + return 0 +} + +type VoteKickRequestMessage struct { + PetitionId *uint32 `protobuf:"varint,1,req,name=petitionId" json:"petitionId,omitempty"` + VoteKick *bool `protobuf:"varint,2,req,name=voteKick" json:"voteKick,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *VoteKickRequestMessage) Reset() { *m = VoteKickRequestMessage{} } +func (m *VoteKickRequestMessage) String() string { return proto.CompactTextString(m) } +func (*VoteKickRequestMessage) ProtoMessage() {} + +func (m *VoteKickRequestMessage) GetPetitionId() uint32 { + if m != nil && m.PetitionId != nil { + return *m.PetitionId + } + return 0 +} + +func (m *VoteKickRequestMessage) GetVoteKick() bool { + if m != nil && m.VoteKick != nil { + return *m.VoteKick + } + return false +} + +type VoteKickReplyMessage struct { + PetitionId *uint32 `protobuf:"varint,1,req,name=petitionId" json:"petitionId,omitempty"` + VoteKickReplyType *VoteKickReplyMessage_VoteKickReplyType `protobuf:"varint,2,req,name=voteKickReplyType,enum=VoteKickReplyMessage_VoteKickReplyType" json:"voteKickReplyType,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *VoteKickReplyMessage) Reset() { *m = VoteKickReplyMessage{} } +func (m *VoteKickReplyMessage) String() string { return proto.CompactTextString(m) } +func (*VoteKickReplyMessage) ProtoMessage() {} + +func (m *VoteKickReplyMessage) GetPetitionId() uint32 { + if m != nil && m.PetitionId != nil { + return *m.PetitionId + } + return 0 +} + +func (m *VoteKickReplyMessage) GetVoteKickReplyType() VoteKickReplyMessage_VoteKickReplyType { + if m != nil && m.VoteKickReplyType != nil { + return *m.VoteKickReplyType + } + return VoteKickReplyMessage_voteKickAck +} + +type KickPetitionUpdateMessage struct { + PetitionId *uint32 `protobuf:"varint,1,req,name=petitionId" json:"petitionId,omitempty"` + NumVotesAgainstKicking *uint32 `protobuf:"varint,2,req,name=numVotesAgainstKicking" json:"numVotesAgainstKicking,omitempty"` + NumVotesInFavourOfKicking *uint32 `protobuf:"varint,3,req,name=numVotesInFavourOfKicking" json:"numVotesInFavourOfKicking,omitempty"` + NumVotesNeededToKick *uint32 `protobuf:"varint,4,req,name=numVotesNeededToKick" json:"numVotesNeededToKick,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *KickPetitionUpdateMessage) Reset() { *m = KickPetitionUpdateMessage{} } +func (m *KickPetitionUpdateMessage) String() string { return proto.CompactTextString(m) } +func (*KickPetitionUpdateMessage) ProtoMessage() {} + +func (m *KickPetitionUpdateMessage) GetPetitionId() uint32 { + if m != nil && m.PetitionId != nil { + return *m.PetitionId + } + return 0 +} + +func (m *KickPetitionUpdateMessage) GetNumVotesAgainstKicking() uint32 { + if m != nil && m.NumVotesAgainstKicking != nil { + return *m.NumVotesAgainstKicking + } + return 0 +} + +func (m *KickPetitionUpdateMessage) GetNumVotesInFavourOfKicking() uint32 { + if m != nil && m.NumVotesInFavourOfKicking != nil { + return *m.NumVotesInFavourOfKicking + } + return 0 +} + +func (m *KickPetitionUpdateMessage) GetNumVotesNeededToKick() uint32 { + if m != nil && m.NumVotesNeededToKick != nil { + return *m.NumVotesNeededToKick + } + return 0 +} + +type EndKickPetitionMessage struct { + PetitionId *uint32 `protobuf:"varint,1,req,name=petitionId" json:"petitionId,omitempty"` + NumVotesAgainstKicking *uint32 `protobuf:"varint,2,req,name=numVotesAgainstKicking" json:"numVotesAgainstKicking,omitempty"` + NumVotesInFavourOfKicking *uint32 `protobuf:"varint,3,req,name=numVotesInFavourOfKicking" json:"numVotesInFavourOfKicking,omitempty"` + ResultPlayerKicked *uint32 `protobuf:"varint,4,req,name=resultPlayerKicked" json:"resultPlayerKicked,omitempty"` + PetitionEndReason *EndKickPetitionMessage_PetitionEndReason `protobuf:"varint,5,req,name=petitionEndReason,enum=EndKickPetitionMessage_PetitionEndReason" json:"petitionEndReason,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *EndKickPetitionMessage) Reset() { *m = EndKickPetitionMessage{} } +func (m *EndKickPetitionMessage) String() string { return proto.CompactTextString(m) } +func (*EndKickPetitionMessage) ProtoMessage() {} + +func (m *EndKickPetitionMessage) GetPetitionId() uint32 { + if m != nil && m.PetitionId != nil { + return *m.PetitionId + } + return 0 +} + +func (m *EndKickPetitionMessage) GetNumVotesAgainstKicking() uint32 { + if m != nil && m.NumVotesAgainstKicking != nil { + return *m.NumVotesAgainstKicking + } + return 0 +} + +func (m *EndKickPetitionMessage) GetNumVotesInFavourOfKicking() uint32 { + if m != nil && m.NumVotesInFavourOfKicking != nil { + return *m.NumVotesInFavourOfKicking + } + return 0 +} + +func (m *EndKickPetitionMessage) GetResultPlayerKicked() uint32 { + if m != nil && m.ResultPlayerKicked != nil { + return *m.ResultPlayerKicked + } + return 0 +} + +func (m *EndKickPetitionMessage) GetPetitionEndReason() EndKickPetitionMessage_PetitionEndReason { + if m != nil && m.PetitionEndReason != nil { + return *m.PetitionEndReason + } + return EndKickPetitionMessage_petitionEndEnoughVotes +} + +type StatisticsMessage struct { + StatisticsData []*StatisticsMessage_StatisticsData `protobuf:"bytes,1,rep,name=statisticsData" json:"statisticsData,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *StatisticsMessage) Reset() { *m = StatisticsMessage{} } +func (m *StatisticsMessage) String() string { return proto.CompactTextString(m) } +func (*StatisticsMessage) ProtoMessage() {} + +func (m *StatisticsMessage) GetStatisticsData() []*StatisticsMessage_StatisticsData { + if m != nil { + return m.StatisticsData + } + return nil +} + +type StatisticsMessage_StatisticsData struct { + StatisticsType *StatisticsMessage_StatisticsData_StatisticsType `protobuf:"varint,1,req,name=statisticsType,enum=StatisticsMessage_StatisticsData_StatisticsType" json:"statisticsType,omitempty"` + StatisticsValue *uint32 `protobuf:"varint,2,req,name=statisticsValue" json:"statisticsValue,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *StatisticsMessage_StatisticsData) Reset() { *m = StatisticsMessage_StatisticsData{} } +func (m *StatisticsMessage_StatisticsData) String() string { return proto.CompactTextString(m) } +func (*StatisticsMessage_StatisticsData) ProtoMessage() {} + +func (m *StatisticsMessage_StatisticsData) GetStatisticsType() StatisticsMessage_StatisticsData_StatisticsType { + if m != nil && m.StatisticsType != nil { + return *m.StatisticsType + } + return StatisticsMessage_StatisticsData_statNumberOfPlayers +} + +func (m *StatisticsMessage_StatisticsData) GetStatisticsValue() uint32 { + if m != nil && m.StatisticsValue != nil { + return *m.StatisticsValue + } + return 0 +} + +type ChatRequestMessage struct { + TargetPlayerId *uint32 `protobuf:"varint,2,opt,name=targetPlayerId" json:"targetPlayerId,omitempty"` + ChatText *string `protobuf:"bytes,3,req,name=chatText" json:"chatText,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ChatRequestMessage) Reset() { *m = ChatRequestMessage{} } +func (m *ChatRequestMessage) String() string { return proto.CompactTextString(m) } +func (*ChatRequestMessage) ProtoMessage() {} + +func (m *ChatRequestMessage) GetTargetPlayerId() uint32 { + if m != nil && m.TargetPlayerId != nil { + return *m.TargetPlayerId + } + return 0 +} + +func (m *ChatRequestMessage) GetChatText() string { + if m != nil && m.ChatText != nil { + return *m.ChatText + } + return "" +} + +type ChatMessage struct { + PlayerId *uint32 `protobuf:"varint,1,opt,name=playerId" json:"playerId,omitempty"` + ChatType *ChatMessage_ChatType `protobuf:"varint,2,req,name=chatType,enum=ChatMessage_ChatType" json:"chatType,omitempty"` + ChatText *string `protobuf:"bytes,3,req,name=chatText" json:"chatText,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ChatMessage) Reset() { *m = ChatMessage{} } +func (m *ChatMessage) String() string { return proto.CompactTextString(m) } +func (*ChatMessage) ProtoMessage() {} + +func (m *ChatMessage) GetPlayerId() uint32 { + if m != nil && m.PlayerId != nil { + return *m.PlayerId + } + return 0 +} + +func (m *ChatMessage) GetChatType() ChatMessage_ChatType { + if m != nil && m.ChatType != nil { + return *m.ChatType + } + return ChatMessage_chatTypeStandard +} + +func (m *ChatMessage) GetChatText() string { + if m != nil && m.ChatText != nil { + return *m.ChatText + } + return "" +} + +type ChatRejectMessage struct { + ChatText *string `protobuf:"bytes,1,req,name=chatText" json:"chatText,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ChatRejectMessage) Reset() { *m = ChatRejectMessage{} } +func (m *ChatRejectMessage) String() string { return proto.CompactTextString(m) } +func (*ChatRejectMessage) ProtoMessage() {} + +func (m *ChatRejectMessage) GetChatText() string { + if m != nil && m.ChatText != nil { + return *m.ChatText + } + return "" +} + +type DialogMessage struct { + NotificationText *string `protobuf:"bytes,1,req,name=notificationText" json:"notificationText,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *DialogMessage) Reset() { *m = DialogMessage{} } +func (m *DialogMessage) String() string { return proto.CompactTextString(m) } +func (*DialogMessage) ProtoMessage() {} + +func (m *DialogMessage) GetNotificationText() string { + if m != nil && m.NotificationText != nil { + return *m.NotificationText + } + return "" +} + +type TimeoutWarningMessage struct { + TimeoutReason *TimeoutWarningMessage_TimeoutReason `protobuf:"varint,1,req,name=timeoutReason,enum=TimeoutWarningMessage_TimeoutReason" json:"timeoutReason,omitempty"` + RemainingSeconds *uint32 `protobuf:"varint,2,req,name=remainingSeconds" json:"remainingSeconds,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *TimeoutWarningMessage) Reset() { *m = TimeoutWarningMessage{} } +func (m *TimeoutWarningMessage) String() string { return proto.CompactTextString(m) } +func (*TimeoutWarningMessage) ProtoMessage() {} + +func (m *TimeoutWarningMessage) GetTimeoutReason() TimeoutWarningMessage_TimeoutReason { + if m != nil && m.TimeoutReason != nil { + return *m.TimeoutReason + } + return TimeoutWarningMessage_timeoutNoDataReceived +} + +func (m *TimeoutWarningMessage) GetRemainingSeconds() uint32 { + if m != nil && m.RemainingSeconds != nil { + return *m.RemainingSeconds + } + return 0 +} + +type ResetTimeoutMessage struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *ResetTimeoutMessage) Reset() { *m = ResetTimeoutMessage{} } +func (m *ResetTimeoutMessage) String() string { return proto.CompactTextString(m) } +func (*ResetTimeoutMessage) ProtoMessage() {} + +type ReportAvatarMessage struct { + ReportedPlayerId *uint32 `protobuf:"varint,1,req,name=reportedPlayerId" json:"reportedPlayerId,omitempty"` + ReportedAvatarHash []byte `protobuf:"bytes,2,req,name=reportedAvatarHash" json:"reportedAvatarHash,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ReportAvatarMessage) Reset() { *m = ReportAvatarMessage{} } +func (m *ReportAvatarMessage) String() string { return proto.CompactTextString(m) } +func (*ReportAvatarMessage) ProtoMessage() {} + +func (m *ReportAvatarMessage) GetReportedPlayerId() uint32 { + if m != nil && m.ReportedPlayerId != nil { + return *m.ReportedPlayerId + } + return 0 +} + +func (m *ReportAvatarMessage) GetReportedAvatarHash() []byte { + if m != nil { + return m.ReportedAvatarHash + } + return nil +} + +type ReportAvatarAckMessage struct { + ReportedPlayerId *uint32 `protobuf:"varint,1,req,name=reportedPlayerId" json:"reportedPlayerId,omitempty"` + ReportAvatarResult *ReportAvatarAckMessage_ReportAvatarResult `protobuf:"varint,2,req,name=reportAvatarResult,enum=ReportAvatarAckMessage_ReportAvatarResult" json:"reportAvatarResult,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ReportAvatarAckMessage) Reset() { *m = ReportAvatarAckMessage{} } +func (m *ReportAvatarAckMessage) String() string { return proto.CompactTextString(m) } +func (*ReportAvatarAckMessage) ProtoMessage() {} + +func (m *ReportAvatarAckMessage) GetReportedPlayerId() uint32 { + if m != nil && m.ReportedPlayerId != nil { + return *m.ReportedPlayerId + } + return 0 +} + +func (m *ReportAvatarAckMessage) GetReportAvatarResult() ReportAvatarAckMessage_ReportAvatarResult { + if m != nil && m.ReportAvatarResult != nil { + return *m.ReportAvatarResult + } + return ReportAvatarAckMessage_avatarReportAccepted +} + +type ReportGameMessage struct { + ReportedGameId *uint32 `protobuf:"varint,1,req,name=reportedGameId" json:"reportedGameId,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ReportGameMessage) Reset() { *m = ReportGameMessage{} } +func (m *ReportGameMessage) String() string { return proto.CompactTextString(m) } +func (*ReportGameMessage) ProtoMessage() {} + +func (m *ReportGameMessage) GetReportedGameId() uint32 { + if m != nil && m.ReportedGameId != nil { + return *m.ReportedGameId + } + return 0 +} + +type ReportGameAckMessage struct { + ReportedGameId *uint32 `protobuf:"varint,1,req,name=reportedGameId" json:"reportedGameId,omitempty"` + ReportGameResult *ReportGameAckMessage_ReportGameResult `protobuf:"varint,2,req,name=reportGameResult,enum=ReportGameAckMessage_ReportGameResult" json:"reportGameResult,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ReportGameAckMessage) Reset() { *m = ReportGameAckMessage{} } +func (m *ReportGameAckMessage) String() string { return proto.CompactTextString(m) } +func (*ReportGameAckMessage) ProtoMessage() {} + +func (m *ReportGameAckMessage) GetReportedGameId() uint32 { + if m != nil && m.ReportedGameId != nil { + return *m.ReportedGameId + } + return 0 +} + +func (m *ReportGameAckMessage) GetReportGameResult() ReportGameAckMessage_ReportGameResult { + if m != nil && m.ReportGameResult != nil { + return *m.ReportGameResult + } + return ReportGameAckMessage_gameReportAccepted +} + +type ErrorMessage struct { + ErrorReason *ErrorMessage_ErrorReason `protobuf:"varint,1,req,name=errorReason,enum=ErrorMessage_ErrorReason" json:"errorReason,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ErrorMessage) Reset() { *m = ErrorMessage{} } +func (m *ErrorMessage) String() string { return proto.CompactTextString(m) } +func (*ErrorMessage) ProtoMessage() {} + +func (m *ErrorMessage) GetErrorReason() ErrorMessage_ErrorReason { + if m != nil && m.ErrorReason != nil { + return *m.ErrorReason + } + return ErrorMessage_reserved +} + +type AdminRemoveGameMessage struct { + RemoveGameId *uint32 `protobuf:"varint,1,req,name=removeGameId" json:"removeGameId,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AdminRemoveGameMessage) Reset() { *m = AdminRemoveGameMessage{} } +func (m *AdminRemoveGameMessage) String() string { return proto.CompactTextString(m) } +func (*AdminRemoveGameMessage) ProtoMessage() {} + +func (m *AdminRemoveGameMessage) GetRemoveGameId() uint32 { + if m != nil && m.RemoveGameId != nil { + return *m.RemoveGameId + } + return 0 +} + +type AdminRemoveGameAckMessage struct { + RemoveGameId *uint32 `protobuf:"varint,1,req,name=removeGameId" json:"removeGameId,omitempty"` + RemoveGameResult *AdminRemoveGameAckMessage_AdminRemoveGameResult `protobuf:"varint,2,req,name=removeGameResult,enum=AdminRemoveGameAckMessage_AdminRemoveGameResult" json:"removeGameResult,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AdminRemoveGameAckMessage) Reset() { *m = AdminRemoveGameAckMessage{} } +func (m *AdminRemoveGameAckMessage) String() string { return proto.CompactTextString(m) } +func (*AdminRemoveGameAckMessage) ProtoMessage() {} + +func (m *AdminRemoveGameAckMessage) GetRemoveGameId() uint32 { + if m != nil && m.RemoveGameId != nil { + return *m.RemoveGameId + } + return 0 +} + +func (m *AdminRemoveGameAckMessage) GetRemoveGameResult() AdminRemoveGameAckMessage_AdminRemoveGameResult { + if m != nil && m.RemoveGameResult != nil { + return *m.RemoveGameResult + } + return AdminRemoveGameAckMessage_gameRemoveAccepted +} + +type AdminBanPlayerMessage struct { + BanPlayerId *uint32 `protobuf:"varint,1,req,name=banPlayerId" json:"banPlayerId,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AdminBanPlayerMessage) Reset() { *m = AdminBanPlayerMessage{} } +func (m *AdminBanPlayerMessage) String() string { return proto.CompactTextString(m) } +func (*AdminBanPlayerMessage) ProtoMessage() {} + +func (m *AdminBanPlayerMessage) GetBanPlayerId() uint32 { + if m != nil && m.BanPlayerId != nil { + return *m.BanPlayerId + } + return 0 +} + +type AdminBanPlayerAckMessage struct { + BanPlayerId *uint32 `protobuf:"varint,1,req,name=banPlayerId" json:"banPlayerId,omitempty"` + BanPlayerResult *AdminBanPlayerAckMessage_AdminBanPlayerResult `protobuf:"varint,2,req,name=banPlayerResult,enum=AdminBanPlayerAckMessage_AdminBanPlayerResult" json:"banPlayerResult,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AdminBanPlayerAckMessage) Reset() { *m = AdminBanPlayerAckMessage{} } +func (m *AdminBanPlayerAckMessage) String() string { return proto.CompactTextString(m) } +func (*AdminBanPlayerAckMessage) ProtoMessage() {} + +func (m *AdminBanPlayerAckMessage) GetBanPlayerId() uint32 { + if m != nil && m.BanPlayerId != nil { + return *m.BanPlayerId + } + return 0 +} + +func (m *AdminBanPlayerAckMessage) GetBanPlayerResult() AdminBanPlayerAckMessage_AdminBanPlayerResult { + if m != nil && m.BanPlayerResult != nil { + return *m.BanPlayerResult + } + return AdminBanPlayerAckMessage_banPlayerAccepted +} + +type AuthMessage struct { + MessageType *AuthMessage_AuthMessageType `protobuf:"varint,1,req,name=messageType,enum=AuthMessage_AuthMessageType" json:"messageType,omitempty"` + AuthClientRequestMessage *AuthClientRequestMessage `protobuf:"bytes,2,opt,name=authClientRequestMessage" json:"authClientRequestMessage,omitempty"` + AuthServerChallengeMessage *AuthServerChallengeMessage `protobuf:"bytes,3,opt,name=authServerChallengeMessage" json:"authServerChallengeMessage,omitempty"` + AuthClientResponseMessage *AuthClientResponseMessage `protobuf:"bytes,4,opt,name=authClientResponseMessage" json:"authClientResponseMessage,omitempty"` + AuthServerVerificationMessage *AuthServerVerificationMessage `protobuf:"bytes,5,opt,name=authServerVerificationMessage" json:"authServerVerificationMessage,omitempty"` + ErrorMessage *ErrorMessage `protobuf:"bytes,1025,opt,name=errorMessage" json:"errorMessage,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AuthMessage) Reset() { *m = AuthMessage{} } +func (m *AuthMessage) String() string { return proto.CompactTextString(m) } +func (*AuthMessage) ProtoMessage() {} + +func (m *AuthMessage) GetMessageType() AuthMessage_AuthMessageType { + if m != nil && m.MessageType != nil { + return *m.MessageType + } + return AuthMessage_Type_AuthClientRequestMessage +} + +func (m *AuthMessage) GetAuthClientRequestMessage() *AuthClientRequestMessage { + if m != nil { + return m.AuthClientRequestMessage + } + return nil +} + +func (m *AuthMessage) GetAuthServerChallengeMessage() *AuthServerChallengeMessage { + if m != nil { + return m.AuthServerChallengeMessage + } + return nil +} + +func (m *AuthMessage) GetAuthClientResponseMessage() *AuthClientResponseMessage { + if m != nil { + return m.AuthClientResponseMessage + } + return nil +} + +func (m *AuthMessage) GetAuthServerVerificationMessage() *AuthServerVerificationMessage { + if m != nil { + return m.AuthServerVerificationMessage + } + return nil +} + +func (m *AuthMessage) GetErrorMessage() *ErrorMessage { + if m != nil { + return m.ErrorMessage + } + return nil +} + +type LobbyMessage struct { + MessageType *LobbyMessage_LobbyMessageType `protobuf:"varint,1,req,name=messageType,enum=LobbyMessage_LobbyMessageType" json:"messageType,omitempty"` + InitMessage *InitMessage `protobuf:"bytes,2,opt,name=initMessage" json:"initMessage,omitempty"` + InitAckMessage *InitAckMessage `protobuf:"bytes,3,opt,name=initAckMessage" json:"initAckMessage,omitempty"` + AvatarRequestMessage *AvatarRequestMessage `protobuf:"bytes,4,opt,name=avatarRequestMessage" json:"avatarRequestMessage,omitempty"` + AvatarHeaderMessage *AvatarHeaderMessage `protobuf:"bytes,5,opt,name=avatarHeaderMessage" json:"avatarHeaderMessage,omitempty"` + AvatarDataMessage *AvatarDataMessage `protobuf:"bytes,6,opt,name=avatarDataMessage" json:"avatarDataMessage,omitempty"` + AvatarEndMessage *AvatarEndMessage `protobuf:"bytes,7,opt,name=avatarEndMessage" json:"avatarEndMessage,omitempty"` + UnknownAvatarMessage *UnknownAvatarMessage `protobuf:"bytes,8,opt,name=unknownAvatarMessage" json:"unknownAvatarMessage,omitempty"` + PlayerListMessage *PlayerListMessage `protobuf:"bytes,9,opt,name=playerListMessage" json:"playerListMessage,omitempty"` + GameListNewMessage *GameListNewMessage `protobuf:"bytes,10,opt,name=gameListNewMessage" json:"gameListNewMessage,omitempty"` + GameListUpdateMessage *GameListUpdateMessage `protobuf:"bytes,11,opt,name=gameListUpdateMessage" json:"gameListUpdateMessage,omitempty"` + GameListPlayerJoinedMessage *GameListPlayerJoinedMessage `protobuf:"bytes,12,opt,name=gameListPlayerJoinedMessage" json:"gameListPlayerJoinedMessage,omitempty"` + GameListPlayerLeftMessage *GameListPlayerLeftMessage `protobuf:"bytes,13,opt,name=gameListPlayerLeftMessage" json:"gameListPlayerLeftMessage,omitempty"` + GameListSpectatorJoinedMessage *GameListSpectatorJoinedMessage `protobuf:"bytes,14,opt,name=gameListSpectatorJoinedMessage" json:"gameListSpectatorJoinedMessage,omitempty"` + GameListSpectatorLeftMessage *GameListSpectatorLeftMessage `protobuf:"bytes,15,opt,name=gameListSpectatorLeftMessage" json:"gameListSpectatorLeftMessage,omitempty"` + GameListAdminChangedMessage *GameListAdminChangedMessage `protobuf:"bytes,16,opt,name=gameListAdminChangedMessage" json:"gameListAdminChangedMessage,omitempty"` + PlayerInfoRequestMessage *PlayerInfoRequestMessage `protobuf:"bytes,17,opt,name=playerInfoRequestMessage" json:"playerInfoRequestMessage,omitempty"` + PlayerInfoReplyMessage *PlayerInfoReplyMessage `protobuf:"bytes,18,opt,name=playerInfoReplyMessage" json:"playerInfoReplyMessage,omitempty"` + SubscriptionRequestMessage *SubscriptionRequestMessage `protobuf:"bytes,19,opt,name=subscriptionRequestMessage" json:"subscriptionRequestMessage,omitempty"` + SubscriptionReplyMessage *SubscriptionReplyMessage `protobuf:"bytes,20,opt,name=subscriptionReplyMessage" json:"subscriptionReplyMessage,omitempty"` + CreateGameMessage *CreateGameMessage `protobuf:"bytes,21,opt,name=createGameMessage" json:"createGameMessage,omitempty"` + CreateGameFailedMessage *CreateGameFailedMessage `protobuf:"bytes,22,opt,name=createGameFailedMessage" json:"createGameFailedMessage,omitempty"` + InvitePlayerToGameMessage *InvitePlayerToGameMessage `protobuf:"bytes,23,opt,name=invitePlayerToGameMessage" json:"invitePlayerToGameMessage,omitempty"` + InviteNotifyMessage *InviteNotifyMessage `protobuf:"bytes,24,opt,name=inviteNotifyMessage" json:"inviteNotifyMessage,omitempty"` + RejectGameInvitationMessage *RejectGameInvitationMessage `protobuf:"bytes,25,opt,name=rejectGameInvitationMessage" json:"rejectGameInvitationMessage,omitempty"` + RejectInvNotifyMessage *RejectInvNotifyMessage `protobuf:"bytes,26,opt,name=rejectInvNotifyMessage" json:"rejectInvNotifyMessage,omitempty"` + StatisticsMessage *StatisticsMessage `protobuf:"bytes,27,opt,name=statisticsMessage" json:"statisticsMessage,omitempty"` + ChatRequestMessage *ChatRequestMessage `protobuf:"bytes,28,opt,name=chatRequestMessage" json:"chatRequestMessage,omitempty"` + ChatMessage *ChatMessage `protobuf:"bytes,29,opt,name=chatMessage" json:"chatMessage,omitempty"` + ChatRejectMessage *ChatRejectMessage `protobuf:"bytes,30,opt,name=chatRejectMessage" json:"chatRejectMessage,omitempty"` + DialogMessage *DialogMessage `protobuf:"bytes,31,opt,name=dialogMessage" json:"dialogMessage,omitempty"` + TimeoutWarningMessage *TimeoutWarningMessage `protobuf:"bytes,32,opt,name=timeoutWarningMessage" json:"timeoutWarningMessage,omitempty"` + ResetTimeoutMessage *ResetTimeoutMessage `protobuf:"bytes,33,opt,name=resetTimeoutMessage" json:"resetTimeoutMessage,omitempty"` + ReportAvatarMessage *ReportAvatarMessage `protobuf:"bytes,34,opt,name=reportAvatarMessage" json:"reportAvatarMessage,omitempty"` + ReportAvatarAckMessage *ReportAvatarAckMessage `protobuf:"bytes,35,opt,name=reportAvatarAckMessage" json:"reportAvatarAckMessage,omitempty"` + ReportGameMessage *ReportGameMessage `protobuf:"bytes,36,opt,name=reportGameMessage" json:"reportGameMessage,omitempty"` + ReportGameAckMessage *ReportGameAckMessage `protobuf:"bytes,37,opt,name=reportGameAckMessage" json:"reportGameAckMessage,omitempty"` + AdminRemoveGameMessage *AdminRemoveGameMessage `protobuf:"bytes,38,opt,name=adminRemoveGameMessage" json:"adminRemoveGameMessage,omitempty"` + AdminRemoveGameAckMessage *AdminRemoveGameAckMessage `protobuf:"bytes,39,opt,name=adminRemoveGameAckMessage" json:"adminRemoveGameAckMessage,omitempty"` + AdminBanPlayerMessage *AdminBanPlayerMessage `protobuf:"bytes,40,opt,name=adminBanPlayerMessage" json:"adminBanPlayerMessage,omitempty"` + AdminBanPlayerAckMessage *AdminBanPlayerAckMessage `protobuf:"bytes,41,opt,name=adminBanPlayerAckMessage" json:"adminBanPlayerAckMessage,omitempty"` + ErrorMessage *ErrorMessage `protobuf:"bytes,1025,opt,name=errorMessage" json:"errorMessage,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *LobbyMessage) Reset() { *m = LobbyMessage{} } +func (m *LobbyMessage) String() string { return proto.CompactTextString(m) } +func (*LobbyMessage) ProtoMessage() {} + +func (m *LobbyMessage) GetMessageType() LobbyMessage_LobbyMessageType { + if m != nil && m.MessageType != nil { + return *m.MessageType + } + return LobbyMessage_Type_InitMessage +} + +func (m *LobbyMessage) GetInitMessage() *InitMessage { + if m != nil { + return m.InitMessage + } + return nil +} + +func (m *LobbyMessage) GetInitAckMessage() *InitAckMessage { + if m != nil { + return m.InitAckMessage + } + return nil +} + +func (m *LobbyMessage) GetAvatarRequestMessage() *AvatarRequestMessage { + if m != nil { + return m.AvatarRequestMessage + } + return nil +} + +func (m *LobbyMessage) GetAvatarHeaderMessage() *AvatarHeaderMessage { + if m != nil { + return m.AvatarHeaderMessage + } + return nil +} + +func (m *LobbyMessage) GetAvatarDataMessage() *AvatarDataMessage { + if m != nil { + return m.AvatarDataMessage + } + return nil +} + +func (m *LobbyMessage) GetAvatarEndMessage() *AvatarEndMessage { + if m != nil { + return m.AvatarEndMessage + } + return nil +} + +func (m *LobbyMessage) GetUnknownAvatarMessage() *UnknownAvatarMessage { + if m != nil { + return m.UnknownAvatarMessage + } + return nil +} + +func (m *LobbyMessage) GetPlayerListMessage() *PlayerListMessage { + if m != nil { + return m.PlayerListMessage + } + return nil +} + +func (m *LobbyMessage) GetGameListNewMessage() *GameListNewMessage { + if m != nil { + return m.GameListNewMessage + } + return nil +} + +func (m *LobbyMessage) GetGameListUpdateMessage() *GameListUpdateMessage { + if m != nil { + return m.GameListUpdateMessage + } + return nil +} + +func (m *LobbyMessage) GetGameListPlayerJoinedMessage() *GameListPlayerJoinedMessage { + if m != nil { + return m.GameListPlayerJoinedMessage + } + return nil +} + +func (m *LobbyMessage) GetGameListPlayerLeftMessage() *GameListPlayerLeftMessage { + if m != nil { + return m.GameListPlayerLeftMessage + } + return nil +} + +func (m *LobbyMessage) GetGameListSpectatorJoinedMessage() *GameListSpectatorJoinedMessage { + if m != nil { + return m.GameListSpectatorJoinedMessage + } + return nil +} + +func (m *LobbyMessage) GetGameListSpectatorLeftMessage() *GameListSpectatorLeftMessage { + if m != nil { + return m.GameListSpectatorLeftMessage + } + return nil +} + +func (m *LobbyMessage) GetGameListAdminChangedMessage() *GameListAdminChangedMessage { + if m != nil { + return m.GameListAdminChangedMessage + } + return nil +} + +func (m *LobbyMessage) GetPlayerInfoRequestMessage() *PlayerInfoRequestMessage { + if m != nil { + return m.PlayerInfoRequestMessage + } + return nil +} + +func (m *LobbyMessage) GetPlayerInfoReplyMessage() *PlayerInfoReplyMessage { + if m != nil { + return m.PlayerInfoReplyMessage + } + return nil +} + +func (m *LobbyMessage) GetSubscriptionRequestMessage() *SubscriptionRequestMessage { + if m != nil { + return m.SubscriptionRequestMessage + } + return nil +} + +func (m *LobbyMessage) GetSubscriptionReplyMessage() *SubscriptionReplyMessage { + if m != nil { + return m.SubscriptionReplyMessage + } + return nil +} + +func (m *LobbyMessage) GetCreateGameMessage() *CreateGameMessage { + if m != nil { + return m.CreateGameMessage + } + return nil +} + +func (m *LobbyMessage) GetCreateGameFailedMessage() *CreateGameFailedMessage { + if m != nil { + return m.CreateGameFailedMessage + } + return nil +} + +func (m *LobbyMessage) GetInvitePlayerToGameMessage() *InvitePlayerToGameMessage { + if m != nil { + return m.InvitePlayerToGameMessage + } + return nil +} + +func (m *LobbyMessage) GetInviteNotifyMessage() *InviteNotifyMessage { + if m != nil { + return m.InviteNotifyMessage + } + return nil +} + +func (m *LobbyMessage) GetRejectGameInvitationMessage() *RejectGameInvitationMessage { + if m != nil { + return m.RejectGameInvitationMessage + } + return nil +} + +func (m *LobbyMessage) GetRejectInvNotifyMessage() *RejectInvNotifyMessage { + if m != nil { + return m.RejectInvNotifyMessage + } + return nil +} + +func (m *LobbyMessage) GetStatisticsMessage() *StatisticsMessage { + if m != nil { + return m.StatisticsMessage + } + return nil +} + +func (m *LobbyMessage) GetChatRequestMessage() *ChatRequestMessage { + if m != nil { + return m.ChatRequestMessage + } + return nil +} + +func (m *LobbyMessage) GetChatMessage() *ChatMessage { + if m != nil { + return m.ChatMessage + } + return nil +} + +func (m *LobbyMessage) GetChatRejectMessage() *ChatRejectMessage { + if m != nil { + return m.ChatRejectMessage + } + return nil +} + +func (m *LobbyMessage) GetDialogMessage() *DialogMessage { + if m != nil { + return m.DialogMessage + } + return nil +} + +func (m *LobbyMessage) GetTimeoutWarningMessage() *TimeoutWarningMessage { + if m != nil { + return m.TimeoutWarningMessage + } + return nil +} + +func (m *LobbyMessage) GetResetTimeoutMessage() *ResetTimeoutMessage { + if m != nil { + return m.ResetTimeoutMessage + } + return nil +} + +func (m *LobbyMessage) GetReportAvatarMessage() *ReportAvatarMessage { + if m != nil { + return m.ReportAvatarMessage + } + return nil +} + +func (m *LobbyMessage) GetReportAvatarAckMessage() *ReportAvatarAckMessage { + if m != nil { + return m.ReportAvatarAckMessage + } + return nil +} + +func (m *LobbyMessage) GetReportGameMessage() *ReportGameMessage { + if m != nil { + return m.ReportGameMessage + } + return nil +} + +func (m *LobbyMessage) GetReportGameAckMessage() *ReportGameAckMessage { + if m != nil { + return m.ReportGameAckMessage + } + return nil +} + +func (m *LobbyMessage) GetAdminRemoveGameMessage() *AdminRemoveGameMessage { + if m != nil { + return m.AdminRemoveGameMessage + } + return nil +} + +func (m *LobbyMessage) GetAdminRemoveGameAckMessage() *AdminRemoveGameAckMessage { + if m != nil { + return m.AdminRemoveGameAckMessage + } + return nil +} + +func (m *LobbyMessage) GetAdminBanPlayerMessage() *AdminBanPlayerMessage { + if m != nil { + return m.AdminBanPlayerMessage + } + return nil +} + +func (m *LobbyMessage) GetAdminBanPlayerAckMessage() *AdminBanPlayerAckMessage { + if m != nil { + return m.AdminBanPlayerAckMessage + } + return nil +} + +func (m *LobbyMessage) GetErrorMessage() *ErrorMessage { + if m != nil { + return m.ErrorMessage + } + return nil +} + +type GameManagementMessage struct { + MessageType *GameManagementMessage_GameManagementMessageType `protobuf:"varint,1,req,name=messageType,enum=GameManagementMessage_GameManagementMessageType" json:"messageType,omitempty"` + JoinGameMessage *JoinGameMessage `protobuf:"bytes,2,opt,name=joinGameMessage" json:"joinGameMessage,omitempty"` + RejoinGameMessage *RejoinGameMessage `protobuf:"bytes,3,opt,name=rejoinGameMessage" json:"rejoinGameMessage,omitempty"` + JoinGameAckMessage *JoinGameAckMessage `protobuf:"bytes,4,opt,name=joinGameAckMessage" json:"joinGameAckMessage,omitempty"` + JoinGameFailedMessage *JoinGameFailedMessage `protobuf:"bytes,5,opt,name=joinGameFailedMessage" json:"joinGameFailedMessage,omitempty"` + GamePlayerJoinedMessage *GamePlayerJoinedMessage `protobuf:"bytes,6,opt,name=gamePlayerJoinedMessage" json:"gamePlayerJoinedMessage,omitempty"` + GamePlayerLeftMessage *GamePlayerLeftMessage `protobuf:"bytes,7,opt,name=gamePlayerLeftMessage" json:"gamePlayerLeftMessage,omitempty"` + GameSpectatorJoinedMessage *GameSpectatorJoinedMessage `protobuf:"bytes,8,opt,name=gameSpectatorJoinedMessage" json:"gameSpectatorJoinedMessage,omitempty"` + GameSpectatorLeftMessage *GameSpectatorLeftMessage `protobuf:"bytes,9,opt,name=gameSpectatorLeftMessage" json:"gameSpectatorLeftMessage,omitempty"` + GameAdminChangedMessage *GameAdminChangedMessage `protobuf:"bytes,10,opt,name=gameAdminChangedMessage" json:"gameAdminChangedMessage,omitempty"` + RemovedFromGameMessage *RemovedFromGameMessage `protobuf:"bytes,11,opt,name=removedFromGameMessage" json:"removedFromGameMessage,omitempty"` + KickPlayerRequestMessage *KickPlayerRequestMessage `protobuf:"bytes,12,opt,name=kickPlayerRequestMessage" json:"kickPlayerRequestMessage,omitempty"` + LeaveGameRequestMessage *LeaveGameRequestMessage `protobuf:"bytes,13,opt,name=leaveGameRequestMessage" json:"leaveGameRequestMessage,omitempty"` + StartEventMessage *StartEventMessage `protobuf:"bytes,14,opt,name=startEventMessage" json:"startEventMessage,omitempty"` + StartEventAckMessage *StartEventAckMessage `protobuf:"bytes,15,opt,name=startEventAckMessage" json:"startEventAckMessage,omitempty"` + GameStartInitialMessage *GameStartInitialMessage `protobuf:"bytes,16,opt,name=gameStartInitialMessage" json:"gameStartInitialMessage,omitempty"` + GameStartRejoinMessage *GameStartRejoinMessage `protobuf:"bytes,17,opt,name=gameStartRejoinMessage" json:"gameStartRejoinMessage,omitempty"` + EndOfGameMessage *EndOfGameMessage `protobuf:"bytes,18,opt,name=endOfGameMessage" json:"endOfGameMessage,omitempty"` + PlayerIdChangedMessage *PlayerIdChangedMessage `protobuf:"bytes,19,opt,name=playerIdChangedMessage" json:"playerIdChangedMessage,omitempty"` + AskKickPlayerMessage *AskKickPlayerMessage `protobuf:"bytes,20,opt,name=askKickPlayerMessage" json:"askKickPlayerMessage,omitempty"` + AskKickDeniedMessage *AskKickDeniedMessage `protobuf:"bytes,21,opt,name=askKickDeniedMessage" json:"askKickDeniedMessage,omitempty"` + StartKickPetitionMessage *StartKickPetitionMessage `protobuf:"bytes,22,opt,name=startKickPetitionMessage" json:"startKickPetitionMessage,omitempty"` + VoteKickRequestMessage *VoteKickRequestMessage `protobuf:"bytes,23,opt,name=voteKickRequestMessage" json:"voteKickRequestMessage,omitempty"` + VoteKickReplyMessage *VoteKickReplyMessage `protobuf:"bytes,24,opt,name=voteKickReplyMessage" json:"voteKickReplyMessage,omitempty"` + KickPetitionUpdateMessage *KickPetitionUpdateMessage `protobuf:"bytes,25,opt,name=kickPetitionUpdateMessage" json:"kickPetitionUpdateMessage,omitempty"` + EndKickPetitionMessage *EndKickPetitionMessage `protobuf:"bytes,26,opt,name=endKickPetitionMessage" json:"endKickPetitionMessage,omitempty"` + ChatRequestMessage *ChatRequestMessage `protobuf:"bytes,27,opt,name=chatRequestMessage" json:"chatRequestMessage,omitempty"` + ChatMessage *ChatMessage `protobuf:"bytes,28,opt,name=chatMessage" json:"chatMessage,omitempty"` + ChatRejectMessage *ChatRejectMessage `protobuf:"bytes,29,opt,name=chatRejectMessage" json:"chatRejectMessage,omitempty"` + ErrorMessage *ErrorMessage `protobuf:"bytes,1025,opt,name=errorMessage" json:"errorMessage,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GameManagementMessage) Reset() { *m = GameManagementMessage{} } +func (m *GameManagementMessage) String() string { return proto.CompactTextString(m) } +func (*GameManagementMessage) ProtoMessage() {} + +func (m *GameManagementMessage) GetMessageType() GameManagementMessage_GameManagementMessageType { + if m != nil && m.MessageType != nil { + return *m.MessageType + } + return GameManagementMessage_Type_JoinGameMessage +} + +func (m *GameManagementMessage) GetJoinGameMessage() *JoinGameMessage { + if m != nil { + return m.JoinGameMessage + } + return nil +} + +func (m *GameManagementMessage) GetRejoinGameMessage() *RejoinGameMessage { + if m != nil { + return m.RejoinGameMessage + } + return nil +} + +func (m *GameManagementMessage) GetJoinGameAckMessage() *JoinGameAckMessage { + if m != nil { + return m.JoinGameAckMessage + } + return nil +} + +func (m *GameManagementMessage) GetJoinGameFailedMessage() *JoinGameFailedMessage { + if m != nil { + return m.JoinGameFailedMessage + } + return nil +} + +func (m *GameManagementMessage) GetGamePlayerJoinedMessage() *GamePlayerJoinedMessage { + if m != nil { + return m.GamePlayerJoinedMessage + } + return nil +} + +func (m *GameManagementMessage) GetGamePlayerLeftMessage() *GamePlayerLeftMessage { + if m != nil { + return m.GamePlayerLeftMessage + } + return nil +} + +func (m *GameManagementMessage) GetGameSpectatorJoinedMessage() *GameSpectatorJoinedMessage { + if m != nil { + return m.GameSpectatorJoinedMessage + } + return nil +} + +func (m *GameManagementMessage) GetGameSpectatorLeftMessage() *GameSpectatorLeftMessage { + if m != nil { + return m.GameSpectatorLeftMessage + } + return nil +} + +func (m *GameManagementMessage) GetGameAdminChangedMessage() *GameAdminChangedMessage { + if m != nil { + return m.GameAdminChangedMessage + } + return nil +} + +func (m *GameManagementMessage) GetRemovedFromGameMessage() *RemovedFromGameMessage { + if m != nil { + return m.RemovedFromGameMessage + } + return nil +} + +func (m *GameManagementMessage) GetKickPlayerRequestMessage() *KickPlayerRequestMessage { + if m != nil { + return m.KickPlayerRequestMessage + } + return nil +} + +func (m *GameManagementMessage) GetLeaveGameRequestMessage() *LeaveGameRequestMessage { + if m != nil { + return m.LeaveGameRequestMessage + } + return nil +} + +func (m *GameManagementMessage) GetStartEventMessage() *StartEventMessage { + if m != nil { + return m.StartEventMessage + } + return nil +} + +func (m *GameManagementMessage) GetStartEventAckMessage() *StartEventAckMessage { + if m != nil { + return m.StartEventAckMessage + } + return nil +} + +func (m *GameManagementMessage) GetGameStartInitialMessage() *GameStartInitialMessage { + if m != nil { + return m.GameStartInitialMessage + } + return nil +} + +func (m *GameManagementMessage) GetGameStartRejoinMessage() *GameStartRejoinMessage { + if m != nil { + return m.GameStartRejoinMessage + } + return nil +} + +func (m *GameManagementMessage) GetEndOfGameMessage() *EndOfGameMessage { + if m != nil { + return m.EndOfGameMessage + } + return nil +} + +func (m *GameManagementMessage) GetPlayerIdChangedMessage() *PlayerIdChangedMessage { + if m != nil { + return m.PlayerIdChangedMessage + } + return nil +} + +func (m *GameManagementMessage) GetAskKickPlayerMessage() *AskKickPlayerMessage { + if m != nil { + return m.AskKickPlayerMessage + } + return nil +} + +func (m *GameManagementMessage) GetAskKickDeniedMessage() *AskKickDeniedMessage { + if m != nil { + return m.AskKickDeniedMessage + } + return nil +} + +func (m *GameManagementMessage) GetStartKickPetitionMessage() *StartKickPetitionMessage { + if m != nil { + return m.StartKickPetitionMessage + } + return nil +} + +func (m *GameManagementMessage) GetVoteKickRequestMessage() *VoteKickRequestMessage { + if m != nil { + return m.VoteKickRequestMessage + } + return nil +} + +func (m *GameManagementMessage) GetVoteKickReplyMessage() *VoteKickReplyMessage { + if m != nil { + return m.VoteKickReplyMessage + } + return nil +} + +func (m *GameManagementMessage) GetKickPetitionUpdateMessage() *KickPetitionUpdateMessage { + if m != nil { + return m.KickPetitionUpdateMessage + } + return nil +} + +func (m *GameManagementMessage) GetEndKickPetitionMessage() *EndKickPetitionMessage { + if m != nil { + return m.EndKickPetitionMessage + } + return nil +} + +func (m *GameManagementMessage) GetChatRequestMessage() *ChatRequestMessage { + if m != nil { + return m.ChatRequestMessage + } + return nil +} + +func (m *GameManagementMessage) GetChatMessage() *ChatMessage { + if m != nil { + return m.ChatMessage + } + return nil +} + +func (m *GameManagementMessage) GetChatRejectMessage() *ChatRejectMessage { + if m != nil { + return m.ChatRejectMessage + } + return nil +} + +func (m *GameManagementMessage) GetErrorMessage() *ErrorMessage { + if m != nil { + return m.ErrorMessage + } + return nil +} + +type GameEngineMessage struct { + MessageType *GameEngineMessage_GameEngineMessageType `protobuf:"varint,1,req,name=messageType,enum=GameEngineMessage_GameEngineMessageType" json:"messageType,omitempty"` + HandStartMessage *HandStartMessage `protobuf:"bytes,2,opt,name=handStartMessage" json:"handStartMessage,omitempty"` + PlayersTurnMessage *PlayersTurnMessage `protobuf:"bytes,3,opt,name=playersTurnMessage" json:"playersTurnMessage,omitempty"` + MyActionRequestMessage *MyActionRequestMessage `protobuf:"bytes,4,opt,name=myActionRequestMessage" json:"myActionRequestMessage,omitempty"` + YourActionRejectedMessage *YourActionRejectedMessage `protobuf:"bytes,5,opt,name=yourActionRejectedMessage" json:"yourActionRejectedMessage,omitempty"` + PlayersActionDoneMessage *PlayersActionDoneMessage `protobuf:"bytes,6,opt,name=playersActionDoneMessage" json:"playersActionDoneMessage,omitempty"` + DealFlopCardsMessage *DealFlopCardsMessage `protobuf:"bytes,7,opt,name=dealFlopCardsMessage" json:"dealFlopCardsMessage,omitempty"` + DealTurnCardMessage *DealTurnCardMessage `protobuf:"bytes,8,opt,name=dealTurnCardMessage" json:"dealTurnCardMessage,omitempty"` + DealRiverCardMessage *DealRiverCardMessage `protobuf:"bytes,9,opt,name=dealRiverCardMessage" json:"dealRiverCardMessage,omitempty"` + AllInShowCardsMessage *AllInShowCardsMessage `protobuf:"bytes,10,opt,name=allInShowCardsMessage" json:"allInShowCardsMessage,omitempty"` + EndOfHandShowCardsMessage *EndOfHandShowCardsMessage `protobuf:"bytes,11,opt,name=endOfHandShowCardsMessage" json:"endOfHandShowCardsMessage,omitempty"` + EndOfHandHideCardsMessage *EndOfHandHideCardsMessage `protobuf:"bytes,12,opt,name=endOfHandHideCardsMessage" json:"endOfHandHideCardsMessage,omitempty"` + ShowMyCardsRequestMessage *ShowMyCardsRequestMessage `protobuf:"bytes,13,opt,name=showMyCardsRequestMessage" json:"showMyCardsRequestMessage,omitempty"` + AfterHandShowCardsMessage *AfterHandShowCardsMessage `protobuf:"bytes,14,opt,name=afterHandShowCardsMessage" json:"afterHandShowCardsMessage,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GameEngineMessage) Reset() { *m = GameEngineMessage{} } +func (m *GameEngineMessage) String() string { return proto.CompactTextString(m) } +func (*GameEngineMessage) ProtoMessage() {} + +func (m *GameEngineMessage) GetMessageType() GameEngineMessage_GameEngineMessageType { + if m != nil && m.MessageType != nil { + return *m.MessageType + } + return GameEngineMessage_Type_HandStartMessage +} + +func (m *GameEngineMessage) GetHandStartMessage() *HandStartMessage { + if m != nil { + return m.HandStartMessage + } + return nil +} + +func (m *GameEngineMessage) GetPlayersTurnMessage() *PlayersTurnMessage { + if m != nil { + return m.PlayersTurnMessage + } + return nil +} + +func (m *GameEngineMessage) GetMyActionRequestMessage() *MyActionRequestMessage { + if m != nil { + return m.MyActionRequestMessage + } + return nil +} + +func (m *GameEngineMessage) GetYourActionRejectedMessage() *YourActionRejectedMessage { + if m != nil { + return m.YourActionRejectedMessage + } + return nil +} + +func (m *GameEngineMessage) GetPlayersActionDoneMessage() *PlayersActionDoneMessage { + if m != nil { + return m.PlayersActionDoneMessage + } + return nil +} + +func (m *GameEngineMessage) GetDealFlopCardsMessage() *DealFlopCardsMessage { + if m != nil { + return m.DealFlopCardsMessage + } + return nil +} + +func (m *GameEngineMessage) GetDealTurnCardMessage() *DealTurnCardMessage { + if m != nil { + return m.DealTurnCardMessage + } + return nil +} + +func (m *GameEngineMessage) GetDealRiverCardMessage() *DealRiverCardMessage { + if m != nil { + return m.DealRiverCardMessage + } + return nil +} + +func (m *GameEngineMessage) GetAllInShowCardsMessage() *AllInShowCardsMessage { + if m != nil { + return m.AllInShowCardsMessage + } + return nil +} + +func (m *GameEngineMessage) GetEndOfHandShowCardsMessage() *EndOfHandShowCardsMessage { + if m != nil { + return m.EndOfHandShowCardsMessage + } + return nil +} + +func (m *GameEngineMessage) GetEndOfHandHideCardsMessage() *EndOfHandHideCardsMessage { + if m != nil { + return m.EndOfHandHideCardsMessage + } + return nil +} + +func (m *GameEngineMessage) GetShowMyCardsRequestMessage() *ShowMyCardsRequestMessage { + if m != nil { + return m.ShowMyCardsRequestMessage + } + return nil +} + +func (m *GameEngineMessage) GetAfterHandShowCardsMessage() *AfterHandShowCardsMessage { + if m != nil { + return m.AfterHandShowCardsMessage + } + return nil +} + +type GameMessage struct { + MessageType *GameMessage_GameMessageType `protobuf:"varint,1,req,name=messageType,enum=GameMessage_GameMessageType" json:"messageType,omitempty"` + GameId *uint32 `protobuf:"varint,2,req,name=gameId" json:"gameId,omitempty"` + GameManagementMessage *GameManagementMessage `protobuf:"bytes,3,opt,name=gameManagementMessage" json:"gameManagementMessage,omitempty"` + GameEngineMessage *GameEngineMessage `protobuf:"bytes,4,opt,name=gameEngineMessage" json:"gameEngineMessage,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GameMessage) Reset() { *m = GameMessage{} } +func (m *GameMessage) String() string { return proto.CompactTextString(m) } +func (*GameMessage) ProtoMessage() {} + +func (m *GameMessage) GetMessageType() GameMessage_GameMessageType { + if m != nil && m.MessageType != nil { + return *m.MessageType + } + return GameMessage_Type_GameManagementMessage +} + +func (m *GameMessage) GetGameId() uint32 { + if m != nil && m.GameId != nil { + return *m.GameId + } + return 0 +} + +func (m *GameMessage) GetGameManagementMessage() *GameManagementMessage { + if m != nil { + return m.GameManagementMessage + } + return nil +} + +func (m *GameMessage) GetGameEngineMessage() *GameEngineMessage { + if m != nil { + return m.GameEngineMessage + } + return nil +} + +// The main message type (with TCP, it is prefixed by 4 bytes length of the message). +type PokerTHMessage struct { + MessageType *PokerTHMessage_PokerTHMessageType `protobuf:"varint,1,req,name=messageType,enum=PokerTHMessage_PokerTHMessageType" json:"messageType,omitempty"` + AnnounceMessage *AnnounceMessage `protobuf:"bytes,2,opt,name=announceMessage" json:"announceMessage,omitempty"` + AuthMessage *AuthMessage `protobuf:"bytes,3,opt,name=authMessage" json:"authMessage,omitempty"` + LobbyMessage *LobbyMessage `protobuf:"bytes,4,opt,name=lobbyMessage" json:"lobbyMessage,omitempty"` + GameMessage *GameMessage `protobuf:"bytes,5,opt,name=gameMessage" json:"gameMessage,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *PokerTHMessage) Reset() { *m = PokerTHMessage{} } +func (m *PokerTHMessage) String() string { return proto.CompactTextString(m) } +func (*PokerTHMessage) ProtoMessage() {} + +func (m *PokerTHMessage) GetMessageType() PokerTHMessage_PokerTHMessageType { + if m != nil && m.MessageType != nil { + return *m.MessageType + } + return PokerTHMessage_Type_AnnounceMessage +} + +func (m *PokerTHMessage) GetAnnounceMessage() *AnnounceMessage { + if m != nil { + return m.AnnounceMessage + } + return nil +} + +func (m *PokerTHMessage) GetAuthMessage() *AuthMessage { + if m != nil { + return m.AuthMessage + } + return nil +} + +func (m *PokerTHMessage) GetLobbyMessage() *LobbyMessage { + if m != nil { + return m.LobbyMessage + } + return nil +} + +func (m *PokerTHMessage) GetGameMessage() *GameMessage { + if m != nil { + return m.GameMessage + } + return nil +} + +func init() { + proto.RegisterEnum("NetGameMode", NetGameMode_name, NetGameMode_value) + proto.RegisterEnum("NetGameState", NetGameState_name, NetGameState_value) + proto.RegisterEnum("NetPlayerAction", NetPlayerAction_name, NetPlayerAction_value) + proto.RegisterEnum("NetPlayerState", NetPlayerState_name, NetPlayerState_value) + proto.RegisterEnum("NetPlayerInfoRights", NetPlayerInfoRights_name, NetPlayerInfoRights_value) + proto.RegisterEnum("NetAvatarType", NetAvatarType_name, NetAvatarType_value) + proto.RegisterEnum("NetGameInfo_NetGameType", NetGameInfo_NetGameType_name, NetGameInfo_NetGameType_value) + proto.RegisterEnum("NetGameInfo_RaiseIntervalMode", NetGameInfo_RaiseIntervalMode_name, NetGameInfo_RaiseIntervalMode_value) + proto.RegisterEnum("NetGameInfo_EndRaiseMode", NetGameInfo_EndRaiseMode_name, NetGameInfo_EndRaiseMode_value) + proto.RegisterEnum("AnnounceMessage_ServerType", AnnounceMessage_ServerType_name, AnnounceMessage_ServerType_value) + proto.RegisterEnum("AuthClientRequestMessage_LoginType", AuthClientRequestMessage_LoginType_name, AuthClientRequestMessage_LoginType_value) + proto.RegisterEnum("PlayerListMessage_PlayerListNotification", PlayerListMessage_PlayerListNotification_name, PlayerListMessage_PlayerListNotification_value) + proto.RegisterEnum("SubscriptionRequestMessage_SubscriptionAction", SubscriptionRequestMessage_SubscriptionAction_name, SubscriptionRequestMessage_SubscriptionAction_value) + proto.RegisterEnum("CreateGameFailedMessage_CreateGameFailureReason", CreateGameFailedMessage_CreateGameFailureReason_name, CreateGameFailedMessage_CreateGameFailureReason_value) + proto.RegisterEnum("JoinGameFailedMessage_JoinGameFailureReason", JoinGameFailedMessage_JoinGameFailureReason_name, JoinGameFailedMessage_JoinGameFailureReason_value) + proto.RegisterEnum("GamePlayerLeftMessage_GamePlayerLeftReason", GamePlayerLeftMessage_GamePlayerLeftReason_name, GamePlayerLeftMessage_GamePlayerLeftReason_value) + proto.RegisterEnum("RemovedFromGameMessage_RemovedFromGameReason", RemovedFromGameMessage_RemovedFromGameReason_name, RemovedFromGameMessage_RemovedFromGameReason_value) + proto.RegisterEnum("RejectGameInvitationMessage_RejectGameInvReason", RejectGameInvitationMessage_RejectGameInvReason_name, RejectGameInvitationMessage_RejectGameInvReason_value) + proto.RegisterEnum("StartEventMessage_StartEventType", StartEventMessage_StartEventType_name, StartEventMessage_StartEventType_value) + proto.RegisterEnum("YourActionRejectedMessage_RejectionReason", YourActionRejectedMessage_RejectionReason_name, YourActionRejectedMessage_RejectionReason_value) + proto.RegisterEnum("AskKickDeniedMessage_KickDeniedReason", AskKickDeniedMessage_KickDeniedReason_name, AskKickDeniedMessage_KickDeniedReason_value) + proto.RegisterEnum("VoteKickReplyMessage_VoteKickReplyType", VoteKickReplyMessage_VoteKickReplyType_name, VoteKickReplyMessage_VoteKickReplyType_value) + proto.RegisterEnum("EndKickPetitionMessage_PetitionEndReason", EndKickPetitionMessage_PetitionEndReason_name, EndKickPetitionMessage_PetitionEndReason_value) + proto.RegisterEnum("StatisticsMessage_StatisticsData_StatisticsType", StatisticsMessage_StatisticsData_StatisticsType_name, StatisticsMessage_StatisticsData_StatisticsType_value) + proto.RegisterEnum("ChatMessage_ChatType", ChatMessage_ChatType_name, ChatMessage_ChatType_value) + proto.RegisterEnum("TimeoutWarningMessage_TimeoutReason", TimeoutWarningMessage_TimeoutReason_name, TimeoutWarningMessage_TimeoutReason_value) + proto.RegisterEnum("ReportAvatarAckMessage_ReportAvatarResult", ReportAvatarAckMessage_ReportAvatarResult_name, ReportAvatarAckMessage_ReportAvatarResult_value) + proto.RegisterEnum("ReportGameAckMessage_ReportGameResult", ReportGameAckMessage_ReportGameResult_name, ReportGameAckMessage_ReportGameResult_value) + proto.RegisterEnum("ErrorMessage_ErrorReason", ErrorMessage_ErrorReason_name, ErrorMessage_ErrorReason_value) + proto.RegisterEnum("AdminRemoveGameAckMessage_AdminRemoveGameResult", AdminRemoveGameAckMessage_AdminRemoveGameResult_name, AdminRemoveGameAckMessage_AdminRemoveGameResult_value) + proto.RegisterEnum("AdminBanPlayerAckMessage_AdminBanPlayerResult", AdminBanPlayerAckMessage_AdminBanPlayerResult_name, AdminBanPlayerAckMessage_AdminBanPlayerResult_value) + proto.RegisterEnum("AuthMessage_AuthMessageType", AuthMessage_AuthMessageType_name, AuthMessage_AuthMessageType_value) + proto.RegisterEnum("LobbyMessage_LobbyMessageType", LobbyMessage_LobbyMessageType_name, LobbyMessage_LobbyMessageType_value) + proto.RegisterEnum("GameManagementMessage_GameManagementMessageType", GameManagementMessage_GameManagementMessageType_name, GameManagementMessage_GameManagementMessageType_value) + proto.RegisterEnum("GameEngineMessage_GameEngineMessageType", GameEngineMessage_GameEngineMessageType_name, GameEngineMessage_GameEngineMessageType_value) + proto.RegisterEnum("GameMessage_GameMessageType", GameMessage_GameMessageType_name, GameMessage_GameMessageType_value) + proto.RegisterEnum("PokerTHMessage_PokerTHMessageType", PokerTHMessage_PokerTHMessageType_name, PokerTHMessage_PokerTHMessageType_value) +} +func (m *NetGameInfo) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + int(stringLen) + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[index:postIndex]) + m.GameName = &s + index = postIndex + case 2: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v NetGameInfo_NetGameType + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (NetGameInfo_NetGameType(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.NetGameType = &v + case 3: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.MaxNumPlayers = &v + case 4: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v NetGameInfo_RaiseIntervalMode + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (NetGameInfo_RaiseIntervalMode(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.RaiseIntervalMode = &v + case 5: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.RaiseEveryHands = &v + case 6: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.RaiseEveryMinutes = &v + case 7: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v NetGameInfo_EndRaiseMode + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (NetGameInfo_EndRaiseMode(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.EndRaiseMode = &v + case 8: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.EndRaiseSmallBlindValue = &v + case 9: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.ProposedGuiSpeed = &v + case 10: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.DelayBetweenHands = &v + case 11: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.PlayerActionTimeout = &v + case 12: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FirstSmallBlind = &v + case 13: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.StartMoney = &v + case 14: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var packedLen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for index < postIndex { + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.ManualBlinds = append(m.ManualBlinds, v) + } + case 15: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.AllowSpectators = &b + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *PlayerResult) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.PlayerId = &v + case 2: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.ResultCard1 = &v + case 3: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.ResultCard2 = &v + case 4: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var packedLen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for index < postIndex { + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.BestHandPosition = append(m.BestHandPosition, v) + } + case 5: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.MoneyWon = &v + case 6: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.PlayerMoney = &v + case 7: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.CardsValue = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *AnnounceMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ProtocolVersion == nil { + m.ProtocolVersion = &AnnounceMessage_Version{} + } + if err := m.ProtocolVersion.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 2: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.LatestGameVersion == nil { + m.LatestGameVersion = &AnnounceMessage_Version{} + } + if err := m.LatestGameVersion.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 3: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.LatestBetaRevision = &v + case 4: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v AnnounceMessage_ServerType + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (AnnounceMessage_ServerType(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.ServerType = &v + case 5: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.NumPlayersOnServer = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *AnnounceMessage_Version) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.MajorVersion = &v + case 2: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.MinorVersion = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *AuthClientRequestMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RequestedVersion == nil { + m.RequestedVersion = &AnnounceMessage_Version{} + } + if err := m.RequestedVersion.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 2: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.BuildId = &v + case 3: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v AuthClientRequestMessage_LoginType + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (AuthClientRequestMessage_LoginType(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Login = &v + case 4: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + int(stringLen) + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[index:postIndex]) + m.AuthServerPassword = &s + index = postIndex + case 5: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + int(stringLen) + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[index:postIndex]) + m.NickName = &s + index = postIndex + case 6: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ClientUserData = append(m.ClientUserData, data[index:postIndex]...) + index = postIndex + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *AuthServerChallengeMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ServerChallenge = append(m.ServerChallenge, data[index:postIndex]...) + index = postIndex + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *AuthClientResponseMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ClientResponse = append(m.ClientResponse, data[index:postIndex]...) + index = postIndex + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *AuthServerVerificationMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.YourSessionId = append(m.YourSessionId, data[index:postIndex]...) + index = postIndex + case 2: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.YourPlayerId = &v + case 3: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ServerVerification = append(m.ServerVerification, data[index:postIndex]...) + index = postIndex + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *InitMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.MyLastSessionId = append(m.MyLastSessionId, data[index:postIndex]...) + index = postIndex + case 2: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.AvatarHash = append(m.AvatarHash, data[index:postIndex]...) + index = postIndex + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *InitAckMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 3: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.YourAvatarHash = append(m.YourAvatarHash, data[index:postIndex]...) + index = postIndex + case 4: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.RejoinGameId = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *AvatarRequestMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.RequestId = &v + case 2: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.AvatarHash = append(m.AvatarHash, data[index:postIndex]...) + index = postIndex + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *AvatarHeaderMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.RequestId = &v + case 2: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v NetAvatarType + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (NetAvatarType(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.AvatarType = &v + case 3: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.AvatarSize = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *AvatarDataMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.RequestId = &v + case 2: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.AvatarBlock = append(m.AvatarBlock, data[index:postIndex]...) + index = postIndex + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *AvatarEndMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.RequestId = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *UnknownAvatarMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.RequestId = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *PlayerListMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.PlayerId = &v + case 2: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v PlayerListMessage_PlayerListNotification + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (PlayerListMessage_PlayerListNotification(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.PlayerListNotification = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *GameListNewMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.GameId = &v + case 2: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v NetGameMode + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (NetGameMode(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.GameMode = &v + case 3: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.IsPrivate = &b + case 4: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var packedLen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for index < postIndex { + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.PlayerIds = append(m.PlayerIds, v) + } + case 5: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.AdminPlayerId = &v + case 6: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GameInfo == nil { + m.GameInfo = &NetGameInfo{} + } + if err := m.GameInfo.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 7: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var packedLen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for index < postIndex { + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.SpectatorIds = append(m.SpectatorIds, v) + } + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *GameListUpdateMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.GameId = &v + case 2: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v NetGameMode + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (NetGameMode(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.GameMode = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *GameListPlayerJoinedMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.GameId = &v + case 2: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.PlayerId = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *GameListPlayerLeftMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.GameId = &v + case 2: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.PlayerId = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *GameListSpectatorJoinedMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.GameId = &v + case 2: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.PlayerId = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *GameListSpectatorLeftMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.GameId = &v + case 2: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.PlayerId = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *GameListAdminChangedMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.GameId = &v + case 2: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.NewAdminPlayerId = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *PlayerInfoRequestMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var packedLen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for index < postIndex { + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.PlayerId = append(m.PlayerId, v) + } + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *PlayerInfoReplyMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.PlayerId = &v + case 2: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PlayerInfoData == nil { + m.PlayerInfoData = &PlayerInfoReplyMessage_PlayerInfoData{} + } + if err := m.PlayerInfoData.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *PlayerInfoReplyMessage_PlayerInfoData) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + int(stringLen) + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[index:postIndex]) + m.PlayerName = &s + index = postIndex + case 2: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.IsHuman = &b + case 3: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v NetPlayerInfoRights + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (NetPlayerInfoRights(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.PlayerRights = &v + case 4: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + int(stringLen) + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[index:postIndex]) + m.CountryCode = &s + index = postIndex + case 5: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AvatarData == nil { + m.AvatarData = &PlayerInfoReplyMessage_PlayerInfoData_AvatarData{} + } + if err := m.AvatarData.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *PlayerInfoReplyMessage_PlayerInfoData_AvatarData) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v NetAvatarType + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (NetAvatarType(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.AvatarType = &v + case 2: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.AvatarHash = append(m.AvatarHash, data[index:postIndex]...) + index = postIndex + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *SubscriptionRequestMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.RequestId = &v + case 2: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v SubscriptionRequestMessage_SubscriptionAction + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (SubscriptionRequestMessage_SubscriptionAction(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.SubscriptionAction = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *SubscriptionReplyMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.RequestId = &v + case 2: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.Ack = &b + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *CreateGameMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.RequestId = &v + case 2: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GameInfo == nil { + m.GameInfo = &NetGameInfo{} + } + if err := m.GameInfo.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 3: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + int(stringLen) + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[index:postIndex]) + m.Password = &s + index = postIndex + case 4: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.AutoLeave = &b + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *CreateGameFailedMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.RequestId = &v + case 2: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v CreateGameFailedMessage_CreateGameFailureReason + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (CreateGameFailedMessage_CreateGameFailureReason(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.CreateGameFailureReason = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *JoinGameMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + int(stringLen) + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[index:postIndex]) + m.Password = &s + index = postIndex + case 2: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.AutoLeave = &b + case 3: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.SpectateOnly = &b + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *RejoinGameMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.AutoLeave = &b + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *JoinGameAckMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.AreYouGameAdmin = &b + case 2: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GameInfo == nil { + m.GameInfo = &NetGameInfo{} + } + if err := m.GameInfo.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 3: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.SpectateOnly = &b + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *JoinGameFailedMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v JoinGameFailedMessage_JoinGameFailureReason + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (JoinGameFailedMessage_JoinGameFailureReason(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.JoinGameFailureReason = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *GamePlayerJoinedMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.PlayerId = &v + case 2: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.IsGameAdmin = &b + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *GamePlayerLeftMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.PlayerId = &v + case 2: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v GamePlayerLeftMessage_GamePlayerLeftReason + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (GamePlayerLeftMessage_GamePlayerLeftReason(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.GamePlayerLeftReason = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *GameSpectatorJoinedMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.PlayerId = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *GameSpectatorLeftMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.PlayerId = &v + case 2: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v GamePlayerLeftMessage_GamePlayerLeftReason + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (GamePlayerLeftMessage_GamePlayerLeftReason(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.GameSpectatorLeftReason = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *GameAdminChangedMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.NewAdminPlayerId = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *RemovedFromGameMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v RemovedFromGameMessage_RemovedFromGameReason + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (RemovedFromGameMessage_RemovedFromGameReason(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.RemovedFromGameReason = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *KickPlayerRequestMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.PlayerId = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *LeaveGameRequestMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + switch fieldNum { + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *InvitePlayerToGameMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.GameId = &v + case 2: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.PlayerId = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *InviteNotifyMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.GameId = &v + case 2: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.PlayerIdWho = &v + case 3: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.PlayerIdByWhom = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *RejectGameInvitationMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.GameId = &v + case 2: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v RejectGameInvitationMessage_RejectGameInvReason + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (RejectGameInvitationMessage_RejectGameInvReason(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.MyRejectReason = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *RejectInvNotifyMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.GameId = &v + case 2: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.PlayerId = &v + case 3: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v RejectGameInvitationMessage_RejectGameInvReason + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (RejectGameInvitationMessage_RejectGameInvReason(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.PlayerRejectReason = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *StartEventMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v StartEventMessage_StartEventType + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (StartEventMessage_StartEventType(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.StartEventType = &v + case 2: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.FillWithComputerPlayers = &b + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *StartEventAckMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + switch fieldNum { + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *GameStartInitialMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.StartDealerPlayerId = &v + case 2: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var packedLen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for index < postIndex { + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.PlayerSeats = append(m.PlayerSeats, v) + } + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *GameStartRejoinMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.StartDealerPlayerId = &v + case 2: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.HandNum = &v + case 3: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RejoinPlayerData = append(m.RejoinPlayerData, &GameStartRejoinMessage_RejoinPlayerData{}) + m.RejoinPlayerData[len(m.RejoinPlayerData)-1].Unmarshal(data[index:postIndex]) + index = postIndex + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *GameStartRejoinMessage_RejoinPlayerData) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.PlayerId = &v + case 2: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.PlayerMoney = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *HandStartMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PlainCards == nil { + m.PlainCards = &HandStartMessage_PlainCards{} + } + if err := m.PlainCards.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 2: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.EncryptedCards = append(m.EncryptedCards, data[index:postIndex]...) + index = postIndex + case 3: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.SmallBlind = &v + case 4: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v NetPlayerState + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (NetPlayerState(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.SeatStates = append(m.SeatStates, v) + case 5: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.DealerPlayerId = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *HandStartMessage_PlainCards) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.PlainCard1 = &v + case 2: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.PlainCard2 = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *PlayersTurnMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.PlayerId = &v + case 2: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v NetGameState + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (NetGameState(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.GameState = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *MyActionRequestMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.HandNum = &v + case 2: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v NetGameState + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (NetGameState(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.GameState = &v + case 3: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v NetPlayerAction + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (NetPlayerAction(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.MyAction = &v + case 4: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.MyRelativeBet = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *YourActionRejectedMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v NetGameState + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (NetGameState(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.GameState = &v + case 2: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v NetPlayerAction + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (NetPlayerAction(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.YourAction = &v + case 3: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.YourRelativeBet = &v + case 4: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v YourActionRejectedMessage_RejectionReason + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (YourActionRejectedMessage_RejectionReason(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.RejectionReason = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *PlayersActionDoneMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.PlayerId = &v + case 2: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v NetGameState + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (NetGameState(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.GameState = &v + case 3: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v NetPlayerAction + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (NetPlayerAction(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.PlayerAction = &v + case 4: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.TotalPlayerBet = &v + case 5: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.PlayerMoney = &v + case 6: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.HighestSet = &v + case 7: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.MinimumRaise = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *DealFlopCardsMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FlopCard1 = &v + case 2: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FlopCard2 = &v + case 3: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FlopCard3 = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *DealTurnCardMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.TurnCard = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *DealRiverCardMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.RiverCard = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *AllInShowCardsMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PlayersAllIn = append(m.PlayersAllIn, &AllInShowCardsMessage_PlayerAllIn{}) + m.PlayersAllIn[len(m.PlayersAllIn)-1].Unmarshal(data[index:postIndex]) + index = postIndex + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *AllInShowCardsMessage_PlayerAllIn) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.PlayerId = &v + case 2: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.AllInCard1 = &v + case 3: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.AllInCard2 = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *EndOfHandShowCardsMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PlayerResults = append(m.PlayerResults, &PlayerResult{}) + m.PlayerResults[len(m.PlayerResults)-1].Unmarshal(data[index:postIndex]) + index = postIndex + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *EndOfHandHideCardsMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.PlayerId = &v + case 2: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.MoneyWon = &v + case 3: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.PlayerMoney = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *ShowMyCardsRequestMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + switch fieldNum { + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *AfterHandShowCardsMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PlayerResult == nil { + m.PlayerResult = &PlayerResult{} + } + if err := m.PlayerResult.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *EndOfGameMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.WinnerPlayerId = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *PlayerIdChangedMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.OldPlayerId = &v + case 2: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.NewPlayerId = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *AskKickPlayerMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.PlayerId = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *AskKickDeniedMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.PlayerId = &v + case 2: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v AskKickDeniedMessage_KickDeniedReason + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (AskKickDeniedMessage_KickDeniedReason(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.KickDeniedReason = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *StartKickPetitionMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.PetitionId = &v + case 2: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.ProposingPlayerId = &v + case 3: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.KickPlayerId = &v + case 4: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.KickTimeoutSec = &v + case 5: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.NumVotesNeededToKick = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *VoteKickRequestMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.PetitionId = &v + case 2: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.VoteKick = &b + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *VoteKickReplyMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.PetitionId = &v + case 2: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v VoteKickReplyMessage_VoteKickReplyType + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (VoteKickReplyMessage_VoteKickReplyType(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.VoteKickReplyType = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *KickPetitionUpdateMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.PetitionId = &v + case 2: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.NumVotesAgainstKicking = &v + case 3: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.NumVotesInFavourOfKicking = &v + case 4: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.NumVotesNeededToKick = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *EndKickPetitionMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.PetitionId = &v + case 2: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.NumVotesAgainstKicking = &v + case 3: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.NumVotesInFavourOfKicking = &v + case 4: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.ResultPlayerKicked = &v + case 5: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v EndKickPetitionMessage_PetitionEndReason + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (EndKickPetitionMessage_PetitionEndReason(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.PetitionEndReason = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *StatisticsMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StatisticsData = append(m.StatisticsData, &StatisticsMessage_StatisticsData{}) + m.StatisticsData[len(m.StatisticsData)-1].Unmarshal(data[index:postIndex]) + index = postIndex + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *StatisticsMessage_StatisticsData) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v StatisticsMessage_StatisticsData_StatisticsType + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (StatisticsMessage_StatisticsData_StatisticsType(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.StatisticsType = &v + case 2: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.StatisticsValue = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *ChatRequestMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 2: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.TargetPlayerId = &v + case 3: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + int(stringLen) + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[index:postIndex]) + m.ChatText = &s + index = postIndex + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *ChatMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.PlayerId = &v + case 2: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v ChatMessage_ChatType + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (ChatMessage_ChatType(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.ChatType = &v + case 3: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + int(stringLen) + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[index:postIndex]) + m.ChatText = &s + index = postIndex + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *ChatRejectMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + int(stringLen) + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[index:postIndex]) + m.ChatText = &s + index = postIndex + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *DialogMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + int(stringLen) + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[index:postIndex]) + m.NotificationText = &s + index = postIndex + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *TimeoutWarningMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v TimeoutWarningMessage_TimeoutReason + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (TimeoutWarningMessage_TimeoutReason(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.TimeoutReason = &v + case 2: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.RemainingSeconds = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *ResetTimeoutMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + switch fieldNum { + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *ReportAvatarMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.ReportedPlayerId = &v + case 2: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ReportedAvatarHash = append(m.ReportedAvatarHash, data[index:postIndex]...) + index = postIndex + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *ReportAvatarAckMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.ReportedPlayerId = &v + case 2: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v ReportAvatarAckMessage_ReportAvatarResult + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (ReportAvatarAckMessage_ReportAvatarResult(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.ReportAvatarResult = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *ReportGameMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.ReportedGameId = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *ReportGameAckMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.ReportedGameId = &v + case 2: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v ReportGameAckMessage_ReportGameResult + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (ReportGameAckMessage_ReportGameResult(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.ReportGameResult = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *ErrorMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v ErrorMessage_ErrorReason + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (ErrorMessage_ErrorReason(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.ErrorReason = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *AdminRemoveGameMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.RemoveGameId = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *AdminRemoveGameAckMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.RemoveGameId = &v + case 2: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v AdminRemoveGameAckMessage_AdminRemoveGameResult + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (AdminRemoveGameAckMessage_AdminRemoveGameResult(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.RemoveGameResult = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *AdminBanPlayerMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.BanPlayerId = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *AdminBanPlayerAckMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.BanPlayerId = &v + case 2: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v AdminBanPlayerAckMessage_AdminBanPlayerResult + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (AdminBanPlayerAckMessage_AdminBanPlayerResult(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.BanPlayerResult = &v + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *AuthMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v AuthMessage_AuthMessageType + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (AuthMessage_AuthMessageType(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.MessageType = &v + case 2: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AuthClientRequestMessage == nil { + m.AuthClientRequestMessage = &AuthClientRequestMessage{} + } + if err := m.AuthClientRequestMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 3: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AuthServerChallengeMessage == nil { + m.AuthServerChallengeMessage = &AuthServerChallengeMessage{} + } + if err := m.AuthServerChallengeMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 4: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AuthClientResponseMessage == nil { + m.AuthClientResponseMessage = &AuthClientResponseMessage{} + } + if err := m.AuthClientResponseMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 5: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AuthServerVerificationMessage == nil { + m.AuthServerVerificationMessage = &AuthServerVerificationMessage{} + } + if err := m.AuthServerVerificationMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 1025: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ErrorMessage == nil { + m.ErrorMessage = &ErrorMessage{} + } + if err := m.ErrorMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *LobbyMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v LobbyMessage_LobbyMessageType + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (LobbyMessage_LobbyMessageType(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.MessageType = &v + case 2: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.InitMessage == nil { + m.InitMessage = &InitMessage{} + } + if err := m.InitMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 3: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.InitAckMessage == nil { + m.InitAckMessage = &InitAckMessage{} + } + if err := m.InitAckMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 4: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AvatarRequestMessage == nil { + m.AvatarRequestMessage = &AvatarRequestMessage{} + } + if err := m.AvatarRequestMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 5: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AvatarHeaderMessage == nil { + m.AvatarHeaderMessage = &AvatarHeaderMessage{} + } + if err := m.AvatarHeaderMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 6: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AvatarDataMessage == nil { + m.AvatarDataMessage = &AvatarDataMessage{} + } + if err := m.AvatarDataMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 7: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AvatarEndMessage == nil { + m.AvatarEndMessage = &AvatarEndMessage{} + } + if err := m.AvatarEndMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 8: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.UnknownAvatarMessage == nil { + m.UnknownAvatarMessage = &UnknownAvatarMessage{} + } + if err := m.UnknownAvatarMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 9: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PlayerListMessage == nil { + m.PlayerListMessage = &PlayerListMessage{} + } + if err := m.PlayerListMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 10: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GameListNewMessage == nil { + m.GameListNewMessage = &GameListNewMessage{} + } + if err := m.GameListNewMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 11: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GameListUpdateMessage == nil { + m.GameListUpdateMessage = &GameListUpdateMessage{} + } + if err := m.GameListUpdateMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 12: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GameListPlayerJoinedMessage == nil { + m.GameListPlayerJoinedMessage = &GameListPlayerJoinedMessage{} + } + if err := m.GameListPlayerJoinedMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 13: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GameListPlayerLeftMessage == nil { + m.GameListPlayerLeftMessage = &GameListPlayerLeftMessage{} + } + if err := m.GameListPlayerLeftMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 14: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GameListSpectatorJoinedMessage == nil { + m.GameListSpectatorJoinedMessage = &GameListSpectatorJoinedMessage{} + } + if err := m.GameListSpectatorJoinedMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 15: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GameListSpectatorLeftMessage == nil { + m.GameListSpectatorLeftMessage = &GameListSpectatorLeftMessage{} + } + if err := m.GameListSpectatorLeftMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 16: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GameListAdminChangedMessage == nil { + m.GameListAdminChangedMessage = &GameListAdminChangedMessage{} + } + if err := m.GameListAdminChangedMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 17: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PlayerInfoRequestMessage == nil { + m.PlayerInfoRequestMessage = &PlayerInfoRequestMessage{} + } + if err := m.PlayerInfoRequestMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 18: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PlayerInfoReplyMessage == nil { + m.PlayerInfoReplyMessage = &PlayerInfoReplyMessage{} + } + if err := m.PlayerInfoReplyMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 19: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SubscriptionRequestMessage == nil { + m.SubscriptionRequestMessage = &SubscriptionRequestMessage{} + } + if err := m.SubscriptionRequestMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 20: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SubscriptionReplyMessage == nil { + m.SubscriptionReplyMessage = &SubscriptionReplyMessage{} + } + if err := m.SubscriptionReplyMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 21: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.CreateGameMessage == nil { + m.CreateGameMessage = &CreateGameMessage{} + } + if err := m.CreateGameMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 22: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.CreateGameFailedMessage == nil { + m.CreateGameFailedMessage = &CreateGameFailedMessage{} + } + if err := m.CreateGameFailedMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 23: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.InvitePlayerToGameMessage == nil { + m.InvitePlayerToGameMessage = &InvitePlayerToGameMessage{} + } + if err := m.InvitePlayerToGameMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 24: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.InviteNotifyMessage == nil { + m.InviteNotifyMessage = &InviteNotifyMessage{} + } + if err := m.InviteNotifyMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 25: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RejectGameInvitationMessage == nil { + m.RejectGameInvitationMessage = &RejectGameInvitationMessage{} + } + if err := m.RejectGameInvitationMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 26: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RejectInvNotifyMessage == nil { + m.RejectInvNotifyMessage = &RejectInvNotifyMessage{} + } + if err := m.RejectInvNotifyMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 27: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.StatisticsMessage == nil { + m.StatisticsMessage = &StatisticsMessage{} + } + if err := m.StatisticsMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 28: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ChatRequestMessage == nil { + m.ChatRequestMessage = &ChatRequestMessage{} + } + if err := m.ChatRequestMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 29: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ChatMessage == nil { + m.ChatMessage = &ChatMessage{} + } + if err := m.ChatMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 30: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ChatRejectMessage == nil { + m.ChatRejectMessage = &ChatRejectMessage{} + } + if err := m.ChatRejectMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 31: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.DialogMessage == nil { + m.DialogMessage = &DialogMessage{} + } + if err := m.DialogMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 32: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.TimeoutWarningMessage == nil { + m.TimeoutWarningMessage = &TimeoutWarningMessage{} + } + if err := m.TimeoutWarningMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 33: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ResetTimeoutMessage == nil { + m.ResetTimeoutMessage = &ResetTimeoutMessage{} + } + if err := m.ResetTimeoutMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 34: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ReportAvatarMessage == nil { + m.ReportAvatarMessage = &ReportAvatarMessage{} + } + if err := m.ReportAvatarMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 35: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ReportAvatarAckMessage == nil { + m.ReportAvatarAckMessage = &ReportAvatarAckMessage{} + } + if err := m.ReportAvatarAckMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 36: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ReportGameMessage == nil { + m.ReportGameMessage = &ReportGameMessage{} + } + if err := m.ReportGameMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 37: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ReportGameAckMessage == nil { + m.ReportGameAckMessage = &ReportGameAckMessage{} + } + if err := m.ReportGameAckMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 38: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AdminRemoveGameMessage == nil { + m.AdminRemoveGameMessage = &AdminRemoveGameMessage{} + } + if err := m.AdminRemoveGameMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 39: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AdminRemoveGameAckMessage == nil { + m.AdminRemoveGameAckMessage = &AdminRemoveGameAckMessage{} + } + if err := m.AdminRemoveGameAckMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 40: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AdminBanPlayerMessage == nil { + m.AdminBanPlayerMessage = &AdminBanPlayerMessage{} + } + if err := m.AdminBanPlayerMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 41: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AdminBanPlayerAckMessage == nil { + m.AdminBanPlayerAckMessage = &AdminBanPlayerAckMessage{} + } + if err := m.AdminBanPlayerAckMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 1025: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ErrorMessage == nil { + m.ErrorMessage = &ErrorMessage{} + } + if err := m.ErrorMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *GameManagementMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v GameManagementMessage_GameManagementMessageType + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (GameManagementMessage_GameManagementMessageType(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.MessageType = &v + case 2: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.JoinGameMessage == nil { + m.JoinGameMessage = &JoinGameMessage{} + } + if err := m.JoinGameMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 3: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RejoinGameMessage == nil { + m.RejoinGameMessage = &RejoinGameMessage{} + } + if err := m.RejoinGameMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 4: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.JoinGameAckMessage == nil { + m.JoinGameAckMessage = &JoinGameAckMessage{} + } + if err := m.JoinGameAckMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 5: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.JoinGameFailedMessage == nil { + m.JoinGameFailedMessage = &JoinGameFailedMessage{} + } + if err := m.JoinGameFailedMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 6: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GamePlayerJoinedMessage == nil { + m.GamePlayerJoinedMessage = &GamePlayerJoinedMessage{} + } + if err := m.GamePlayerJoinedMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 7: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GamePlayerLeftMessage == nil { + m.GamePlayerLeftMessage = &GamePlayerLeftMessage{} + } + if err := m.GamePlayerLeftMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 8: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GameSpectatorJoinedMessage == nil { + m.GameSpectatorJoinedMessage = &GameSpectatorJoinedMessage{} + } + if err := m.GameSpectatorJoinedMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 9: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GameSpectatorLeftMessage == nil { + m.GameSpectatorLeftMessage = &GameSpectatorLeftMessage{} + } + if err := m.GameSpectatorLeftMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 10: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GameAdminChangedMessage == nil { + m.GameAdminChangedMessage = &GameAdminChangedMessage{} + } + if err := m.GameAdminChangedMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 11: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RemovedFromGameMessage == nil { + m.RemovedFromGameMessage = &RemovedFromGameMessage{} + } + if err := m.RemovedFromGameMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 12: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.KickPlayerRequestMessage == nil { + m.KickPlayerRequestMessage = &KickPlayerRequestMessage{} + } + if err := m.KickPlayerRequestMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 13: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.LeaveGameRequestMessage == nil { + m.LeaveGameRequestMessage = &LeaveGameRequestMessage{} + } + if err := m.LeaveGameRequestMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 14: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.StartEventMessage == nil { + m.StartEventMessage = &StartEventMessage{} + } + if err := m.StartEventMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 15: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.StartEventAckMessage == nil { + m.StartEventAckMessage = &StartEventAckMessage{} + } + if err := m.StartEventAckMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 16: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GameStartInitialMessage == nil { + m.GameStartInitialMessage = &GameStartInitialMessage{} + } + if err := m.GameStartInitialMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 17: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GameStartRejoinMessage == nil { + m.GameStartRejoinMessage = &GameStartRejoinMessage{} + } + if err := m.GameStartRejoinMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 18: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.EndOfGameMessage == nil { + m.EndOfGameMessage = &EndOfGameMessage{} + } + if err := m.EndOfGameMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 19: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PlayerIdChangedMessage == nil { + m.PlayerIdChangedMessage = &PlayerIdChangedMessage{} + } + if err := m.PlayerIdChangedMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 20: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AskKickPlayerMessage == nil { + m.AskKickPlayerMessage = &AskKickPlayerMessage{} + } + if err := m.AskKickPlayerMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 21: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AskKickDeniedMessage == nil { + m.AskKickDeniedMessage = &AskKickDeniedMessage{} + } + if err := m.AskKickDeniedMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 22: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.StartKickPetitionMessage == nil { + m.StartKickPetitionMessage = &StartKickPetitionMessage{} + } + if err := m.StartKickPetitionMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 23: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.VoteKickRequestMessage == nil { + m.VoteKickRequestMessage = &VoteKickRequestMessage{} + } + if err := m.VoteKickRequestMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 24: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.VoteKickReplyMessage == nil { + m.VoteKickReplyMessage = &VoteKickReplyMessage{} + } + if err := m.VoteKickReplyMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 25: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.KickPetitionUpdateMessage == nil { + m.KickPetitionUpdateMessage = &KickPetitionUpdateMessage{} + } + if err := m.KickPetitionUpdateMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 26: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.EndKickPetitionMessage == nil { + m.EndKickPetitionMessage = &EndKickPetitionMessage{} + } + if err := m.EndKickPetitionMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 27: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ChatRequestMessage == nil { + m.ChatRequestMessage = &ChatRequestMessage{} + } + if err := m.ChatRequestMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 28: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ChatMessage == nil { + m.ChatMessage = &ChatMessage{} + } + if err := m.ChatMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 29: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ChatRejectMessage == nil { + m.ChatRejectMessage = &ChatRejectMessage{} + } + if err := m.ChatRejectMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 1025: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ErrorMessage == nil { + m.ErrorMessage = &ErrorMessage{} + } + if err := m.ErrorMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *GameEngineMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v GameEngineMessage_GameEngineMessageType + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (GameEngineMessage_GameEngineMessageType(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.MessageType = &v + case 2: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.HandStartMessage == nil { + m.HandStartMessage = &HandStartMessage{} + } + if err := m.HandStartMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 3: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PlayersTurnMessage == nil { + m.PlayersTurnMessage = &PlayersTurnMessage{} + } + if err := m.PlayersTurnMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 4: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.MyActionRequestMessage == nil { + m.MyActionRequestMessage = &MyActionRequestMessage{} + } + if err := m.MyActionRequestMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 5: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.YourActionRejectedMessage == nil { + m.YourActionRejectedMessage = &YourActionRejectedMessage{} + } + if err := m.YourActionRejectedMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 6: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PlayersActionDoneMessage == nil { + m.PlayersActionDoneMessage = &PlayersActionDoneMessage{} + } + if err := m.PlayersActionDoneMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 7: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.DealFlopCardsMessage == nil { + m.DealFlopCardsMessage = &DealFlopCardsMessage{} + } + if err := m.DealFlopCardsMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 8: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.DealTurnCardMessage == nil { + m.DealTurnCardMessage = &DealTurnCardMessage{} + } + if err := m.DealTurnCardMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 9: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.DealRiverCardMessage == nil { + m.DealRiverCardMessage = &DealRiverCardMessage{} + } + if err := m.DealRiverCardMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 10: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AllInShowCardsMessage == nil { + m.AllInShowCardsMessage = &AllInShowCardsMessage{} + } + if err := m.AllInShowCardsMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 11: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.EndOfHandShowCardsMessage == nil { + m.EndOfHandShowCardsMessage = &EndOfHandShowCardsMessage{} + } + if err := m.EndOfHandShowCardsMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 12: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.EndOfHandHideCardsMessage == nil { + m.EndOfHandHideCardsMessage = &EndOfHandHideCardsMessage{} + } + if err := m.EndOfHandHideCardsMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 13: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ShowMyCardsRequestMessage == nil { + m.ShowMyCardsRequestMessage = &ShowMyCardsRequestMessage{} + } + if err := m.ShowMyCardsRequestMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 14: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AfterHandShowCardsMessage == nil { + m.AfterHandShowCardsMessage = &AfterHandShowCardsMessage{} + } + if err := m.AfterHandShowCardsMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *GameMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v GameMessage_GameMessageType + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (GameMessage_GameMessageType(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.MessageType = &v + case 2: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.GameId = &v + case 3: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GameManagementMessage == nil { + m.GameManagementMessage = &GameManagementMessage{} + } + if err := m.GameManagementMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 4: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GameEngineMessage == nil { + m.GameEngineMessage = &GameEngineMessage{} + } + if err := m.GameEngineMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *PokerTHMessage) Unmarshal(data []byte) error { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 0 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var v PokerTHMessage_PokerTHMessageType + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + v |= (PokerTHMessage_PokerTHMessageType(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.MessageType = &v + case 2: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AnnounceMessage == nil { + m.AnnounceMessage = &AnnounceMessage{} + } + if err := m.AnnounceMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 3: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AuthMessage == nil { + m.AuthMessage = &AuthMessage{} + } + if err := m.AuthMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 4: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.LobbyMessage == nil { + m.LobbyMessage = &LobbyMessage{} + } + if err := m.LobbyMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + case 5: + if wireType != 2 { + return code_google_com_p_gogoprotobuf_proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if index >= l { + return io.ErrUnexpectedEOF + } + b := data[index] + index++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := index + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GameMessage == nil { + m.GameMessage = &GameMessage{} + } + if err := m.GameMessage.Unmarshal(data[index:postIndex]); err != nil { + return err + } + index = postIndex + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + index -= sizeOfWire + skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:]) + if err != nil { + return err + } + if (index + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...) + index += skippy + } + } + return nil +} +func (m *NetGameInfo) Size() (n int) { + var l int + _ = l + if m.GameName != nil { + l = len(*m.GameName) + n += 1 + l + sovPokerth(uint64(l)) + } + if m.NetGameType != nil { + n += 1 + sovPokerth(uint64(*m.NetGameType)) + } + if m.MaxNumPlayers != nil { + n += 1 + sovPokerth(uint64(*m.MaxNumPlayers)) + } + if m.RaiseIntervalMode != nil { + n += 1 + sovPokerth(uint64(*m.RaiseIntervalMode)) + } + if m.RaiseEveryHands != nil { + n += 1 + sovPokerth(uint64(*m.RaiseEveryHands)) + } + if m.RaiseEveryMinutes != nil { + n += 1 + sovPokerth(uint64(*m.RaiseEveryMinutes)) + } + if m.EndRaiseMode != nil { + n += 1 + sovPokerth(uint64(*m.EndRaiseMode)) + } + if m.EndRaiseSmallBlindValue != nil { + n += 1 + sovPokerth(uint64(*m.EndRaiseSmallBlindValue)) + } + if m.ProposedGuiSpeed != nil { + n += 1 + sovPokerth(uint64(*m.ProposedGuiSpeed)) + } + if m.DelayBetweenHands != nil { + n += 1 + sovPokerth(uint64(*m.DelayBetweenHands)) + } + if m.PlayerActionTimeout != nil { + n += 1 + sovPokerth(uint64(*m.PlayerActionTimeout)) + } + if m.FirstSmallBlind != nil { + n += 1 + sovPokerth(uint64(*m.FirstSmallBlind)) + } + if m.StartMoney != nil { + n += 1 + sovPokerth(uint64(*m.StartMoney)) + } + if len(m.ManualBlinds) > 0 { + l = 0 + for _, e := range m.ManualBlinds { + l += sovPokerth(uint64(e)) + } + n += 1 + sovPokerth(uint64(l)) + l + } + if m.AllowSpectators != nil { + n += 2 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *PlayerResult) Size() (n int) { + var l int + _ = l + if m.PlayerId != nil { + n += 1 + sovPokerth(uint64(*m.PlayerId)) + } + if m.ResultCard1 != nil { + n += 1 + sovPokerth(uint64(*m.ResultCard1)) + } + if m.ResultCard2 != nil { + n += 1 + sovPokerth(uint64(*m.ResultCard2)) + } + if len(m.BestHandPosition) > 0 { + l = 0 + for _, e := range m.BestHandPosition { + l += sovPokerth(uint64(e)) + } + n += 1 + sovPokerth(uint64(l)) + l + } + if m.MoneyWon != nil { + n += 1 + sovPokerth(uint64(*m.MoneyWon)) + } + if m.PlayerMoney != nil { + n += 1 + sovPokerth(uint64(*m.PlayerMoney)) + } + if m.CardsValue != nil { + n += 1 + sovPokerth(uint64(*m.CardsValue)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *AnnounceMessage) Size() (n int) { + var l int + _ = l + if m.ProtocolVersion != nil { + l = m.ProtocolVersion.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.LatestGameVersion != nil { + l = m.LatestGameVersion.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.LatestBetaRevision != nil { + n += 1 + sovPokerth(uint64(*m.LatestBetaRevision)) + } + if m.ServerType != nil { + n += 1 + sovPokerth(uint64(*m.ServerType)) + } + if m.NumPlayersOnServer != nil { + n += 1 + sovPokerth(uint64(*m.NumPlayersOnServer)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *AnnounceMessage_Version) Size() (n int) { + var l int + _ = l + if m.MajorVersion != nil { + n += 1 + sovPokerth(uint64(*m.MajorVersion)) + } + if m.MinorVersion != nil { + n += 1 + sovPokerth(uint64(*m.MinorVersion)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *AuthClientRequestMessage) Size() (n int) { + var l int + _ = l + if m.RequestedVersion != nil { + l = m.RequestedVersion.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.BuildId != nil { + n += 1 + sovPokerth(uint64(*m.BuildId)) + } + if m.Login != nil { + n += 1 + sovPokerth(uint64(*m.Login)) + } + if m.AuthServerPassword != nil { + l = len(*m.AuthServerPassword) + n += 1 + l + sovPokerth(uint64(l)) + } + if m.NickName != nil { + l = len(*m.NickName) + n += 1 + l + sovPokerth(uint64(l)) + } + if m.ClientUserData != nil { + l = len(m.ClientUserData) + n += 1 + l + sovPokerth(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *AuthServerChallengeMessage) Size() (n int) { + var l int + _ = l + if m.ServerChallenge != nil { + l = len(m.ServerChallenge) + n += 1 + l + sovPokerth(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *AuthClientResponseMessage) Size() (n int) { + var l int + _ = l + if m.ClientResponse != nil { + l = len(m.ClientResponse) + n += 1 + l + sovPokerth(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *AuthServerVerificationMessage) Size() (n int) { + var l int + _ = l + if m.YourSessionId != nil { + l = len(m.YourSessionId) + n += 1 + l + sovPokerth(uint64(l)) + } + if m.YourPlayerId != nil { + n += 1 + sovPokerth(uint64(*m.YourPlayerId)) + } + if m.ServerVerification != nil { + l = len(m.ServerVerification) + n += 1 + l + sovPokerth(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *InitMessage) Size() (n int) { + var l int + _ = l + if m.MyLastSessionId != nil { + l = len(m.MyLastSessionId) + n += 1 + l + sovPokerth(uint64(l)) + } + if m.AvatarHash != nil { + l = len(m.AvatarHash) + n += 1 + l + sovPokerth(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *InitAckMessage) Size() (n int) { + var l int + _ = l + if m.YourAvatarHash != nil { + l = len(m.YourAvatarHash) + n += 1 + l + sovPokerth(uint64(l)) + } + if m.RejoinGameId != nil { + n += 1 + sovPokerth(uint64(*m.RejoinGameId)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *AvatarRequestMessage) Size() (n int) { + var l int + _ = l + if m.RequestId != nil { + n += 1 + sovPokerth(uint64(*m.RequestId)) + } + if m.AvatarHash != nil { + l = len(m.AvatarHash) + n += 1 + l + sovPokerth(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *AvatarHeaderMessage) Size() (n int) { + var l int + _ = l + if m.RequestId != nil { + n += 1 + sovPokerth(uint64(*m.RequestId)) + } + if m.AvatarType != nil { + n += 1 + sovPokerth(uint64(*m.AvatarType)) + } + if m.AvatarSize != nil { + n += 1 + sovPokerth(uint64(*m.AvatarSize)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *AvatarDataMessage) Size() (n int) { + var l int + _ = l + if m.RequestId != nil { + n += 1 + sovPokerth(uint64(*m.RequestId)) + } + if m.AvatarBlock != nil { + l = len(m.AvatarBlock) + n += 1 + l + sovPokerth(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *AvatarEndMessage) Size() (n int) { + var l int + _ = l + if m.RequestId != nil { + n += 1 + sovPokerth(uint64(*m.RequestId)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *UnknownAvatarMessage) Size() (n int) { + var l int + _ = l + if m.RequestId != nil { + n += 1 + sovPokerth(uint64(*m.RequestId)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *PlayerListMessage) Size() (n int) { + var l int + _ = l + if m.PlayerId != nil { + n += 1 + sovPokerth(uint64(*m.PlayerId)) + } + if m.PlayerListNotification != nil { + n += 1 + sovPokerth(uint64(*m.PlayerListNotification)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *GameListNewMessage) Size() (n int) { + var l int + _ = l + if m.GameId != nil { + n += 1 + sovPokerth(uint64(*m.GameId)) + } + if m.GameMode != nil { + n += 1 + sovPokerth(uint64(*m.GameMode)) + } + if m.IsPrivate != nil { + n += 2 + } + if len(m.PlayerIds) > 0 { + l = 0 + for _, e := range m.PlayerIds { + l += sovPokerth(uint64(e)) + } + n += 1 + sovPokerth(uint64(l)) + l + } + if m.AdminPlayerId != nil { + n += 1 + sovPokerth(uint64(*m.AdminPlayerId)) + } + if m.GameInfo != nil { + l = m.GameInfo.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if len(m.SpectatorIds) > 0 { + l = 0 + for _, e := range m.SpectatorIds { + l += sovPokerth(uint64(e)) + } + n += 1 + sovPokerth(uint64(l)) + l + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *GameListUpdateMessage) Size() (n int) { + var l int + _ = l + if m.GameId != nil { + n += 1 + sovPokerth(uint64(*m.GameId)) + } + if m.GameMode != nil { + n += 1 + sovPokerth(uint64(*m.GameMode)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *GameListPlayerJoinedMessage) Size() (n int) { + var l int + _ = l + if m.GameId != nil { + n += 1 + sovPokerth(uint64(*m.GameId)) + } + if m.PlayerId != nil { + n += 1 + sovPokerth(uint64(*m.PlayerId)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *GameListPlayerLeftMessage) Size() (n int) { + var l int + _ = l + if m.GameId != nil { + n += 1 + sovPokerth(uint64(*m.GameId)) + } + if m.PlayerId != nil { + n += 1 + sovPokerth(uint64(*m.PlayerId)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *GameListSpectatorJoinedMessage) Size() (n int) { + var l int + _ = l + if m.GameId != nil { + n += 1 + sovPokerth(uint64(*m.GameId)) + } + if m.PlayerId != nil { + n += 1 + sovPokerth(uint64(*m.PlayerId)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *GameListSpectatorLeftMessage) Size() (n int) { + var l int + _ = l + if m.GameId != nil { + n += 1 + sovPokerth(uint64(*m.GameId)) + } + if m.PlayerId != nil { + n += 1 + sovPokerth(uint64(*m.PlayerId)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *GameListAdminChangedMessage) Size() (n int) { + var l int + _ = l + if m.GameId != nil { + n += 1 + sovPokerth(uint64(*m.GameId)) + } + if m.NewAdminPlayerId != nil { + n += 1 + sovPokerth(uint64(*m.NewAdminPlayerId)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *PlayerInfoRequestMessage) Size() (n int) { + var l int + _ = l + if len(m.PlayerId) > 0 { + l = 0 + for _, e := range m.PlayerId { + l += sovPokerth(uint64(e)) + } + n += 1 + sovPokerth(uint64(l)) + l + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *PlayerInfoReplyMessage) Size() (n int) { + var l int + _ = l + if m.PlayerId != nil { + n += 1 + sovPokerth(uint64(*m.PlayerId)) + } + if m.PlayerInfoData != nil { + l = m.PlayerInfoData.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *PlayerInfoReplyMessage_PlayerInfoData) Size() (n int) { + var l int + _ = l + if m.PlayerName != nil { + l = len(*m.PlayerName) + n += 1 + l + sovPokerth(uint64(l)) + } + if m.IsHuman != nil { + n += 2 + } + if m.PlayerRights != nil { + n += 1 + sovPokerth(uint64(*m.PlayerRights)) + } + if m.CountryCode != nil { + l = len(*m.CountryCode) + n += 1 + l + sovPokerth(uint64(l)) + } + if m.AvatarData != nil { + l = m.AvatarData.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *PlayerInfoReplyMessage_PlayerInfoData_AvatarData) Size() (n int) { + var l int + _ = l + if m.AvatarType != nil { + n += 1 + sovPokerth(uint64(*m.AvatarType)) + } + if m.AvatarHash != nil { + l = len(m.AvatarHash) + n += 1 + l + sovPokerth(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *SubscriptionRequestMessage) Size() (n int) { + var l int + _ = l + if m.RequestId != nil { + n += 1 + sovPokerth(uint64(*m.RequestId)) + } + if m.SubscriptionAction != nil { + n += 1 + sovPokerth(uint64(*m.SubscriptionAction)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *SubscriptionReplyMessage) Size() (n int) { + var l int + _ = l + if m.RequestId != nil { + n += 1 + sovPokerth(uint64(*m.RequestId)) + } + if m.Ack != nil { + n += 2 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *CreateGameMessage) Size() (n int) { + var l int + _ = l + if m.RequestId != nil { + n += 1 + sovPokerth(uint64(*m.RequestId)) + } + if m.GameInfo != nil { + l = m.GameInfo.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.Password != nil { + l = len(*m.Password) + n += 1 + l + sovPokerth(uint64(l)) + } + if m.AutoLeave != nil { + n += 2 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *CreateGameFailedMessage) Size() (n int) { + var l int + _ = l + if m.RequestId != nil { + n += 1 + sovPokerth(uint64(*m.RequestId)) + } + if m.CreateGameFailureReason != nil { + n += 1 + sovPokerth(uint64(*m.CreateGameFailureReason)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *JoinGameMessage) Size() (n int) { + var l int + _ = l + if m.Password != nil { + l = len(*m.Password) + n += 1 + l + sovPokerth(uint64(l)) + } + if m.AutoLeave != nil { + n += 2 + } + if m.SpectateOnly != nil { + n += 2 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *RejoinGameMessage) Size() (n int) { + var l int + _ = l + if m.AutoLeave != nil { + n += 2 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *JoinGameAckMessage) Size() (n int) { + var l int + _ = l + if m.AreYouGameAdmin != nil { + n += 2 + } + if m.GameInfo != nil { + l = m.GameInfo.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.SpectateOnly != nil { + n += 2 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *JoinGameFailedMessage) Size() (n int) { + var l int + _ = l + if m.JoinGameFailureReason != nil { + n += 1 + sovPokerth(uint64(*m.JoinGameFailureReason)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *GamePlayerJoinedMessage) Size() (n int) { + var l int + _ = l + if m.PlayerId != nil { + n += 1 + sovPokerth(uint64(*m.PlayerId)) + } + if m.IsGameAdmin != nil { + n += 2 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *GamePlayerLeftMessage) Size() (n int) { + var l int + _ = l + if m.PlayerId != nil { + n += 1 + sovPokerth(uint64(*m.PlayerId)) + } + if m.GamePlayerLeftReason != nil { + n += 1 + sovPokerth(uint64(*m.GamePlayerLeftReason)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *GameSpectatorJoinedMessage) Size() (n int) { + var l int + _ = l + if m.PlayerId != nil { + n += 1 + sovPokerth(uint64(*m.PlayerId)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *GameSpectatorLeftMessage) Size() (n int) { + var l int + _ = l + if m.PlayerId != nil { + n += 1 + sovPokerth(uint64(*m.PlayerId)) + } + if m.GameSpectatorLeftReason != nil { + n += 1 + sovPokerth(uint64(*m.GameSpectatorLeftReason)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *GameAdminChangedMessage) Size() (n int) { + var l int + _ = l + if m.NewAdminPlayerId != nil { + n += 1 + sovPokerth(uint64(*m.NewAdminPlayerId)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *RemovedFromGameMessage) Size() (n int) { + var l int + _ = l + if m.RemovedFromGameReason != nil { + n += 1 + sovPokerth(uint64(*m.RemovedFromGameReason)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *KickPlayerRequestMessage) Size() (n int) { + var l int + _ = l + if m.PlayerId != nil { + n += 1 + sovPokerth(uint64(*m.PlayerId)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *LeaveGameRequestMessage) Size() (n int) { + var l int + _ = l + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *InvitePlayerToGameMessage) Size() (n int) { + var l int + _ = l + if m.GameId != nil { + n += 1 + sovPokerth(uint64(*m.GameId)) + } + if m.PlayerId != nil { + n += 1 + sovPokerth(uint64(*m.PlayerId)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *InviteNotifyMessage) Size() (n int) { + var l int + _ = l + if m.GameId != nil { + n += 1 + sovPokerth(uint64(*m.GameId)) + } + if m.PlayerIdWho != nil { + n += 1 + sovPokerth(uint64(*m.PlayerIdWho)) + } + if m.PlayerIdByWhom != nil { + n += 1 + sovPokerth(uint64(*m.PlayerIdByWhom)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *RejectGameInvitationMessage) Size() (n int) { + var l int + _ = l + if m.GameId != nil { + n += 1 + sovPokerth(uint64(*m.GameId)) + } + if m.MyRejectReason != nil { + n += 1 + sovPokerth(uint64(*m.MyRejectReason)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *RejectInvNotifyMessage) Size() (n int) { + var l int + _ = l + if m.GameId != nil { + n += 1 + sovPokerth(uint64(*m.GameId)) + } + if m.PlayerId != nil { + n += 1 + sovPokerth(uint64(*m.PlayerId)) + } + if m.PlayerRejectReason != nil { + n += 1 + sovPokerth(uint64(*m.PlayerRejectReason)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *StartEventMessage) Size() (n int) { + var l int + _ = l + if m.StartEventType != nil { + n += 1 + sovPokerth(uint64(*m.StartEventType)) + } + if m.FillWithComputerPlayers != nil { + n += 2 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *StartEventAckMessage) Size() (n int) { + var l int + _ = l + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *GameStartInitialMessage) Size() (n int) { + var l int + _ = l + if m.StartDealerPlayerId != nil { + n += 1 + sovPokerth(uint64(*m.StartDealerPlayerId)) + } + if len(m.PlayerSeats) > 0 { + l = 0 + for _, e := range m.PlayerSeats { + l += sovPokerth(uint64(e)) + } + n += 1 + sovPokerth(uint64(l)) + l + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *GameStartRejoinMessage) Size() (n int) { + var l int + _ = l + if m.StartDealerPlayerId != nil { + n += 1 + sovPokerth(uint64(*m.StartDealerPlayerId)) + } + if m.HandNum != nil { + n += 1 + sovPokerth(uint64(*m.HandNum)) + } + if len(m.RejoinPlayerData) > 0 { + for _, e := range m.RejoinPlayerData { + l = e.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *GameStartRejoinMessage_RejoinPlayerData) Size() (n int) { + var l int + _ = l + if m.PlayerId != nil { + n += 1 + sovPokerth(uint64(*m.PlayerId)) + } + if m.PlayerMoney != nil { + n += 1 + sovPokerth(uint64(*m.PlayerMoney)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *HandStartMessage) Size() (n int) { + var l int + _ = l + if m.PlainCards != nil { + l = m.PlainCards.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.EncryptedCards != nil { + l = len(m.EncryptedCards) + n += 1 + l + sovPokerth(uint64(l)) + } + if m.SmallBlind != nil { + n += 1 + sovPokerth(uint64(*m.SmallBlind)) + } + if len(m.SeatStates) > 0 { + for _, e := range m.SeatStates { + n += 1 + sovPokerth(uint64(e)) + } + } + if m.DealerPlayerId != nil { + n += 1 + sovPokerth(uint64(*m.DealerPlayerId)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *HandStartMessage_PlainCards) Size() (n int) { + var l int + _ = l + if m.PlainCard1 != nil { + n += 1 + sovPokerth(uint64(*m.PlainCard1)) + } + if m.PlainCard2 != nil { + n += 1 + sovPokerth(uint64(*m.PlainCard2)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *PlayersTurnMessage) Size() (n int) { + var l int + _ = l + if m.PlayerId != nil { + n += 1 + sovPokerth(uint64(*m.PlayerId)) + } + if m.GameState != nil { + n += 1 + sovPokerth(uint64(*m.GameState)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *MyActionRequestMessage) Size() (n int) { + var l int + _ = l + if m.HandNum != nil { + n += 1 + sovPokerth(uint64(*m.HandNum)) + } + if m.GameState != nil { + n += 1 + sovPokerth(uint64(*m.GameState)) + } + if m.MyAction != nil { + n += 1 + sovPokerth(uint64(*m.MyAction)) + } + if m.MyRelativeBet != nil { + n += 1 + sovPokerth(uint64(*m.MyRelativeBet)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *YourActionRejectedMessage) Size() (n int) { + var l int + _ = l + if m.GameState != nil { + n += 1 + sovPokerth(uint64(*m.GameState)) + } + if m.YourAction != nil { + n += 1 + sovPokerth(uint64(*m.YourAction)) + } + if m.YourRelativeBet != nil { + n += 1 + sovPokerth(uint64(*m.YourRelativeBet)) + } + if m.RejectionReason != nil { + n += 1 + sovPokerth(uint64(*m.RejectionReason)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *PlayersActionDoneMessage) Size() (n int) { + var l int + _ = l + if m.PlayerId != nil { + n += 1 + sovPokerth(uint64(*m.PlayerId)) + } + if m.GameState != nil { + n += 1 + sovPokerth(uint64(*m.GameState)) + } + if m.PlayerAction != nil { + n += 1 + sovPokerth(uint64(*m.PlayerAction)) + } + if m.TotalPlayerBet != nil { + n += 1 + sovPokerth(uint64(*m.TotalPlayerBet)) + } + if m.PlayerMoney != nil { + n += 1 + sovPokerth(uint64(*m.PlayerMoney)) + } + if m.HighestSet != nil { + n += 1 + sovPokerth(uint64(*m.HighestSet)) + } + if m.MinimumRaise != nil { + n += 1 + sovPokerth(uint64(*m.MinimumRaise)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *DealFlopCardsMessage) Size() (n int) { + var l int + _ = l + if m.FlopCard1 != nil { + n += 1 + sovPokerth(uint64(*m.FlopCard1)) + } + if m.FlopCard2 != nil { + n += 1 + sovPokerth(uint64(*m.FlopCard2)) + } + if m.FlopCard3 != nil { + n += 1 + sovPokerth(uint64(*m.FlopCard3)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *DealTurnCardMessage) Size() (n int) { + var l int + _ = l + if m.TurnCard != nil { + n += 1 + sovPokerth(uint64(*m.TurnCard)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *DealRiverCardMessage) Size() (n int) { + var l int + _ = l + if m.RiverCard != nil { + n += 1 + sovPokerth(uint64(*m.RiverCard)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *AllInShowCardsMessage) Size() (n int) { + var l int + _ = l + if len(m.PlayersAllIn) > 0 { + for _, e := range m.PlayersAllIn { + l = e.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *AllInShowCardsMessage_PlayerAllIn) Size() (n int) { + var l int + _ = l + if m.PlayerId != nil { + n += 1 + sovPokerth(uint64(*m.PlayerId)) + } + if m.AllInCard1 != nil { + n += 1 + sovPokerth(uint64(*m.AllInCard1)) + } + if m.AllInCard2 != nil { + n += 1 + sovPokerth(uint64(*m.AllInCard2)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *EndOfHandShowCardsMessage) Size() (n int) { + var l int + _ = l + if len(m.PlayerResults) > 0 { + for _, e := range m.PlayerResults { + l = e.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *EndOfHandHideCardsMessage) Size() (n int) { + var l int + _ = l + if m.PlayerId != nil { + n += 1 + sovPokerth(uint64(*m.PlayerId)) + } + if m.MoneyWon != nil { + n += 1 + sovPokerth(uint64(*m.MoneyWon)) + } + if m.PlayerMoney != nil { + n += 1 + sovPokerth(uint64(*m.PlayerMoney)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *ShowMyCardsRequestMessage) Size() (n int) { + var l int + _ = l + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *AfterHandShowCardsMessage) Size() (n int) { + var l int + _ = l + if m.PlayerResult != nil { + l = m.PlayerResult.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *EndOfGameMessage) Size() (n int) { + var l int + _ = l + if m.WinnerPlayerId != nil { + n += 1 + sovPokerth(uint64(*m.WinnerPlayerId)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *PlayerIdChangedMessage) Size() (n int) { + var l int + _ = l + if m.OldPlayerId != nil { + n += 1 + sovPokerth(uint64(*m.OldPlayerId)) + } + if m.NewPlayerId != nil { + n += 1 + sovPokerth(uint64(*m.NewPlayerId)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *AskKickPlayerMessage) Size() (n int) { + var l int + _ = l + if m.PlayerId != nil { + n += 1 + sovPokerth(uint64(*m.PlayerId)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *AskKickDeniedMessage) Size() (n int) { + var l int + _ = l + if m.PlayerId != nil { + n += 1 + sovPokerth(uint64(*m.PlayerId)) + } + if m.KickDeniedReason != nil { + n += 1 + sovPokerth(uint64(*m.KickDeniedReason)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *StartKickPetitionMessage) Size() (n int) { + var l int + _ = l + if m.PetitionId != nil { + n += 1 + sovPokerth(uint64(*m.PetitionId)) + } + if m.ProposingPlayerId != nil { + n += 1 + sovPokerth(uint64(*m.ProposingPlayerId)) + } + if m.KickPlayerId != nil { + n += 1 + sovPokerth(uint64(*m.KickPlayerId)) + } + if m.KickTimeoutSec != nil { + n += 1 + sovPokerth(uint64(*m.KickTimeoutSec)) + } + if m.NumVotesNeededToKick != nil { + n += 1 + sovPokerth(uint64(*m.NumVotesNeededToKick)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *VoteKickRequestMessage) Size() (n int) { + var l int + _ = l + if m.PetitionId != nil { + n += 1 + sovPokerth(uint64(*m.PetitionId)) + } + if m.VoteKick != nil { + n += 2 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *VoteKickReplyMessage) Size() (n int) { + var l int + _ = l + if m.PetitionId != nil { + n += 1 + sovPokerth(uint64(*m.PetitionId)) + } + if m.VoteKickReplyType != nil { + n += 1 + sovPokerth(uint64(*m.VoteKickReplyType)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *KickPetitionUpdateMessage) Size() (n int) { + var l int + _ = l + if m.PetitionId != nil { + n += 1 + sovPokerth(uint64(*m.PetitionId)) + } + if m.NumVotesAgainstKicking != nil { + n += 1 + sovPokerth(uint64(*m.NumVotesAgainstKicking)) + } + if m.NumVotesInFavourOfKicking != nil { + n += 1 + sovPokerth(uint64(*m.NumVotesInFavourOfKicking)) + } + if m.NumVotesNeededToKick != nil { + n += 1 + sovPokerth(uint64(*m.NumVotesNeededToKick)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *EndKickPetitionMessage) Size() (n int) { + var l int + _ = l + if m.PetitionId != nil { + n += 1 + sovPokerth(uint64(*m.PetitionId)) + } + if m.NumVotesAgainstKicking != nil { + n += 1 + sovPokerth(uint64(*m.NumVotesAgainstKicking)) + } + if m.NumVotesInFavourOfKicking != nil { + n += 1 + sovPokerth(uint64(*m.NumVotesInFavourOfKicking)) + } + if m.ResultPlayerKicked != nil { + n += 1 + sovPokerth(uint64(*m.ResultPlayerKicked)) + } + if m.PetitionEndReason != nil { + n += 1 + sovPokerth(uint64(*m.PetitionEndReason)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *StatisticsMessage) Size() (n int) { + var l int + _ = l + if len(m.StatisticsData) > 0 { + for _, e := range m.StatisticsData { + l = e.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *StatisticsMessage_StatisticsData) Size() (n int) { + var l int + _ = l + if m.StatisticsType != nil { + n += 1 + sovPokerth(uint64(*m.StatisticsType)) + } + if m.StatisticsValue != nil { + n += 1 + sovPokerth(uint64(*m.StatisticsValue)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *ChatRequestMessage) Size() (n int) { + var l int + _ = l + if m.TargetPlayerId != nil { + n += 1 + sovPokerth(uint64(*m.TargetPlayerId)) + } + if m.ChatText != nil { + l = len(*m.ChatText) + n += 1 + l + sovPokerth(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *ChatMessage) Size() (n int) { + var l int + _ = l + if m.PlayerId != nil { + n += 1 + sovPokerth(uint64(*m.PlayerId)) + } + if m.ChatType != nil { + n += 1 + sovPokerth(uint64(*m.ChatType)) + } + if m.ChatText != nil { + l = len(*m.ChatText) + n += 1 + l + sovPokerth(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *ChatRejectMessage) Size() (n int) { + var l int + _ = l + if m.ChatText != nil { + l = len(*m.ChatText) + n += 1 + l + sovPokerth(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *DialogMessage) Size() (n int) { + var l int + _ = l + if m.NotificationText != nil { + l = len(*m.NotificationText) + n += 1 + l + sovPokerth(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *TimeoutWarningMessage) Size() (n int) { + var l int + _ = l + if m.TimeoutReason != nil { + n += 1 + sovPokerth(uint64(*m.TimeoutReason)) + } + if m.RemainingSeconds != nil { + n += 1 + sovPokerth(uint64(*m.RemainingSeconds)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *ResetTimeoutMessage) Size() (n int) { + var l int + _ = l + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *ReportAvatarMessage) Size() (n int) { + var l int + _ = l + if m.ReportedPlayerId != nil { + n += 1 + sovPokerth(uint64(*m.ReportedPlayerId)) + } + if m.ReportedAvatarHash != nil { + l = len(m.ReportedAvatarHash) + n += 1 + l + sovPokerth(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *ReportAvatarAckMessage) Size() (n int) { + var l int + _ = l + if m.ReportedPlayerId != nil { + n += 1 + sovPokerth(uint64(*m.ReportedPlayerId)) + } + if m.ReportAvatarResult != nil { + n += 1 + sovPokerth(uint64(*m.ReportAvatarResult)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *ReportGameMessage) Size() (n int) { + var l int + _ = l + if m.ReportedGameId != nil { + n += 1 + sovPokerth(uint64(*m.ReportedGameId)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *ReportGameAckMessage) Size() (n int) { + var l int + _ = l + if m.ReportedGameId != nil { + n += 1 + sovPokerth(uint64(*m.ReportedGameId)) + } + if m.ReportGameResult != nil { + n += 1 + sovPokerth(uint64(*m.ReportGameResult)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *ErrorMessage) Size() (n int) { + var l int + _ = l + if m.ErrorReason != nil { + n += 1 + sovPokerth(uint64(*m.ErrorReason)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *AdminRemoveGameMessage) Size() (n int) { + var l int + _ = l + if m.RemoveGameId != nil { + n += 1 + sovPokerth(uint64(*m.RemoveGameId)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *AdminRemoveGameAckMessage) Size() (n int) { + var l int + _ = l + if m.RemoveGameId != nil { + n += 1 + sovPokerth(uint64(*m.RemoveGameId)) + } + if m.RemoveGameResult != nil { + n += 1 + sovPokerth(uint64(*m.RemoveGameResult)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *AdminBanPlayerMessage) Size() (n int) { + var l int + _ = l + if m.BanPlayerId != nil { + n += 1 + sovPokerth(uint64(*m.BanPlayerId)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *AdminBanPlayerAckMessage) Size() (n int) { + var l int + _ = l + if m.BanPlayerId != nil { + n += 1 + sovPokerth(uint64(*m.BanPlayerId)) + } + if m.BanPlayerResult != nil { + n += 1 + sovPokerth(uint64(*m.BanPlayerResult)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *AuthMessage) Size() (n int) { + var l int + _ = l + if m.MessageType != nil { + n += 1 + sovPokerth(uint64(*m.MessageType)) + } + if m.AuthClientRequestMessage != nil { + l = m.AuthClientRequestMessage.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.AuthServerChallengeMessage != nil { + l = m.AuthServerChallengeMessage.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.AuthClientResponseMessage != nil { + l = m.AuthClientResponseMessage.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.AuthServerVerificationMessage != nil { + l = m.AuthServerVerificationMessage.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.ErrorMessage != nil { + l = m.ErrorMessage.Size() + n += 2 + l + sovPokerth(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *LobbyMessage) Size() (n int) { + var l int + _ = l + if m.MessageType != nil { + n += 1 + sovPokerth(uint64(*m.MessageType)) + } + if m.InitMessage != nil { + l = m.InitMessage.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.InitAckMessage != nil { + l = m.InitAckMessage.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.AvatarRequestMessage != nil { + l = m.AvatarRequestMessage.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.AvatarHeaderMessage != nil { + l = m.AvatarHeaderMessage.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.AvatarDataMessage != nil { + l = m.AvatarDataMessage.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.AvatarEndMessage != nil { + l = m.AvatarEndMessage.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.UnknownAvatarMessage != nil { + l = m.UnknownAvatarMessage.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.PlayerListMessage != nil { + l = m.PlayerListMessage.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.GameListNewMessage != nil { + l = m.GameListNewMessage.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.GameListUpdateMessage != nil { + l = m.GameListUpdateMessage.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.GameListPlayerJoinedMessage != nil { + l = m.GameListPlayerJoinedMessage.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.GameListPlayerLeftMessage != nil { + l = m.GameListPlayerLeftMessage.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.GameListSpectatorJoinedMessage != nil { + l = m.GameListSpectatorJoinedMessage.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.GameListSpectatorLeftMessage != nil { + l = m.GameListSpectatorLeftMessage.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.GameListAdminChangedMessage != nil { + l = m.GameListAdminChangedMessage.Size() + n += 2 + l + sovPokerth(uint64(l)) + } + if m.PlayerInfoRequestMessage != nil { + l = m.PlayerInfoRequestMessage.Size() + n += 2 + l + sovPokerth(uint64(l)) + } + if m.PlayerInfoReplyMessage != nil { + l = m.PlayerInfoReplyMessage.Size() + n += 2 + l + sovPokerth(uint64(l)) + } + if m.SubscriptionRequestMessage != nil { + l = m.SubscriptionRequestMessage.Size() + n += 2 + l + sovPokerth(uint64(l)) + } + if m.SubscriptionReplyMessage != nil { + l = m.SubscriptionReplyMessage.Size() + n += 2 + l + sovPokerth(uint64(l)) + } + if m.CreateGameMessage != nil { + l = m.CreateGameMessage.Size() + n += 2 + l + sovPokerth(uint64(l)) + } + if m.CreateGameFailedMessage != nil { + l = m.CreateGameFailedMessage.Size() + n += 2 + l + sovPokerth(uint64(l)) + } + if m.InvitePlayerToGameMessage != nil { + l = m.InvitePlayerToGameMessage.Size() + n += 2 + l + sovPokerth(uint64(l)) + } + if m.InviteNotifyMessage != nil { + l = m.InviteNotifyMessage.Size() + n += 2 + l + sovPokerth(uint64(l)) + } + if m.RejectGameInvitationMessage != nil { + l = m.RejectGameInvitationMessage.Size() + n += 2 + l + sovPokerth(uint64(l)) + } + if m.RejectInvNotifyMessage != nil { + l = m.RejectInvNotifyMessage.Size() + n += 2 + l + sovPokerth(uint64(l)) + } + if m.StatisticsMessage != nil { + l = m.StatisticsMessage.Size() + n += 2 + l + sovPokerth(uint64(l)) + } + if m.ChatRequestMessage != nil { + l = m.ChatRequestMessage.Size() + n += 2 + l + sovPokerth(uint64(l)) + } + if m.ChatMessage != nil { + l = m.ChatMessage.Size() + n += 2 + l + sovPokerth(uint64(l)) + } + if m.ChatRejectMessage != nil { + l = m.ChatRejectMessage.Size() + n += 2 + l + sovPokerth(uint64(l)) + } + if m.DialogMessage != nil { + l = m.DialogMessage.Size() + n += 2 + l + sovPokerth(uint64(l)) + } + if m.TimeoutWarningMessage != nil { + l = m.TimeoutWarningMessage.Size() + n += 2 + l + sovPokerth(uint64(l)) + } + if m.ResetTimeoutMessage != nil { + l = m.ResetTimeoutMessage.Size() + n += 2 + l + sovPokerth(uint64(l)) + } + if m.ReportAvatarMessage != nil { + l = m.ReportAvatarMessage.Size() + n += 2 + l + sovPokerth(uint64(l)) + } + if m.ReportAvatarAckMessage != nil { + l = m.ReportAvatarAckMessage.Size() + n += 2 + l + sovPokerth(uint64(l)) + } + if m.ReportGameMessage != nil { + l = m.ReportGameMessage.Size() + n += 2 + l + sovPokerth(uint64(l)) + } + if m.ReportGameAckMessage != nil { + l = m.ReportGameAckMessage.Size() + n += 2 + l + sovPokerth(uint64(l)) + } + if m.AdminRemoveGameMessage != nil { + l = m.AdminRemoveGameMessage.Size() + n += 2 + l + sovPokerth(uint64(l)) + } + if m.AdminRemoveGameAckMessage != nil { + l = m.AdminRemoveGameAckMessage.Size() + n += 2 + l + sovPokerth(uint64(l)) + } + if m.AdminBanPlayerMessage != nil { + l = m.AdminBanPlayerMessage.Size() + n += 2 + l + sovPokerth(uint64(l)) + } + if m.AdminBanPlayerAckMessage != nil { + l = m.AdminBanPlayerAckMessage.Size() + n += 2 + l + sovPokerth(uint64(l)) + } + if m.ErrorMessage != nil { + l = m.ErrorMessage.Size() + n += 2 + l + sovPokerth(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *GameManagementMessage) Size() (n int) { + var l int + _ = l + if m.MessageType != nil { + n += 1 + sovPokerth(uint64(*m.MessageType)) + } + if m.JoinGameMessage != nil { + l = m.JoinGameMessage.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.RejoinGameMessage != nil { + l = m.RejoinGameMessage.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.JoinGameAckMessage != nil { + l = m.JoinGameAckMessage.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.JoinGameFailedMessage != nil { + l = m.JoinGameFailedMessage.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.GamePlayerJoinedMessage != nil { + l = m.GamePlayerJoinedMessage.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.GamePlayerLeftMessage != nil { + l = m.GamePlayerLeftMessage.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.GameSpectatorJoinedMessage != nil { + l = m.GameSpectatorJoinedMessage.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.GameSpectatorLeftMessage != nil { + l = m.GameSpectatorLeftMessage.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.GameAdminChangedMessage != nil { + l = m.GameAdminChangedMessage.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.RemovedFromGameMessage != nil { + l = m.RemovedFromGameMessage.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.KickPlayerRequestMessage != nil { + l = m.KickPlayerRequestMessage.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.LeaveGameRequestMessage != nil { + l = m.LeaveGameRequestMessage.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.StartEventMessage != nil { + l = m.StartEventMessage.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.StartEventAckMessage != nil { + l = m.StartEventAckMessage.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.GameStartInitialMessage != nil { + l = m.GameStartInitialMessage.Size() + n += 2 + l + sovPokerth(uint64(l)) + } + if m.GameStartRejoinMessage != nil { + l = m.GameStartRejoinMessage.Size() + n += 2 + l + sovPokerth(uint64(l)) + } + if m.EndOfGameMessage != nil { + l = m.EndOfGameMessage.Size() + n += 2 + l + sovPokerth(uint64(l)) + } + if m.PlayerIdChangedMessage != nil { + l = m.PlayerIdChangedMessage.Size() + n += 2 + l + sovPokerth(uint64(l)) + } + if m.AskKickPlayerMessage != nil { + l = m.AskKickPlayerMessage.Size() + n += 2 + l + sovPokerth(uint64(l)) + } + if m.AskKickDeniedMessage != nil { + l = m.AskKickDeniedMessage.Size() + n += 2 + l + sovPokerth(uint64(l)) + } + if m.StartKickPetitionMessage != nil { + l = m.StartKickPetitionMessage.Size() + n += 2 + l + sovPokerth(uint64(l)) + } + if m.VoteKickRequestMessage != nil { + l = m.VoteKickRequestMessage.Size() + n += 2 + l + sovPokerth(uint64(l)) + } + if m.VoteKickReplyMessage != nil { + l = m.VoteKickReplyMessage.Size() + n += 2 + l + sovPokerth(uint64(l)) + } + if m.KickPetitionUpdateMessage != nil { + l = m.KickPetitionUpdateMessage.Size() + n += 2 + l + sovPokerth(uint64(l)) + } + if m.EndKickPetitionMessage != nil { + l = m.EndKickPetitionMessage.Size() + n += 2 + l + sovPokerth(uint64(l)) + } + if m.ChatRequestMessage != nil { + l = m.ChatRequestMessage.Size() + n += 2 + l + sovPokerth(uint64(l)) + } + if m.ChatMessage != nil { + l = m.ChatMessage.Size() + n += 2 + l + sovPokerth(uint64(l)) + } + if m.ChatRejectMessage != nil { + l = m.ChatRejectMessage.Size() + n += 2 + l + sovPokerth(uint64(l)) + } + if m.ErrorMessage != nil { + l = m.ErrorMessage.Size() + n += 2 + l + sovPokerth(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *GameEngineMessage) Size() (n int) { + var l int + _ = l + if m.MessageType != nil { + n += 1 + sovPokerth(uint64(*m.MessageType)) + } + if m.HandStartMessage != nil { + l = m.HandStartMessage.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.PlayersTurnMessage != nil { + l = m.PlayersTurnMessage.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.MyActionRequestMessage != nil { + l = m.MyActionRequestMessage.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.YourActionRejectedMessage != nil { + l = m.YourActionRejectedMessage.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.PlayersActionDoneMessage != nil { + l = m.PlayersActionDoneMessage.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.DealFlopCardsMessage != nil { + l = m.DealFlopCardsMessage.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.DealTurnCardMessage != nil { + l = m.DealTurnCardMessage.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.DealRiverCardMessage != nil { + l = m.DealRiverCardMessage.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.AllInShowCardsMessage != nil { + l = m.AllInShowCardsMessage.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.EndOfHandShowCardsMessage != nil { + l = m.EndOfHandShowCardsMessage.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.EndOfHandHideCardsMessage != nil { + l = m.EndOfHandHideCardsMessage.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.ShowMyCardsRequestMessage != nil { + l = m.ShowMyCardsRequestMessage.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.AfterHandShowCardsMessage != nil { + l = m.AfterHandShowCardsMessage.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *GameMessage) Size() (n int) { + var l int + _ = l + if m.MessageType != nil { + n += 1 + sovPokerth(uint64(*m.MessageType)) + } + if m.GameId != nil { + n += 1 + sovPokerth(uint64(*m.GameId)) + } + if m.GameManagementMessage != nil { + l = m.GameManagementMessage.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.GameEngineMessage != nil { + l = m.GameEngineMessage.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} +func (m *PokerTHMessage) Size() (n int) { + var l int + _ = l + if m.MessageType != nil { + n += 1 + sovPokerth(uint64(*m.MessageType)) + } + if m.AnnounceMessage != nil { + l = m.AnnounceMessage.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.AuthMessage != nil { + l = m.AuthMessage.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.LobbyMessage != nil { + l = m.LobbyMessage.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.GameMessage != nil { + l = m.GameMessage.Size() + n += 1 + l + sovPokerth(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func sovPokerth(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozPokerth(x uint64) (n int) { + return sovPokerth(uint64((x << 1) ^ uint64((int64(x) >> 63)))) + return sovPokerth(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *NetGameInfo) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NetGameInfo) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.GameName != nil { + data[i] = 0xa + i++ + i = encodeVarintPokerth(data, i, uint64(len(*m.GameName))) + i += copy(data[i:], *m.GameName) + } + if m.NetGameType != nil { + data[i] = 0x10 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.NetGameType)) + } + if m.MaxNumPlayers != nil { + data[i] = 0x18 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.MaxNumPlayers)) + } + if m.RaiseIntervalMode != nil { + data[i] = 0x20 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.RaiseIntervalMode)) + } + if m.RaiseEveryHands != nil { + data[i] = 0x28 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.RaiseEveryHands)) + } + if m.RaiseEveryMinutes != nil { + data[i] = 0x30 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.RaiseEveryMinutes)) + } + if m.EndRaiseMode != nil { + data[i] = 0x38 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.EndRaiseMode)) + } + if m.EndRaiseSmallBlindValue != nil { + data[i] = 0x40 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.EndRaiseSmallBlindValue)) + } + if m.ProposedGuiSpeed != nil { + data[i] = 0x48 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.ProposedGuiSpeed)) + } + if m.DelayBetweenHands != nil { + data[i] = 0x50 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.DelayBetweenHands)) + } + if m.PlayerActionTimeout != nil { + data[i] = 0x58 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.PlayerActionTimeout)) + } + if m.FirstSmallBlind != nil { + data[i] = 0x60 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.FirstSmallBlind)) + } + if m.StartMoney != nil { + data[i] = 0x68 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.StartMoney)) + } + if len(m.ManualBlinds) > 0 { + data2 := make([]byte, len(m.ManualBlinds)*10) + var j1 int + for _, num := range m.ManualBlinds { + for num >= 1<<7 { + data2[j1] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j1++ + } + data2[j1] = uint8(num) + j1++ + } + data[i] = 0x72 + i++ + i = encodeVarintPokerth(data, i, uint64(j1)) + i += copy(data[i:], data2[:j1]) + } + if m.AllowSpectators != nil { + data[i] = 0x78 + i++ + if *m.AllowSpectators { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *PlayerResult) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *PlayerResult) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.PlayerId != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.PlayerId)) + } + if m.ResultCard1 != nil { + data[i] = 0x10 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.ResultCard1)) + } + if m.ResultCard2 != nil { + data[i] = 0x18 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.ResultCard2)) + } + if len(m.BestHandPosition) > 0 { + data4 := make([]byte, len(m.BestHandPosition)*10) + var j3 int + for _, num := range m.BestHandPosition { + for num >= 1<<7 { + data4[j3] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j3++ + } + data4[j3] = uint8(num) + j3++ + } + data[i] = 0x22 + i++ + i = encodeVarintPokerth(data, i, uint64(j3)) + i += copy(data[i:], data4[:j3]) + } + if m.MoneyWon != nil { + data[i] = 0x28 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.MoneyWon)) + } + if m.PlayerMoney != nil { + data[i] = 0x30 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.PlayerMoney)) + } + if m.CardsValue != nil { + data[i] = 0x38 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.CardsValue)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *AnnounceMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AnnounceMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.ProtocolVersion != nil { + data[i] = 0xa + i++ + i = encodeVarintPokerth(data, i, uint64(m.ProtocolVersion.Size())) + n5, err := m.ProtocolVersion.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n5 + } + if m.LatestGameVersion != nil { + data[i] = 0x12 + i++ + i = encodeVarintPokerth(data, i, uint64(m.LatestGameVersion.Size())) + n6, err := m.LatestGameVersion.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n6 + } + if m.LatestBetaRevision != nil { + data[i] = 0x18 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.LatestBetaRevision)) + } + if m.ServerType != nil { + data[i] = 0x20 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.ServerType)) + } + if m.NumPlayersOnServer != nil { + data[i] = 0x28 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.NumPlayersOnServer)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *AnnounceMessage_Version) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AnnounceMessage_Version) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.MajorVersion != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.MajorVersion)) + } + if m.MinorVersion != nil { + data[i] = 0x10 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.MinorVersion)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *AuthClientRequestMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AuthClientRequestMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.RequestedVersion != nil { + data[i] = 0xa + i++ + i = encodeVarintPokerth(data, i, uint64(m.RequestedVersion.Size())) + n7, err := m.RequestedVersion.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n7 + } + if m.BuildId != nil { + data[i] = 0x10 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.BuildId)) + } + if m.Login != nil { + data[i] = 0x18 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.Login)) + } + if m.AuthServerPassword != nil { + data[i] = 0x22 + i++ + i = encodeVarintPokerth(data, i, uint64(len(*m.AuthServerPassword))) + i += copy(data[i:], *m.AuthServerPassword) + } + if m.NickName != nil { + data[i] = 0x2a + i++ + i = encodeVarintPokerth(data, i, uint64(len(*m.NickName))) + i += copy(data[i:], *m.NickName) + } + if m.ClientUserData != nil { + data[i] = 0x32 + i++ + i = encodeVarintPokerth(data, i, uint64(len(m.ClientUserData))) + i += copy(data[i:], m.ClientUserData) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *AuthServerChallengeMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AuthServerChallengeMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.ServerChallenge != nil { + data[i] = 0xa + i++ + i = encodeVarintPokerth(data, i, uint64(len(m.ServerChallenge))) + i += copy(data[i:], m.ServerChallenge) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *AuthClientResponseMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AuthClientResponseMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.ClientResponse != nil { + data[i] = 0xa + i++ + i = encodeVarintPokerth(data, i, uint64(len(m.ClientResponse))) + i += copy(data[i:], m.ClientResponse) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *AuthServerVerificationMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AuthServerVerificationMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.YourSessionId != nil { + data[i] = 0xa + i++ + i = encodeVarintPokerth(data, i, uint64(len(m.YourSessionId))) + i += copy(data[i:], m.YourSessionId) + } + if m.YourPlayerId != nil { + data[i] = 0x10 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.YourPlayerId)) + } + if m.ServerVerification != nil { + data[i] = 0x1a + i++ + i = encodeVarintPokerth(data, i, uint64(len(m.ServerVerification))) + i += copy(data[i:], m.ServerVerification) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *InitMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *InitMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.MyLastSessionId != nil { + data[i] = 0xa + i++ + i = encodeVarintPokerth(data, i, uint64(len(m.MyLastSessionId))) + i += copy(data[i:], m.MyLastSessionId) + } + if m.AvatarHash != nil { + data[i] = 0x12 + i++ + i = encodeVarintPokerth(data, i, uint64(len(m.AvatarHash))) + i += copy(data[i:], m.AvatarHash) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *InitAckMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *InitAckMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.YourAvatarHash != nil { + data[i] = 0x1a + i++ + i = encodeVarintPokerth(data, i, uint64(len(m.YourAvatarHash))) + i += copy(data[i:], m.YourAvatarHash) + } + if m.RejoinGameId != nil { + data[i] = 0x20 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.RejoinGameId)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *AvatarRequestMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AvatarRequestMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.RequestId != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.RequestId)) + } + if m.AvatarHash != nil { + data[i] = 0x12 + i++ + i = encodeVarintPokerth(data, i, uint64(len(m.AvatarHash))) + i += copy(data[i:], m.AvatarHash) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *AvatarHeaderMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AvatarHeaderMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.RequestId != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.RequestId)) + } + if m.AvatarType != nil { + data[i] = 0x10 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.AvatarType)) + } + if m.AvatarSize != nil { + data[i] = 0x18 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.AvatarSize)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *AvatarDataMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AvatarDataMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.RequestId != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.RequestId)) + } + if m.AvatarBlock != nil { + data[i] = 0x12 + i++ + i = encodeVarintPokerth(data, i, uint64(len(m.AvatarBlock))) + i += copy(data[i:], m.AvatarBlock) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *AvatarEndMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AvatarEndMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.RequestId != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.RequestId)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *UnknownAvatarMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *UnknownAvatarMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.RequestId != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.RequestId)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *PlayerListMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *PlayerListMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.PlayerId != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.PlayerId)) + } + if m.PlayerListNotification != nil { + data[i] = 0x10 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.PlayerListNotification)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *GameListNewMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *GameListNewMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.GameId != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.GameId)) + } + if m.GameMode != nil { + data[i] = 0x10 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.GameMode)) + } + if m.IsPrivate != nil { + data[i] = 0x18 + i++ + if *m.IsPrivate { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if len(m.PlayerIds) > 0 { + data9 := make([]byte, len(m.PlayerIds)*10) + var j8 int + for _, num := range m.PlayerIds { + for num >= 1<<7 { + data9[j8] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j8++ + } + data9[j8] = uint8(num) + j8++ + } + data[i] = 0x22 + i++ + i = encodeVarintPokerth(data, i, uint64(j8)) + i += copy(data[i:], data9[:j8]) + } + if m.AdminPlayerId != nil { + data[i] = 0x28 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.AdminPlayerId)) + } + if m.GameInfo != nil { + data[i] = 0x32 + i++ + i = encodeVarintPokerth(data, i, uint64(m.GameInfo.Size())) + n10, err := m.GameInfo.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n10 + } + if len(m.SpectatorIds) > 0 { + data12 := make([]byte, len(m.SpectatorIds)*10) + var j11 int + for _, num := range m.SpectatorIds { + for num >= 1<<7 { + data12[j11] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j11++ + } + data12[j11] = uint8(num) + j11++ + } + data[i] = 0x3a + i++ + i = encodeVarintPokerth(data, i, uint64(j11)) + i += copy(data[i:], data12[:j11]) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *GameListUpdateMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *GameListUpdateMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.GameId != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.GameId)) + } + if m.GameMode != nil { + data[i] = 0x10 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.GameMode)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *GameListPlayerJoinedMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *GameListPlayerJoinedMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.GameId != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.GameId)) + } + if m.PlayerId != nil { + data[i] = 0x10 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.PlayerId)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *GameListPlayerLeftMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *GameListPlayerLeftMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.GameId != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.GameId)) + } + if m.PlayerId != nil { + data[i] = 0x10 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.PlayerId)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *GameListSpectatorJoinedMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *GameListSpectatorJoinedMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.GameId != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.GameId)) + } + if m.PlayerId != nil { + data[i] = 0x10 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.PlayerId)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *GameListSpectatorLeftMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *GameListSpectatorLeftMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.GameId != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.GameId)) + } + if m.PlayerId != nil { + data[i] = 0x10 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.PlayerId)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *GameListAdminChangedMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *GameListAdminChangedMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.GameId != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.GameId)) + } + if m.NewAdminPlayerId != nil { + data[i] = 0x10 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.NewAdminPlayerId)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *PlayerInfoRequestMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *PlayerInfoRequestMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if len(m.PlayerId) > 0 { + data14 := make([]byte, len(m.PlayerId)*10) + var j13 int + for _, num := range m.PlayerId { + for num >= 1<<7 { + data14[j13] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j13++ + } + data14[j13] = uint8(num) + j13++ + } + data[i] = 0xa + i++ + i = encodeVarintPokerth(data, i, uint64(j13)) + i += copy(data[i:], data14[:j13]) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *PlayerInfoReplyMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *PlayerInfoReplyMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.PlayerId != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.PlayerId)) + } + if m.PlayerInfoData != nil { + data[i] = 0x12 + i++ + i = encodeVarintPokerth(data, i, uint64(m.PlayerInfoData.Size())) + n15, err := m.PlayerInfoData.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n15 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *PlayerInfoReplyMessage_PlayerInfoData) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *PlayerInfoReplyMessage_PlayerInfoData) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.PlayerName != nil { + data[i] = 0xa + i++ + i = encodeVarintPokerth(data, i, uint64(len(*m.PlayerName))) + i += copy(data[i:], *m.PlayerName) + } + if m.IsHuman != nil { + data[i] = 0x10 + i++ + if *m.IsHuman { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.PlayerRights != nil { + data[i] = 0x18 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.PlayerRights)) + } + if m.CountryCode != nil { + data[i] = 0x22 + i++ + i = encodeVarintPokerth(data, i, uint64(len(*m.CountryCode))) + i += copy(data[i:], *m.CountryCode) + } + if m.AvatarData != nil { + data[i] = 0x2a + i++ + i = encodeVarintPokerth(data, i, uint64(m.AvatarData.Size())) + n16, err := m.AvatarData.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n16 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *PlayerInfoReplyMessage_PlayerInfoData_AvatarData) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *PlayerInfoReplyMessage_PlayerInfoData_AvatarData) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.AvatarType != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.AvatarType)) + } + if m.AvatarHash != nil { + data[i] = 0x12 + i++ + i = encodeVarintPokerth(data, i, uint64(len(m.AvatarHash))) + i += copy(data[i:], m.AvatarHash) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *SubscriptionRequestMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *SubscriptionRequestMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.RequestId != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.RequestId)) + } + if m.SubscriptionAction != nil { + data[i] = 0x10 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.SubscriptionAction)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *SubscriptionReplyMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *SubscriptionReplyMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.RequestId != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.RequestId)) + } + if m.Ack != nil { + data[i] = 0x10 + i++ + if *m.Ack { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *CreateGameMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *CreateGameMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.RequestId != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.RequestId)) + } + if m.GameInfo != nil { + data[i] = 0x12 + i++ + i = encodeVarintPokerth(data, i, uint64(m.GameInfo.Size())) + n17, err := m.GameInfo.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n17 + } + if m.Password != nil { + data[i] = 0x1a + i++ + i = encodeVarintPokerth(data, i, uint64(len(*m.Password))) + i += copy(data[i:], *m.Password) + } + if m.AutoLeave != nil { + data[i] = 0x20 + i++ + if *m.AutoLeave { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *CreateGameFailedMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *CreateGameFailedMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.RequestId != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.RequestId)) + } + if m.CreateGameFailureReason != nil { + data[i] = 0x10 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.CreateGameFailureReason)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *JoinGameMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *JoinGameMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.Password != nil { + data[i] = 0xa + i++ + i = encodeVarintPokerth(data, i, uint64(len(*m.Password))) + i += copy(data[i:], *m.Password) + } + if m.AutoLeave != nil { + data[i] = 0x10 + i++ + if *m.AutoLeave { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.SpectateOnly != nil { + data[i] = 0x18 + i++ + if *m.SpectateOnly { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *RejoinGameMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *RejoinGameMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.AutoLeave != nil { + data[i] = 0x8 + i++ + if *m.AutoLeave { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *JoinGameAckMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *JoinGameAckMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.AreYouGameAdmin != nil { + data[i] = 0x8 + i++ + if *m.AreYouGameAdmin { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.GameInfo != nil { + data[i] = 0x12 + i++ + i = encodeVarintPokerth(data, i, uint64(m.GameInfo.Size())) + n18, err := m.GameInfo.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n18 + } + if m.SpectateOnly != nil { + data[i] = 0x18 + i++ + if *m.SpectateOnly { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *JoinGameFailedMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *JoinGameFailedMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.JoinGameFailureReason != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.JoinGameFailureReason)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *GamePlayerJoinedMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *GamePlayerJoinedMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.PlayerId != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.PlayerId)) + } + if m.IsGameAdmin != nil { + data[i] = 0x10 + i++ + if *m.IsGameAdmin { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *GamePlayerLeftMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *GamePlayerLeftMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.PlayerId != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.PlayerId)) + } + if m.GamePlayerLeftReason != nil { + data[i] = 0x10 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.GamePlayerLeftReason)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *GameSpectatorJoinedMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *GameSpectatorJoinedMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.PlayerId != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.PlayerId)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *GameSpectatorLeftMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *GameSpectatorLeftMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.PlayerId != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.PlayerId)) + } + if m.GameSpectatorLeftReason != nil { + data[i] = 0x10 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.GameSpectatorLeftReason)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *GameAdminChangedMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *GameAdminChangedMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.NewAdminPlayerId != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.NewAdminPlayerId)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *RemovedFromGameMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *RemovedFromGameMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.RemovedFromGameReason != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.RemovedFromGameReason)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *KickPlayerRequestMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *KickPlayerRequestMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.PlayerId != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.PlayerId)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *LeaveGameRequestMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *LeaveGameRequestMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *InvitePlayerToGameMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *InvitePlayerToGameMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.GameId != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.GameId)) + } + if m.PlayerId != nil { + data[i] = 0x10 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.PlayerId)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *InviteNotifyMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *InviteNotifyMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.GameId != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.GameId)) + } + if m.PlayerIdWho != nil { + data[i] = 0x10 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.PlayerIdWho)) + } + if m.PlayerIdByWhom != nil { + data[i] = 0x18 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.PlayerIdByWhom)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *RejectGameInvitationMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *RejectGameInvitationMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.GameId != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.GameId)) + } + if m.MyRejectReason != nil { + data[i] = 0x10 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.MyRejectReason)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *RejectInvNotifyMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *RejectInvNotifyMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.GameId != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.GameId)) + } + if m.PlayerId != nil { + data[i] = 0x10 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.PlayerId)) + } + if m.PlayerRejectReason != nil { + data[i] = 0x18 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.PlayerRejectReason)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *StartEventMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *StartEventMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.StartEventType != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.StartEventType)) + } + if m.FillWithComputerPlayers != nil { + data[i] = 0x10 + i++ + if *m.FillWithComputerPlayers { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *StartEventAckMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *StartEventAckMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *GameStartInitialMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *GameStartInitialMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.StartDealerPlayerId != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.StartDealerPlayerId)) + } + if len(m.PlayerSeats) > 0 { + data20 := make([]byte, len(m.PlayerSeats)*10) + var j19 int + for _, num := range m.PlayerSeats { + for num >= 1<<7 { + data20[j19] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j19++ + } + data20[j19] = uint8(num) + j19++ + } + data[i] = 0x12 + i++ + i = encodeVarintPokerth(data, i, uint64(j19)) + i += copy(data[i:], data20[:j19]) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *GameStartRejoinMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *GameStartRejoinMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.StartDealerPlayerId != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.StartDealerPlayerId)) + } + if m.HandNum != nil { + data[i] = 0x10 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.HandNum)) + } + if len(m.RejoinPlayerData) > 0 { + for _, msg := range m.RejoinPlayerData { + data[i] = 0x1a + i++ + i = encodeVarintPokerth(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *GameStartRejoinMessage_RejoinPlayerData) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *GameStartRejoinMessage_RejoinPlayerData) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.PlayerId != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.PlayerId)) + } + if m.PlayerMoney != nil { + data[i] = 0x10 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.PlayerMoney)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *HandStartMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *HandStartMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.PlainCards != nil { + data[i] = 0xa + i++ + i = encodeVarintPokerth(data, i, uint64(m.PlainCards.Size())) + n21, err := m.PlainCards.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n21 + } + if m.EncryptedCards != nil { + data[i] = 0x12 + i++ + i = encodeVarintPokerth(data, i, uint64(len(m.EncryptedCards))) + i += copy(data[i:], m.EncryptedCards) + } + if m.SmallBlind != nil { + data[i] = 0x18 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.SmallBlind)) + } + if len(m.SeatStates) > 0 { + for _, num := range m.SeatStates { + data[i] = 0x20 + i++ + for num >= 1<<7 { + data[i] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + i++ + } + data[i] = uint8(num) + i++ + } + } + if m.DealerPlayerId != nil { + data[i] = 0x28 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.DealerPlayerId)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *HandStartMessage_PlainCards) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *HandStartMessage_PlainCards) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.PlainCard1 != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.PlainCard1)) + } + if m.PlainCard2 != nil { + data[i] = 0x10 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.PlainCard2)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *PlayersTurnMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *PlayersTurnMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.PlayerId != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.PlayerId)) + } + if m.GameState != nil { + data[i] = 0x10 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.GameState)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *MyActionRequestMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *MyActionRequestMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.HandNum != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.HandNum)) + } + if m.GameState != nil { + data[i] = 0x10 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.GameState)) + } + if m.MyAction != nil { + data[i] = 0x18 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.MyAction)) + } + if m.MyRelativeBet != nil { + data[i] = 0x20 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.MyRelativeBet)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *YourActionRejectedMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *YourActionRejectedMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.GameState != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.GameState)) + } + if m.YourAction != nil { + data[i] = 0x10 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.YourAction)) + } + if m.YourRelativeBet != nil { + data[i] = 0x18 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.YourRelativeBet)) + } + if m.RejectionReason != nil { + data[i] = 0x20 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.RejectionReason)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *PlayersActionDoneMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *PlayersActionDoneMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.PlayerId != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.PlayerId)) + } + if m.GameState != nil { + data[i] = 0x10 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.GameState)) + } + if m.PlayerAction != nil { + data[i] = 0x18 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.PlayerAction)) + } + if m.TotalPlayerBet != nil { + data[i] = 0x20 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.TotalPlayerBet)) + } + if m.PlayerMoney != nil { + data[i] = 0x28 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.PlayerMoney)) + } + if m.HighestSet != nil { + data[i] = 0x30 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.HighestSet)) + } + if m.MinimumRaise != nil { + data[i] = 0x38 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.MinimumRaise)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *DealFlopCardsMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *DealFlopCardsMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.FlopCard1 != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.FlopCard1)) + } + if m.FlopCard2 != nil { + data[i] = 0x10 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.FlopCard2)) + } + if m.FlopCard3 != nil { + data[i] = 0x18 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.FlopCard3)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *DealTurnCardMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *DealTurnCardMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.TurnCard != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.TurnCard)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *DealRiverCardMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *DealRiverCardMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.RiverCard != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.RiverCard)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *AllInShowCardsMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AllInShowCardsMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if len(m.PlayersAllIn) > 0 { + for _, msg := range m.PlayersAllIn { + data[i] = 0xa + i++ + i = encodeVarintPokerth(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *AllInShowCardsMessage_PlayerAllIn) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AllInShowCardsMessage_PlayerAllIn) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.PlayerId != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.PlayerId)) + } + if m.AllInCard1 != nil { + data[i] = 0x10 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.AllInCard1)) + } + if m.AllInCard2 != nil { + data[i] = 0x18 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.AllInCard2)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *EndOfHandShowCardsMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *EndOfHandShowCardsMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if len(m.PlayerResults) > 0 { + for _, msg := range m.PlayerResults { + data[i] = 0xa + i++ + i = encodeVarintPokerth(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *EndOfHandHideCardsMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *EndOfHandHideCardsMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.PlayerId != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.PlayerId)) + } + if m.MoneyWon != nil { + data[i] = 0x10 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.MoneyWon)) + } + if m.PlayerMoney != nil { + data[i] = 0x18 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.PlayerMoney)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *ShowMyCardsRequestMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *ShowMyCardsRequestMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *AfterHandShowCardsMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AfterHandShowCardsMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.PlayerResult != nil { + data[i] = 0xa + i++ + i = encodeVarintPokerth(data, i, uint64(m.PlayerResult.Size())) + n22, err := m.PlayerResult.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n22 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *EndOfGameMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *EndOfGameMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.WinnerPlayerId != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.WinnerPlayerId)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *PlayerIdChangedMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *PlayerIdChangedMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.OldPlayerId != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.OldPlayerId)) + } + if m.NewPlayerId != nil { + data[i] = 0x10 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.NewPlayerId)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *AskKickPlayerMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AskKickPlayerMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.PlayerId != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.PlayerId)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *AskKickDeniedMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AskKickDeniedMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.PlayerId != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.PlayerId)) + } + if m.KickDeniedReason != nil { + data[i] = 0x10 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.KickDeniedReason)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *StartKickPetitionMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *StartKickPetitionMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.PetitionId != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.PetitionId)) + } + if m.ProposingPlayerId != nil { + data[i] = 0x10 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.ProposingPlayerId)) + } + if m.KickPlayerId != nil { + data[i] = 0x18 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.KickPlayerId)) + } + if m.KickTimeoutSec != nil { + data[i] = 0x20 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.KickTimeoutSec)) + } + if m.NumVotesNeededToKick != nil { + data[i] = 0x28 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.NumVotesNeededToKick)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *VoteKickRequestMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *VoteKickRequestMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.PetitionId != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.PetitionId)) + } + if m.VoteKick != nil { + data[i] = 0x10 + i++ + if *m.VoteKick { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *VoteKickReplyMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *VoteKickReplyMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.PetitionId != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.PetitionId)) + } + if m.VoteKickReplyType != nil { + data[i] = 0x10 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.VoteKickReplyType)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *KickPetitionUpdateMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *KickPetitionUpdateMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.PetitionId != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.PetitionId)) + } + if m.NumVotesAgainstKicking != nil { + data[i] = 0x10 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.NumVotesAgainstKicking)) + } + if m.NumVotesInFavourOfKicking != nil { + data[i] = 0x18 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.NumVotesInFavourOfKicking)) + } + if m.NumVotesNeededToKick != nil { + data[i] = 0x20 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.NumVotesNeededToKick)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *EndKickPetitionMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *EndKickPetitionMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.PetitionId != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.PetitionId)) + } + if m.NumVotesAgainstKicking != nil { + data[i] = 0x10 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.NumVotesAgainstKicking)) + } + if m.NumVotesInFavourOfKicking != nil { + data[i] = 0x18 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.NumVotesInFavourOfKicking)) + } + if m.ResultPlayerKicked != nil { + data[i] = 0x20 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.ResultPlayerKicked)) + } + if m.PetitionEndReason != nil { + data[i] = 0x28 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.PetitionEndReason)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *StatisticsMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *StatisticsMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if len(m.StatisticsData) > 0 { + for _, msg := range m.StatisticsData { + data[i] = 0xa + i++ + i = encodeVarintPokerth(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *StatisticsMessage_StatisticsData) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *StatisticsMessage_StatisticsData) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.StatisticsType != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.StatisticsType)) + } + if m.StatisticsValue != nil { + data[i] = 0x10 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.StatisticsValue)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *ChatRequestMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *ChatRequestMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.TargetPlayerId != nil { + data[i] = 0x10 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.TargetPlayerId)) + } + if m.ChatText != nil { + data[i] = 0x1a + i++ + i = encodeVarintPokerth(data, i, uint64(len(*m.ChatText))) + i += copy(data[i:], *m.ChatText) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *ChatMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *ChatMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.PlayerId != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.PlayerId)) + } + if m.ChatType != nil { + data[i] = 0x10 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.ChatType)) + } + if m.ChatText != nil { + data[i] = 0x1a + i++ + i = encodeVarintPokerth(data, i, uint64(len(*m.ChatText))) + i += copy(data[i:], *m.ChatText) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *ChatRejectMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *ChatRejectMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.ChatText != nil { + data[i] = 0xa + i++ + i = encodeVarintPokerth(data, i, uint64(len(*m.ChatText))) + i += copy(data[i:], *m.ChatText) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *DialogMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *DialogMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.NotificationText != nil { + data[i] = 0xa + i++ + i = encodeVarintPokerth(data, i, uint64(len(*m.NotificationText))) + i += copy(data[i:], *m.NotificationText) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *TimeoutWarningMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *TimeoutWarningMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.TimeoutReason != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.TimeoutReason)) + } + if m.RemainingSeconds != nil { + data[i] = 0x10 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.RemainingSeconds)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *ResetTimeoutMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *ResetTimeoutMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *ReportAvatarMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *ReportAvatarMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.ReportedPlayerId != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.ReportedPlayerId)) + } + if m.ReportedAvatarHash != nil { + data[i] = 0x12 + i++ + i = encodeVarintPokerth(data, i, uint64(len(m.ReportedAvatarHash))) + i += copy(data[i:], m.ReportedAvatarHash) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *ReportAvatarAckMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *ReportAvatarAckMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.ReportedPlayerId != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.ReportedPlayerId)) + } + if m.ReportAvatarResult != nil { + data[i] = 0x10 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.ReportAvatarResult)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *ReportGameMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *ReportGameMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.ReportedGameId != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.ReportedGameId)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *ReportGameAckMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *ReportGameAckMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.ReportedGameId != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.ReportedGameId)) + } + if m.ReportGameResult != nil { + data[i] = 0x10 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.ReportGameResult)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *ErrorMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *ErrorMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.ErrorReason != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.ErrorReason)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *AdminRemoveGameMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AdminRemoveGameMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.RemoveGameId != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.RemoveGameId)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *AdminRemoveGameAckMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AdminRemoveGameAckMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.RemoveGameId != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.RemoveGameId)) + } + if m.RemoveGameResult != nil { + data[i] = 0x10 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.RemoveGameResult)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *AdminBanPlayerMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AdminBanPlayerMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.BanPlayerId != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.BanPlayerId)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *AdminBanPlayerAckMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AdminBanPlayerAckMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.BanPlayerId != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.BanPlayerId)) + } + if m.BanPlayerResult != nil { + data[i] = 0x10 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.BanPlayerResult)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *AuthMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AuthMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.MessageType != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.MessageType)) + } + if m.AuthClientRequestMessage != nil { + data[i] = 0x12 + i++ + i = encodeVarintPokerth(data, i, uint64(m.AuthClientRequestMessage.Size())) + n23, err := m.AuthClientRequestMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n23 + } + if m.AuthServerChallengeMessage != nil { + data[i] = 0x1a + i++ + i = encodeVarintPokerth(data, i, uint64(m.AuthServerChallengeMessage.Size())) + n24, err := m.AuthServerChallengeMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n24 + } + if m.AuthClientResponseMessage != nil { + data[i] = 0x22 + i++ + i = encodeVarintPokerth(data, i, uint64(m.AuthClientResponseMessage.Size())) + n25, err := m.AuthClientResponseMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n25 + } + if m.AuthServerVerificationMessage != nil { + data[i] = 0x2a + i++ + i = encodeVarintPokerth(data, i, uint64(m.AuthServerVerificationMessage.Size())) + n26, err := m.AuthServerVerificationMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n26 + } + if m.ErrorMessage != nil { + data[i] = 0x8a + i++ + data[i] = 0x40 + i++ + i = encodeVarintPokerth(data, i, uint64(m.ErrorMessage.Size())) + n27, err := m.ErrorMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n27 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *LobbyMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *LobbyMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.MessageType != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.MessageType)) + } + if m.InitMessage != nil { + data[i] = 0x12 + i++ + i = encodeVarintPokerth(data, i, uint64(m.InitMessage.Size())) + n28, err := m.InitMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n28 + } + if m.InitAckMessage != nil { + data[i] = 0x1a + i++ + i = encodeVarintPokerth(data, i, uint64(m.InitAckMessage.Size())) + n29, err := m.InitAckMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n29 + } + if m.AvatarRequestMessage != nil { + data[i] = 0x22 + i++ + i = encodeVarintPokerth(data, i, uint64(m.AvatarRequestMessage.Size())) + n30, err := m.AvatarRequestMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n30 + } + if m.AvatarHeaderMessage != nil { + data[i] = 0x2a + i++ + i = encodeVarintPokerth(data, i, uint64(m.AvatarHeaderMessage.Size())) + n31, err := m.AvatarHeaderMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n31 + } + if m.AvatarDataMessage != nil { + data[i] = 0x32 + i++ + i = encodeVarintPokerth(data, i, uint64(m.AvatarDataMessage.Size())) + n32, err := m.AvatarDataMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n32 + } + if m.AvatarEndMessage != nil { + data[i] = 0x3a + i++ + i = encodeVarintPokerth(data, i, uint64(m.AvatarEndMessage.Size())) + n33, err := m.AvatarEndMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n33 + } + if m.UnknownAvatarMessage != nil { + data[i] = 0x42 + i++ + i = encodeVarintPokerth(data, i, uint64(m.UnknownAvatarMessage.Size())) + n34, err := m.UnknownAvatarMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n34 + } + if m.PlayerListMessage != nil { + data[i] = 0x4a + i++ + i = encodeVarintPokerth(data, i, uint64(m.PlayerListMessage.Size())) + n35, err := m.PlayerListMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n35 + } + if m.GameListNewMessage != nil { + data[i] = 0x52 + i++ + i = encodeVarintPokerth(data, i, uint64(m.GameListNewMessage.Size())) + n36, err := m.GameListNewMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n36 + } + if m.GameListUpdateMessage != nil { + data[i] = 0x5a + i++ + i = encodeVarintPokerth(data, i, uint64(m.GameListUpdateMessage.Size())) + n37, err := m.GameListUpdateMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n37 + } + if m.GameListPlayerJoinedMessage != nil { + data[i] = 0x62 + i++ + i = encodeVarintPokerth(data, i, uint64(m.GameListPlayerJoinedMessage.Size())) + n38, err := m.GameListPlayerJoinedMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n38 + } + if m.GameListPlayerLeftMessage != nil { + data[i] = 0x6a + i++ + i = encodeVarintPokerth(data, i, uint64(m.GameListPlayerLeftMessage.Size())) + n39, err := m.GameListPlayerLeftMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n39 + } + if m.GameListSpectatorJoinedMessage != nil { + data[i] = 0x72 + i++ + i = encodeVarintPokerth(data, i, uint64(m.GameListSpectatorJoinedMessage.Size())) + n40, err := m.GameListSpectatorJoinedMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n40 + } + if m.GameListSpectatorLeftMessage != nil { + data[i] = 0x7a + i++ + i = encodeVarintPokerth(data, i, uint64(m.GameListSpectatorLeftMessage.Size())) + n41, err := m.GameListSpectatorLeftMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n41 + } + if m.GameListAdminChangedMessage != nil { + data[i] = 0x82 + i++ + data[i] = 0x1 + i++ + i = encodeVarintPokerth(data, i, uint64(m.GameListAdminChangedMessage.Size())) + n42, err := m.GameListAdminChangedMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n42 + } + if m.PlayerInfoRequestMessage != nil { + data[i] = 0x8a + i++ + data[i] = 0x1 + i++ + i = encodeVarintPokerth(data, i, uint64(m.PlayerInfoRequestMessage.Size())) + n43, err := m.PlayerInfoRequestMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n43 + } + if m.PlayerInfoReplyMessage != nil { + data[i] = 0x92 + i++ + data[i] = 0x1 + i++ + i = encodeVarintPokerth(data, i, uint64(m.PlayerInfoReplyMessage.Size())) + n44, err := m.PlayerInfoReplyMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n44 + } + if m.SubscriptionRequestMessage != nil { + data[i] = 0x9a + i++ + data[i] = 0x1 + i++ + i = encodeVarintPokerth(data, i, uint64(m.SubscriptionRequestMessage.Size())) + n45, err := m.SubscriptionRequestMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n45 + } + if m.SubscriptionReplyMessage != nil { + data[i] = 0xa2 + i++ + data[i] = 0x1 + i++ + i = encodeVarintPokerth(data, i, uint64(m.SubscriptionReplyMessage.Size())) + n46, err := m.SubscriptionReplyMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n46 + } + if m.CreateGameMessage != nil { + data[i] = 0xaa + i++ + data[i] = 0x1 + i++ + i = encodeVarintPokerth(data, i, uint64(m.CreateGameMessage.Size())) + n47, err := m.CreateGameMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n47 + } + if m.CreateGameFailedMessage != nil { + data[i] = 0xb2 + i++ + data[i] = 0x1 + i++ + i = encodeVarintPokerth(data, i, uint64(m.CreateGameFailedMessage.Size())) + n48, err := m.CreateGameFailedMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n48 + } + if m.InvitePlayerToGameMessage != nil { + data[i] = 0xba + i++ + data[i] = 0x1 + i++ + i = encodeVarintPokerth(data, i, uint64(m.InvitePlayerToGameMessage.Size())) + n49, err := m.InvitePlayerToGameMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n49 + } + if m.InviteNotifyMessage != nil { + data[i] = 0xc2 + i++ + data[i] = 0x1 + i++ + i = encodeVarintPokerth(data, i, uint64(m.InviteNotifyMessage.Size())) + n50, err := m.InviteNotifyMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n50 + } + if m.RejectGameInvitationMessage != nil { + data[i] = 0xca + i++ + data[i] = 0x1 + i++ + i = encodeVarintPokerth(data, i, uint64(m.RejectGameInvitationMessage.Size())) + n51, err := m.RejectGameInvitationMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n51 + } + if m.RejectInvNotifyMessage != nil { + data[i] = 0xd2 + i++ + data[i] = 0x1 + i++ + i = encodeVarintPokerth(data, i, uint64(m.RejectInvNotifyMessage.Size())) + n52, err := m.RejectInvNotifyMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n52 + } + if m.StatisticsMessage != nil { + data[i] = 0xda + i++ + data[i] = 0x1 + i++ + i = encodeVarintPokerth(data, i, uint64(m.StatisticsMessage.Size())) + n53, err := m.StatisticsMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n53 + } + if m.ChatRequestMessage != nil { + data[i] = 0xe2 + i++ + data[i] = 0x1 + i++ + i = encodeVarintPokerth(data, i, uint64(m.ChatRequestMessage.Size())) + n54, err := m.ChatRequestMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n54 + } + if m.ChatMessage != nil { + data[i] = 0xea + i++ + data[i] = 0x1 + i++ + i = encodeVarintPokerth(data, i, uint64(m.ChatMessage.Size())) + n55, err := m.ChatMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n55 + } + if m.ChatRejectMessage != nil { + data[i] = 0xf2 + i++ + data[i] = 0x1 + i++ + i = encodeVarintPokerth(data, i, uint64(m.ChatRejectMessage.Size())) + n56, err := m.ChatRejectMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n56 + } + if m.DialogMessage != nil { + data[i] = 0xfa + i++ + data[i] = 0x1 + i++ + i = encodeVarintPokerth(data, i, uint64(m.DialogMessage.Size())) + n57, err := m.DialogMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n57 + } + if m.TimeoutWarningMessage != nil { + data[i] = 0x82 + i++ + data[i] = 0x2 + i++ + i = encodeVarintPokerth(data, i, uint64(m.TimeoutWarningMessage.Size())) + n58, err := m.TimeoutWarningMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n58 + } + if m.ResetTimeoutMessage != nil { + data[i] = 0x8a + i++ + data[i] = 0x2 + i++ + i = encodeVarintPokerth(data, i, uint64(m.ResetTimeoutMessage.Size())) + n59, err := m.ResetTimeoutMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n59 + } + if m.ReportAvatarMessage != nil { + data[i] = 0x92 + i++ + data[i] = 0x2 + i++ + i = encodeVarintPokerth(data, i, uint64(m.ReportAvatarMessage.Size())) + n60, err := m.ReportAvatarMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n60 + } + if m.ReportAvatarAckMessage != nil { + data[i] = 0x9a + i++ + data[i] = 0x2 + i++ + i = encodeVarintPokerth(data, i, uint64(m.ReportAvatarAckMessage.Size())) + n61, err := m.ReportAvatarAckMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n61 + } + if m.ReportGameMessage != nil { + data[i] = 0xa2 + i++ + data[i] = 0x2 + i++ + i = encodeVarintPokerth(data, i, uint64(m.ReportGameMessage.Size())) + n62, err := m.ReportGameMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n62 + } + if m.ReportGameAckMessage != nil { + data[i] = 0xaa + i++ + data[i] = 0x2 + i++ + i = encodeVarintPokerth(data, i, uint64(m.ReportGameAckMessage.Size())) + n63, err := m.ReportGameAckMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n63 + } + if m.AdminRemoveGameMessage != nil { + data[i] = 0xb2 + i++ + data[i] = 0x2 + i++ + i = encodeVarintPokerth(data, i, uint64(m.AdminRemoveGameMessage.Size())) + n64, err := m.AdminRemoveGameMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n64 + } + if m.AdminRemoveGameAckMessage != nil { + data[i] = 0xba + i++ + data[i] = 0x2 + i++ + i = encodeVarintPokerth(data, i, uint64(m.AdminRemoveGameAckMessage.Size())) + n65, err := m.AdminRemoveGameAckMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n65 + } + if m.AdminBanPlayerMessage != nil { + data[i] = 0xc2 + i++ + data[i] = 0x2 + i++ + i = encodeVarintPokerth(data, i, uint64(m.AdminBanPlayerMessage.Size())) + n66, err := m.AdminBanPlayerMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n66 + } + if m.AdminBanPlayerAckMessage != nil { + data[i] = 0xca + i++ + data[i] = 0x2 + i++ + i = encodeVarintPokerth(data, i, uint64(m.AdminBanPlayerAckMessage.Size())) + n67, err := m.AdminBanPlayerAckMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n67 + } + if m.ErrorMessage != nil { + data[i] = 0x8a + i++ + data[i] = 0x40 + i++ + i = encodeVarintPokerth(data, i, uint64(m.ErrorMessage.Size())) + n68, err := m.ErrorMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n68 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *GameManagementMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *GameManagementMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.MessageType != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.MessageType)) + } + if m.JoinGameMessage != nil { + data[i] = 0x12 + i++ + i = encodeVarintPokerth(data, i, uint64(m.JoinGameMessage.Size())) + n69, err := m.JoinGameMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n69 + } + if m.RejoinGameMessage != nil { + data[i] = 0x1a + i++ + i = encodeVarintPokerth(data, i, uint64(m.RejoinGameMessage.Size())) + n70, err := m.RejoinGameMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n70 + } + if m.JoinGameAckMessage != nil { + data[i] = 0x22 + i++ + i = encodeVarintPokerth(data, i, uint64(m.JoinGameAckMessage.Size())) + n71, err := m.JoinGameAckMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n71 + } + if m.JoinGameFailedMessage != nil { + data[i] = 0x2a + i++ + i = encodeVarintPokerth(data, i, uint64(m.JoinGameFailedMessage.Size())) + n72, err := m.JoinGameFailedMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n72 + } + if m.GamePlayerJoinedMessage != nil { + data[i] = 0x32 + i++ + i = encodeVarintPokerth(data, i, uint64(m.GamePlayerJoinedMessage.Size())) + n73, err := m.GamePlayerJoinedMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n73 + } + if m.GamePlayerLeftMessage != nil { + data[i] = 0x3a + i++ + i = encodeVarintPokerth(data, i, uint64(m.GamePlayerLeftMessage.Size())) + n74, err := m.GamePlayerLeftMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n74 + } + if m.GameSpectatorJoinedMessage != nil { + data[i] = 0x42 + i++ + i = encodeVarintPokerth(data, i, uint64(m.GameSpectatorJoinedMessage.Size())) + n75, err := m.GameSpectatorJoinedMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n75 + } + if m.GameSpectatorLeftMessage != nil { + data[i] = 0x4a + i++ + i = encodeVarintPokerth(data, i, uint64(m.GameSpectatorLeftMessage.Size())) + n76, err := m.GameSpectatorLeftMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n76 + } + if m.GameAdminChangedMessage != nil { + data[i] = 0x52 + i++ + i = encodeVarintPokerth(data, i, uint64(m.GameAdminChangedMessage.Size())) + n77, err := m.GameAdminChangedMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n77 + } + if m.RemovedFromGameMessage != nil { + data[i] = 0x5a + i++ + i = encodeVarintPokerth(data, i, uint64(m.RemovedFromGameMessage.Size())) + n78, err := m.RemovedFromGameMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n78 + } + if m.KickPlayerRequestMessage != nil { + data[i] = 0x62 + i++ + i = encodeVarintPokerth(data, i, uint64(m.KickPlayerRequestMessage.Size())) + n79, err := m.KickPlayerRequestMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n79 + } + if m.LeaveGameRequestMessage != nil { + data[i] = 0x6a + i++ + i = encodeVarintPokerth(data, i, uint64(m.LeaveGameRequestMessage.Size())) + n80, err := m.LeaveGameRequestMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n80 + } + if m.StartEventMessage != nil { + data[i] = 0x72 + i++ + i = encodeVarintPokerth(data, i, uint64(m.StartEventMessage.Size())) + n81, err := m.StartEventMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n81 + } + if m.StartEventAckMessage != nil { + data[i] = 0x7a + i++ + i = encodeVarintPokerth(data, i, uint64(m.StartEventAckMessage.Size())) + n82, err := m.StartEventAckMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n82 + } + if m.GameStartInitialMessage != nil { + data[i] = 0x82 + i++ + data[i] = 0x1 + i++ + i = encodeVarintPokerth(data, i, uint64(m.GameStartInitialMessage.Size())) + n83, err := m.GameStartInitialMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n83 + } + if m.GameStartRejoinMessage != nil { + data[i] = 0x8a + i++ + data[i] = 0x1 + i++ + i = encodeVarintPokerth(data, i, uint64(m.GameStartRejoinMessage.Size())) + n84, err := m.GameStartRejoinMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n84 + } + if m.EndOfGameMessage != nil { + data[i] = 0x92 + i++ + data[i] = 0x1 + i++ + i = encodeVarintPokerth(data, i, uint64(m.EndOfGameMessage.Size())) + n85, err := m.EndOfGameMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n85 + } + if m.PlayerIdChangedMessage != nil { + data[i] = 0x9a + i++ + data[i] = 0x1 + i++ + i = encodeVarintPokerth(data, i, uint64(m.PlayerIdChangedMessage.Size())) + n86, err := m.PlayerIdChangedMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n86 + } + if m.AskKickPlayerMessage != nil { + data[i] = 0xa2 + i++ + data[i] = 0x1 + i++ + i = encodeVarintPokerth(data, i, uint64(m.AskKickPlayerMessage.Size())) + n87, err := m.AskKickPlayerMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n87 + } + if m.AskKickDeniedMessage != nil { + data[i] = 0xaa + i++ + data[i] = 0x1 + i++ + i = encodeVarintPokerth(data, i, uint64(m.AskKickDeniedMessage.Size())) + n88, err := m.AskKickDeniedMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n88 + } + if m.StartKickPetitionMessage != nil { + data[i] = 0xb2 + i++ + data[i] = 0x1 + i++ + i = encodeVarintPokerth(data, i, uint64(m.StartKickPetitionMessage.Size())) + n89, err := m.StartKickPetitionMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n89 + } + if m.VoteKickRequestMessage != nil { + data[i] = 0xba + i++ + data[i] = 0x1 + i++ + i = encodeVarintPokerth(data, i, uint64(m.VoteKickRequestMessage.Size())) + n90, err := m.VoteKickRequestMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n90 + } + if m.VoteKickReplyMessage != nil { + data[i] = 0xc2 + i++ + data[i] = 0x1 + i++ + i = encodeVarintPokerth(data, i, uint64(m.VoteKickReplyMessage.Size())) + n91, err := m.VoteKickReplyMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n91 + } + if m.KickPetitionUpdateMessage != nil { + data[i] = 0xca + i++ + data[i] = 0x1 + i++ + i = encodeVarintPokerth(data, i, uint64(m.KickPetitionUpdateMessage.Size())) + n92, err := m.KickPetitionUpdateMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n92 + } + if m.EndKickPetitionMessage != nil { + data[i] = 0xd2 + i++ + data[i] = 0x1 + i++ + i = encodeVarintPokerth(data, i, uint64(m.EndKickPetitionMessage.Size())) + n93, err := m.EndKickPetitionMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n93 + } + if m.ChatRequestMessage != nil { + data[i] = 0xda + i++ + data[i] = 0x1 + i++ + i = encodeVarintPokerth(data, i, uint64(m.ChatRequestMessage.Size())) + n94, err := m.ChatRequestMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n94 + } + if m.ChatMessage != nil { + data[i] = 0xe2 + i++ + data[i] = 0x1 + i++ + i = encodeVarintPokerth(data, i, uint64(m.ChatMessage.Size())) + n95, err := m.ChatMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n95 + } + if m.ChatRejectMessage != nil { + data[i] = 0xea + i++ + data[i] = 0x1 + i++ + i = encodeVarintPokerth(data, i, uint64(m.ChatRejectMessage.Size())) + n96, err := m.ChatRejectMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n96 + } + if m.ErrorMessage != nil { + data[i] = 0x8a + i++ + data[i] = 0x40 + i++ + i = encodeVarintPokerth(data, i, uint64(m.ErrorMessage.Size())) + n97, err := m.ErrorMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n97 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *GameEngineMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *GameEngineMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.MessageType != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.MessageType)) + } + if m.HandStartMessage != nil { + data[i] = 0x12 + i++ + i = encodeVarintPokerth(data, i, uint64(m.HandStartMessage.Size())) + n98, err := m.HandStartMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n98 + } + if m.PlayersTurnMessage != nil { + data[i] = 0x1a + i++ + i = encodeVarintPokerth(data, i, uint64(m.PlayersTurnMessage.Size())) + n99, err := m.PlayersTurnMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n99 + } + if m.MyActionRequestMessage != nil { + data[i] = 0x22 + i++ + i = encodeVarintPokerth(data, i, uint64(m.MyActionRequestMessage.Size())) + n100, err := m.MyActionRequestMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n100 + } + if m.YourActionRejectedMessage != nil { + data[i] = 0x2a + i++ + i = encodeVarintPokerth(data, i, uint64(m.YourActionRejectedMessage.Size())) + n101, err := m.YourActionRejectedMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n101 + } + if m.PlayersActionDoneMessage != nil { + data[i] = 0x32 + i++ + i = encodeVarintPokerth(data, i, uint64(m.PlayersActionDoneMessage.Size())) + n102, err := m.PlayersActionDoneMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n102 + } + if m.DealFlopCardsMessage != nil { + data[i] = 0x3a + i++ + i = encodeVarintPokerth(data, i, uint64(m.DealFlopCardsMessage.Size())) + n103, err := m.DealFlopCardsMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n103 + } + if m.DealTurnCardMessage != nil { + data[i] = 0x42 + i++ + i = encodeVarintPokerth(data, i, uint64(m.DealTurnCardMessage.Size())) + n104, err := m.DealTurnCardMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n104 + } + if m.DealRiverCardMessage != nil { + data[i] = 0x4a + i++ + i = encodeVarintPokerth(data, i, uint64(m.DealRiverCardMessage.Size())) + n105, err := m.DealRiverCardMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n105 + } + if m.AllInShowCardsMessage != nil { + data[i] = 0x52 + i++ + i = encodeVarintPokerth(data, i, uint64(m.AllInShowCardsMessage.Size())) + n106, err := m.AllInShowCardsMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n106 + } + if m.EndOfHandShowCardsMessage != nil { + data[i] = 0x5a + i++ + i = encodeVarintPokerth(data, i, uint64(m.EndOfHandShowCardsMessage.Size())) + n107, err := m.EndOfHandShowCardsMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n107 + } + if m.EndOfHandHideCardsMessage != nil { + data[i] = 0x62 + i++ + i = encodeVarintPokerth(data, i, uint64(m.EndOfHandHideCardsMessage.Size())) + n108, err := m.EndOfHandHideCardsMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n108 + } + if m.ShowMyCardsRequestMessage != nil { + data[i] = 0x6a + i++ + i = encodeVarintPokerth(data, i, uint64(m.ShowMyCardsRequestMessage.Size())) + n109, err := m.ShowMyCardsRequestMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n109 + } + if m.AfterHandShowCardsMessage != nil { + data[i] = 0x72 + i++ + i = encodeVarintPokerth(data, i, uint64(m.AfterHandShowCardsMessage.Size())) + n110, err := m.AfterHandShowCardsMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n110 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *GameMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *GameMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.MessageType != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.MessageType)) + } + if m.GameId != nil { + data[i] = 0x10 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.GameId)) + } + if m.GameManagementMessage != nil { + data[i] = 0x1a + i++ + i = encodeVarintPokerth(data, i, uint64(m.GameManagementMessage.Size())) + n111, err := m.GameManagementMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n111 + } + if m.GameEngineMessage != nil { + data[i] = 0x22 + i++ + i = encodeVarintPokerth(data, i, uint64(m.GameEngineMessage.Size())) + n112, err := m.GameEngineMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n112 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func (m *PokerTHMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *PokerTHMessage) MarshalTo(data []byte) (n int, err error) { + var i int + _ = i + var l int + _ = l + if m.MessageType != nil { + data[i] = 0x8 + i++ + i = encodeVarintPokerth(data, i, uint64(*m.MessageType)) + } + if m.AnnounceMessage != nil { + data[i] = 0x12 + i++ + i = encodeVarintPokerth(data, i, uint64(m.AnnounceMessage.Size())) + n113, err := m.AnnounceMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n113 + } + if m.AuthMessage != nil { + data[i] = 0x1a + i++ + i = encodeVarintPokerth(data, i, uint64(m.AuthMessage.Size())) + n114, err := m.AuthMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n114 + } + if m.LobbyMessage != nil { + data[i] = 0x22 + i++ + i = encodeVarintPokerth(data, i, uint64(m.LobbyMessage.Size())) + n115, err := m.LobbyMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n115 + } + if m.GameMessage != nil { + data[i] = 0x2a + i++ + i = encodeVarintPokerth(data, i, uint64(m.GameMessage.Size())) + n116, err := m.GameMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n116 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} +func encodeFixed64Pokerth(data []byte, offset int, v uint64) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + data[offset+4] = uint8(v >> 32) + data[offset+5] = uint8(v >> 40) + data[offset+6] = uint8(v >> 48) + data[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32Pokerth(data []byte, offset int, v uint32) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintPokerth(data []byte, offset int, v uint64) int { + for v >= 1<<7 { + data[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + data[offset] = uint8(v) + return offset + 1 +} diff --git a/pokerth.proto b/pokerth.proto index bc880873..f0ec6860 100644 --- a/pokerth.proto +++ b/pokerth.proto @@ -1,6 +1,6 @@ /***************************************************************************** * PokerTH - The open source texas holdem engine * - * Copyright (C) 2006-2013 Felix Hammer, Florian Thauer, Lothar May * + * Copyright (C) 2006-2014 Felix Hammer, Florian Thauer, Lothar May * * * * This program is free software: you can redistribute it and/or modify * * it under the terms of the GNU Affero General Public License as * @@ -29,10 +29,16 @@ * as that of the covered work. * *****************************************************************************/ +import "src/third_party/gogoprotobuf/gogo.proto"; + option java_package = "de.pokerth.protocol"; option java_outer_classname = "ProtoBuf"; option optimize_for = LITE_RUNTIME; +option (gogoproto.marshaler_all) = true; +option (gogoproto.unmarshaler_all) = true; +option (gogoproto.sizer_all) = true; + // Enumerations used by several messages. enum NetGameMode { @@ -145,24 +151,21 @@ message AnnounceMessage { required uint32 numPlayersOnServer = 5; } -// buildId contains a constant build id (specific for Windows/Linux/Mac builds) -message InitMessage { +message AuthClientRequestMessage { required AnnounceMessage.Version requestedVersion = 1; + // buildId contains a constant build id (specific for Windows/Linux/Mac builds) required uint32 buildId = 2; - optional bytes myLastSessionId = 3; - optional string authServerPassword = 4; enum LoginType { guestLogin = 0; authenticatedLogin = 1; unauthenticatedLogin = 2; } - required LoginType login = 5; + required LoginType login = 3; + optional string authServerPassword = 4; // Only used for guest login or unauthenticated login. - optional string nickName = 6; + optional string nickName = 5; // Authenticated login data is according to SCRAM SHA-1 - optional bytes clientUserData = 7; - // Ignored for guest login. - optional bytes avatarHash = 8; + optional bytes clientUserData = 6; } message AuthServerChallengeMessage { @@ -174,12 +177,18 @@ message AuthClientResponseMessage { } message AuthServerVerificationMessage { - required bytes serverVerification = 1; + required bytes yourSessionId = 1; + required uint32 yourPlayerId = 2; + optional bytes serverVerification = 3; +} + +message InitMessage { + optional bytes myLastSessionId = 1; + // Ignored for guest login. + optional bytes avatarHash = 2; } message InitAckMessage { - required bytes yourSessionId = 1; - required uint32 yourPlayerId = 2; optional bytes yourAvatarHash = 3; optional uint32 rejoinGameId = 4; } @@ -277,95 +286,98 @@ message PlayerInfoReplyMessage { optional PlayerInfoData playerInfoData = 2; } -// The following request will not be confirmed by the server. It is used, -// optionally, to reduce server traffic. The server might ignore it. +// The following request is used optionally to reduce server traffic. message SubscriptionRequestMessage { + required uint32 requestId = 1; enum SubscriptionAction { unsubscribeGameList = 1; resubscribeGameList = 2; } - required SubscriptionAction subscriptionAction = 1; + required SubscriptionAction subscriptionAction = 2; } -message JoinExistingGameMessage { - required uint32 gameId = 1; - optional string password = 2; - optional bool autoLeave = 3 [default = false]; - optional bool spectateOnly = 4 [default = false]; +message SubscriptionReplyMessage { + required uint32 requestId = 1; + required bool ack = 2; } -message JoinNewGameMessage { - required NetGameInfo gameInfo = 1; - optional string password = 2; - optional bool autoLeave = 3; +message CreateGameMessage { + required uint32 requestId = 1; + required NetGameInfo gameInfo = 2; + optional string password = 3; + optional bool autoLeave = 4; } -message RejoinExistingGameMessage { - required uint32 gameId = 1; - optional bool autoLeave = 2; +message CreateGameFailedMessage { + required uint32 requestId = 1; + enum CreateGameFailureReason { + notAllowedAsGuest = 1; + gameNameInUse = 2; + badGameName = 3; + invalidSettings = 4; + } + required CreateGameFailureReason createGameFailureReason = 2; +} + +message JoinGameMessage { + optional string password = 1; + optional bool autoLeave = 2 [default = false]; + optional bool spectateOnly = 3 [default = false]; +} + +message RejoinGameMessage { + optional bool autoLeave = 1 [default = false]; } message JoinGameAckMessage { - required uint32 gameId = 1; - required bool areYouGameAdmin = 2; - required NetGameInfo gameInfo = 3; - optional bool spectateOnly = 4; + required bool areYouGameAdmin = 1; + required NetGameInfo gameInfo = 2; + optional bool spectateOnly = 3; } message JoinGameFailedMessage { - required uint32 gameId = 1; enum JoinGameFailureReason { invalidGame = 1; gameIsFull = 2; gameIsRunning = 3; invalidPassword = 4; - notAllowedAsGuest = 5; - notInvited = 6; - gameNameInUse = 7; - badGameName = 8; - invalidSettings = 9; - ipAddressBlocked = 10; - rejoinFailed = 11; - noSpectatorsAllowed = 12; + notInvited = 5; + ipAddressBlocked = 6; + rejoinFailed = 7; + noSpectatorsAllowed = 8; } - required JoinGameFailureReason joinGameFailureReason = 2; + required JoinGameFailureReason joinGameFailureReason = 1; } message GamePlayerJoinedMessage { - required uint32 gameId = 1; - required uint32 playerId = 2; - required bool isGameAdmin = 3; + required uint32 playerId = 1; + required bool isGameAdmin = 2; } message GamePlayerLeftMessage { - required uint32 gameId = 1; - required uint32 playerId = 2; + required uint32 playerId = 1; enum GamePlayerLeftReason { leftOnRequest = 0; leftKicked = 1; leftError = 2; } - required GamePlayerLeftReason gamePlayerLeftReason = 3; + required GamePlayerLeftReason gamePlayerLeftReason = 2; } message GameSpectatorJoinedMessage { - required uint32 gameId = 1; - required uint32 playerId = 2; + required uint32 playerId = 1; } message GameSpectatorLeftMessage { - required uint32 gameId = 1; - required uint32 playerId = 2; - required GamePlayerLeftMessage.GamePlayerLeftReason gameSpectatorLeftReason = 3; + required uint32 playerId = 1; + required GamePlayerLeftMessage.GamePlayerLeftReason gameSpectatorLeftReason = 2; } message GameAdminChangedMessage { - required uint32 gameId = 1; - required uint32 newAdminPlayerId = 2; + required uint32 newAdminPlayerId = 1; } message RemovedFromGameMessage { - required uint32 gameId = 1; enum RemovedFromGameReason { removedOnRequest = 0; // No error, client wished to leave. kickedFromGame = 1; @@ -375,16 +387,14 @@ message RemovedFromGameMessage { removedStartFailed = 5; gameClosed = 6; } - required RemovedFromGameReason removedFromGameReason = 2; + required RemovedFromGameReason removedFromGameReason = 1; } message KickPlayerRequestMessage { - required uint32 gameId = 1; - required uint32 playerId = 2; + required uint32 playerId = 1; } message LeaveGameRequestMessage { - required uint32 gameId = 1; } message InvitePlayerToGameMessage { @@ -414,124 +424,109 @@ message RejectInvNotifyMessage { } message StartEventMessage { - required uint32 gameId = 1; enum StartEventType { startEvent = 0; rejoinEvent = 1; } - required StartEventType startEventType = 2; - optional bool fillWithComputerPlayers = 3; + required StartEventType startEventType = 1; + optional bool fillWithComputerPlayers = 2; } message StartEventAckMessage { - required uint32 gameId = 1; } message GameStartInitialMessage { - required uint32 gameId = 1; - required uint32 startDealerPlayerId = 2; - repeated uint32 playerSeats = 3 [packed = true]; + required uint32 startDealerPlayerId = 1; + repeated uint32 playerSeats = 2 [packed = true]; } message GameStartRejoinMessage { - required uint32 gameId = 1; - required uint32 startDealerPlayerId = 2; - required uint32 handNum = 3; + required uint32 startDealerPlayerId = 1; + required uint32 handNum = 2; message RejoinPlayerData { required uint32 playerId = 1; required uint32 playerMoney = 2; } - repeated RejoinPlayerData rejoinPlayerData = 4; + repeated RejoinPlayerData rejoinPlayerData = 3; } message HandStartMessage { - required uint32 gameId = 1; message PlainCards { required uint32 plainCard1 = 1; required uint32 plainCard2 = 2; } - optional PlainCards plainCards = 2; - optional bytes encryptedCards = 3; - required uint32 smallBlind = 4; - repeated NetPlayerState seatStates = 5; - optional uint32 dealerPlayerId = 6; + optional PlainCards plainCards = 1; + optional bytes encryptedCards = 2; + required uint32 smallBlind = 3; + repeated NetPlayerState seatStates = 4; + optional uint32 dealerPlayerId = 5; } message PlayersTurnMessage { - required uint32 gameId = 1; - required uint32 playerId = 2; - required NetGameState gameState = 3; + required uint32 playerId = 1; + required NetGameState gameState = 2; } message MyActionRequestMessage { - required uint32 gameId = 1; - required uint32 handNum = 2; - required NetGameState gameState = 3; - required NetPlayerAction myAction = 4; - required uint32 myRelativeBet = 5; + required uint32 handNum = 1; + required NetGameState gameState = 2; + required NetPlayerAction myAction = 3; + required uint32 myRelativeBet = 4; } message YourActionRejectedMessage { - required uint32 gameId = 1; - required NetGameState gameState = 2; - required NetPlayerAction yourAction = 3; - required uint32 yourRelativeBet = 4; + required NetGameState gameState = 1; + required NetPlayerAction yourAction = 2; + required uint32 yourRelativeBet = 3; enum RejectionReason { rejectedInvalidGameState = 1; rejectedNotYourTurn = 2; rejectedActionNotAllowed = 3; } - required RejectionReason rejectionReason = 5; + required RejectionReason rejectionReason = 4; } message PlayersActionDoneMessage { - required uint32 gameId = 1; - required uint32 playerId = 2; - required NetGameState gameState = 3; - required NetPlayerAction playerAction = 4; - required uint32 totalPlayerBet = 5; - required uint32 playerMoney = 6; - required uint32 highestSet = 7; - required uint32 minimumRaise = 8; + required uint32 playerId = 1; + required NetGameState gameState = 2; + required NetPlayerAction playerAction = 3; + required uint32 totalPlayerBet = 4; + required uint32 playerMoney = 5; + required uint32 highestSet = 6; + required uint32 minimumRaise = 7; } message DealFlopCardsMessage { - required uint32 gameId = 1; - required uint32 flopCard1 = 2; - required uint32 flopCard2 = 3; - required uint32 flopCard3 = 4; + required uint32 flopCard1 = 1; + required uint32 flopCard2 = 2; + required uint32 flopCard3 = 3; } message DealTurnCardMessage { - required uint32 gameId = 1; - required uint32 turnCard = 2; + required uint32 turnCard = 1; } message DealRiverCardMessage { - required uint32 gameId = 1; - required uint32 riverCard = 2; + required uint32 riverCard = 1; } message AllInShowCardsMessage { - required uint32 gameId = 1; message PlayerAllIn { required uint32 playerId = 1; required uint32 allInCard1 = 2; required uint32 allInCard2 = 3; } - repeated PlayerAllIn playersAllIn = 2; + repeated PlayerAllIn playersAllIn = 1; } message EndOfHandShowCardsMessage { - required uint32 gameId = 1; - repeated PlayerResult playerResults = 2; + repeated PlayerResult playerResults = 1; } message EndOfHandHideCardsMessage { - required uint32 gameId = 1; - required uint32 playerId = 2; - required uint32 moneyWon = 3; - required uint32 playerMoney = 4; + required uint32 playerId = 1; + required uint32 moneyWon = 2; + required uint32 playerMoney = 3; } message ShowMyCardsRequestMessage { @@ -542,8 +537,7 @@ message AfterHandShowCardsMessage { } message EndOfGameMessage { - required uint32 gameId = 1; - required uint32 winnerPlayerId = 2; + required uint32 winnerPlayerId = 1; } message PlayerIdChangedMessage { @@ -552,13 +546,11 @@ message PlayerIdChangedMessage { } message AskKickPlayerMessage { - required uint32 gameId = 1; - required uint32 playerId = 2; + required uint32 playerId = 1; } message AskKickDeniedMessage { - required uint32 gameId = 1; - required uint32 playerId = 2; + required uint32 playerId = 1; enum KickDeniedReason { kickDeniedInvalidGameState = 0; kickDeniedNotPossible = 1; @@ -566,56 +558,51 @@ message AskKickDeniedMessage { kickDeniedAlreadyInProgress = 3; kickDeniedInvalidPlayerId = 4; } - required KickDeniedReason kickDeniedReason = 3; + required KickDeniedReason kickDeniedReason = 2; } message StartKickPetitionMessage { - required uint32 gameId = 1; - required uint32 petitionId = 2; - required uint32 proposingPlayerId = 3; - required uint32 kickPlayerId = 4; - required uint32 kickTimeoutSec = 5; - required uint32 numVotesNeededToKick = 6; + required uint32 petitionId = 1; + required uint32 proposingPlayerId = 2; + required uint32 kickPlayerId = 3; + required uint32 kickTimeoutSec = 4; + required uint32 numVotesNeededToKick = 5; } message VoteKickRequestMessage { - required uint32 gameId = 1; - required uint32 petitionId = 2; - required bool voteKick = 3; + required uint32 petitionId = 1; + required bool voteKick = 2; } message VoteKickReplyMessage { - required uint32 gameId = 1; - required uint32 petitionId = 2; + required uint32 petitionId = 1; enum VoteKickReplyType { voteKickAck = 0; voteKickDeniedInvalid = 1; voteKickDeniedAlreadyVoted = 2; } - required VoteKickReplyType voteKickReplyType = 3; + required VoteKickReplyType voteKickReplyType = 2; } message KickPetitionUpdateMessage { - required uint32 gameId = 1; - required uint32 petitionId = 2; - required uint32 numVotesAgainstKicking = 3; - required uint32 numVotesInFavourOfKicking = 4; - required uint32 numVotesNeededToKick = 5; + required uint32 petitionId = 1; + required uint32 numVotesAgainstKicking = 2; + required uint32 numVotesInFavourOfKicking = 3; + required uint32 numVotesNeededToKick = 4; } message EndKickPetitionMessage { - required uint32 gameId = 1; - required uint32 petitionId = 2; - required uint32 numVotesAgainstKicking = 3; - required uint32 numVotesInFavourOfKicking = 4; - required uint32 resultPlayerKicked = 5; + required uint32 petitionId = 1; + required uint32 numVotesAgainstKicking = 2; + required uint32 numVotesInFavourOfKicking = 3; + required uint32 resultPlayerKicked = 4; enum PetitionEndReason { petitionEndEnoughVotes = 0; petitionEndTooFewPlayers = 1; petitionEndPlayerLeft = 2; petitionEndTimeout = 3; } - required PetitionEndReason petitionEndReason = 6; + required PetitionEndReason petitionEndReason = 5; } message StatisticsMessage { @@ -630,23 +617,20 @@ message StatisticsMessage { } message ChatRequestMessage { - optional uint32 targetGameId = 1; optional uint32 targetPlayerId = 2; required string chatText = 3; } message ChatMessage { - optional uint32 gameId = 1; - optional uint32 playerId = 2; + optional uint32 playerId = 1; enum ChatType { - chatTypeLobby = 0; - chatTypeGame = 1; - chatTypeBot = 2; - chatTypeBroadcast = 3; - chatTypePrivate = 4; + chatTypeStandard = 0; + chatTypeBot = 1; + chatTypeBroadcast = 2; + chatTypePrivate = 3; } - required ChatType chatType = 3; - required string chatText = 4; + required ChatType chatType = 2; + required string chatText = 3; } message ChatRejectMessage { @@ -749,173 +733,234 @@ message AdminBanPlayerAckMessage { required AdminBanPlayerResult banPlayerResult = 2; } -// The main message type (it is prefixed by 4 bytes length of the message). +message AuthMessage { + enum AuthMessageType { + Type_AuthClientRequestMessage = 1; + Type_AuthServerChallengeMessage = 2; + Type_AuthClientResponseMessage = 3; + Type_AuthServerVerificationMessage = 4; + Type_ErrorMessage = 1024; + } + required AuthMessageType messageType = 1; + optional AuthClientRequestMessage authClientRequestMessage = 2; + optional AuthServerChallengeMessage authServerChallengeMessage = 3; + optional AuthClientResponseMessage authClientResponseMessage = 4; + optional AuthServerVerificationMessage authServerVerificationMessage = 5; + optional ErrorMessage errorMessage = 1025; +} + +message LobbyMessage { + enum LobbyMessageType { + Type_InitMessage = 1; + Type_InitAckMessage = 2; + Type_AvatarRequestMessage = 3; + Type_AvatarHeaderMessage = 4; + Type_AvatarDataMessage = 5; + Type_AvatarEndMessage = 6; + Type_UnknownAvatarMessage = 7; + Type_PlayerListMessage = 8; + Type_GameListNewMessage = 9; + Type_GameListUpdateMessage = 10; + Type_GameListPlayerJoinedMessage = 11; + Type_GameListPlayerLeftMessage = 12; + Type_GameListSpectatorJoinedMessage = 13; + Type_GameListSpectatorLeftMessage = 14; + Type_GameListAdminChangedMessage = 15; + Type_PlayerInfoRequestMessage = 16; + Type_PlayerInfoReplyMessage = 17; + Type_SubscriptionRequestMessage = 18; + Type_SubscriptionReplyMessage = 19; + Type_CreateGameMessage = 20; + Type_CreateGameFailedMessage = 21; + Type_InvitePlayerToGameMessage = 22; + Type_InviteNotifyMessage = 23; + Type_RejectGameInvitationMessage = 24; + Type_RejectInvNotifyMessage = 25; + Type_StatisticsMessage = 26; + Type_ChatRequestMessage = 27; + Type_ChatMessage = 28; + Type_ChatRejectMessage = 29; + Type_DialogMessage = 30; + Type_TimeoutWarningMessage = 31; + Type_ResetTimeoutMessage = 32; + Type_ReportAvatarMessage = 33; + Type_ReportAvatarAckMessage = 34; + Type_ReportGameMessage = 35; + Type_ReportGameAckMessage = 36; + Type_AdminRemoveGameMessage = 37; + Type_AdminRemoveGameAckMessage = 38; + Type_AdminBanPlayerMessage = 39; + Type_AdminBanPlayerAckMessage = 40; + Type_ErrorMessage = 1024; + } + required LobbyMessageType messageType = 1; + + optional InitMessage initMessage = 2; + optional InitAckMessage initAckMessage = 3; + optional AvatarRequestMessage avatarRequestMessage = 4; + optional AvatarHeaderMessage avatarHeaderMessage = 5; + optional AvatarDataMessage avatarDataMessage = 6; + optional AvatarEndMessage avatarEndMessage = 7; + optional UnknownAvatarMessage unknownAvatarMessage = 8; + optional PlayerListMessage playerListMessage = 9; + optional GameListNewMessage gameListNewMessage = 10; + optional GameListUpdateMessage gameListUpdateMessage = 11; + optional GameListPlayerJoinedMessage gameListPlayerJoinedMessage = 12; + optional GameListPlayerLeftMessage gameListPlayerLeftMessage = 13; + optional GameListSpectatorJoinedMessage gameListSpectatorJoinedMessage = 14; + optional GameListSpectatorLeftMessage gameListSpectatorLeftMessage = 15; + optional GameListAdminChangedMessage gameListAdminChangedMessage = 16; + optional PlayerInfoRequestMessage playerInfoRequestMessage = 17; + optional PlayerInfoReplyMessage playerInfoReplyMessage = 18; + optional SubscriptionRequestMessage subscriptionRequestMessage = 19; + optional SubscriptionReplyMessage subscriptionReplyMessage = 20; + optional CreateGameMessage createGameMessage = 21; + optional CreateGameFailedMessage createGameFailedMessage = 22; + optional InvitePlayerToGameMessage invitePlayerToGameMessage = 23; + optional InviteNotifyMessage inviteNotifyMessage = 24; + optional RejectGameInvitationMessage rejectGameInvitationMessage = 25; + optional RejectInvNotifyMessage rejectInvNotifyMessage = 26; + optional StatisticsMessage statisticsMessage = 27; + optional ChatRequestMessage chatRequestMessage = 28; + optional ChatMessage chatMessage = 29; + optional ChatRejectMessage chatRejectMessage = 30; + optional DialogMessage dialogMessage = 31; + optional TimeoutWarningMessage timeoutWarningMessage = 32; + optional ResetTimeoutMessage resetTimeoutMessage = 33; + optional ReportAvatarMessage reportAvatarMessage = 34; + optional ReportAvatarAckMessage reportAvatarAckMessage = 35; + optional ReportGameMessage reportGameMessage = 36; + optional ReportGameAckMessage reportGameAckMessage = 37; + optional AdminRemoveGameMessage adminRemoveGameMessage = 38; + optional AdminRemoveGameAckMessage adminRemoveGameAckMessage = 39; + optional AdminBanPlayerMessage adminBanPlayerMessage = 40; + optional AdminBanPlayerAckMessage adminBanPlayerAckMessage = 41; + optional ErrorMessage errorMessage = 1025; +} + +message GameManagementMessage { + enum GameManagementMessageType { + Type_JoinGameMessage = 1; + Type_RejoinGameMessage = 2; + Type_JoinGameAckMessage = 3; + Type_JoinGameFailedMessage = 4; + Type_GamePlayerJoinedMessage = 5; + Type_GamePlayerLeftMessage = 6; + Type_GameSpectatorJoinedMessage = 7; + Type_GameSpectatorLeftMessage = 8; + Type_GameAdminChangedMessage = 9; + Type_RemovedFromGameMessage = 10; + Type_KickPlayerRequestMessage = 11; + Type_LeaveGameRequestMessage = 12; + Type_StartEventMessage = 13; + Type_StartEventAckMessage = 14; + Type_GameStartInitialMessage = 15; + Type_GameStartRejoinMessage = 16; + Type_EndOfGameMessage = 17; + Type_PlayerIdChangedMessage = 18; + Type_AskKickPlayerMessage = 19; + Type_AskKickDeniedMessage = 20; + Type_StartKickPetitionMessage = 21; + Type_VoteKickRequestMessage = 22; + Type_VoteKickReplyMessage = 23; + Type_KickPetitionUpdateMessage = 24; + Type_EndKickPetitionMessage = 25; + Type_ChatRequestMessage = 26; + Type_ChatMessage = 27; + Type_ChatRejectMessage = 28; + Type_ErrorMessage = 1024; + } + required GameManagementMessageType messageType = 1; + + optional JoinGameMessage joinGameMessage = 2; + optional RejoinGameMessage rejoinGameMessage = 3; + optional JoinGameAckMessage joinGameAckMessage = 4; + optional JoinGameFailedMessage joinGameFailedMessage = 5; + optional GamePlayerJoinedMessage gamePlayerJoinedMessage = 6; + optional GamePlayerLeftMessage gamePlayerLeftMessage = 7; + optional GameSpectatorJoinedMessage gameSpectatorJoinedMessage = 8; + optional GameSpectatorLeftMessage gameSpectatorLeftMessage = 9; + optional GameAdminChangedMessage gameAdminChangedMessage = 10; + optional RemovedFromGameMessage removedFromGameMessage = 11; + optional KickPlayerRequestMessage kickPlayerRequestMessage = 12; + optional LeaveGameRequestMessage leaveGameRequestMessage = 13; + optional StartEventMessage startEventMessage = 14; + optional StartEventAckMessage startEventAckMessage = 15; + optional GameStartInitialMessage gameStartInitialMessage = 16; + optional GameStartRejoinMessage gameStartRejoinMessage = 17; + optional EndOfGameMessage endOfGameMessage = 18; + optional PlayerIdChangedMessage playerIdChangedMessage = 19; + optional AskKickPlayerMessage askKickPlayerMessage = 20; + optional AskKickDeniedMessage askKickDeniedMessage = 21; + optional StartKickPetitionMessage startKickPetitionMessage = 22; + optional VoteKickRequestMessage voteKickRequestMessage = 23; + optional VoteKickReplyMessage voteKickReplyMessage = 24; + optional KickPetitionUpdateMessage kickPetitionUpdateMessage = 25; + optional EndKickPetitionMessage endKickPetitionMessage = 26; + optional ChatRequestMessage chatRequestMessage = 27; + optional ChatMessage chatMessage = 28; + optional ChatRejectMessage chatRejectMessage = 29; + optional ErrorMessage errorMessage = 1025; +} + +message GameEngineMessage { + enum GameEngineMessageType { + Type_HandStartMessage = 1; + Type_PlayersTurnMessage = 2; + Type_MyActionRequestMessage = 3; + Type_YourActionRejectedMessage = 4; + Type_PlayersActionDoneMessage = 5; + Type_DealFlopCardsMessage = 6; + Type_DealTurnCardMessage = 7; + Type_DealRiverCardMessage = 8; + Type_AllInShowCardsMessage = 9; + Type_EndOfHandShowCardsMessage = 10; + Type_EndOfHandHideCardsMessage = 11; + Type_ShowMyCardsRequestMessage = 12; + Type_AfterHandShowCardsMessage = 13; + } + required GameEngineMessageType messageType = 1; + + optional HandStartMessage handStartMessage = 2; + optional PlayersTurnMessage playersTurnMessage = 3; + optional MyActionRequestMessage myActionRequestMessage = 4; + optional YourActionRejectedMessage yourActionRejectedMessage = 5; + optional PlayersActionDoneMessage playersActionDoneMessage = 6; + optional DealFlopCardsMessage dealFlopCardsMessage = 7; + optional DealTurnCardMessage dealTurnCardMessage = 8; + optional DealRiverCardMessage dealRiverCardMessage = 9; + optional AllInShowCardsMessage allInShowCardsMessage = 10; + optional EndOfHandShowCardsMessage endOfHandShowCardsMessage = 11; + optional EndOfHandHideCardsMessage endOfHandHideCardsMessage = 12; + optional ShowMyCardsRequestMessage showMyCardsRequestMessage = 13; + optional AfterHandShowCardsMessage afterHandShowCardsMessage = 14; +} + +message GameMessage { + enum GameMessageType { + Type_GameManagementMessage = 1; + Type_GameEngineMessage = 2; + } + required GameMessageType messageType = 1; + required uint32 gameId = 2; + + optional GameManagementMessage gameManagementMessage = 3; + optional GameEngineMessage gameEngineMessage = 4; +} + +// The main message type (with TCP, it is prefixed by 4 bytes length of the message). message PokerTHMessage { enum PokerTHMessageType { Type_AnnounceMessage = 1; - Type_InitMessage = 2; - Type_AuthServerChallengeMessage = 3; - Type_AuthClientResponseMessage = 4; - Type_AuthServerVerificationMessage = 5; - Type_InitAckMessage = 6; - Type_AvatarRequestMessage = 7; - Type_AvatarHeaderMessage = 8; - Type_AvatarDataMessage = 9; - Type_AvatarEndMessage = 10; - Type_UnknownAvatarMessage = 11; - Type_PlayerListMessage = 12; - Type_GameListNewMessage = 13; - Type_GameListUpdateMessage = 14; - Type_GameListPlayerJoinedMessage = 15; - Type_GameListPlayerLeftMessage = 16; - Type_GameListAdminChangedMessage = 17; - Type_PlayerInfoRequestMessage = 18; - Type_PlayerInfoReplyMessage = 19; - Type_SubscriptionRequestMessage = 20; - Type_JoinExistingGameMessage = 21; - Type_JoinNewGameMessage = 22; - Type_RejoinExistingGameMessage = 23; - Type_JoinGameAckMessage = 24; - Type_JoinGameFailedMessage = 25; - Type_GamePlayerJoinedMessage = 26; - Type_GamePlayerLeftMessage = 27; - Type_GameAdminChangedMessage = 28; - Type_RemovedFromGameMessage = 29; - Type_KickPlayerRequestMessage = 30; - Type_LeaveGameRequestMessage = 31; - Type_InvitePlayerToGameMessage = 32; - Type_InviteNotifyMessage = 33; - Type_RejectGameInvitationMessage = 34; - Type_RejectInvNotifyMessage = 35; - Type_StartEventMessage = 36; - Type_StartEventAckMessage = 37; - Type_GameStartInitialMessage = 38; - Type_GameStartRejoinMessage = 39; - Type_HandStartMessage = 40; - Type_PlayersTurnMessage = 41; - Type_MyActionRequestMessage = 42; - Type_YourActionRejectedMessage = 43; - Type_PlayersActionDoneMessage = 44; - Type_DealFlopCardsMessage = 45; - Type_DealTurnCardMessage = 46; - Type_DealRiverCardMessage = 47; - Type_AllInShowCardsMessage = 48; - Type_EndOfHandShowCardsMessage = 49; - Type_EndOfHandHideCardsMessage = 50; - Type_ShowMyCardsRequestMessage = 51; - Type_AfterHandShowCardsMessage = 52; - Type_EndOfGameMessage = 53; - Type_PlayerIdChangedMessage = 54; - Type_AskKickPlayerMessage = 55; - Type_AskKickDeniedMessage = 56; - Type_StartKickPetitionMessage = 57; - Type_VoteKickRequestMessage = 58; - Type_VoteKickReplyMessage = 59; - Type_KickPetitionUpdateMessage = 60; - Type_EndKickPetitionMessage = 61; - Type_StatisticsMessage = 62; - Type_ChatRequestMessage = 63; - Type_ChatMessage = 64; - Type_ChatRejectMessage = 65; - Type_DialogMessage = 66; - Type_TimeoutWarningMessage = 67; - Type_ResetTimeoutMessage = 68; - Type_ReportAvatarMessage = 69; - Type_ReportAvatarAckMessage = 70; - Type_ReportGameMessage = 71; - Type_ReportGameAckMessage = 72; - Type_ErrorMessage = 73; - Type_AdminRemoveGameMessage = 74; - Type_AdminRemoveGameAckMessage = 75; - Type_AdminBanPlayerMessage = 76; - Type_AdminBanPlayerAckMessage = 77; - Type_GameListSpectatorJoinedMessage = 78; - Type_GameListSpectatorLeftMessage = 79; - Type_GameSpectatorJoinedMessage = 80; - Type_GameSpectatorLeftMessage = 81; + Type_AuthMessage = 2; + Type_LobbyMessage = 3; + Type_GameMessage = 4; } required PokerTHMessageType messageType = 1; optional AnnounceMessage announceMessage = 2; - optional InitMessage initMessage = 3; - optional AuthServerChallengeMessage authServerChallengeMessage = 4; - optional AuthClientResponseMessage authClientResponseMessage = 5; - optional AuthServerVerificationMessage authServerVerificationMessage = 6; - optional InitAckMessage initAckMessage = 7; - optional AvatarRequestMessage avatarRequestMessage = 8; - optional AvatarHeaderMessage avatarHeaderMessage = 9; - optional AvatarDataMessage avatarDataMessage = 10; - optional AvatarEndMessage avatarEndMessage = 11; - optional UnknownAvatarMessage unknownAvatarMessage = 12; - optional PlayerListMessage playerListMessage = 13; - optional GameListNewMessage gameListNewMessage = 14; - optional GameListUpdateMessage gameListUpdateMessage = 15; - optional GameListPlayerJoinedMessage gameListPlayerJoinedMessage = 16; - optional GameListPlayerLeftMessage gameListPlayerLeftMessage = 17; - optional GameListAdminChangedMessage gameListAdminChangedMessage = 18; - optional PlayerInfoRequestMessage playerInfoRequestMessage = 19; - optional PlayerInfoReplyMessage playerInfoReplyMessage = 20; - optional SubscriptionRequestMessage subscriptionRequestMessage = 21; - optional JoinExistingGameMessage joinExistingGameMessage = 22; - optional JoinNewGameMessage joinNewGameMessage = 23; - optional RejoinExistingGameMessage rejoinExistingGameMessage = 24; - optional JoinGameAckMessage joinGameAckMessage = 25; - optional JoinGameFailedMessage joinGameFailedMessage = 26; - optional GamePlayerJoinedMessage gamePlayerJoinedMessage = 27; - optional GamePlayerLeftMessage gamePlayerLeftMessage = 28; - optional GameAdminChangedMessage gameAdminChangedMessage = 29; - optional RemovedFromGameMessage removedFromGameMessage = 30; - optional KickPlayerRequestMessage kickPlayerRequestMessage = 31; - optional LeaveGameRequestMessage leaveGameRequestMessage = 32; - optional InvitePlayerToGameMessage invitePlayerToGameMessage = 33; - optional InviteNotifyMessage inviteNotifyMessage = 34; - optional RejectGameInvitationMessage rejectGameInvitationMessage = 35; - optional RejectInvNotifyMessage rejectInvNotifyMessage = 36; - optional StartEventMessage startEventMessage = 37; - optional StartEventAckMessage startEventAckMessage = 38; - optional GameStartInitialMessage gameStartInitialMessage = 39; - optional GameStartRejoinMessage gameStartRejoinMessage = 40; - optional HandStartMessage handStartMessage = 41; - optional PlayersTurnMessage playersTurnMessage = 42; - optional MyActionRequestMessage myActionRequestMessage = 43; - optional YourActionRejectedMessage yourActionRejectedMessage = 44; - optional PlayersActionDoneMessage playersActionDoneMessage = 45; - optional DealFlopCardsMessage dealFlopCardsMessage = 46; - optional DealTurnCardMessage dealTurnCardMessage = 47; - optional DealRiverCardMessage dealRiverCardMessage = 48; - optional AllInShowCardsMessage allInShowCardsMessage = 49; - optional EndOfHandShowCardsMessage endOfHandShowCardsMessage = 50; - optional EndOfHandHideCardsMessage endOfHandHideCardsMessage = 51; - optional ShowMyCardsRequestMessage showMyCardsRequestMessage = 52; - optional AfterHandShowCardsMessage afterHandShowCardsMessage = 53; - optional EndOfGameMessage endOfGameMessage = 54; - optional PlayerIdChangedMessage playerIdChangedMessage = 55; - optional AskKickPlayerMessage askKickPlayerMessage = 56; - optional AskKickDeniedMessage askKickDeniedMessage = 57; - optional StartKickPetitionMessage startKickPetitionMessage = 58; - optional VoteKickRequestMessage voteKickRequestMessage = 59; - optional VoteKickReplyMessage voteKickReplyMessage = 60; - optional KickPetitionUpdateMessage kickPetitionUpdateMessage = 61; - optional EndKickPetitionMessage endKickPetitionMessage = 62; - optional StatisticsMessage statisticsMessage = 63; - optional ChatRequestMessage chatRequestMessage = 64; - optional ChatMessage chatMessage = 65; - optional ChatRejectMessage chatRejectMessage = 66; - optional DialogMessage dialogMessage = 67; - optional TimeoutWarningMessage timeoutWarningMessage = 68; - optional ResetTimeoutMessage resetTimeoutMessage = 69; - optional ReportAvatarMessage reportAvatarMessage = 70; - optional ReportAvatarAckMessage reportAvatarAckMessage = 71; - optional ReportGameMessage reportGameMessage = 72; - optional ReportGameAckMessage reportGameAckMessage = 73; - optional ErrorMessage errorMessage = 74; - optional AdminRemoveGameMessage adminRemoveGameMessage = 75; - optional AdminRemoveGameAckMessage adminRemoveGameAckMessage = 76; - optional AdminBanPlayerMessage adminBanPlayerMessage = 77; - optional AdminBanPlayerAckMessage adminBanPlayerAckMessage = 78; - optional GameListSpectatorJoinedMessage gameListSpectatorJoinedMessage = 79; - optional GameListSpectatorLeftMessage gameListSpectatorLeftMessage = 80; - optional GameSpectatorJoinedMessage gameSpectatorJoinedMessage = 81; - optional GameSpectatorLeftMessage gameSpectatorLeftMessage = 82; + optional AuthMessage authMessage = 3; + optional LobbyMessage lobbyMessage = 4; + optional GameMessage gameMessage = 5; } diff --git a/src/third_party/gogoprotobuf/descriptor.proto b/src/third_party/gogoprotobuf/descriptor.proto new file mode 100644 index 00000000..3d35c62d --- /dev/null +++ b/src/third_party/gogoprotobuf/descriptor.proto @@ -0,0 +1,622 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// http://code.google.com/p/protobuf/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Author: kenton@google.com (Kenton Varda) +// Based on original Protocol Buffers design by +// Sanjay Ghemawat, Jeff Dean, and others. +// +// The messages in this file describe the definitions found in .proto files. +// A valid .proto file can be translated directly to a FileDescriptorProto +// without any other information (e.g. without reading its imports). + + + +package google.protobuf; +option java_package = "com.google.protobuf"; +option java_outer_classname = "DescriptorProtos"; + +// descriptor.proto must be optimized for speed because reflection-based +// algorithms don't work during bootstrapping. +option optimize_for = SPEED; + +// The protocol compiler can output a FileDescriptorSet containing the .proto +// files it parses. +message FileDescriptorSet { + repeated FileDescriptorProto file = 1; +} + +// Describes a complete .proto file. +message FileDescriptorProto { + optional string name = 1; // file name, relative to root of source tree + optional string package = 2; // e.g. "foo", "foo.bar", etc. + + // Names of files imported by this file. + repeated string dependency = 3; + // Indexes of the public imported files in the dependency list above. + repeated int32 public_dependency = 10; + // Indexes of the weak imported files in the dependency list. + // For Google-internal migration only. Do not use. + repeated int32 weak_dependency = 11; + + // All top-level definitions in this file. + repeated DescriptorProto message_type = 4; + repeated EnumDescriptorProto enum_type = 5; + repeated ServiceDescriptorProto service = 6; + repeated FieldDescriptorProto extension = 7; + + optional FileOptions options = 8; + + // This field contains optional information about the original source code. + // You may safely remove this entire field whithout harming runtime + // functionality of the descriptors -- the information is needed only by + // development tools. + optional SourceCodeInfo source_code_info = 9; +} + +// Describes a message type. +message DescriptorProto { + optional string name = 1; + + repeated FieldDescriptorProto field = 2; + repeated FieldDescriptorProto extension = 6; + + repeated DescriptorProto nested_type = 3; + repeated EnumDescriptorProto enum_type = 4; + + message ExtensionRange { + optional int32 start = 1; + optional int32 end = 2; + } + repeated ExtensionRange extension_range = 5; + + optional MessageOptions options = 7; +} + +// Describes a field within a message. +message FieldDescriptorProto { + enum Type { + // 0 is reserved for errors. + // Order is weird for historical reasons. + TYPE_DOUBLE = 1; + TYPE_FLOAT = 2; + // Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT64 if + // negative values are likely. + TYPE_INT64 = 3; + TYPE_UINT64 = 4; + // Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT32 if + // negative values are likely. + TYPE_INT32 = 5; + TYPE_FIXED64 = 6; + TYPE_FIXED32 = 7; + TYPE_BOOL = 8; + TYPE_STRING = 9; + TYPE_GROUP = 10; // Tag-delimited aggregate. + TYPE_MESSAGE = 11; // Length-delimited aggregate. + + // New in version 2. + TYPE_BYTES = 12; + TYPE_UINT32 = 13; + TYPE_ENUM = 14; + TYPE_SFIXED32 = 15; + TYPE_SFIXED64 = 16; + TYPE_SINT32 = 17; // Uses ZigZag encoding. + TYPE_SINT64 = 18; // Uses ZigZag encoding. + }; + + enum Label { + // 0 is reserved for errors + LABEL_OPTIONAL = 1; + LABEL_REQUIRED = 2; + LABEL_REPEATED = 3; + // TODO(sanjay): Should we add LABEL_MAP? + }; + + optional string name = 1; + optional int32 number = 3; + optional Label label = 4; + + // If type_name is set, this need not be set. If both this and type_name + // are set, this must be either TYPE_ENUM or TYPE_MESSAGE. + optional Type type = 5; + + // For message and enum types, this is the name of the type. If the name + // starts with a '.', it is fully-qualified. Otherwise, C++-like scoping + // rules are used to find the type (i.e. first the nested types within this + // message are searched, then within the parent, on up to the root + // namespace). + optional string type_name = 6; + + // For extensions, this is the name of the type being extended. It is + // resolved in the same manner as type_name. + optional string extendee = 2; + + // For numeric types, contains the original text representation of the value. + // For booleans, "true" or "false". + // For strings, contains the default text contents (not escaped in any way). + // For bytes, contains the C escaped value. All bytes >= 128 are escaped. + // TODO(kenton): Base-64 encode? + optional string default_value = 7; + + optional FieldOptions options = 8; +} + +// Describes an enum type. +message EnumDescriptorProto { + optional string name = 1; + + repeated EnumValueDescriptorProto value = 2; + + optional EnumOptions options = 3; +} + +// Describes a value within an enum. +message EnumValueDescriptorProto { + optional string name = 1; + optional int32 number = 2; + + optional EnumValueOptions options = 3; +} + +// Describes a service. +message ServiceDescriptorProto { + optional string name = 1; + repeated MethodDescriptorProto method = 2; + + optional ServiceOptions options = 3; +} + +// Describes a method of a service. +message MethodDescriptorProto { + optional string name = 1; + + // Input and output type names. These are resolved in the same way as + // FieldDescriptorProto.type_name, but must refer to a message type. + optional string input_type = 2; + optional string output_type = 3; + + optional MethodOptions options = 4; +} + + +// =================================================================== +// Options + +// Each of the definitions above may have "options" attached. These are +// just annotations which may cause code to be generated slightly differently +// or may contain hints for code that manipulates protocol messages. +// +// Clients may define custom options as extensions of the *Options messages. +// These extensions may not yet be known at parsing time, so the parser cannot +// store the values in them. Instead it stores them in a field in the *Options +// message called uninterpreted_option. This field must have the same name +// across all *Options messages. We then use this field to populate the +// extensions when we build a descriptor, at which point all protos have been +// parsed and so all extensions are known. +// +// Extension numbers for custom options may be chosen as follows: +// * For options which will only be used within a single application or +// organization, or for experimental options, use field numbers 50000 +// through 99999. It is up to you to ensure that you do not use the +// same number for multiple options. +// * For options which will be published and used publicly by multiple +// independent entities, e-mail protobuf-global-extension-registry@google.com +// to reserve extension numbers. Simply provide your project name (e.g. +// Object-C plugin) and your porject website (if available) -- there's no need +// to explain how you intend to use them. Usually you only need one extension +// number. You can declare multiple options with only one extension number by +// putting them in a sub-message. See the Custom Options section of the docs +// for examples: +// http://code.google.com/apis/protocolbuffers/docs/proto.html#options +// If this turns out to be popular, a web service will be set up +// to automatically assign option numbers. + + +message FileOptions { + + // Sets the Java package where classes generated from this .proto will be + // placed. By default, the proto package is used, but this is often + // inappropriate because proto packages do not normally start with backwards + // domain names. + optional string java_package = 1; + + + // If set, all the classes from the .proto file are wrapped in a single + // outer class with the given name. This applies to both Proto1 + // (equivalent to the old "--one_java_file" option) and Proto2 (where + // a .proto always translates to a single class, but you may want to + // explicitly choose the class name). + optional string java_outer_classname = 8; + + // If set true, then the Java code generator will generate a separate .java + // file for each top-level message, enum, and service defined in the .proto + // file. Thus, these types will *not* be nested inside the outer class + // named by java_outer_classname. However, the outer class will still be + // generated to contain the file's getDescriptor() method as well as any + // top-level extensions defined in the file. + optional bool java_multiple_files = 10 [default=false]; + + // If set true, then the Java code generator will generate equals() and + // hashCode() methods for all messages defined in the .proto file. This is + // purely a speed optimization, as the AbstractMessage base class includes + // reflection-based implementations of these methods. + optional bool java_generate_equals_and_hash = 20 [default=false]; + + // Generated classes can be optimized for speed or code size. + enum OptimizeMode { + SPEED = 1; // Generate complete code for parsing, serialization, + // etc. + CODE_SIZE = 2; // Use ReflectionOps to implement these methods. + LITE_RUNTIME = 3; // Generate code using MessageLite and the lite runtime. + } + optional OptimizeMode optimize_for = 9 [default=SPEED]; + + // Sets the Go package where structs generated from this .proto will be + // placed. There is no default. + optional string go_package = 11; + + + + // Should generic services be generated in each language? "Generic" services + // are not specific to any particular RPC system. They are generated by the + // main code generators in each language (without additional plugins). + // Generic services were the only kind of service generation supported by + // early versions of proto2. + // + // Generic services are now considered deprecated in favor of using plugins + // that generate code specific to your particular RPC system. Therefore, + // these default to false. Old code which depends on generic services should + // explicitly set them to true. + optional bool cc_generic_services = 16 [default=false]; + optional bool java_generic_services = 17 [default=false]; + optional bool py_generic_services = 18 [default=false]; + + // The parser stores options it doesn't recognize here. See above. + repeated UninterpretedOption uninterpreted_option = 999; + + // Clients can define custom options in extensions of this message. See above. + extensions 1000 to max; +} + +message MessageOptions { + // Set true to use the old proto1 MessageSet wire format for extensions. + // This is provided for backwards-compatibility with the MessageSet wire + // format. You should not use this for any other reason: It's less + // efficient, has fewer features, and is more complicated. + // + // The message must be defined exactly as follows: + // message Foo { + // option message_set_wire_format = true; + // extensions 4 to max; + // } + // Note that the message cannot have any defined fields; MessageSets only + // have extensions. + // + // All extensions of your type must be singular messages; e.g. they cannot + // be int32s, enums, or repeated messages. + // + // Because this is an option, the above two restrictions are not enforced by + // the protocol compiler. + optional bool message_set_wire_format = 1 [default=false]; + + // Disables the generation of the standard "descriptor()" accessor, which can + // conflict with a field of the same name. This is meant to make migration + // from proto1 easier; new code should avoid fields named "descriptor". + optional bool no_standard_descriptor_accessor = 2 [default=false]; + + // The parser stores options it doesn't recognize here. See above. + repeated UninterpretedOption uninterpreted_option = 999; + + // Clients can define custom options in extensions of this message. See above. + extensions 1000 to max; +} + +message FieldOptions { + // The ctype option instructs the C++ code generator to use a different + // representation of the field than it normally would. See the specific + // options below. This option is not yet implemented in the open source + // release -- sorry, we'll try to include it in a future version! + optional CType ctype = 1 [default = STRING]; + enum CType { + // Default mode. + STRING = 0; + + CORD = 1; + + STRING_PIECE = 2; + } + // The packed option can be enabled for repeated primitive fields to enable + // a more efficient representation on the wire. Rather than repeatedly + // writing the tag and type for each element, the entire array is encoded as + // a single length-delimited blob. + optional bool packed = 2; + + + + // Should this field be parsed lazily? Lazy applies only to message-type + // fields. It means that when the outer message is initially parsed, the + // inner message's contents will not be parsed but instead stored in encoded + // form. The inner message will actually be parsed when it is first accessed. + // + // This is only a hint. Implementations are free to choose whether to use + // eager or lazy parsing regardless of the value of this option. However, + // setting this option true suggests that the protocol author believes that + // using lazy parsing on this field is worth the additional bookkeeping + // overhead typically needed to implement it. + // + // This option does not affect the public interface of any generated code; + // all method signatures remain the same. Furthermore, thread-safety of the + // interface is not affected by this option; const methods remain safe to + // call from multiple threads concurrently, while non-const methods continue + // to require exclusive access. + // + // + // Note that implementations may choose not to check required fields within + // a lazy sub-message. That is, calling IsInitialized() on the outher message + // may return true even if the inner message has missing required fields. + // This is necessary because otherwise the inner message would have to be + // parsed in order to perform the check, defeating the purpose of lazy + // parsing. An implementation which chooses not to check required fields + // must be consistent about it. That is, for any particular sub-message, the + // implementation must either *always* check its required fields, or *never* + // check its required fields, regardless of whether or not the message has + // been parsed. + optional bool lazy = 5 [default=false]; + + // Is this field deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for accessors, or it will be completely ignored; in the very least, this + // is a formalization for deprecating fields. + optional bool deprecated = 3 [default=false]; + + // EXPERIMENTAL. DO NOT USE. + // For "map" fields, the name of the field in the enclosed type that + // is the key for this map. For example, suppose we have: + // message Item { + // required string name = 1; + // required string value = 2; + // } + // message Config { + // repeated Item items = 1 [experimental_map_key="name"]; + // } + // In this situation, the map key for Item will be set to "name". + // TODO: Fully-implement this, then remove the "experimental_" prefix. + optional string experimental_map_key = 9; + + // For Google-internal migration only. Do not use. + optional bool weak = 10 [default=false]; + + optional string interpreted_customtype = 616; + + // The parser stores options it doesn't recognize here. See above. + repeated UninterpretedOption uninterpreted_option = 999; + + // Clients can define custom options in extensions of this message. See above. + extensions 1000 to max; +} + +message EnumOptions { + + // Set this option to false to disallow mapping different tag names to a same + // value. + optional bool allow_alias = 2 [default=true]; + + // The parser stores options it doesn't recognize here. See above. + repeated UninterpretedOption uninterpreted_option = 999; + + // Clients can define custom options in extensions of this message. See above. + extensions 1000 to max; +} + +message EnumValueOptions { + // The parser stores options it doesn't recognize here. See above. + repeated UninterpretedOption uninterpreted_option = 999; + + // Clients can define custom options in extensions of this message. See above. + extensions 1000 to max; +} + +message ServiceOptions { + + // Note: Field numbers 1 through 32 are reserved for Google's internal RPC + // framework. We apologize for hoarding these numbers to ourselves, but + // we were already using them long before we decided to release Protocol + // Buffers. + + // The parser stores options it doesn't recognize here. See above. + repeated UninterpretedOption uninterpreted_option = 999; + + // Clients can define custom options in extensions of this message. See above. + extensions 1000 to max; +} + +message MethodOptions { + + // Note: Field numbers 1 through 32 are reserved for Google's internal RPC + // framework. We apologize for hoarding these numbers to ourselves, but + // we were already using them long before we decided to release Protocol + // Buffers. + + // The parser stores options it doesn't recognize here. See above. + repeated UninterpretedOption uninterpreted_option = 999; + + // Clients can define custom options in extensions of this message. See above. + extensions 1000 to max; +} + + +// A message representing a option the parser does not recognize. This only +// appears in options protos created by the compiler::Parser class. +// DescriptorPool resolves these when building Descriptor objects. Therefore, +// options protos in descriptor objects (e.g. returned by Descriptor::options(), +// or produced by Descriptor::CopyTo()) will never have UninterpretedOptions +// in them. +message UninterpretedOption { + // The name of the uninterpreted option. Each string represents a segment in + // a dot-separated name. is_extension is true iff a segment represents an + // extension (denoted with parentheses in options specs in .proto files). + // E.g.,{ ["foo", false], ["bar.baz", true], ["qux", false] } represents + // "foo.(bar.baz).qux". + message NamePart { + required string name_part = 1; + required bool is_extension = 2; + } + repeated NamePart name = 2; + + // The value of the uninterpreted option, in whatever type the tokenizer + // identified it as during parsing. Exactly one of these should be set. + optional string identifier_value = 3; + optional uint64 positive_int_value = 4; + optional int64 negative_int_value = 5; + optional double double_value = 6; + optional bytes string_value = 7; + optional string aggregate_value = 8; +} + +// =================================================================== +// Optional source code info + +// Encapsulates information about the original source file from which a +// FileDescriptorProto was generated. +message SourceCodeInfo { + // A Location identifies a piece of source code in a .proto file which + // corresponds to a particular definition. This information is intended + // to be useful to IDEs, code indexers, documentation generators, and similar + // tools. + // + // For example, say we have a file like: + // message Foo { + // optional string foo = 1; + // } + // Let's look at just the field definition: + // optional string foo = 1; + // ^ ^^ ^^ ^ ^^^ + // a bc de f ghi + // We have the following locations: + // span path represents + // [a,i) [ 4, 0, 2, 0 ] The whole field definition. + // [a,b) [ 4, 0, 2, 0, 4 ] The label (optional). + // [c,d) [ 4, 0, 2, 0, 5 ] The type (string). + // [e,f) [ 4, 0, 2, 0, 1 ] The name (foo). + // [g,h) [ 4, 0, 2, 0, 3 ] The number (1). + // + // Notes: + // - A location may refer to a repeated field itself (i.e. not to any + // particular index within it). This is used whenever a set of elements are + // logically enclosed in a single code segment. For example, an entire + // extend block (possibly containing multiple extension definitions) will + // have an outer location whose path refers to the "extensions" repeated + // field without an index. + // - Multiple locations may have the same path. This happens when a single + // logical declaration is spread out across multiple places. The most + // obvious example is the "extend" block again -- there may be multiple + // extend blocks in the same scope, each of which will have the same path. + // - A location's span is not always a subset of its parent's span. For + // example, the "extendee" of an extension declaration appears at the + // beginning of the "extend" block and is shared by all extensions within + // the block. + // - Just because a location's span is a subset of some other location's span + // does not mean that it is a descendent. For example, a "group" defines + // both a type and a field in a single declaration. Thus, the locations + // corresponding to the type and field and their components will overlap. + // - Code which tries to interpret locations should probably be designed to + // ignore those that it doesn't understand, as more types of locations could + // be recorded in the future. + repeated Location location = 1; + message Location { + // Identifies which part of the FileDescriptorProto was defined at this + // location. + // + // Each element is a field number or an index. They form a path from + // the root FileDescriptorProto to the place where the definition. For + // example, this path: + // [ 4, 3, 2, 7, 1 ] + // refers to: + // file.message_type(3) // 4, 3 + // .field(7) // 2, 7 + // .name() // 1 + // This is because FileDescriptorProto.message_type has field number 4: + // repeated DescriptorProto message_type = 4; + // and DescriptorProto.field has field number 2: + // repeated FieldDescriptorProto field = 2; + // and FieldDescriptorProto.name has field number 1: + // optional string name = 1; + // + // Thus, the above path gives the location of a field name. If we removed + // the last element: + // [ 4, 3, 2, 7 ] + // this path refers to the whole field declaration (from the beginning + // of the label to the terminating semicolon). + repeated int32 path = 1 [packed=true]; + + // Always has exactly three or four elements: start line, start column, + // end line (optional, otherwise assumed same as start line), end column. + // These are packed into a single field for efficiency. Note that line + // and column numbers are zero-based -- typically you will want to add + // 1 to each before displaying to a user. + repeated int32 span = 2 [packed=true]; + + // If this SourceCodeInfo represents a complete declaration, these are any + // comments appearing before and after the declaration which appear to be + // attached to the declaration. + // + // A series of line comments appearing on consecutive lines, with no other + // tokens appearing on those lines, will be treated as a single comment. + // + // Only the comment content is provided; comment markers (e.g. //) are + // stripped out. For block comments, leading whitespace and an asterisk + // will be stripped from the beginning of each line other than the first. + // Newlines are included in the output. + // + // Examples: + // + // optional int32 foo = 1; // Comment attached to foo. + // // Comment attached to bar. + // optional int32 bar = 2; + // + // optional string baz = 3; + // // Comment attached to baz. + // // Another line attached to baz. + // + // // Comment attached to qux. + // // + // // Another line attached to qux. + // optional double qux = 4; + // + // optional string corge = 5; + // /* Block comment attached + // * to corge. Leading asterisks + // * will be removed. */ + // /* Block comment attached to + // * grault. */ + // optional int32 grault = 6; + optional string leading_comments = 3; + optional string trailing_comments = 4; + } +} diff --git a/src/third_party/gogoprotobuf/gogo.proto b/src/third_party/gogoprotobuf/gogo.proto new file mode 100644 index 00000000..a3ccb6e9 --- /dev/null +++ b/src/third_party/gogoprotobuf/gogo.proto @@ -0,0 +1,93 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://code.google.com/p/gogoprotobuf/gogoproto +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +package gogoproto; + +import "src/third_party/gogoprotobuf/descriptor.proto"; + +extend google.protobuf.EnumOptions { + optional bool goproto_enum_prefix = 62001; + optional bool goproto_enum_stringer = 62021; + optional bool enum_stringer = 62022; +} + +extend google.protobuf.FileOptions { + optional bool goproto_getters_all = 63001; + optional bool goproto_enum_prefix_all = 63002; + optional bool goproto_stringer_all = 63003; + optional bool verbose_equal_all = 63004; + optional bool face_all = 63005; + optional bool gostring_all = 63006; + optional bool populate_all = 63007; + optional bool stringer_all = 63008; + optional bool union_all = 63009; + + optional bool equal_all = 63013; + optional bool description_all = 63014; + optional bool testgen_all = 63015; + optional bool benchgen_all = 63016; + optional bool marshaler_all = 63017; + optional bool unmarshaler_all = 63018; + optional bool bufferto_all = 63019; + optional bool sizer_all = 63020; + + optional bool goproto_enum_stringer_all = 63021; + optional bool enum_stringer_all = 63022; + + optional bool unsafe_marshaler_all = 63023; + optional bool unsafe_unmarshaler_all = 63024; +} + +extend google.protobuf.MessageOptions { + optional bool goproto_getters = 64001; + optional bool goproto_stringer = 64003; + optional bool verbose_equal = 64004; + optional bool face = 64005; + optional bool gostring = 64006; + optional bool populate = 64007; + optional bool stringer = 67008; + optional bool union = 64009; + + optional bool equal = 64013; + optional bool description = 64014; + optional bool testgen = 64015; + optional bool benchgen = 64016; + optional bool marshaler = 64017; + optional bool unmarshaler = 64018; + optional bool bufferto = 64019; + optional bool sizer = 64020; + + optional bool unsafe_marshaler = 64023; + optional bool unsafe_unmarshaler = 64024; +} + +extend google.protobuf.FieldOptions { + optional bool nullable = 65001; + optional bool embed = 65002; + optional string customtype = 65003; + optional string customname = 65004; +} +