// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.11
// 	protoc        v7.34.1
// source: response.proto

package protocol

import (
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	reflect "reflect"
	sync "sync"
	unsafe "unsafe"
)

const (
	// Verify that this generated code is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
	// Verify that runtime/protoimpl is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)

// Piece color for gomoku stones.
type Piece int32

const (
	Piece_PIECE_UNSPECIFIED Piece = 0
	Piece_BLACK             Piece = 1
	Piece_WHITE             Piece = 2
)

// Enum value maps for Piece.
var (
	Piece_name = map[int32]string{
		0: "PIECE_UNSPECIFIED",
		1: "BLACK",
		2: "WHITE",
	}
	Piece_value = map[string]int32{
		"PIECE_UNSPECIFIED": 0,
		"BLACK":             1,
		"WHITE":             2,
	}
)

func (x Piece) Enum() *Piece {
	p := new(Piece)
	*p = x
	return p
}

func (x Piece) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (Piece) Descriptor() protoreflect.EnumDescriptor {
	return file_response_proto_enumTypes[0].Descriptor()
}

func (Piece) Type() protoreflect.EnumType {
	return &file_response_proto_enumTypes[0]
}

func (x Piece) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use Piece.Descriptor instead.
func (Piece) EnumDescriptor() ([]byte, []int) {
	return file_response_proto_rawDescGZIP(), []int{0}
}

// Outcome of a finished game.
type GameResult int32

const (
	GameResult_GAME_RESULT_UNSPECIFIED GameResult = 0
	GameResult_BLACK_WIN               GameResult = 1
	GameResult_WHITE_WIN               GameResult = 2
	GameResult_DRAW                    GameResult = 3
)

// Enum value maps for GameResult.
var (
	GameResult_name = map[int32]string{
		0: "GAME_RESULT_UNSPECIFIED",
		1: "BLACK_WIN",
		2: "WHITE_WIN",
		3: "DRAW",
	}
	GameResult_value = map[string]int32{
		"GAME_RESULT_UNSPECIFIED": 0,
		"BLACK_WIN":               1,
		"WHITE_WIN":               2,
		"DRAW":                    3,
	}
)

func (x GameResult) Enum() *GameResult {
	p := new(GameResult)
	*p = x
	return p
}

func (x GameResult) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (GameResult) Descriptor() protoreflect.EnumDescriptor {
	return file_response_proto_enumTypes[1].Descriptor()
}

func (GameResult) Type() protoreflect.EnumType {
	return &file_response_proto_enumTypes[1]
}

func (x GameResult) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use GameResult.Descriptor instead.
func (GameResult) EnumDescriptor() ([]byte, []int) {
	return file_response_proto_rawDescGZIP(), []int{1}
}

// Room mode: player-vs-player or player-vs-AI.
type RoomType int32

const (
	RoomType_ROOM_TYPE_UNSPECIFIED RoomType = 0
	RoomType_PVP                   RoomType = 1
	RoomType_PVE                   RoomType = 2
)

// Enum value maps for RoomType.
var (
	RoomType_name = map[int32]string{
		0: "ROOM_TYPE_UNSPECIFIED",
		1: "PVP",
		2: "PVE",
	}
	RoomType_value = map[string]int32{
		"ROOM_TYPE_UNSPECIFIED": 0,
		"PVP":                   1,
		"PVE":                   2,
	}
)

func (x RoomType) Enum() *RoomType {
	p := new(RoomType)
	*p = x
	return p
}

func (x RoomType) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (RoomType) Descriptor() protoreflect.EnumDescriptor {
	return file_response_proto_enumTypes[2].Descriptor()
}

func (RoomType) Type() protoreflect.EnumType {
	return &file_response_proto_enumTypes[2]
}

func (x RoomType) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use RoomType.Descriptor instead.
func (RoomType) EnumDescriptor() ([]byte, []int) {
	return file_response_proto_rawDescGZIP(), []int{2}
}

// Room lifecycle status.
type RoomStatus int32

const (
	RoomStatus_ROOM_STATUS_UNSPECIFIED RoomStatus = 0
	RoomStatus_WAITING                 RoomStatus = 1
	RoomStatus_PLAYING                 RoomStatus = 2
	RoomStatus_FINISHED                RoomStatus = 3
)

// Enum value maps for RoomStatus.
var (
	RoomStatus_name = map[int32]string{
		0: "ROOM_STATUS_UNSPECIFIED",
		1: "WAITING",
		2: "PLAYING",
		3: "FINISHED",
	}
	RoomStatus_value = map[string]int32{
		"ROOM_STATUS_UNSPECIFIED": 0,
		"WAITING":                 1,
		"PLAYING":                 2,
		"FINISHED":                3,
	}
)

func (x RoomStatus) Enum() *RoomStatus {
	p := new(RoomStatus)
	*p = x
	return p
}

func (x RoomStatus) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (RoomStatus) Descriptor() protoreflect.EnumDescriptor {
	return file_response_proto_enumTypes[3].Descriptor()
}

func (RoomStatus) Type() protoreflect.EnumType {
	return &file_response_proto_enumTypes[3]
}

func (x RoomStatus) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use RoomStatus.Descriptor instead.
func (RoomStatus) EnumDescriptor() ([]byte, []int) {
	return file_response_proto_rawDescGZIP(), []int{3}
}

// Wrapper for all server -> client messages. The oneof case IS the event code.
type Response struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Payload:
	//
	//	*Response_ClientConnect
	//	*Response_NicknameSet
	//	*Response_ShowOptions
	//	*Response_ShowRooms
	//	*Response_RoomCreateSuccess
	//	*Response_RoomJoinSuccess
	//	*Response_RoomJoinFailFull
	//	*Response_RoomJoinFailNotFound
	//	*Response_RoomPlayFailNotFound
	//	*Response_GameStarting
	//	*Response_GameMoveSuccess
	//	*Response_GameMoveInvalid
	//	*Response_GameMoveOccupied
	//	*Response_GameMoveOutOfBounds
	//	*Response_GameMoveNotYourTurn
	//	*Response_GameOver
	//	*Response_PveDifficultyNotSupport
	//	*Response_WatchGameSuccess
	//	*Response_ClientExit
	//	*Response_SpectatorCannotAct
	Payload       isResponse_Payload `protobuf_oneof:"payload"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Response) Reset() {
	*x = Response{}
	mi := &file_response_proto_msgTypes[0]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Response) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Response) ProtoMessage() {}

func (x *Response) ProtoReflect() protoreflect.Message {
	mi := &file_response_proto_msgTypes[0]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Response.ProtoReflect.Descriptor instead.
func (*Response) Descriptor() ([]byte, []int) {
	return file_response_proto_rawDescGZIP(), []int{0}
}

func (x *Response) GetPayload() isResponse_Payload {
	if x != nil {
		return x.Payload
	}
	return nil
}

func (x *Response) GetClientConnect() *ClientConnectResponse {
	if x != nil {
		if x, ok := x.Payload.(*Response_ClientConnect); ok {
			return x.ClientConnect
		}
	}
	return nil
}

func (x *Response) GetNicknameSet() *NicknameSetResponse {
	if x != nil {
		if x, ok := x.Payload.(*Response_NicknameSet); ok {
			return x.NicknameSet
		}
	}
	return nil
}

func (x *Response) GetShowOptions() *ShowOptionsResponse {
	if x != nil {
		if x, ok := x.Payload.(*Response_ShowOptions); ok {
			return x.ShowOptions
		}
	}
	return nil
}

func (x *Response) GetShowRooms() *ShowRoomsResponse {
	if x != nil {
		if x, ok := x.Payload.(*Response_ShowRooms); ok {
			return x.ShowRooms
		}
	}
	return nil
}

func (x *Response) GetRoomCreateSuccess() *RoomCreateSuccessResponse {
	if x != nil {
		if x, ok := x.Payload.(*Response_RoomCreateSuccess); ok {
			return x.RoomCreateSuccess
		}
	}
	return nil
}

func (x *Response) GetRoomJoinSuccess() *RoomJoinSuccessResponse {
	if x != nil {
		if x, ok := x.Payload.(*Response_RoomJoinSuccess); ok {
			return x.RoomJoinSuccess
		}
	}
	return nil
}

func (x *Response) GetRoomJoinFailFull() *RoomJoinFailFullResponse {
	if x != nil {
		if x, ok := x.Payload.(*Response_RoomJoinFailFull); ok {
			return x.RoomJoinFailFull
		}
	}
	return nil
}

func (x *Response) GetRoomJoinFailNotFound() *RoomJoinFailNotFoundResponse {
	if x != nil {
		if x, ok := x.Payload.(*Response_RoomJoinFailNotFound); ok {
			return x.RoomJoinFailNotFound
		}
	}
	return nil
}

func (x *Response) GetRoomPlayFailNotFound() *RoomPlayFailNotFoundResponse {
	if x != nil {
		if x, ok := x.Payload.(*Response_RoomPlayFailNotFound); ok {
			return x.RoomPlayFailNotFound
		}
	}
	return nil
}

func (x *Response) GetGameStarting() *GameStartingResponse {
	if x != nil {
		if x, ok := x.Payload.(*Response_GameStarting); ok {
			return x.GameStarting
		}
	}
	return nil
}

func (x *Response) GetGameMoveSuccess() *GameMoveSuccessResponse {
	if x != nil {
		if x, ok := x.Payload.(*Response_GameMoveSuccess); ok {
			return x.GameMoveSuccess
		}
	}
	return nil
}

func (x *Response) GetGameMoveInvalid() *GameMoveInvalidResponse {
	if x != nil {
		if x, ok := x.Payload.(*Response_GameMoveInvalid); ok {
			return x.GameMoveInvalid
		}
	}
	return nil
}

func (x *Response) GetGameMoveOccupied() *GameMoveOccupiedResponse {
	if x != nil {
		if x, ok := x.Payload.(*Response_GameMoveOccupied); ok {
			return x.GameMoveOccupied
		}
	}
	return nil
}

func (x *Response) GetGameMoveOutOfBounds() *GameMoveOutOfBoundsResponse {
	if x != nil {
		if x, ok := x.Payload.(*Response_GameMoveOutOfBounds); ok {
			return x.GameMoveOutOfBounds
		}
	}
	return nil
}

func (x *Response) GetGameMoveNotYourTurn() *GameMoveNotYourTurnResponse {
	if x != nil {
		if x, ok := x.Payload.(*Response_GameMoveNotYourTurn); ok {
			return x.GameMoveNotYourTurn
		}
	}
	return nil
}

func (x *Response) GetGameOver() *GameOverResponse {
	if x != nil {
		if x, ok := x.Payload.(*Response_GameOver); ok {
			return x.GameOver
		}
	}
	return nil
}

func (x *Response) GetPveDifficultyNotSupport() *PveDifficultyNotSupportResponse {
	if x != nil {
		if x, ok := x.Payload.(*Response_PveDifficultyNotSupport); ok {
			return x.PveDifficultyNotSupport
		}
	}
	return nil
}

func (x *Response) GetWatchGameSuccess() *WatchGameSuccessResponse {
	if x != nil {
		if x, ok := x.Payload.(*Response_WatchGameSuccess); ok {
			return x.WatchGameSuccess
		}
	}
	return nil
}

func (x *Response) GetClientExit() *ClientExitResponse {
	if x != nil {
		if x, ok := x.Payload.(*Response_ClientExit); ok {
			return x.ClientExit
		}
	}
	return nil
}

func (x *Response) GetSpectatorCannotAct() *SpectatorCannotActResponse {
	if x != nil {
		if x, ok := x.Payload.(*Response_SpectatorCannotAct); ok {
			return x.SpectatorCannotAct
		}
	}
	return nil
}

type isResponse_Payload interface {
	isResponse_Payload()
}

type Response_ClientConnect struct {
	ClientConnect *ClientConnectResponse `protobuf:"bytes,1,opt,name=client_connect,json=clientConnect,proto3,oneof"`
}

type Response_NicknameSet struct {
	NicknameSet *NicknameSetResponse `protobuf:"bytes,2,opt,name=nickname_set,json=nicknameSet,proto3,oneof"`
}

type Response_ShowOptions struct {
	ShowOptions *ShowOptionsResponse `protobuf:"bytes,3,opt,name=show_options,json=showOptions,proto3,oneof"`
}

type Response_ShowRooms struct {
	ShowRooms *ShowRoomsResponse `protobuf:"bytes,4,opt,name=show_rooms,json=showRooms,proto3,oneof"`
}

type Response_RoomCreateSuccess struct {
	RoomCreateSuccess *RoomCreateSuccessResponse `protobuf:"bytes,5,opt,name=room_create_success,json=roomCreateSuccess,proto3,oneof"`
}

type Response_RoomJoinSuccess struct {
	RoomJoinSuccess *RoomJoinSuccessResponse `protobuf:"bytes,6,opt,name=room_join_success,json=roomJoinSuccess,proto3,oneof"`
}

type Response_RoomJoinFailFull struct {
	RoomJoinFailFull *RoomJoinFailFullResponse `protobuf:"bytes,7,opt,name=room_join_fail_full,json=roomJoinFailFull,proto3,oneof"`
}

type Response_RoomJoinFailNotFound struct {
	RoomJoinFailNotFound *RoomJoinFailNotFoundResponse `protobuf:"bytes,8,opt,name=room_join_fail_not_found,json=roomJoinFailNotFound,proto3,oneof"`
}

type Response_RoomPlayFailNotFound struct {
	RoomPlayFailNotFound *RoomPlayFailNotFoundResponse `protobuf:"bytes,9,opt,name=room_play_fail_not_found,json=roomPlayFailNotFound,proto3,oneof"`
}

type Response_GameStarting struct {
	GameStarting *GameStartingResponse `protobuf:"bytes,10,opt,name=game_starting,json=gameStarting,proto3,oneof"`
}

type Response_GameMoveSuccess struct {
	GameMoveSuccess *GameMoveSuccessResponse `protobuf:"bytes,11,opt,name=game_move_success,json=gameMoveSuccess,proto3,oneof"`
}

type Response_GameMoveInvalid struct {
	GameMoveInvalid *GameMoveInvalidResponse `protobuf:"bytes,12,opt,name=game_move_invalid,json=gameMoveInvalid,proto3,oneof"`
}

type Response_GameMoveOccupied struct {
	GameMoveOccupied *GameMoveOccupiedResponse `protobuf:"bytes,13,opt,name=game_move_occupied,json=gameMoveOccupied,proto3,oneof"`
}

type Response_GameMoveOutOfBounds struct {
	GameMoveOutOfBounds *GameMoveOutOfBoundsResponse `protobuf:"bytes,14,opt,name=game_move_out_of_bounds,json=gameMoveOutOfBounds,proto3,oneof"`
}

type Response_GameMoveNotYourTurn struct {
	GameMoveNotYourTurn *GameMoveNotYourTurnResponse `protobuf:"bytes,15,opt,name=game_move_not_your_turn,json=gameMoveNotYourTurn,proto3,oneof"`
}

type Response_GameOver struct {
	GameOver *GameOverResponse `protobuf:"bytes,16,opt,name=game_over,json=gameOver,proto3,oneof"`
}

type Response_PveDifficultyNotSupport struct {
	PveDifficultyNotSupport *PveDifficultyNotSupportResponse `protobuf:"bytes,17,opt,name=pve_difficulty_not_support,json=pveDifficultyNotSupport,proto3,oneof"`
}

type Response_WatchGameSuccess struct {
	WatchGameSuccess *WatchGameSuccessResponse `protobuf:"bytes,18,opt,name=watch_game_success,json=watchGameSuccess,proto3,oneof"`
}

type Response_ClientExit struct {
	ClientExit *ClientExitResponse `protobuf:"bytes,19,opt,name=client_exit,json=clientExit,proto3,oneof"`
}

type Response_SpectatorCannotAct struct {
	SpectatorCannotAct *SpectatorCannotActResponse `protobuf:"bytes,20,opt,name=spectator_cannot_act,json=spectatorCannotAct,proto3,oneof"`
}

func (*Response_ClientConnect) isResponse_Payload() {}

func (*Response_NicknameSet) isResponse_Payload() {}

func (*Response_ShowOptions) isResponse_Payload() {}

func (*Response_ShowRooms) isResponse_Payload() {}

func (*Response_RoomCreateSuccess) isResponse_Payload() {}

func (*Response_RoomJoinSuccess) isResponse_Payload() {}

func (*Response_RoomJoinFailFull) isResponse_Payload() {}

func (*Response_RoomJoinFailNotFound) isResponse_Payload() {}

func (*Response_RoomPlayFailNotFound) isResponse_Payload() {}

func (*Response_GameStarting) isResponse_Payload() {}

func (*Response_GameMoveSuccess) isResponse_Payload() {}

func (*Response_GameMoveInvalid) isResponse_Payload() {}

func (*Response_GameMoveOccupied) isResponse_Payload() {}

func (*Response_GameMoveOutOfBounds) isResponse_Payload() {}

func (*Response_GameMoveNotYourTurn) isResponse_Payload() {}

func (*Response_GameOver) isResponse_Payload() {}

func (*Response_PveDifficultyNotSupport) isResponse_Payload() {}

func (*Response_WatchGameSuccess) isResponse_Payload() {}

func (*Response_ClientExit) isResponse_Payload() {}

func (*Response_SpectatorCannotAct) isResponse_Payload() {}

type ClientConnectResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	ClientId      int32                  `protobuf:"varint,1,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ClientConnectResponse) Reset() {
	*x = ClientConnectResponse{}
	mi := &file_response_proto_msgTypes[1]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *ClientConnectResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*ClientConnectResponse) ProtoMessage() {}

func (x *ClientConnectResponse) ProtoReflect() protoreflect.Message {
	mi := &file_response_proto_msgTypes[1]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ClientConnectResponse.ProtoReflect.Descriptor instead.
func (*ClientConnectResponse) Descriptor() ([]byte, []int) {
	return file_response_proto_rawDescGZIP(), []int{1}
}

func (x *ClientConnectResponse) GetClientId() int32 {
	if x != nil {
		return x.ClientId
	}
	return 0
}

// invalid_length = 0 means "prompt only — ask the user for a nickname"
type NicknameSetResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	InvalidLength int32                  `protobuf:"varint,1,opt,name=invalid_length,json=invalidLength,proto3" json:"invalid_length,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *NicknameSetResponse) Reset() {
	*x = NicknameSetResponse{}
	mi := &file_response_proto_msgTypes[2]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *NicknameSetResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*NicknameSetResponse) ProtoMessage() {}

func (x *NicknameSetResponse) ProtoReflect() protoreflect.Message {
	mi := &file_response_proto_msgTypes[2]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use NicknameSetResponse.ProtoReflect.Descriptor instead.
func (*NicknameSetResponse) Descriptor() ([]byte, []int) {
	return file_response_proto_rawDescGZIP(), []int{2}
}

func (x *NicknameSetResponse) GetInvalidLength() int32 {
	if x != nil {
		return x.InvalidLength
	}
	return 0
}

type ShowOptionsResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ShowOptionsResponse) Reset() {
	*x = ShowOptionsResponse{}
	mi := &file_response_proto_msgTypes[3]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *ShowOptionsResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*ShowOptionsResponse) ProtoMessage() {}

func (x *ShowOptionsResponse) ProtoReflect() protoreflect.Message {
	mi := &file_response_proto_msgTypes[3]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ShowOptionsResponse.ProtoReflect.Descriptor instead.
func (*ShowOptionsResponse) Descriptor() ([]byte, []int) {
	return file_response_proto_rawDescGZIP(), []int{3}
}

type RoomSummary struct {
	state           protoimpl.MessageState `protogen:"open.v1"`
	RoomId          int32                  `protobuf:"varint,1,opt,name=room_id,json=roomId,proto3" json:"room_id,omitempty"`
	RoomOwner       string                 `protobuf:"bytes,2,opt,name=room_owner,json=roomOwner,proto3" json:"room_owner,omitempty"`
	RoomClientCount int32                  `protobuf:"varint,3,opt,name=room_client_count,json=roomClientCount,proto3" json:"room_client_count,omitempty"`
	RoomType        RoomType               `protobuf:"varint,4,opt,name=room_type,json=roomType,proto3,enum=com.miti99.gomoku.proto.RoomType" json:"room_type,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

func (x *RoomSummary) Reset() {
	*x = RoomSummary{}
	mi := &file_response_proto_msgTypes[4]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *RoomSummary) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*RoomSummary) ProtoMessage() {}

func (x *RoomSummary) ProtoReflect() protoreflect.Message {
	mi := &file_response_proto_msgTypes[4]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use RoomSummary.ProtoReflect.Descriptor instead.
func (*RoomSummary) Descriptor() ([]byte, []int) {
	return file_response_proto_rawDescGZIP(), []int{4}
}

func (x *RoomSummary) GetRoomId() int32 {
	if x != nil {
		return x.RoomId
	}
	return 0
}

func (x *RoomSummary) GetRoomOwner() string {
	if x != nil {
		return x.RoomOwner
	}
	return ""
}

func (x *RoomSummary) GetRoomClientCount() int32 {
	if x != nil {
		return x.RoomClientCount
	}
	return 0
}

func (x *RoomSummary) GetRoomType() RoomType {
	if x != nil {
		return x.RoomType
	}
	return RoomType_ROOM_TYPE_UNSPECIFIED
}

type ShowRoomsResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Rooms         []*RoomSummary         `protobuf:"bytes,1,rep,name=rooms,proto3" json:"rooms,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ShowRoomsResponse) Reset() {
	*x = ShowRoomsResponse{}
	mi := &file_response_proto_msgTypes[5]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *ShowRoomsResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*ShowRoomsResponse) ProtoMessage() {}

func (x *ShowRoomsResponse) ProtoReflect() protoreflect.Message {
	mi := &file_response_proto_msgTypes[5]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ShowRoomsResponse.ProtoReflect.Descriptor instead.
func (*ShowRoomsResponse) Descriptor() ([]byte, []int) {
	return file_response_proto_rawDescGZIP(), []int{5}
}

func (x *ShowRoomsResponse) GetRooms() []*RoomSummary {
	if x != nil {
		return x.Rooms
	}
	return nil
}

type RoomCreateSuccessResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Id            int32                  `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	RoomOwner     string                 `protobuf:"bytes,2,opt,name=room_owner,json=roomOwner,proto3" json:"room_owner,omitempty"`
	RoomType      RoomType               `protobuf:"varint,3,opt,name=room_type,json=roomType,proto3,enum=com.miti99.gomoku.proto.RoomType" json:"room_type,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *RoomCreateSuccessResponse) Reset() {
	*x = RoomCreateSuccessResponse{}
	mi := &file_response_proto_msgTypes[6]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *RoomCreateSuccessResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*RoomCreateSuccessResponse) ProtoMessage() {}

func (x *RoomCreateSuccessResponse) ProtoReflect() protoreflect.Message {
	mi := &file_response_proto_msgTypes[6]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use RoomCreateSuccessResponse.ProtoReflect.Descriptor instead.
func (*RoomCreateSuccessResponse) Descriptor() ([]byte, []int) {
	return file_response_proto_rawDescGZIP(), []int{6}
}

func (x *RoomCreateSuccessResponse) GetId() int32 {
	if x != nil {
		return x.Id
	}
	return 0
}

func (x *RoomCreateSuccessResponse) GetRoomOwner() string {
	if x != nil {
		return x.RoomOwner
	}
	return ""
}

func (x *RoomCreateSuccessResponse) GetRoomType() RoomType {
	if x != nil {
		return x.RoomType
	}
	return RoomType_ROOM_TYPE_UNSPECIFIED
}

type RoomJoinSuccessResponse struct {
	state           protoimpl.MessageState `protogen:"open.v1"`
	ClientId        int32                  `protobuf:"varint,1,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"`
	ClientNickname  string                 `protobuf:"bytes,2,opt,name=client_nickname,json=clientNickname,proto3" json:"client_nickname,omitempty"`
	RoomId          int32                  `protobuf:"varint,3,opt,name=room_id,json=roomId,proto3" json:"room_id,omitempty"`
	RoomOwner       string                 `protobuf:"bytes,4,opt,name=room_owner,json=roomOwner,proto3" json:"room_owner,omitempty"`
	RoomClientCount int32                  `protobuf:"varint,5,opt,name=room_client_count,json=roomClientCount,proto3" json:"room_client_count,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

func (x *RoomJoinSuccessResponse) Reset() {
	*x = RoomJoinSuccessResponse{}
	mi := &file_response_proto_msgTypes[7]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *RoomJoinSuccessResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*RoomJoinSuccessResponse) ProtoMessage() {}

func (x *RoomJoinSuccessResponse) ProtoReflect() protoreflect.Message {
	mi := &file_response_proto_msgTypes[7]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use RoomJoinSuccessResponse.ProtoReflect.Descriptor instead.
func (*RoomJoinSuccessResponse) Descriptor() ([]byte, []int) {
	return file_response_proto_rawDescGZIP(), []int{7}
}

func (x *RoomJoinSuccessResponse) GetClientId() int32 {
	if x != nil {
		return x.ClientId
	}
	return 0
}

func (x *RoomJoinSuccessResponse) GetClientNickname() string {
	if x != nil {
		return x.ClientNickname
	}
	return ""
}

func (x *RoomJoinSuccessResponse) GetRoomId() int32 {
	if x != nil {
		return x.RoomId
	}
	return 0
}

func (x *RoomJoinSuccessResponse) GetRoomOwner() string {
	if x != nil {
		return x.RoomOwner
	}
	return ""
}

func (x *RoomJoinSuccessResponse) GetRoomClientCount() int32 {
	if x != nil {
		return x.RoomClientCount
	}
	return 0
}

type RoomJoinFailFullResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	RoomId        int32                  `protobuf:"varint,1,opt,name=room_id,json=roomId,proto3" json:"room_id,omitempty"`
	RoomOwner     string                 `protobuf:"bytes,2,opt,name=room_owner,json=roomOwner,proto3" json:"room_owner,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *RoomJoinFailFullResponse) Reset() {
	*x = RoomJoinFailFullResponse{}
	mi := &file_response_proto_msgTypes[8]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *RoomJoinFailFullResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*RoomJoinFailFullResponse) ProtoMessage() {}

func (x *RoomJoinFailFullResponse) ProtoReflect() protoreflect.Message {
	mi := &file_response_proto_msgTypes[8]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use RoomJoinFailFullResponse.ProtoReflect.Descriptor instead.
func (*RoomJoinFailFullResponse) Descriptor() ([]byte, []int) {
	return file_response_proto_rawDescGZIP(), []int{8}
}

func (x *RoomJoinFailFullResponse) GetRoomId() int32 {
	if x != nil {
		return x.RoomId
	}
	return 0
}

func (x *RoomJoinFailFullResponse) GetRoomOwner() string {
	if x != nil {
		return x.RoomOwner
	}
	return ""
}

type RoomJoinFailNotFoundResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	RoomId        int32                  `protobuf:"varint,1,opt,name=room_id,json=roomId,proto3" json:"room_id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *RoomJoinFailNotFoundResponse) Reset() {
	*x = RoomJoinFailNotFoundResponse{}
	mi := &file_response_proto_msgTypes[9]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *RoomJoinFailNotFoundResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*RoomJoinFailNotFoundResponse) ProtoMessage() {}

func (x *RoomJoinFailNotFoundResponse) ProtoReflect() protoreflect.Message {
	mi := &file_response_proto_msgTypes[9]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use RoomJoinFailNotFoundResponse.ProtoReflect.Descriptor instead.
func (*RoomJoinFailNotFoundResponse) Descriptor() ([]byte, []int) {
	return file_response_proto_rawDescGZIP(), []int{9}
}

func (x *RoomJoinFailNotFoundResponse) GetRoomId() int32 {
	if x != nil {
		return x.RoomId
	}
	return 0
}

type RoomPlayFailNotFoundResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *RoomPlayFailNotFoundResponse) Reset() {
	*x = RoomPlayFailNotFoundResponse{}
	mi := &file_response_proto_msgTypes[10]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *RoomPlayFailNotFoundResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*RoomPlayFailNotFoundResponse) ProtoMessage() {}

func (x *RoomPlayFailNotFoundResponse) ProtoReflect() protoreflect.Message {
	mi := &file_response_proto_msgTypes[10]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use RoomPlayFailNotFoundResponse.ProtoReflect.Descriptor instead.
func (*RoomPlayFailNotFoundResponse) Descriptor() ([]byte, []int) {
	return file_response_proto_rawDescGZIP(), []int{10}
}

type GameStartingResponse struct {
	state               protoimpl.MessageState `protogen:"open.v1"`
	RoomId              int32                  `protobuf:"varint,1,opt,name=room_id,json=roomId,proto3" json:"room_id,omitempty"`
	BlackPlayerId       int32                  `protobuf:"varint,2,opt,name=black_player_id,json=blackPlayerId,proto3" json:"black_player_id,omitempty"`
	BlackPlayerNickname string                 `protobuf:"bytes,3,opt,name=black_player_nickname,json=blackPlayerNickname,proto3" json:"black_player_nickname,omitempty"`
	WhitePlayerId       int32                  `protobuf:"varint,4,opt,name=white_player_id,json=whitePlayerId,proto3" json:"white_player_id,omitempty"`
	WhitePlayerNickname string                 `protobuf:"bytes,5,opt,name=white_player_nickname,json=whitePlayerNickname,proto3" json:"white_player_nickname,omitempty"`
	BoardSize           int32                  `protobuf:"varint,6,opt,name=board_size,json=boardSize,proto3" json:"board_size,omitempty"`
	unknownFields       protoimpl.UnknownFields
	sizeCache           protoimpl.SizeCache
}

func (x *GameStartingResponse) Reset() {
	*x = GameStartingResponse{}
	mi := &file_response_proto_msgTypes[11]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *GameStartingResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*GameStartingResponse) ProtoMessage() {}

func (x *GameStartingResponse) ProtoReflect() protoreflect.Message {
	mi := &file_response_proto_msgTypes[11]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use GameStartingResponse.ProtoReflect.Descriptor instead.
func (*GameStartingResponse) Descriptor() ([]byte, []int) {
	return file_response_proto_rawDescGZIP(), []int{11}
}

func (x *GameStartingResponse) GetRoomId() int32 {
	if x != nil {
		return x.RoomId
	}
	return 0
}

func (x *GameStartingResponse) GetBlackPlayerId() int32 {
	if x != nil {
		return x.BlackPlayerId
	}
	return 0
}

func (x *GameStartingResponse) GetBlackPlayerNickname() string {
	if x != nil {
		return x.BlackPlayerNickname
	}
	return ""
}

func (x *GameStartingResponse) GetWhitePlayerId() int32 {
	if x != nil {
		return x.WhitePlayerId
	}
	return 0
}

func (x *GameStartingResponse) GetWhitePlayerNickname() string {
	if x != nil {
		return x.WhitePlayerNickname
	}
	return ""
}

func (x *GameStartingResponse) GetBoardSize() int32 {
	if x != nil {
		return x.BoardSize
	}
	return 0
}

type GameMoveSuccessResponse struct {
	state          protoimpl.MessageState `protogen:"open.v1"`
	Row            int32                  `protobuf:"varint,1,opt,name=row,proto3" json:"row,omitempty"`
	Col            int32                  `protobuf:"varint,2,opt,name=col,proto3" json:"col,omitempty"`
	Piece          Piece                  `protobuf:"varint,3,opt,name=piece,proto3,enum=com.miti99.gomoku.proto.Piece" json:"piece,omitempty"`
	PlayerNickname string                 `protobuf:"bytes,4,opt,name=player_nickname,json=playerNickname,proto3" json:"player_nickname,omitempty"`
	PlayerId       int32                  `protobuf:"varint,5,opt,name=player_id,json=playerId,proto3" json:"player_id,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

func (x *GameMoveSuccessResponse) Reset() {
	*x = GameMoveSuccessResponse{}
	mi := &file_response_proto_msgTypes[12]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *GameMoveSuccessResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*GameMoveSuccessResponse) ProtoMessage() {}

func (x *GameMoveSuccessResponse) ProtoReflect() protoreflect.Message {
	mi := &file_response_proto_msgTypes[12]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use GameMoveSuccessResponse.ProtoReflect.Descriptor instead.
func (*GameMoveSuccessResponse) Descriptor() ([]byte, []int) {
	return file_response_proto_rawDescGZIP(), []int{12}
}

func (x *GameMoveSuccessResponse) GetRow() int32 {
	if x != nil {
		return x.Row
	}
	return 0
}

func (x *GameMoveSuccessResponse) GetCol() int32 {
	if x != nil {
		return x.Col
	}
	return 0
}

func (x *GameMoveSuccessResponse) GetPiece() Piece {
	if x != nil {
		return x.Piece
	}
	return Piece_PIECE_UNSPECIFIED
}

func (x *GameMoveSuccessResponse) GetPlayerNickname() string {
	if x != nil {
		return x.PlayerNickname
	}
	return ""
}

func (x *GameMoveSuccessResponse) GetPlayerId() int32 {
	if x != nil {
		return x.PlayerId
	}
	return 0
}

type GameMoveInvalidResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GameMoveInvalidResponse) Reset() {
	*x = GameMoveInvalidResponse{}
	mi := &file_response_proto_msgTypes[13]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *GameMoveInvalidResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*GameMoveInvalidResponse) ProtoMessage() {}

func (x *GameMoveInvalidResponse) ProtoReflect() protoreflect.Message {
	mi := &file_response_proto_msgTypes[13]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use GameMoveInvalidResponse.ProtoReflect.Descriptor instead.
func (*GameMoveInvalidResponse) Descriptor() ([]byte, []int) {
	return file_response_proto_rawDescGZIP(), []int{13}
}

type GameMoveOccupiedResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GameMoveOccupiedResponse) Reset() {
	*x = GameMoveOccupiedResponse{}
	mi := &file_response_proto_msgTypes[14]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *GameMoveOccupiedResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*GameMoveOccupiedResponse) ProtoMessage() {}

func (x *GameMoveOccupiedResponse) ProtoReflect() protoreflect.Message {
	mi := &file_response_proto_msgTypes[14]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use GameMoveOccupiedResponse.ProtoReflect.Descriptor instead.
func (*GameMoveOccupiedResponse) Descriptor() ([]byte, []int) {
	return file_response_proto_rawDescGZIP(), []int{14}
}

type GameMoveOutOfBoundsResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GameMoveOutOfBoundsResponse) Reset() {
	*x = GameMoveOutOfBoundsResponse{}
	mi := &file_response_proto_msgTypes[15]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *GameMoveOutOfBoundsResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*GameMoveOutOfBoundsResponse) ProtoMessage() {}

func (x *GameMoveOutOfBoundsResponse) ProtoReflect() protoreflect.Message {
	mi := &file_response_proto_msgTypes[15]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use GameMoveOutOfBoundsResponse.ProtoReflect.Descriptor instead.
func (*GameMoveOutOfBoundsResponse) Descriptor() ([]byte, []int) {
	return file_response_proto_rawDescGZIP(), []int{15}
}

type GameMoveNotYourTurnResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GameMoveNotYourTurnResponse) Reset() {
	*x = GameMoveNotYourTurnResponse{}
	mi := &file_response_proto_msgTypes[16]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *GameMoveNotYourTurnResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*GameMoveNotYourTurnResponse) ProtoMessage() {}

func (x *GameMoveNotYourTurnResponse) ProtoReflect() protoreflect.Message {
	mi := &file_response_proto_msgTypes[16]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use GameMoveNotYourTurnResponse.ProtoReflect.Descriptor instead.
func (*GameMoveNotYourTurnResponse) Descriptor() ([]byte, []int) {
	return file_response_proto_rawDescGZIP(), []int{16}
}

type GameOverResponse struct {
	state          protoimpl.MessageState `protogen:"open.v1"`
	Result         GameResult             `protobuf:"varint,1,opt,name=result,proto3,enum=com.miti99.gomoku.proto.GameResult" json:"result,omitempty"`
	WinnerNickname string                 `protobuf:"bytes,2,opt,name=winner_nickname,json=winnerNickname,proto3" json:"winner_nickname,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

func (x *GameOverResponse) Reset() {
	*x = GameOverResponse{}
	mi := &file_response_proto_msgTypes[17]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *GameOverResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*GameOverResponse) ProtoMessage() {}

func (x *GameOverResponse) ProtoReflect() protoreflect.Message {
	mi := &file_response_proto_msgTypes[17]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use GameOverResponse.ProtoReflect.Descriptor instead.
func (*GameOverResponse) Descriptor() ([]byte, []int) {
	return file_response_proto_rawDescGZIP(), []int{17}
}

func (x *GameOverResponse) GetResult() GameResult {
	if x != nil {
		return x.Result
	}
	return GameResult_GAME_RESULT_UNSPECIFIED
}

func (x *GameOverResponse) GetWinnerNickname() string {
	if x != nil {
		return x.WinnerNickname
	}
	return ""
}

type PveDifficultyNotSupportResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PveDifficultyNotSupportResponse) Reset() {
	*x = PveDifficultyNotSupportResponse{}
	mi := &file_response_proto_msgTypes[18]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PveDifficultyNotSupportResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PveDifficultyNotSupportResponse) ProtoMessage() {}

func (x *PveDifficultyNotSupportResponse) ProtoReflect() protoreflect.Message {
	mi := &file_response_proto_msgTypes[18]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use PveDifficultyNotSupportResponse.ProtoReflect.Descriptor instead.
func (*PveDifficultyNotSupportResponse) Descriptor() ([]byte, []int) {
	return file_response_proto_rawDescGZIP(), []int{18}
}

type WatchGameSuccessResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Owner         string                 `protobuf:"bytes,1,opt,name=owner,proto3" json:"owner,omitempty"`
	Status        RoomStatus             `protobuf:"varint,2,opt,name=status,proto3,enum=com.miti99.gomoku.proto.RoomStatus" json:"status,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *WatchGameSuccessResponse) Reset() {
	*x = WatchGameSuccessResponse{}
	mi := &file_response_proto_msgTypes[19]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *WatchGameSuccessResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*WatchGameSuccessResponse) ProtoMessage() {}

func (x *WatchGameSuccessResponse) ProtoReflect() protoreflect.Message {
	mi := &file_response_proto_msgTypes[19]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use WatchGameSuccessResponse.ProtoReflect.Descriptor instead.
func (*WatchGameSuccessResponse) Descriptor() ([]byte, []int) {
	return file_response_proto_rawDescGZIP(), []int{19}
}

func (x *WatchGameSuccessResponse) GetOwner() string {
	if x != nil {
		return x.Owner
	}
	return ""
}

func (x *WatchGameSuccessResponse) GetStatus() RoomStatus {
	if x != nil {
		return x.Status
	}
	return RoomStatus_ROOM_STATUS_UNSPECIFIED
}

type ClientExitResponse struct {
	state              protoimpl.MessageState `protogen:"open.v1"`
	RoomId             int32                  `protobuf:"varint,1,opt,name=room_id,json=roomId,proto3" json:"room_id,omitempty"`
	ExitClientId       int32                  `protobuf:"varint,2,opt,name=exit_client_id,json=exitClientId,proto3" json:"exit_client_id,omitempty"`
	ExitClientNickname string                 `protobuf:"bytes,3,opt,name=exit_client_nickname,json=exitClientNickname,proto3" json:"exit_client_nickname,omitempty"`
	unknownFields      protoimpl.UnknownFields
	sizeCache          protoimpl.SizeCache
}

func (x *ClientExitResponse) Reset() {
	*x = ClientExitResponse{}
	mi := &file_response_proto_msgTypes[20]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *ClientExitResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*ClientExitResponse) ProtoMessage() {}

func (x *ClientExitResponse) ProtoReflect() protoreflect.Message {
	mi := &file_response_proto_msgTypes[20]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ClientExitResponse.ProtoReflect.Descriptor instead.
func (*ClientExitResponse) Descriptor() ([]byte, []int) {
	return file_response_proto_rawDescGZIP(), []int{20}
}

func (x *ClientExitResponse) GetRoomId() int32 {
	if x != nil {
		return x.RoomId
	}
	return 0
}

func (x *ClientExitResponse) GetExitClientId() int32 {
	if x != nil {
		return x.ExitClientId
	}
	return 0
}

func (x *ClientExitResponse) GetExitClientNickname() string {
	if x != nil {
		return x.ExitClientNickname
	}
	return ""
}

// Sent when a spectator attempts an action that requires being a player.
type SpectatorCannotActResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SpectatorCannotActResponse) Reset() {
	*x = SpectatorCannotActResponse{}
	mi := &file_response_proto_msgTypes[21]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *SpectatorCannotActResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*SpectatorCannotActResponse) ProtoMessage() {}

func (x *SpectatorCannotActResponse) ProtoReflect() protoreflect.Message {
	mi := &file_response_proto_msgTypes[21]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use SpectatorCannotActResponse.ProtoReflect.Descriptor instead.
func (*SpectatorCannotActResponse) Descriptor() ([]byte, []int) {
	return file_response_proto_rawDescGZIP(), []int{21}
}

var File_response_proto protoreflect.FileDescriptor

const file_response_proto_rawDesc = "" +
	"\n" +
	"\x0eresponse.proto\x12\x17com.miti99.gomoku.proto\"\xa1\x0f\n" +
	"\bResponse\x12W\n" +
	"\x0eclient_connect\x18\x01 \x01(\v2..com.miti99.gomoku.proto.ClientConnectResponseH\x00R\rclientConnect\x12Q\n" +
	"\fnickname_set\x18\x02 \x01(\v2,.com.miti99.gomoku.proto.NicknameSetResponseH\x00R\vnicknameSet\x12Q\n" +
	"\fshow_options\x18\x03 \x01(\v2,.com.miti99.gomoku.proto.ShowOptionsResponseH\x00R\vshowOptions\x12K\n" +
	"\n" +
	"show_rooms\x18\x04 \x01(\v2*.com.miti99.gomoku.proto.ShowRoomsResponseH\x00R\tshowRooms\x12d\n" +
	"\x13room_create_success\x18\x05 \x01(\v22.com.miti99.gomoku.proto.RoomCreateSuccessResponseH\x00R\x11roomCreateSuccess\x12^\n" +
	"\x11room_join_success\x18\x06 \x01(\v20.com.miti99.gomoku.proto.RoomJoinSuccessResponseH\x00R\x0froomJoinSuccess\x12b\n" +
	"\x13room_join_fail_full\x18\a \x01(\v21.com.miti99.gomoku.proto.RoomJoinFailFullResponseH\x00R\x10roomJoinFailFull\x12o\n" +
	"\x18room_join_fail_not_found\x18\b \x01(\v25.com.miti99.gomoku.proto.RoomJoinFailNotFoundResponseH\x00R\x14roomJoinFailNotFound\x12o\n" +
	"\x18room_play_fail_not_found\x18\t \x01(\v25.com.miti99.gomoku.proto.RoomPlayFailNotFoundResponseH\x00R\x14roomPlayFailNotFound\x12T\n" +
	"\rgame_starting\x18\n" +
	" \x01(\v2-.com.miti99.gomoku.proto.GameStartingResponseH\x00R\fgameStarting\x12^\n" +
	"\x11game_move_success\x18\v \x01(\v20.com.miti99.gomoku.proto.GameMoveSuccessResponseH\x00R\x0fgameMoveSuccess\x12^\n" +
	"\x11game_move_invalid\x18\f \x01(\v20.com.miti99.gomoku.proto.GameMoveInvalidResponseH\x00R\x0fgameMoveInvalid\x12a\n" +
	"\x12game_move_occupied\x18\r \x01(\v21.com.miti99.gomoku.proto.GameMoveOccupiedResponseH\x00R\x10gameMoveOccupied\x12l\n" +
	"\x17game_move_out_of_bounds\x18\x0e \x01(\v24.com.miti99.gomoku.proto.GameMoveOutOfBoundsResponseH\x00R\x13gameMoveOutOfBounds\x12l\n" +
	"\x17game_move_not_your_turn\x18\x0f \x01(\v24.com.miti99.gomoku.proto.GameMoveNotYourTurnResponseH\x00R\x13gameMoveNotYourTurn\x12H\n" +
	"\tgame_over\x18\x10 \x01(\v2).com.miti99.gomoku.proto.GameOverResponseH\x00R\bgameOver\x12w\n" +
	"\x1apve_difficulty_not_support\x18\x11 \x01(\v28.com.miti99.gomoku.proto.PveDifficultyNotSupportResponseH\x00R\x17pveDifficultyNotSupport\x12a\n" +
	"\x12watch_game_success\x18\x12 \x01(\v21.com.miti99.gomoku.proto.WatchGameSuccessResponseH\x00R\x10watchGameSuccess\x12N\n" +
	"\vclient_exit\x18\x13 \x01(\v2+.com.miti99.gomoku.proto.ClientExitResponseH\x00R\n" +
	"clientExit\x12g\n" +
	"\x14spectator_cannot_act\x18\x14 \x01(\v23.com.miti99.gomoku.proto.SpectatorCannotActResponseH\x00R\x12spectatorCannotActB\t\n" +
	"\apayload\"4\n" +
	"\x15ClientConnectResponse\x12\x1b\n" +
	"\tclient_id\x18\x01 \x01(\x05R\bclientId\"<\n" +
	"\x13NicknameSetResponse\x12%\n" +
	"\x0einvalid_length\x18\x01 \x01(\x05R\rinvalidLength\"\x15\n" +
	"\x13ShowOptionsResponse\"\xb1\x01\n" +
	"\vRoomSummary\x12\x17\n" +
	"\aroom_id\x18\x01 \x01(\x05R\x06roomId\x12\x1d\n" +
	"\n" +
	"room_owner\x18\x02 \x01(\tR\troomOwner\x12*\n" +
	"\x11room_client_count\x18\x03 \x01(\x05R\x0froomClientCount\x12>\n" +
	"\troom_type\x18\x04 \x01(\x0e2!.com.miti99.gomoku.proto.RoomTypeR\broomType\"O\n" +
	"\x11ShowRoomsResponse\x12:\n" +
	"\x05rooms\x18\x01 \x03(\v2$.com.miti99.gomoku.proto.RoomSummaryR\x05rooms\"\x8a\x01\n" +
	"\x19RoomCreateSuccessResponse\x12\x0e\n" +
	"\x02id\x18\x01 \x01(\x05R\x02id\x12\x1d\n" +
	"\n" +
	"room_owner\x18\x02 \x01(\tR\troomOwner\x12>\n" +
	"\troom_type\x18\x03 \x01(\x0e2!.com.miti99.gomoku.proto.RoomTypeR\broomType\"\xc3\x01\n" +
	"\x17RoomJoinSuccessResponse\x12\x1b\n" +
	"\tclient_id\x18\x01 \x01(\x05R\bclientId\x12'\n" +
	"\x0fclient_nickname\x18\x02 \x01(\tR\x0eclientNickname\x12\x17\n" +
	"\aroom_id\x18\x03 \x01(\x05R\x06roomId\x12\x1d\n" +
	"\n" +
	"room_owner\x18\x04 \x01(\tR\troomOwner\x12*\n" +
	"\x11room_client_count\x18\x05 \x01(\x05R\x0froomClientCount\"R\n" +
	"\x18RoomJoinFailFullResponse\x12\x17\n" +
	"\aroom_id\x18\x01 \x01(\x05R\x06roomId\x12\x1d\n" +
	"\n" +
	"room_owner\x18\x02 \x01(\tR\troomOwner\"7\n" +
	"\x1cRoomJoinFailNotFoundResponse\x12\x17\n" +
	"\aroom_id\x18\x01 \x01(\x05R\x06roomId\"\x1e\n" +
	"\x1cRoomPlayFailNotFoundResponse\"\x86\x02\n" +
	"\x14GameStartingResponse\x12\x17\n" +
	"\aroom_id\x18\x01 \x01(\x05R\x06roomId\x12&\n" +
	"\x0fblack_player_id\x18\x02 \x01(\x05R\rblackPlayerId\x122\n" +
	"\x15black_player_nickname\x18\x03 \x01(\tR\x13blackPlayerNickname\x12&\n" +
	"\x0fwhite_player_id\x18\x04 \x01(\x05R\rwhitePlayerId\x122\n" +
	"\x15white_player_nickname\x18\x05 \x01(\tR\x13whitePlayerNickname\x12\x1d\n" +
	"\n" +
	"board_size\x18\x06 \x01(\x05R\tboardSize\"\xb9\x01\n" +
	"\x17GameMoveSuccessResponse\x12\x10\n" +
	"\x03row\x18\x01 \x01(\x05R\x03row\x12\x10\n" +
	"\x03col\x18\x02 \x01(\x05R\x03col\x124\n" +
	"\x05piece\x18\x03 \x01(\x0e2\x1e.com.miti99.gomoku.proto.PieceR\x05piece\x12'\n" +
	"\x0fplayer_nickname\x18\x04 \x01(\tR\x0eplayerNickname\x12\x1b\n" +
	"\tplayer_id\x18\x05 \x01(\x05R\bplayerId\"\x19\n" +
	"\x17GameMoveInvalidResponse\"\x1a\n" +
	"\x18GameMoveOccupiedResponse\"\x1d\n" +
	"\x1bGameMoveOutOfBoundsResponse\"\x1d\n" +
	"\x1bGameMoveNotYourTurnResponse\"x\n" +
	"\x10GameOverResponse\x12;\n" +
	"\x06result\x18\x01 \x01(\x0e2#.com.miti99.gomoku.proto.GameResultR\x06result\x12'\n" +
	"\x0fwinner_nickname\x18\x02 \x01(\tR\x0ewinnerNickname\"!\n" +
	"\x1fPveDifficultyNotSupportResponse\"m\n" +
	"\x18WatchGameSuccessResponse\x12\x14\n" +
	"\x05owner\x18\x01 \x01(\tR\x05owner\x12;\n" +
	"\x06status\x18\x02 \x01(\x0e2#.com.miti99.gomoku.proto.RoomStatusR\x06status\"\x85\x01\n" +
	"\x12ClientExitResponse\x12\x17\n" +
	"\aroom_id\x18\x01 \x01(\x05R\x06roomId\x12$\n" +
	"\x0eexit_client_id\x18\x02 \x01(\x05R\fexitClientId\x120\n" +
	"\x14exit_client_nickname\x18\x03 \x01(\tR\x12exitClientNickname\"\x1c\n" +
	"\x1aSpectatorCannotActResponse*4\n" +
	"\x05Piece\x12\x15\n" +
	"\x11PIECE_UNSPECIFIED\x10\x00\x12\t\n" +
	"\x05BLACK\x10\x01\x12\t\n" +
	"\x05WHITE\x10\x02*Q\n" +
	"\n" +
	"GameResult\x12\x1b\n" +
	"\x17GAME_RESULT_UNSPECIFIED\x10\x00\x12\r\n" +
	"\tBLACK_WIN\x10\x01\x12\r\n" +
	"\tWHITE_WIN\x10\x02\x12\b\n" +
	"\x04DRAW\x10\x03*7\n" +
	"\bRoomType\x12\x19\n" +
	"\x15ROOM_TYPE_UNSPECIFIED\x10\x00\x12\a\n" +
	"\x03PVP\x10\x01\x12\a\n" +
	"\x03PVE\x10\x02*Q\n" +
	"\n" +
	"RoomStatus\x12\x1b\n" +
	"\x17ROOM_STATUS_UNSPECIFIED\x10\x00\x12\v\n" +
	"\aWAITING\x10\x01\x12\v\n" +
	"\aPLAYING\x10\x02\x12\f\n" +
	"\bFINISHED\x10\x03B5Z3github.com/tiennm99/gomoku/server/protocol;protocolb\x06proto3"

var (
	file_response_proto_rawDescOnce sync.Once
	file_response_proto_rawDescData []byte
)

func file_response_proto_rawDescGZIP() []byte {
	file_response_proto_rawDescOnce.Do(func() {
		file_response_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_response_proto_rawDesc), len(file_response_proto_rawDesc)))
	})
	return file_response_proto_rawDescData
}

var file_response_proto_enumTypes = make([]protoimpl.EnumInfo, 4)
var file_response_proto_msgTypes = make([]protoimpl.MessageInfo, 22)
var file_response_proto_goTypes = []any{
	(Piece)(0),                              // 0: com.miti99.gomoku.proto.Piece
	(GameResult)(0),                         // 1: com.miti99.gomoku.proto.GameResult
	(RoomType)(0),                           // 2: com.miti99.gomoku.proto.RoomType
	(RoomStatus)(0),                         // 3: com.miti99.gomoku.proto.RoomStatus
	(*Response)(nil),                        // 4: com.miti99.gomoku.proto.Response
	(*ClientConnectResponse)(nil),           // 5: com.miti99.gomoku.proto.ClientConnectResponse
	(*NicknameSetResponse)(nil),             // 6: com.miti99.gomoku.proto.NicknameSetResponse
	(*ShowOptionsResponse)(nil),             // 7: com.miti99.gomoku.proto.ShowOptionsResponse
	(*RoomSummary)(nil),                     // 8: com.miti99.gomoku.proto.RoomSummary
	(*ShowRoomsResponse)(nil),               // 9: com.miti99.gomoku.proto.ShowRoomsResponse
	(*RoomCreateSuccessResponse)(nil),       // 10: com.miti99.gomoku.proto.RoomCreateSuccessResponse
	(*RoomJoinSuccessResponse)(nil),         // 11: com.miti99.gomoku.proto.RoomJoinSuccessResponse
	(*RoomJoinFailFullResponse)(nil),        // 12: com.miti99.gomoku.proto.RoomJoinFailFullResponse
	(*RoomJoinFailNotFoundResponse)(nil),    // 13: com.miti99.gomoku.proto.RoomJoinFailNotFoundResponse
	(*RoomPlayFailNotFoundResponse)(nil),    // 14: com.miti99.gomoku.proto.RoomPlayFailNotFoundResponse
	(*GameStartingResponse)(nil),            // 15: com.miti99.gomoku.proto.GameStartingResponse
	(*GameMoveSuccessResponse)(nil),         // 16: com.miti99.gomoku.proto.GameMoveSuccessResponse
	(*GameMoveInvalidResponse)(nil),         // 17: com.miti99.gomoku.proto.GameMoveInvalidResponse
	(*GameMoveOccupiedResponse)(nil),        // 18: com.miti99.gomoku.proto.GameMoveOccupiedResponse
	(*GameMoveOutOfBoundsResponse)(nil),     // 19: com.miti99.gomoku.proto.GameMoveOutOfBoundsResponse
	(*GameMoveNotYourTurnResponse)(nil),     // 20: com.miti99.gomoku.proto.GameMoveNotYourTurnResponse
	(*GameOverResponse)(nil),                // 21: com.miti99.gomoku.proto.GameOverResponse
	(*PveDifficultyNotSupportResponse)(nil), // 22: com.miti99.gomoku.proto.PveDifficultyNotSupportResponse
	(*WatchGameSuccessResponse)(nil),        // 23: com.miti99.gomoku.proto.WatchGameSuccessResponse
	(*ClientExitResponse)(nil),              // 24: com.miti99.gomoku.proto.ClientExitResponse
	(*SpectatorCannotActResponse)(nil),      // 25: com.miti99.gomoku.proto.SpectatorCannotActResponse
}
var file_response_proto_depIdxs = []int32{
	5,  // 0: com.miti99.gomoku.proto.Response.client_connect:type_name -> com.miti99.gomoku.proto.ClientConnectResponse
	6,  // 1: com.miti99.gomoku.proto.Response.nickname_set:type_name -> com.miti99.gomoku.proto.NicknameSetResponse
	7,  // 2: com.miti99.gomoku.proto.Response.show_options:type_name -> com.miti99.gomoku.proto.ShowOptionsResponse
	9,  // 3: com.miti99.gomoku.proto.Response.show_rooms:type_name -> com.miti99.gomoku.proto.ShowRoomsResponse
	10, // 4: com.miti99.gomoku.proto.Response.room_create_success:type_name -> com.miti99.gomoku.proto.RoomCreateSuccessResponse
	11, // 5: com.miti99.gomoku.proto.Response.room_join_success:type_name -> com.miti99.gomoku.proto.RoomJoinSuccessResponse
	12, // 6: com.miti99.gomoku.proto.Response.room_join_fail_full:type_name -> com.miti99.gomoku.proto.RoomJoinFailFullResponse
	13, // 7: com.miti99.gomoku.proto.Response.room_join_fail_not_found:type_name -> com.miti99.gomoku.proto.RoomJoinFailNotFoundResponse
	14, // 8: com.miti99.gomoku.proto.Response.room_play_fail_not_found:type_name -> com.miti99.gomoku.proto.RoomPlayFailNotFoundResponse
	15, // 9: com.miti99.gomoku.proto.Response.game_starting:type_name -> com.miti99.gomoku.proto.GameStartingResponse
	16, // 10: com.miti99.gomoku.proto.Response.game_move_success:type_name -> com.miti99.gomoku.proto.GameMoveSuccessResponse
	17, // 11: com.miti99.gomoku.proto.Response.game_move_invalid:type_name -> com.miti99.gomoku.proto.GameMoveInvalidResponse
	18, // 12: com.miti99.gomoku.proto.Response.game_move_occupied:type_name -> com.miti99.gomoku.proto.GameMoveOccupiedResponse
	19, // 13: com.miti99.gomoku.proto.Response.game_move_out_of_bounds:type_name -> com.miti99.gomoku.proto.GameMoveOutOfBoundsResponse
	20, // 14: com.miti99.gomoku.proto.Response.game_move_not_your_turn:type_name -> com.miti99.gomoku.proto.GameMoveNotYourTurnResponse
	21, // 15: com.miti99.gomoku.proto.Response.game_over:type_name -> com.miti99.gomoku.proto.GameOverResponse
	22, // 16: com.miti99.gomoku.proto.Response.pve_difficulty_not_support:type_name -> com.miti99.gomoku.proto.PveDifficultyNotSupportResponse
	23, // 17: com.miti99.gomoku.proto.Response.watch_game_success:type_name -> com.miti99.gomoku.proto.WatchGameSuccessResponse
	24, // 18: com.miti99.gomoku.proto.Response.client_exit:type_name -> com.miti99.gomoku.proto.ClientExitResponse
	25, // 19: com.miti99.gomoku.proto.Response.spectator_cannot_act:type_name -> com.miti99.gomoku.proto.SpectatorCannotActResponse
	2,  // 20: com.miti99.gomoku.proto.RoomSummary.room_type:type_name -> com.miti99.gomoku.proto.RoomType
	8,  // 21: com.miti99.gomoku.proto.ShowRoomsResponse.rooms:type_name -> com.miti99.gomoku.proto.RoomSummary
	2,  // 22: com.miti99.gomoku.proto.RoomCreateSuccessResponse.room_type:type_name -> com.miti99.gomoku.proto.RoomType
	0,  // 23: com.miti99.gomoku.proto.GameMoveSuccessResponse.piece:type_name -> com.miti99.gomoku.proto.Piece
	1,  // 24: com.miti99.gomoku.proto.GameOverResponse.result:type_name -> com.miti99.gomoku.proto.GameResult
	3,  // 25: com.miti99.gomoku.proto.WatchGameSuccessResponse.status:type_name -> com.miti99.gomoku.proto.RoomStatus
	26, // [26:26] is the sub-list for method output_type
	26, // [26:26] is the sub-list for method input_type
	26, // [26:26] is the sub-list for extension type_name
	26, // [26:26] is the sub-list for extension extendee
	0,  // [0:26] is the sub-list for field type_name
}

func init() { file_response_proto_init() }
func file_response_proto_init() {
	if File_response_proto != nil {
		return
	}
	file_response_proto_msgTypes[0].OneofWrappers = []any{
		(*Response_ClientConnect)(nil),
		(*Response_NicknameSet)(nil),
		(*Response_ShowOptions)(nil),
		(*Response_ShowRooms)(nil),
		(*Response_RoomCreateSuccess)(nil),
		(*Response_RoomJoinSuccess)(nil),
		(*Response_RoomJoinFailFull)(nil),
		(*Response_RoomJoinFailNotFound)(nil),
		(*Response_RoomPlayFailNotFound)(nil),
		(*Response_GameStarting)(nil),
		(*Response_GameMoveSuccess)(nil),
		(*Response_GameMoveInvalid)(nil),
		(*Response_GameMoveOccupied)(nil),
		(*Response_GameMoveOutOfBounds)(nil),
		(*Response_GameMoveNotYourTurn)(nil),
		(*Response_GameOver)(nil),
		(*Response_PveDifficultyNotSupport)(nil),
		(*Response_WatchGameSuccess)(nil),
		(*Response_ClientExit)(nil),
		(*Response_SpectatorCannotAct)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_response_proto_rawDesc), len(file_response_proto_rawDesc)),
			NumEnums:      4,
			NumMessages:   22,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_response_proto_goTypes,
		DependencyIndexes: file_response_proto_depIdxs,
		EnumInfos:         file_response_proto_enumTypes,
		MessageInfos:      file_response_proto_msgTypes,
	}.Build()
	File_response_proto = out.File
	file_response_proto_goTypes = nil
	file_response_proto_depIdxs = nil
}