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

package utils

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)
)

type ChatMessage struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Msg           string                 `protobuf:"bytes,1,opt,name=msg,proto3" json:"msg,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ChatMessage) ProtoMessage() {}

func (x *ChatMessage) ProtoReflect() protoreflect.Message {
	mi := &file_packets_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 ChatMessage.ProtoReflect.Descriptor instead.
func (*ChatMessage) Descriptor() ([]byte, []int) {
	return file_packets_proto_rawDescGZIP(), []int{0}
}

func (x *ChatMessage) GetMsg() string {
	if x != nil {
		return x.Msg
	}
	return ""
}

type IdMessage struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Id            uint64                 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*IdMessage) ProtoMessage() {}

func (x *IdMessage) ProtoReflect() protoreflect.Message {
	mi := &file_packets_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 IdMessage.ProtoReflect.Descriptor instead.
func (*IdMessage) Descriptor() ([]byte, []int) {
	return file_packets_proto_rawDescGZIP(), []int{1}
}

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

type LoginRequestMessage struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Username      string                 `protobuf:"bytes,1,opt,name=username,proto3" json:"username,omitempty"`
	Password      string                 `protobuf:"bytes,2,opt,name=password,proto3" json:"password,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*LoginRequestMessage) ProtoMessage() {}

func (x *LoginRequestMessage) ProtoReflect() protoreflect.Message {
	mi := &file_packets_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 LoginRequestMessage.ProtoReflect.Descriptor instead.
func (*LoginRequestMessage) Descriptor() ([]byte, []int) {
	return file_packets_proto_rawDescGZIP(), []int{2}
}

func (x *LoginRequestMessage) GetUsername() string {
	if x != nil {
		return x.Username
	}
	return ""
}

func (x *LoginRequestMessage) GetPassword() string {
	if x != nil {
		return x.Password
	}
	return ""
}

type RegisterRequestMessage struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Username      string                 `protobuf:"bytes,1,opt,name=username,proto3" json:"username,omitempty"`
	Password      string                 `protobuf:"bytes,2,opt,name=password,proto3" json:"password,omitempty"`
	Color         int32                  `protobuf:"varint,3,opt,name=color,proto3" json:"color,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*RegisterRequestMessage) ProtoMessage() {}

func (x *RegisterRequestMessage) ProtoReflect() protoreflect.Message {
	mi := &file_packets_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 RegisterRequestMessage.ProtoReflect.Descriptor instead.
func (*RegisterRequestMessage) Descriptor() ([]byte, []int) {
	return file_packets_proto_rawDescGZIP(), []int{3}
}

func (x *RegisterRequestMessage) GetUsername() string {
	if x != nil {
		return x.Username
	}
	return ""
}

func (x *RegisterRequestMessage) GetPassword() string {
	if x != nil {
		return x.Password
	}
	return ""
}

func (x *RegisterRequestMessage) GetColor() int32 {
	if x != nil {
		return x.Color
	}
	return 0
}

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

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

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

func (*OkResponseMessage) ProtoMessage() {}

func (x *OkResponseMessage) ProtoReflect() protoreflect.Message {
	mi := &file_packets_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 OkResponseMessage.ProtoReflect.Descriptor instead.
func (*OkResponseMessage) Descriptor() ([]byte, []int) {
	return file_packets_proto_rawDescGZIP(), []int{4}
}

type DenyResponseMessage struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Reason        string                 `protobuf:"bytes,1,opt,name=reason,proto3" json:"reason,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*DenyResponseMessage) ProtoMessage() {}

func (x *DenyResponseMessage) ProtoReflect() protoreflect.Message {
	mi := &file_packets_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 DenyResponseMessage.ProtoReflect.Descriptor instead.
func (*DenyResponseMessage) Descriptor() ([]byte, []int) {
	return file_packets_proto_rawDescGZIP(), []int{5}
}

func (x *DenyResponseMessage) GetReason() string {
	if x != nil {
		return x.Reason
	}
	return ""
}

type PlayerMessage struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Id            uint64                 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	Name          string                 `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	X             float64                `protobuf:"fixed64,3,opt,name=x,proto3" json:"x,omitempty"`
	Y             float64                `protobuf:"fixed64,4,opt,name=y,proto3" json:"y,omitempty"`
	Radius        float64                `protobuf:"fixed64,5,opt,name=radius,proto3" json:"radius,omitempty"`
	Direction     float64                `protobuf:"fixed64,6,opt,name=direction,proto3" json:"direction,omitempty"`
	Speed         float64                `protobuf:"fixed64,7,opt,name=speed,proto3" json:"speed,omitempty"`
	Color         int32                  `protobuf:"varint,8,opt,name=color,proto3" json:"color,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*PlayerMessage) ProtoMessage() {}

func (x *PlayerMessage) ProtoReflect() protoreflect.Message {
	mi := &file_packets_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 PlayerMessage.ProtoReflect.Descriptor instead.
func (*PlayerMessage) Descriptor() ([]byte, []int) {
	return file_packets_proto_rawDescGZIP(), []int{6}
}

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

func (x *PlayerMessage) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

func (x *PlayerMessage) GetX() float64 {
	if x != nil {
		return x.X
	}
	return 0
}

func (x *PlayerMessage) GetY() float64 {
	if x != nil {
		return x.Y
	}
	return 0
}

func (x *PlayerMessage) GetRadius() float64 {
	if x != nil {
		return x.Radius
	}
	return 0
}

func (x *PlayerMessage) GetDirection() float64 {
	if x != nil {
		return x.Direction
	}
	return 0
}

func (x *PlayerMessage) GetSpeed() float64 {
	if x != nil {
		return x.Speed
	}
	return 0
}

func (x *PlayerMessage) GetColor() int32 {
	if x != nil {
		return x.Color
	}
	return 0
}

type PlayerDirectionMessage struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Direction     float64                `protobuf:"fixed64,1,opt,name=direction,proto3" json:"direction,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*PlayerDirectionMessage) ProtoMessage() {}

func (x *PlayerDirectionMessage) ProtoReflect() protoreflect.Message {
	mi := &file_packets_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 PlayerDirectionMessage.ProtoReflect.Descriptor instead.
func (*PlayerDirectionMessage) Descriptor() ([]byte, []int) {
	return file_packets_proto_rawDescGZIP(), []int{7}
}

func (x *PlayerDirectionMessage) GetDirection() float64 {
	if x != nil {
		return x.Direction
	}
	return 0
}

type SporeMessage struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Id            uint64                 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	X             float64                `protobuf:"fixed64,2,opt,name=x,proto3" json:"x,omitempty"`
	Y             float64                `protobuf:"fixed64,3,opt,name=y,proto3" json:"y,omitempty"`
	Radius        float64                `protobuf:"fixed64,4,opt,name=radius,proto3" json:"radius,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*SporeMessage) ProtoMessage() {}

func (x *SporeMessage) ProtoReflect() protoreflect.Message {
	mi := &file_packets_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 SporeMessage.ProtoReflect.Descriptor instead.
func (*SporeMessage) Descriptor() ([]byte, []int) {
	return file_packets_proto_rawDescGZIP(), []int{8}
}

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

func (x *SporeMessage) GetX() float64 {
	if x != nil {
		return x.X
	}
	return 0
}

func (x *SporeMessage) GetY() float64 {
	if x != nil {
		return x.Y
	}
	return 0
}

func (x *SporeMessage) GetRadius() float64 {
	if x != nil {
		return x.Radius
	}
	return 0
}

type SporeConsumedMessage struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	SporeId       uint64                 `protobuf:"varint,1,opt,name=spore_id,json=sporeId,proto3" json:"spore_id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*SporeConsumedMessage) ProtoMessage() {}

func (x *SporeConsumedMessage) ProtoReflect() protoreflect.Message {
	mi := &file_packets_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 SporeConsumedMessage.ProtoReflect.Descriptor instead.
func (*SporeConsumedMessage) Descriptor() ([]byte, []int) {
	return file_packets_proto_rawDescGZIP(), []int{9}
}

func (x *SporeConsumedMessage) GetSporeId() uint64 {
	if x != nil {
		return x.SporeId
	}
	return 0
}

type SporesBatchMessage struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Spores        []*SporeMessage        `protobuf:"bytes,1,rep,name=spores,proto3" json:"spores,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*SporesBatchMessage) ProtoMessage() {}

func (x *SporesBatchMessage) ProtoReflect() protoreflect.Message {
	mi := &file_packets_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 SporesBatchMessage.ProtoReflect.Descriptor instead.
func (*SporesBatchMessage) Descriptor() ([]byte, []int) {
	return file_packets_proto_rawDescGZIP(), []int{10}
}

func (x *SporesBatchMessage) GetSpores() []*SporeMessage {
	if x != nil {
		return x.Spores
	}
	return nil
}

type PlayerConsumedMessage struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	PlayerId      uint64                 `protobuf:"varint,1,opt,name=player_id,json=playerId,proto3" json:"player_id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*PlayerConsumedMessage) ProtoMessage() {}

func (x *PlayerConsumedMessage) ProtoReflect() protoreflect.Message {
	mi := &file_packets_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 PlayerConsumedMessage.ProtoReflect.Descriptor instead.
func (*PlayerConsumedMessage) Descriptor() ([]byte, []int) {
	return file_packets_proto_rawDescGZIP(), []int{11}
}

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

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

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

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

func (*HiscoreBoardRequestMessage) ProtoMessage() {}

func (x *HiscoreBoardRequestMessage) ProtoReflect() protoreflect.Message {
	mi := &file_packets_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 HiscoreBoardRequestMessage.ProtoReflect.Descriptor instead.
func (*HiscoreBoardRequestMessage) Descriptor() ([]byte, []int) {
	return file_packets_proto_rawDescGZIP(), []int{12}
}

type HiscoreMessage struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Rank          uint64                 `protobuf:"varint,1,opt,name=rank,proto3" json:"rank,omitempty"`
	Name          string                 `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	Score         uint64                 `protobuf:"varint,3,opt,name=score,proto3" json:"score,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*HiscoreMessage) ProtoMessage() {}

func (x *HiscoreMessage) ProtoReflect() protoreflect.Message {
	mi := &file_packets_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 HiscoreMessage.ProtoReflect.Descriptor instead.
func (*HiscoreMessage) Descriptor() ([]byte, []int) {
	return file_packets_proto_rawDescGZIP(), []int{13}
}

func (x *HiscoreMessage) GetRank() uint64 {
	if x != nil {
		return x.Rank
	}
	return 0
}

func (x *HiscoreMessage) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

func (x *HiscoreMessage) GetScore() uint64 {
	if x != nil {
		return x.Score
	}
	return 0
}

type HiscoreBoardMessage struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Hiscores      []*HiscoreMessage      `protobuf:"bytes,1,rep,name=hiscores,proto3" json:"hiscores,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*HiscoreBoardMessage) ProtoMessage() {}

func (x *HiscoreBoardMessage) ProtoReflect() protoreflect.Message {
	mi := &file_packets_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 HiscoreBoardMessage.ProtoReflect.Descriptor instead.
func (*HiscoreBoardMessage) Descriptor() ([]byte, []int) {
	return file_packets_proto_rawDescGZIP(), []int{14}
}

func (x *HiscoreBoardMessage) GetHiscores() []*HiscoreMessage {
	if x != nil {
		return x.Hiscores
	}
	return nil
}

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

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

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

func (*FinishedBrowsingHiscoresMessage) ProtoMessage() {}

func (x *FinishedBrowsingHiscoresMessage) ProtoReflect() protoreflect.Message {
	mi := &file_packets_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 FinishedBrowsingHiscoresMessage.ProtoReflect.Descriptor instead.
func (*FinishedBrowsingHiscoresMessage) Descriptor() ([]byte, []int) {
	return file_packets_proto_rawDescGZIP(), []int{15}
}

type SearchHiscoreMessage struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Name          string                 `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*SearchHiscoreMessage) ProtoMessage() {}

func (x *SearchHiscoreMessage) ProtoReflect() protoreflect.Message {
	mi := &file_packets_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 SearchHiscoreMessage.ProtoReflect.Descriptor instead.
func (*SearchHiscoreMessage) Descriptor() ([]byte, []int) {
	return file_packets_proto_rawDescGZIP(), []int{16}
}

func (x *SearchHiscoreMessage) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

type DisconnectMessage struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Reason        string                 `protobuf:"bytes,1,opt,name=reason,proto3" json:"reason,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*DisconnectMessage) ProtoMessage() {}

func (x *DisconnectMessage) ProtoReflect() protoreflect.Message {
	mi := &file_packets_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 DisconnectMessage.ProtoReflect.Descriptor instead.
func (*DisconnectMessage) Descriptor() ([]byte, []int) {
	return file_packets_proto_rawDescGZIP(), []int{17}
}

func (x *DisconnectMessage) GetReason() string {
	if x != nil {
		return x.Reason
	}
	return ""
}

type Packet struct {
	state    protoimpl.MessageState `protogen:"open.v1"`
	SenderId uint64                 `protobuf:"varint,1,opt,name=sender_id,json=senderId,proto3" json:"sender_id,omitempty"`
	// Types that are valid to be assigned to Msg:
	//
	//	*Packet_Chat
	//	*Packet_Id
	//	*Packet_LoginRequest
	//	*Packet_RegisterRequest
	//	*Packet_OkResponse
	//	*Packet_DenyResponse
	//	*Packet_Player
	//	*Packet_PlayerDirection
	//	*Packet_Spore
	//	*Packet_SporeConsumed
	//	*Packet_SporesBatch
	//	*Packet_PlayerConsumed
	//	*Packet_HiscoreBoardRequest
	//	*Packet_Hiscore
	//	*Packet_HiscoreBoard
	//	*Packet_FinishedBrowsingHiscores
	//	*Packet_SearchHiscore
	//	*Packet_Disconnect
	Msg           isPacket_Msg `protobuf_oneof:"msg"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Packet) ProtoMessage() {}

func (x *Packet) ProtoReflect() protoreflect.Message {
	mi := &file_packets_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 Packet.ProtoReflect.Descriptor instead.
func (*Packet) Descriptor() ([]byte, []int) {
	return file_packets_proto_rawDescGZIP(), []int{18}
}

func (x *Packet) GetSenderId() uint64 {
	if x != nil {
		return x.SenderId
	}
	return 0
}

func (x *Packet) GetMsg() isPacket_Msg {
	if x != nil {
		return x.Msg
	}
	return nil
}

func (x *Packet) GetChat() *ChatMessage {
	if x != nil {
		if x, ok := x.Msg.(*Packet_Chat); ok {
			return x.Chat
		}
	}
	return nil
}

func (x *Packet) GetId() *IdMessage {
	if x != nil {
		if x, ok := x.Msg.(*Packet_Id); ok {
			return x.Id
		}
	}
	return nil
}

func (x *Packet) GetLoginRequest() *LoginRequestMessage {
	if x != nil {
		if x, ok := x.Msg.(*Packet_LoginRequest); ok {
			return x.LoginRequest
		}
	}
	return nil
}

func (x *Packet) GetRegisterRequest() *RegisterRequestMessage {
	if x != nil {
		if x, ok := x.Msg.(*Packet_RegisterRequest); ok {
			return x.RegisterRequest
		}
	}
	return nil
}

func (x *Packet) GetOkResponse() *OkResponseMessage {
	if x != nil {
		if x, ok := x.Msg.(*Packet_OkResponse); ok {
			return x.OkResponse
		}
	}
	return nil
}

func (x *Packet) GetDenyResponse() *DenyResponseMessage {
	if x != nil {
		if x, ok := x.Msg.(*Packet_DenyResponse); ok {
			return x.DenyResponse
		}
	}
	return nil
}

func (x *Packet) GetPlayer() *PlayerMessage {
	if x != nil {
		if x, ok := x.Msg.(*Packet_Player); ok {
			return x.Player
		}
	}
	return nil
}

func (x *Packet) GetPlayerDirection() *PlayerDirectionMessage {
	if x != nil {
		if x, ok := x.Msg.(*Packet_PlayerDirection); ok {
			return x.PlayerDirection
		}
	}
	return nil
}

func (x *Packet) GetSpore() *SporeMessage {
	if x != nil {
		if x, ok := x.Msg.(*Packet_Spore); ok {
			return x.Spore
		}
	}
	return nil
}

func (x *Packet) GetSporeConsumed() *SporeConsumedMessage {
	if x != nil {
		if x, ok := x.Msg.(*Packet_SporeConsumed); ok {
			return x.SporeConsumed
		}
	}
	return nil
}

func (x *Packet) GetSporesBatch() *SporesBatchMessage {
	if x != nil {
		if x, ok := x.Msg.(*Packet_SporesBatch); ok {
			return x.SporesBatch
		}
	}
	return nil
}

func (x *Packet) GetPlayerConsumed() *PlayerConsumedMessage {
	if x != nil {
		if x, ok := x.Msg.(*Packet_PlayerConsumed); ok {
			return x.PlayerConsumed
		}
	}
	return nil
}

func (x *Packet) GetHiscoreBoardRequest() *HiscoreBoardRequestMessage {
	if x != nil {
		if x, ok := x.Msg.(*Packet_HiscoreBoardRequest); ok {
			return x.HiscoreBoardRequest
		}
	}
	return nil
}

func (x *Packet) GetHiscore() *HiscoreMessage {
	if x != nil {
		if x, ok := x.Msg.(*Packet_Hiscore); ok {
			return x.Hiscore
		}
	}
	return nil
}

func (x *Packet) GetHiscoreBoard() *HiscoreBoardMessage {
	if x != nil {
		if x, ok := x.Msg.(*Packet_HiscoreBoard); ok {
			return x.HiscoreBoard
		}
	}
	return nil
}

func (x *Packet) GetFinishedBrowsingHiscores() *FinishedBrowsingHiscoresMessage {
	if x != nil {
		if x, ok := x.Msg.(*Packet_FinishedBrowsingHiscores); ok {
			return x.FinishedBrowsingHiscores
		}
	}
	return nil
}

func (x *Packet) GetSearchHiscore() *SearchHiscoreMessage {
	if x != nil {
		if x, ok := x.Msg.(*Packet_SearchHiscore); ok {
			return x.SearchHiscore
		}
	}
	return nil
}

func (x *Packet) GetDisconnect() *DisconnectMessage {
	if x != nil {
		if x, ok := x.Msg.(*Packet_Disconnect); ok {
			return x.Disconnect
		}
	}
	return nil
}

type isPacket_Msg interface {
	isPacket_Msg()
}

type Packet_Chat struct {
	Chat *ChatMessage `protobuf:"bytes,2,opt,name=chat,proto3,oneof"`
}

type Packet_Id struct {
	Id *IdMessage `protobuf:"bytes,3,opt,name=id,proto3,oneof"`
}

type Packet_LoginRequest struct {
	LoginRequest *LoginRequestMessage `protobuf:"bytes,4,opt,name=login_request,json=loginRequest,proto3,oneof"`
}

type Packet_RegisterRequest struct {
	RegisterRequest *RegisterRequestMessage `protobuf:"bytes,5,opt,name=register_request,json=registerRequest,proto3,oneof"`
}

type Packet_OkResponse struct {
	OkResponse *OkResponseMessage `protobuf:"bytes,6,opt,name=ok_response,json=okResponse,proto3,oneof"`
}

type Packet_DenyResponse struct {
	DenyResponse *DenyResponseMessage `protobuf:"bytes,7,opt,name=deny_response,json=denyResponse,proto3,oneof"`
}

type Packet_Player struct {
	Player *PlayerMessage `protobuf:"bytes,8,opt,name=player,proto3,oneof"`
}

type Packet_PlayerDirection struct {
	PlayerDirection *PlayerDirectionMessage `protobuf:"bytes,9,opt,name=player_direction,json=playerDirection,proto3,oneof"`
}

type Packet_Spore struct {
	Spore *SporeMessage `protobuf:"bytes,10,opt,name=spore,proto3,oneof"`
}

type Packet_SporeConsumed struct {
	SporeConsumed *SporeConsumedMessage `protobuf:"bytes,11,opt,name=spore_consumed,json=sporeConsumed,proto3,oneof"`
}

type Packet_SporesBatch struct {
	SporesBatch *SporesBatchMessage `protobuf:"bytes,12,opt,name=spores_batch,json=sporesBatch,proto3,oneof"`
}

type Packet_PlayerConsumed struct {
	PlayerConsumed *PlayerConsumedMessage `protobuf:"bytes,13,opt,name=player_consumed,json=playerConsumed,proto3,oneof"`
}

type Packet_HiscoreBoardRequest struct {
	HiscoreBoardRequest *HiscoreBoardRequestMessage `protobuf:"bytes,14,opt,name=hiscore_board_request,json=hiscoreBoardRequest,proto3,oneof"`
}

type Packet_Hiscore struct {
	Hiscore *HiscoreMessage `protobuf:"bytes,15,opt,name=hiscore,proto3,oneof"`
}

type Packet_HiscoreBoard struct {
	HiscoreBoard *HiscoreBoardMessage `protobuf:"bytes,16,opt,name=hiscore_board,json=hiscoreBoard,proto3,oneof"`
}

type Packet_FinishedBrowsingHiscores struct {
	FinishedBrowsingHiscores *FinishedBrowsingHiscoresMessage `protobuf:"bytes,17,opt,name=finished_browsing_hiscores,json=finishedBrowsingHiscores,proto3,oneof"`
}

type Packet_SearchHiscore struct {
	SearchHiscore *SearchHiscoreMessage `protobuf:"bytes,18,opt,name=search_hiscore,json=searchHiscore,proto3,oneof"`
}

type Packet_Disconnect struct {
	Disconnect *DisconnectMessage `protobuf:"bytes,19,opt,name=disconnect,proto3,oneof"`
}

func (*Packet_Chat) isPacket_Msg() {}

func (*Packet_Id) isPacket_Msg() {}

func (*Packet_LoginRequest) isPacket_Msg() {}

func (*Packet_RegisterRequest) isPacket_Msg() {}

func (*Packet_OkResponse) isPacket_Msg() {}

func (*Packet_DenyResponse) isPacket_Msg() {}

func (*Packet_Player) isPacket_Msg() {}

func (*Packet_PlayerDirection) isPacket_Msg() {}

func (*Packet_Spore) isPacket_Msg() {}

func (*Packet_SporeConsumed) isPacket_Msg() {}

func (*Packet_SporesBatch) isPacket_Msg() {}

func (*Packet_PlayerConsumed) isPacket_Msg() {}

func (*Packet_HiscoreBoardRequest) isPacket_Msg() {}

func (*Packet_Hiscore) isPacket_Msg() {}

func (*Packet_HiscoreBoard) isPacket_Msg() {}

func (*Packet_FinishedBrowsingHiscores) isPacket_Msg() {}

func (*Packet_SearchHiscore) isPacket_Msg() {}

func (*Packet_Disconnect) isPacket_Msg() {}

var File_packets_proto protoreflect.FileDescriptor

const file_packets_proto_rawDesc = "" +
	"\n" +
	"\rpackets.proto\x12\apackets\"\x1f\n" +
	"\vChatMessage\x12\x10\n" +
	"\x03msg\x18\x01 \x01(\tR\x03msg\"\x1b\n" +
	"\tIdMessage\x12\x0e\n" +
	"\x02id\x18\x01 \x01(\x04R\x02id\"M\n" +
	"\x13LoginRequestMessage\x12\x1a\n" +
	"\busername\x18\x01 \x01(\tR\busername\x12\x1a\n" +
	"\bpassword\x18\x02 \x01(\tR\bpassword\"f\n" +
	"\x16RegisterRequestMessage\x12\x1a\n" +
	"\busername\x18\x01 \x01(\tR\busername\x12\x1a\n" +
	"\bpassword\x18\x02 \x01(\tR\bpassword\x12\x14\n" +
	"\x05color\x18\x03 \x01(\x05R\x05color\"\x13\n" +
	"\x11OkResponseMessage\"-\n" +
	"\x13DenyResponseMessage\x12\x16\n" +
	"\x06reason\x18\x01 \x01(\tR\x06reason\"\xb1\x01\n" +
	"\rPlayerMessage\x12\x0e\n" +
	"\x02id\x18\x01 \x01(\x04R\x02id\x12\x12\n" +
	"\x04name\x18\x02 \x01(\tR\x04name\x12\f\n" +
	"\x01x\x18\x03 \x01(\x01R\x01x\x12\f\n" +
	"\x01y\x18\x04 \x01(\x01R\x01y\x12\x16\n" +
	"\x06radius\x18\x05 \x01(\x01R\x06radius\x12\x1c\n" +
	"\tdirection\x18\x06 \x01(\x01R\tdirection\x12\x14\n" +
	"\x05speed\x18\a \x01(\x01R\x05speed\x12\x14\n" +
	"\x05color\x18\b \x01(\x05R\x05color\"6\n" +
	"\x16PlayerDirectionMessage\x12\x1c\n" +
	"\tdirection\x18\x01 \x01(\x01R\tdirection\"R\n" +
	"\fSporeMessage\x12\x0e\n" +
	"\x02id\x18\x01 \x01(\x04R\x02id\x12\f\n" +
	"\x01x\x18\x02 \x01(\x01R\x01x\x12\f\n" +
	"\x01y\x18\x03 \x01(\x01R\x01y\x12\x16\n" +
	"\x06radius\x18\x04 \x01(\x01R\x06radius\"1\n" +
	"\x14SporeConsumedMessage\x12\x19\n" +
	"\bspore_id\x18\x01 \x01(\x04R\asporeId\"C\n" +
	"\x12SporesBatchMessage\x12-\n" +
	"\x06spores\x18\x01 \x03(\v2\x15.packets.SporeMessageR\x06spores\"4\n" +
	"\x15PlayerConsumedMessage\x12\x1b\n" +
	"\tplayer_id\x18\x01 \x01(\x04R\bplayerId\"\x1c\n" +
	"\x1aHiscoreBoardRequestMessage\"N\n" +
	"\x0eHiscoreMessage\x12\x12\n" +
	"\x04rank\x18\x01 \x01(\x04R\x04rank\x12\x12\n" +
	"\x04name\x18\x02 \x01(\tR\x04name\x12\x14\n" +
	"\x05score\x18\x03 \x01(\x04R\x05score\"J\n" +
	"\x13HiscoreBoardMessage\x123\n" +
	"\bhiscores\x18\x01 \x03(\v2\x17.packets.HiscoreMessageR\bhiscores\"!\n" +
	"\x1fFinishedBrowsingHiscoresMessage\"*\n" +
	"\x14SearchHiscoreMessage\x12\x12\n" +
	"\x04name\x18\x01 \x01(\tR\x04name\"+\n" +
	"\x11DisconnectMessage\x12\x16\n" +
	"\x06reason\x18\x01 \x01(\tR\x06reason\"\xde\t\n" +
	"\x06Packet\x12\x1b\n" +
	"\tsender_id\x18\x01 \x01(\x04R\bsenderId\x12*\n" +
	"\x04chat\x18\x02 \x01(\v2\x14.packets.ChatMessageH\x00R\x04chat\x12$\n" +
	"\x02id\x18\x03 \x01(\v2\x12.packets.IdMessageH\x00R\x02id\x12C\n" +
	"\rlogin_request\x18\x04 \x01(\v2\x1c.packets.LoginRequestMessageH\x00R\floginRequest\x12L\n" +
	"\x10register_request\x18\x05 \x01(\v2\x1f.packets.RegisterRequestMessageH\x00R\x0fregisterRequest\x12=\n" +
	"\vok_response\x18\x06 \x01(\v2\x1a.packets.OkResponseMessageH\x00R\n" +
	"okResponse\x12C\n" +
	"\rdeny_response\x18\a \x01(\v2\x1c.packets.DenyResponseMessageH\x00R\fdenyResponse\x120\n" +
	"\x06player\x18\b \x01(\v2\x16.packets.PlayerMessageH\x00R\x06player\x12L\n" +
	"\x10player_direction\x18\t \x01(\v2\x1f.packets.PlayerDirectionMessageH\x00R\x0fplayerDirection\x12-\n" +
	"\x05spore\x18\n" +
	" \x01(\v2\x15.packets.SporeMessageH\x00R\x05spore\x12F\n" +
	"\x0espore_consumed\x18\v \x01(\v2\x1d.packets.SporeConsumedMessageH\x00R\rsporeConsumed\x12@\n" +
	"\fspores_batch\x18\f \x01(\v2\x1b.packets.SporesBatchMessageH\x00R\vsporesBatch\x12I\n" +
	"\x0fplayer_consumed\x18\r \x01(\v2\x1e.packets.PlayerConsumedMessageH\x00R\x0eplayerConsumed\x12Y\n" +
	"\x15hiscore_board_request\x18\x0e \x01(\v2#.packets.HiscoreBoardRequestMessageH\x00R\x13hiscoreBoardRequest\x123\n" +
	"\ahiscore\x18\x0f \x01(\v2\x17.packets.HiscoreMessageH\x00R\ahiscore\x12C\n" +
	"\rhiscore_board\x18\x10 \x01(\v2\x1c.packets.HiscoreBoardMessageH\x00R\fhiscoreBoard\x12h\n" +
	"\x1afinished_browsing_hiscores\x18\x11 \x01(\v2(.packets.FinishedBrowsingHiscoresMessageH\x00R\x18finishedBrowsingHiscores\x12F\n" +
	"\x0esearch_hiscore\x18\x12 \x01(\v2\x1d.packets.SearchHiscoreMessageH\x00R\rsearchHiscore\x12<\n" +
	"\n" +
	"disconnect\x18\x13 \x01(\v2\x1a.packets.DisconnectMessageH\x00R\n" +
	"disconnectB\x05\n" +
	"\x03msgB\bZ\x06utils/b\x06proto3"

var (
	file_packets_proto_rawDescOnce sync.Once
	file_packets_proto_rawDescData []byte
)

func file_packets_proto_rawDescGZIP() []byte {
	file_packets_proto_rawDescOnce.Do(func() {
		file_packets_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_packets_proto_rawDesc), len(file_packets_proto_rawDesc)))
	})
	return file_packets_proto_rawDescData
}

var file_packets_proto_msgTypes = make([]protoimpl.MessageInfo, 19)
var file_packets_proto_goTypes = []any{
	(*ChatMessage)(nil),                     // 0: packets.ChatMessage
	(*IdMessage)(nil),                       // 1: packets.IdMessage
	(*LoginRequestMessage)(nil),             // 2: packets.LoginRequestMessage
	(*RegisterRequestMessage)(nil),          // 3: packets.RegisterRequestMessage
	(*OkResponseMessage)(nil),               // 4: packets.OkResponseMessage
	(*DenyResponseMessage)(nil),             // 5: packets.DenyResponseMessage
	(*PlayerMessage)(nil),                   // 6: packets.PlayerMessage
	(*PlayerDirectionMessage)(nil),          // 7: packets.PlayerDirectionMessage
	(*SporeMessage)(nil),                    // 8: packets.SporeMessage
	(*SporeConsumedMessage)(nil),            // 9: packets.SporeConsumedMessage
	(*SporesBatchMessage)(nil),              // 10: packets.SporesBatchMessage
	(*PlayerConsumedMessage)(nil),           // 11: packets.PlayerConsumedMessage
	(*HiscoreBoardRequestMessage)(nil),      // 12: packets.HiscoreBoardRequestMessage
	(*HiscoreMessage)(nil),                  // 13: packets.HiscoreMessage
	(*HiscoreBoardMessage)(nil),             // 14: packets.HiscoreBoardMessage
	(*FinishedBrowsingHiscoresMessage)(nil), // 15: packets.FinishedBrowsingHiscoresMessage
	(*SearchHiscoreMessage)(nil),            // 16: packets.SearchHiscoreMessage
	(*DisconnectMessage)(nil),               // 17: packets.DisconnectMessage
	(*Packet)(nil),                          // 18: packets.Packet
}
var file_packets_proto_depIdxs = []int32{
	8,  // 0: packets.SporesBatchMessage.spores:type_name -> packets.SporeMessage
	13, // 1: packets.HiscoreBoardMessage.hiscores:type_name -> packets.HiscoreMessage
	0,  // 2: packets.Packet.chat:type_name -> packets.ChatMessage
	1,  // 3: packets.Packet.id:type_name -> packets.IdMessage
	2,  // 4: packets.Packet.login_request:type_name -> packets.LoginRequestMessage
	3,  // 5: packets.Packet.register_request:type_name -> packets.RegisterRequestMessage
	4,  // 6: packets.Packet.ok_response:type_name -> packets.OkResponseMessage
	5,  // 7: packets.Packet.deny_response:type_name -> packets.DenyResponseMessage
	6,  // 8: packets.Packet.player:type_name -> packets.PlayerMessage
	7,  // 9: packets.Packet.player_direction:type_name -> packets.PlayerDirectionMessage
	8,  // 10: packets.Packet.spore:type_name -> packets.SporeMessage
	9,  // 11: packets.Packet.spore_consumed:type_name -> packets.SporeConsumedMessage
	10, // 12: packets.Packet.spores_batch:type_name -> packets.SporesBatchMessage
	11, // 13: packets.Packet.player_consumed:type_name -> packets.PlayerConsumedMessage
	12, // 14: packets.Packet.hiscore_board_request:type_name -> packets.HiscoreBoardRequestMessage
	13, // 15: packets.Packet.hiscore:type_name -> packets.HiscoreMessage
	14, // 16: packets.Packet.hiscore_board:type_name -> packets.HiscoreBoardMessage
	15, // 17: packets.Packet.finished_browsing_hiscores:type_name -> packets.FinishedBrowsingHiscoresMessage
	16, // 18: packets.Packet.search_hiscore:type_name -> packets.SearchHiscoreMessage
	17, // 19: packets.Packet.disconnect:type_name -> packets.DisconnectMessage
	20, // [20:20] is the sub-list for method output_type
	20, // [20:20] is the sub-list for method input_type
	20, // [20:20] is the sub-list for extension type_name
	20, // [20:20] is the sub-list for extension extendee
	0,  // [0:20] is the sub-list for field type_name
}

func init() { file_packets_proto_init() }
func file_packets_proto_init() {
	if File_packets_proto != nil {
		return
	}
	file_packets_proto_msgTypes[18].OneofWrappers = []any{
		(*Packet_Chat)(nil),
		(*Packet_Id)(nil),
		(*Packet_LoginRequest)(nil),
		(*Packet_RegisterRequest)(nil),
		(*Packet_OkResponse)(nil),
		(*Packet_DenyResponse)(nil),
		(*Packet_Player)(nil),
		(*Packet_PlayerDirection)(nil),
		(*Packet_Spore)(nil),
		(*Packet_SporeConsumed)(nil),
		(*Packet_SporesBatch)(nil),
		(*Packet_PlayerConsumed)(nil),
		(*Packet_HiscoreBoardRequest)(nil),
		(*Packet_Hiscore)(nil),
		(*Packet_HiscoreBoard)(nil),
		(*Packet_FinishedBrowsingHiscores)(nil),
		(*Packet_SearchHiscore)(nil),
		(*Packet_Disconnect)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_packets_proto_rawDesc), len(file_packets_proto_rawDesc)),
			NumEnums:      0,
			NumMessages:   19,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_packets_proto_goTypes,
		DependencyIndexes: file_packets_proto_depIdxs,
		MessageInfos:      file_packets_proto_msgTypes,
	}.Build()
	File_packets_proto = out.File
	file_packets_proto_goTypes = nil
	file_packets_proto_depIdxs = nil
}