server.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.23.0
// 	protoc        v3.19.4
// source: server.proto

package proto

import (
	context "context"
	proto "github.com/golang/protobuf/proto"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	reflect "reflect"
	sync "sync"
)

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

// This is a compile-time assertion that a sufficiently up-to-date version
// of the legacy proto package is being used.
const _ = proto.ProtoPackageIsVersion4

type GameSnapshot_State int32

const (
	// The game is waiting for all players be connected. There is a configurable time limit to wait for players. After
	// this limit expires, the match is considered over.
	GameSnapshot_WAITING GameSnapshot_State = 0
	// The game resets the players position to start the match or to restart the match after a goal.
	GameSnapshot_GET_READY GameSnapshot_State = 1
	// The game is waiting for players orders. There is a configurable time window for this phase. After the time
	// limit expires, the server will ignore the missing orders and process the ones it got.
	// (when running on dev mode, the server may allow different behaviours)
	GameSnapshot_LISTENING GameSnapshot_State = 2
	// The game is executing the players' orders in the same sequence they were gotten.
	// If the ball is NOT been holden, its velocity will be processed first. Otherwise, it position will be updated
	// when the ball holder movement be processed.
	// If there is no movement orders from a player, but it has speed greater than 0, it will be processed after
	// all its orders are processed.
	// Each player orders will be processed in the same sequence they were included in the message (e.g. first move,
	// than kick)
	// The ball kick is processed immediately after the order (the ball position is updated as its new velocity
	// after the kick)
	GameSnapshot_PLAYING GameSnapshot_State = 3
	// The game interrupt the match to shift the ball possession. It happens only when the shot time is over (see
	// shot_clock property). The ball will be given to the goalkeeper of the defense team, and the next state will
	// "listening", so the bots will not have time to rearrange before the next turn.
	GameSnapshot_SHIFTING GameSnapshot_State = 4
	// The game may be over after any phase.
	// It can be over after Waiting if there is no players connected after the time limit for connections
	// It can be over after GetReady or Listening if there is no enough players (e.g. connection lost)
	// And it also can be over after Playing state if that was the last turn of the match.
	GameSnapshot_OVER GameSnapshot_State = 99
)

// Enum value maps for GameSnapshot_State.
var (
	GameSnapshot_State_name = map[int32]string{
		0:  "WAITING",
		1:  "GET_READY",
		2:  "LISTENING",
		3:  "PLAYING",
		4:  "SHIFTING",
		99: "OVER",
	}
	GameSnapshot_State_value = map[string]int32{
		"WAITING":   0,
		"GET_READY": 1,
		"LISTENING": 2,
		"PLAYING":   3,
		"SHIFTING":  4,
		"OVER":      99,
	}
)

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

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

func (GameSnapshot_State) Descriptor() protoreflect.EnumDescriptor {
	return file_server_proto_enumTypes[0].Descriptor()
}

func (GameSnapshot_State) Type() protoreflect.EnumType {
	return &file_server_proto_enumTypes[0]
}

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

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

type Team_Side int32

const (
	// Team playing on the left side of field
	Team_HOME Team_Side = 0
	// Team playing on the right side of the field
	Team_AWAY Team_Side = 1
)

// Enum value maps for Team_Side.
var (
	Team_Side_name = map[int32]string{
		0: "HOME",
		1: "AWAY",
	}
	Team_Side_value = map[string]int32{
		"HOME": 0,
		"AWAY": 1,
	}
)

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

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

func (Team_Side) Descriptor() protoreflect.EnumDescriptor {
	return file_server_proto_enumTypes[1].Descriptor()
}

func (Team_Side) Type() protoreflect.EnumType {
	return &file_server_proto_enumTypes[1]
}

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

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

type OrderResponse_StatusCode int32

const (
	OrderResponse_SUCCESS        OrderResponse_StatusCode = 0
	OrderResponse_UNKNOWN_PLAYER OrderResponse_StatusCode = 1
	OrderResponse_NOT_LISTENING  OrderResponse_StatusCode = 2
	OrderResponse_WRONG_TURN     OrderResponse_StatusCode = 3
	OrderResponse_OTHER          OrderResponse_StatusCode = 99
)

// Enum value maps for OrderResponse_StatusCode.
var (
	OrderResponse_StatusCode_name = map[int32]string{
		0:  "SUCCESS",
		1:  "UNKNOWN_PLAYER",
		2:  "NOT_LISTENING",
		3:  "WRONG_TURN",
		99: "OTHER",
	}
	OrderResponse_StatusCode_value = map[string]int32{
		"SUCCESS":        0,
		"UNKNOWN_PLAYER": 1,
		"NOT_LISTENING":  2,
		"WRONG_TURN":     3,
		"OTHER":          99,
	}
)

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

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

func (OrderResponse_StatusCode) Descriptor() protoreflect.EnumDescriptor {
	return file_server_proto_enumTypes[2].Descriptor()
}

func (OrderResponse_StatusCode) Type() protoreflect.EnumType {
	return &file_server_proto_enumTypes[2]
}

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

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

// JoinRequest define the player configuration to the game.
type JoinRequest struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// Only used in official matches to guarantee that only one process will assume that player position (team and number).
	// The bot process will receive this token as an argument, and must send it to the server in this message.
	Token string `protobuf:"bytes,1,opt,name=token,proto3" json:"token,omitempty"`
	// Identifies the protocol version of the bot.
	ProtocolVersion string `protobuf:"bytes,2,opt,name=protocol_version,json=protocolVersion,proto3" json:"protocol_version,omitempty"`
	// Identify the bot's team side (Team_Home or Team_Away)
	TeamSide Team_Side `protobuf:"varint,3,opt,name=team_side,json=teamSide,proto3,enum=lugo.Team_Side" json:"team_side,omitempty"`
	// Player's number 1-11
	Number uint32 `protobuf:"varint,4,opt,name=number,proto3" json:"number,omitempty"`
	// Position where the player must be set at "GetReady" state (at beginning of the match or after a goal)
	InitPosition *Point `protobuf:"bytes,5,opt,name=init_position,json=initPosition,proto3" json:"init_position,omitempty"`
}

func (x *JoinRequest) Reset() {
	*x = JoinRequest{}
	if protoimpl.UnsafeEnabled {
		mi := &file_server_proto_msgTypes[0]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*JoinRequest) ProtoMessage() {}

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

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

func (x *JoinRequest) GetToken() string {
	if x != nil {
		return x.Token
	}
	return ""
}

func (x *JoinRequest) GetProtocolVersion() string {
	if x != nil {
		return x.ProtocolVersion
	}
	return ""
}

func (x *JoinRequest) GetTeamSide() Team_Side {
	if x != nil {
		return x.TeamSide
	}
	return Team_HOME
}

func (x *JoinRequest) GetNumber() uint32 {
	if x != nil {
		return x.Number
	}
	return 0
}

func (x *JoinRequest) GetInitPosition() *Point {
	if x != nil {
		return x.InitPosition
	}
	return nil
}

// GameSnapshot stores all game elements data.
type GameSnapshot struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// The game state defines which phase the game is. The phase determine what the server is doing, are going to do, or
	// what it is waiting for.
	State GameSnapshot_State `protobuf:"varint,1,opt,name=state,proto3,enum=lugo.GameSnapshot_State" json:"state,omitempty"`
	// Turns counter. It starts from 1, but before the match starts, it may be zero.
	Turn uint32 `protobuf:"varint,2,opt,name=turn,proto3" json:"turn,omitempty"`
	// Store the home team elements.
	HomeTeam *Team `protobuf:"bytes,3,opt,name=home_team,json=homeTeam,proto3" json:"home_team,omitempty"`
	// Store the away team elements.
	AwayTeam *Team `protobuf:"bytes,4,opt,name=away_team,json=awayTeam,proto3" json:"away_team,omitempty"`
	// Store the ball element.
	Ball *Ball `protobuf:"bytes,5,opt,name=ball,proto3" json:"ball,omitempty"`
	// number of turns the ball is in a goal zone
	TurnsBallInGoalZone uint32 `protobuf:"varint,6,opt,name=turns_ball_in_goal_zone,json=turnsBallInGoalZone,proto3" json:"turns_ball_in_goal_zone,omitempty"`
	// Store the shot clock to control ball possession limit
	ShotClock *ShotClock `protobuf:"bytes,7,opt,name=shot_clock,json=shotClock,proto3" json:"shot_clock,omitempty"`
}

func (x *GameSnapshot) Reset() {
	*x = GameSnapshot{}
	if protoimpl.UnsafeEnabled {
		mi := &file_server_proto_msgTypes[1]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*GameSnapshot) ProtoMessage() {}

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

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

func (x *GameSnapshot) GetState() GameSnapshot_State {
	if x != nil {
		return x.State
	}
	return GameSnapshot_WAITING
}

func (x *GameSnapshot) GetTurn() uint32 {
	if x != nil {
		return x.Turn
	}
	return 0
}

func (x *GameSnapshot) GetHomeTeam() *Team {
	if x != nil {
		return x.HomeTeam
	}
	return nil
}

func (x *GameSnapshot) GetAwayTeam() *Team {
	if x != nil {
		return x.AwayTeam
	}
	return nil
}

func (x *GameSnapshot) GetBall() *Ball {
	if x != nil {
		return x.Ball
	}
	return nil
}

func (x *GameSnapshot) GetTurnsBallInGoalZone() uint32 {
	if x != nil {
		return x.TurnsBallInGoalZone
	}
	return 0
}

func (x *GameSnapshot) GetShotClock() *ShotClock {
	if x != nil {
		return x.ShotClock
	}
	return nil
}

// Stores all team elements and data.
type Team struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// List of player in the team
	Players []*Player `protobuf:"bytes,1,rep,name=players,proto3" json:"players,omitempty"`
	// Team name
	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	// Team score in the present turn
	Score uint32 `protobuf:"varint,3,opt,name=score,proto3" json:"score,omitempty"`
	// Side which the team is playing on.
	Side Team_Side `protobuf:"varint,4,opt,name=side,proto3,enum=lugo.Team_Side" json:"side,omitempty"`
}

func (x *Team) Reset() {
	*x = Team{}
	if protoimpl.UnsafeEnabled {
		mi := &file_server_proto_msgTypes[2]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*Team) ProtoMessage() {}

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

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

func (x *Team) GetPlayers() []*Player {
	if x != nil {
		return x.Players
	}
	return nil
}

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

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

func (x *Team) GetSide() Team_Side {
	if x != nil {
		return x.Side
	}
	return Team_HOME
}

// Stores the side of the team in attack and the time remaining holding the ball.
// The team side is changed as soon a bot of the defense team catch the ball.
type ShotClock struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// Team side of the team in attack.
	TeamSide Team_Side `protobuf:"varint,6,opt,name=team_side,json=teamSide,proto3,enum=lugo.Team_Side" json:"team_side,omitempty"`
	// Remaining turns the attack team may hold the ball
	RemainingTurns uint32 `protobuf:"varint,7,opt,name=remaining_turns,json=remainingTurns,proto3" json:"remaining_turns,omitempty"`
}

func (x *ShotClock) Reset() {
	*x = ShotClock{}
	if protoimpl.UnsafeEnabled {
		mi := &file_server_proto_msgTypes[3]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*ShotClock) ProtoMessage() {}

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

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

func (x *ShotClock) GetTeamSide() Team_Side {
	if x != nil {
		return x.TeamSide
	}
	return Team_HOME
}

func (x *ShotClock) GetRemainingTurns() uint32 {
	if x != nil {
		return x.RemainingTurns
	}
	return 0
}

// Stores all player attributes
type Player struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// Number of this player in its team (1-11)
	Number uint32 `protobuf:"varint,1,opt,name=number,proto3" json:"number,omitempty"`
	// Current player position
	Position *Point `protobuf:"bytes,2,opt,name=position,proto3" json:"position,omitempty"`
	// Current player velocity
	Velocity *Velocity `protobuf:"bytes,3,opt,name=velocity,proto3" json:"velocity,omitempty"`
	// Team side which its playing in (it's used to speed up some readings since the player element will be in a list
	// of players of a team)
	TeamSide Team_Side `protobuf:"varint,4,opt,name=team_side,json=teamSide,proto3,enum=lugo.Team_Side" json:"team_side,omitempty"`
	// Default position when it's position is reset
	InitPosition *Point `protobuf:"bytes,5,opt,name=init_position,json=initPosition,proto3" json:"init_position,omitempty"`
}

func (x *Player) Reset() {
	*x = Player{}
	if protoimpl.UnsafeEnabled {
		mi := &file_server_proto_msgTypes[4]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*Player) ProtoMessage() {}

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

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

func (x *Player) GetNumber() uint32 {
	if x != nil {
		return x.Number
	}
	return 0
}

func (x *Player) GetPosition() *Point {
	if x != nil {
		return x.Position
	}
	return nil
}

func (x *Player) GetVelocity() *Velocity {
	if x != nil {
		return x.Velocity
	}
	return nil
}

func (x *Player) GetTeamSide() Team_Side {
	if x != nil {
		return x.TeamSide
	}
	return Team_HOME
}

func (x *Player) GetInitPosition() *Point {
	if x != nil {
		return x.InitPosition
	}
	return nil
}

// Stores all ball attributes
type Ball struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// Current position
	Position *Point `protobuf:"bytes,1,opt,name=position,proto3" json:"position,omitempty"`
	// Current velocity. It will be the exactly same velocity as the ball holder when a player is holding it.
	Velocity *Velocity `protobuf:"bytes,2,opt,name=velocity,proto3" json:"velocity,omitempty"`
	// Player that is currently holding the ball. Null if the ball is not holden.
	Holder *Player `protobuf:"bytes,3,opt,name=holder,proto3" json:"holder,omitempty"`
}

func (x *Ball) Reset() {
	*x = Ball{}
	if protoimpl.UnsafeEnabled {
		mi := &file_server_proto_msgTypes[5]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*Ball) ProtoMessage() {}

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

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

func (x *Ball) GetPosition() *Point {
	if x != nil {
		return x.Position
	}
	return nil
}

func (x *Ball) GetVelocity() *Velocity {
	if x != nil {
		return x.Velocity
	}
	return nil
}

func (x *Ball) GetHolder() *Player {
	if x != nil {
		return x.Holder
	}
	return nil
}

// Message sent to the player as a response after sending a order set to the the server.
type OrderResponse struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// Define if the order will be correctly processed.
	Code OrderResponse_StatusCode `protobuf:"varint,1,opt,name=code,proto3,enum=lugo.OrderResponse_StatusCode" json:"code,omitempty"`
	// String message used for debugging proposes.
	Details string `protobuf:"bytes,2,opt,name=details,proto3" json:"details,omitempty"`
}

func (x *OrderResponse) Reset() {
	*x = OrderResponse{}
	if protoimpl.UnsafeEnabled {
		mi := &file_server_proto_msgTypes[6]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*OrderResponse) ProtoMessage() {}

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

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

func (x *OrderResponse) GetCode() OrderResponse_StatusCode {
	if x != nil {
		return x.Code
	}
	return OrderResponse_SUCCESS
}

func (x *OrderResponse) GetDetails() string {
	if x != nil {
		return x.Details
	}
	return ""
}

// Message containing the orders the player want to send to the server in that turn.
type OrderSet struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// Turn which this order set should be processed at.
	Turn uint32 `protobuf:"varint,1,opt,name=turn,proto3" json:"turn,omitempty"`
	// List of orders in the expected order of execution
	Orders []*Order `protobuf:"bytes,2,rep,name=orders,proto3" json:"orders,omitempty"`
	// String message used for debugging proposes.
	DebugMessage string `protobuf:"bytes,3,opt,name=debug_message,json=debugMessage,proto3" json:"debug_message,omitempty"`
}

func (x *OrderSet) Reset() {
	*x = OrderSet{}
	if protoimpl.UnsafeEnabled {
		mi := &file_server_proto_msgTypes[7]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*OrderSet) ProtoMessage() {}

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

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

func (x *OrderSet) GetTurn() uint32 {
	if x != nil {
		return x.Turn
	}
	return 0
}

func (x *OrderSet) GetOrders() []*Order {
	if x != nil {
		return x.Orders
	}
	return nil
}

func (x *OrderSet) GetDebugMessage() string {
	if x != nil {
		return x.DebugMessage
	}
	return ""
}

// Order to the game server. To be sent by players during the Listening phase.
type Order struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// Types that are assignable to Action:
	//	*Order_Move
	//	*Order_Catch
	//	*Order_Kick
	//	*Order_Jump
	Action isOrder_Action `protobuf_oneof:"action"`
}

func (x *Order) Reset() {
	*x = Order{}
	if protoimpl.UnsafeEnabled {
		mi := &file_server_proto_msgTypes[8]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*Order) ProtoMessage() {}

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

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

func (m *Order) GetAction() isOrder_Action {
	if m != nil {
		return m.Action
	}
	return nil
}

func (x *Order) GetMove() *Move {
	if x, ok := x.GetAction().(*Order_Move); ok {
		return x.Move
	}
	return nil
}

func (x *Order) GetCatch() *Catch {
	if x, ok := x.GetAction().(*Order_Catch); ok {
		return x.Catch
	}
	return nil
}

func (x *Order) GetKick() *Kick {
	if x, ok := x.GetAction().(*Order_Kick); ok {
		return x.Kick
	}
	return nil
}

func (x *Order) GetJump() *Jump {
	if x, ok := x.GetAction().(*Order_Jump); ok {
		return x.Jump
	}
	return nil
}

type isOrder_Action interface {
	isOrder_Action()
}

type Order_Move struct {
	Move *Move `protobuf:"bytes,1,opt,name=move,proto3,oneof"`
}

type Order_Catch struct {
	Catch *Catch `protobuf:"bytes,2,opt,name=catch,proto3,oneof"`
}

type Order_Kick struct {
	Kick *Kick `protobuf:"bytes,3,opt,name=kick,proto3,oneof"`
}

type Order_Jump struct {
	Jump *Jump `protobuf:"bytes,4,opt,name=jump,proto3,oneof"`
}

func (*Order_Move) isOrder_Action() {}

func (*Order_Catch) isOrder_Action() {}

func (*Order_Kick) isOrder_Action() {}

func (*Order_Jump) isOrder_Action() {}

// Order to ask the server to change the player velocity (direction and speed).
// This order replaces the current player velocity, and the new velocity attribute will be immediately processed
// in that turn. There is a limit speed to the player. The server will cap the velocity if the request is higher than
// the limit.
type Move struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// The nex Velocity
	Velocity *Velocity `protobuf:"bytes,1,opt,name=velocity,proto3" json:"velocity,omitempty"`
}

func (x *Move) Reset() {
	*x = Move{}
	if protoimpl.UnsafeEnabled {
		mi := &file_server_proto_msgTypes[9]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*Move) ProtoMessage() {}

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

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

func (x *Move) GetVelocity() *Velocity {
	if x != nil {
		return x.Velocity
	}
	return nil
}

// Order to try to catch the ball. The player can only catch the ball when the player is touching the ball.
// Only one catching order can be executed in a turn. So, if more than one player try to catch the ball in the same
// turn, the first processed catch order will succeed, and the next ones will fail.
type Catch struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields
}

func (x *Catch) Reset() {
	*x = Catch{}
	if protoimpl.UnsafeEnabled {
		mi := &file_server_proto_msgTypes[10]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*Catch) ProtoMessage() {}

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

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

// The kick order is only executed by the ball holder, and it is processed immediately.
// Important: The kick velocity is summed to the current ball velocity.
// The kick speed will suffer a power reduction proportionally to the player direction when the kick is not in the
// same direction of the player direction. The reduction is calculated based on the angle with the player direction
// using the formula `SpeedReducerFactor = 0.5 + (0.5 * ((180 - ang) / 180))`
// In summary, the speed will by reduced proportionally to the angle from 100% at 0 degrees until the limit of
// 50% at 180 degrees.
type Kick struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// Kick velocity (it won't be necessarily the final ball velocity)
	Velocity *Velocity `protobuf:"bytes,1,opt,name=velocity,proto3" json:"velocity,omitempty"`
}

func (x *Kick) Reset() {
	*x = Kick{}
	if protoimpl.UnsafeEnabled {
		mi := &file_server_proto_msgTypes[11]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*Kick) ProtoMessage() {}

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

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

func (x *Kick) GetVelocity() *Velocity {
	if x != nil {
		return x.Velocity
	}
	return nil
}

// Changes the goalkeepers velocity in a higher speed.
// The goalkeepers may move kicker than other players when they jump, however the jump movement cannot be interrupted
// after triggered. (read specs to find out the number of turns the jump lasts)
type Jump struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// Goalkeeper's velocity during the jump.
	Velocity *Velocity `protobuf:"bytes,1,opt,name=velocity,proto3" json:"velocity,omitempty"`
}

func (x *Jump) Reset() {
	*x = Jump{}
	if protoimpl.UnsafeEnabled {
		mi := &file_server_proto_msgTypes[12]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*Jump) ProtoMessage() {}

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

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

func (x *Jump) GetVelocity() *Velocity {
	if x != nil {
		return x.Velocity
	}
	return nil
}

var File_server_proto protoreflect.FileDescriptor

var file_server_proto_rawDesc = []byte{
	0x0a, 0x0c, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x04,
	0x6c, 0x75, 0x67, 0x6f, 0x1a, 0x0d, 0x70, 0x68, 0x79, 0x73, 0x69, 0x63, 0x73, 0x2e, 0x70, 0x72,
	0x6f, 0x74, 0x6f, 0x22, 0xc6, 0x01, 0x0a, 0x0b, 0x4a, 0x6f, 0x69, 0x6e, 0x52, 0x65, 0x71, 0x75,
	0x65, 0x73, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x01, 0x20, 0x01,
	0x28, 0x09, 0x52, 0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x12, 0x29, 0x0a, 0x10, 0x70, 0x72, 0x6f,
	0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20,
	0x01, 0x28, 0x09, 0x52, 0x0f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x56, 0x65, 0x72,
	0x73, 0x69, 0x6f, 0x6e, 0x12, 0x2c, 0x0a, 0x09, 0x74, 0x65, 0x61, 0x6d, 0x5f, 0x73, 0x69, 0x64,
	0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x0f, 0x2e, 0x6c, 0x75, 0x67, 0x6f, 0x2e, 0x54,
	0x65, 0x61, 0x6d, 0x2e, 0x53, 0x69, 0x64, 0x65, 0x52, 0x08, 0x74, 0x65, 0x61, 0x6d, 0x53, 0x69,
	0x64, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x04, 0x20, 0x01,
	0x28, 0x0d, 0x52, 0x06, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x12, 0x30, 0x0a, 0x0d, 0x69, 0x6e,
	0x69, 0x74, 0x5f, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28,
	0x0b, 0x32, 0x0b, 0x2e, 0x6c, 0x75, 0x67, 0x6f, 0x2e, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x52, 0x0c,
	0x69, 0x6e, 0x69, 0x74, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x83, 0x03, 0x0a,
	0x0c, 0x47, 0x61, 0x6d, 0x65, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x12, 0x2e, 0x0a,
	0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x18, 0x2e, 0x6c,
	0x75, 0x67, 0x6f, 0x2e, 0x47, 0x61, 0x6d, 0x65, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74,
	0x2e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x12, 0x12, 0x0a,
	0x04, 0x74, 0x75, 0x72, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x04, 0x74, 0x75, 0x72,
	0x6e, 0x12, 0x27, 0x0a, 0x09, 0x68, 0x6f, 0x6d, 0x65, 0x5f, 0x74, 0x65, 0x61, 0x6d, 0x18, 0x03,
	0x20, 0x01, 0x28, 0x0b, 0x32, 0x0a, 0x2e, 0x6c, 0x75, 0x67, 0x6f, 0x2e, 0x54, 0x65, 0x61, 0x6d,
	0x52, 0x08, 0x68, 0x6f, 0x6d, 0x65, 0x54, 0x65, 0x61, 0x6d, 0x12, 0x27, 0x0a, 0x09, 0x61, 0x77,
	0x61, 0x79, 0x5f, 0x74, 0x65, 0x61, 0x6d, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0a, 0x2e,
	0x6c, 0x75, 0x67, 0x6f, 0x2e, 0x54, 0x65, 0x61, 0x6d, 0x52, 0x08, 0x61, 0x77, 0x61, 0x79, 0x54,
	0x65, 0x61, 0x6d, 0x12, 0x1e, 0x0a, 0x04, 0x62, 0x61, 0x6c, 0x6c, 0x18, 0x05, 0x20, 0x01, 0x28,
	0x0b, 0x32, 0x0a, 0x2e, 0x6c, 0x75, 0x67, 0x6f, 0x2e, 0x42, 0x61, 0x6c, 0x6c, 0x52, 0x04, 0x62,
	0x61, 0x6c, 0x6c, 0x12, 0x34, 0x0a, 0x17, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x5f, 0x62, 0x61, 0x6c,
	0x6c, 0x5f, 0x69, 0x6e, 0x5f, 0x67, 0x6f, 0x61, 0x6c, 0x5f, 0x7a, 0x6f, 0x6e, 0x65, 0x18, 0x06,
	0x20, 0x01, 0x28, 0x0d, 0x52, 0x13, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x42, 0x61, 0x6c, 0x6c, 0x49,
	0x6e, 0x47, 0x6f, 0x61, 0x6c, 0x5a, 0x6f, 0x6e, 0x65, 0x12, 0x2e, 0x0a, 0x0a, 0x73, 0x68, 0x6f,
	0x74, 0x5f, 0x63, 0x6c, 0x6f, 0x63, 0x6b, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e,
	0x6c, 0x75, 0x67, 0x6f, 0x2e, 0x53, 0x68, 0x6f, 0x74, 0x43, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x09,
	0x73, 0x68, 0x6f, 0x74, 0x43, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x57, 0x0a, 0x05, 0x53, 0x74, 0x61,
	0x74, 0x65, 0x12, 0x0b, 0x0a, 0x07, 0x57, 0x41, 0x49, 0x54, 0x49, 0x4e, 0x47, 0x10, 0x00, 0x12,
	0x0d, 0x0a, 0x09, 0x47, 0x45, 0x54, 0x5f, 0x52, 0x45, 0x41, 0x44, 0x59, 0x10, 0x01, 0x12, 0x0d,
	0x0a, 0x09, 0x4c, 0x49, 0x53, 0x54, 0x45, 0x4e, 0x49, 0x4e, 0x47, 0x10, 0x02, 0x12, 0x0b, 0x0a,
	0x07, 0x50, 0x4c, 0x41, 0x59, 0x49, 0x4e, 0x47, 0x10, 0x03, 0x12, 0x0c, 0x0a, 0x08, 0x53, 0x48,
	0x49, 0x46, 0x54, 0x49, 0x4e, 0x47, 0x10, 0x04, 0x12, 0x08, 0x0a, 0x04, 0x4f, 0x56, 0x45, 0x52,
	0x10, 0x63, 0x22, 0x99, 0x01, 0x0a, 0x04, 0x54, 0x65, 0x61, 0x6d, 0x12, 0x26, 0x0a, 0x07, 0x70,
	0x6c, 0x61, 0x79, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x6c,
	0x75, 0x67, 0x6f, 0x2e, 0x50, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x52, 0x07, 0x70, 0x6c, 0x61, 0x79,
	0x65, 0x72, 0x73, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28,
	0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x63, 0x6f, 0x72, 0x65,
	0x18, 0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x05, 0x73, 0x63, 0x6f, 0x72, 0x65, 0x12, 0x23, 0x0a,
	0x04, 0x73, 0x69, 0x64, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x0f, 0x2e, 0x6c, 0x75,
	0x67, 0x6f, 0x2e, 0x54, 0x65, 0x61, 0x6d, 0x2e, 0x53, 0x69, 0x64, 0x65, 0x52, 0x04, 0x73, 0x69,
	0x64, 0x65, 0x22, 0x1a, 0x0a, 0x04, 0x53, 0x69, 0x64, 0x65, 0x12, 0x08, 0x0a, 0x04, 0x48, 0x4f,
	0x4d, 0x45, 0x10, 0x00, 0x12, 0x08, 0x0a, 0x04, 0x41, 0x57, 0x41, 0x59, 0x10, 0x01, 0x22, 0x62,
	0x0a, 0x09, 0x53, 0x68, 0x6f, 0x74, 0x43, 0x6c, 0x6f, 0x63, 0x6b, 0x12, 0x2c, 0x0a, 0x09, 0x74,
	0x65, 0x61, 0x6d, 0x5f, 0x73, 0x69, 0x64, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x0f,
	0x2e, 0x6c, 0x75, 0x67, 0x6f, 0x2e, 0x54, 0x65, 0x61, 0x6d, 0x2e, 0x53, 0x69, 0x64, 0x65, 0x52,
	0x08, 0x74, 0x65, 0x61, 0x6d, 0x53, 0x69, 0x64, 0x65, 0x12, 0x27, 0x0a, 0x0f, 0x72, 0x65, 0x6d,
	0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x5f, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x18, 0x07, 0x20, 0x01,
	0x28, 0x0d, 0x52, 0x0e, 0x72, 0x65, 0x6d, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x54, 0x75, 0x72,
	0x6e, 0x73, 0x22, 0xd5, 0x01, 0x0a, 0x06, 0x50, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x12, 0x16, 0x0a,
	0x06, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x06, 0x6e,
	0x75, 0x6d, 0x62, 0x65, 0x72, 0x12, 0x27, 0x0a, 0x08, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f,
	0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0b, 0x2e, 0x6c, 0x75, 0x67, 0x6f, 0x2e, 0x50,
	0x6f, 0x69, 0x6e, 0x74, 0x52, 0x08, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2a,
	0x0a, 0x08, 0x76, 0x65, 0x6c, 0x6f, 0x63, 0x69, 0x74, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b,
	0x32, 0x0e, 0x2e, 0x6c, 0x75, 0x67, 0x6f, 0x2e, 0x56, 0x65, 0x6c, 0x6f, 0x63, 0x69, 0x74, 0x79,
	0x52, 0x08, 0x76, 0x65, 0x6c, 0x6f, 0x63, 0x69, 0x74, 0x79, 0x12, 0x2c, 0x0a, 0x09, 0x74, 0x65,
	0x61, 0x6d, 0x5f, 0x73, 0x69, 0x64, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x0f, 0x2e,
	0x6c, 0x75, 0x67, 0x6f, 0x2e, 0x54, 0x65, 0x61, 0x6d, 0x2e, 0x53, 0x69, 0x64, 0x65, 0x52, 0x08,
	0x74, 0x65, 0x61, 0x6d, 0x53, 0x69, 0x64, 0x65, 0x12, 0x30, 0x0a, 0x0d, 0x69, 0x6e, 0x69, 0x74,
	0x5f, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32,
	0x0b, 0x2e, 0x6c, 0x75, 0x67, 0x6f, 0x2e, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x52, 0x0c, 0x69, 0x6e,
	0x69, 0x74, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x81, 0x01, 0x0a, 0x04, 0x42,
	0x61, 0x6c, 0x6c, 0x12, 0x27, 0x0a, 0x08, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18,
	0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0b, 0x2e, 0x6c, 0x75, 0x67, 0x6f, 0x2e, 0x50, 0x6f, 0x69,
	0x6e, 0x74, 0x52, 0x08, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2a, 0x0a, 0x08,
	0x76, 0x65, 0x6c, 0x6f, 0x63, 0x69, 0x74, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0e,
	0x2e, 0x6c, 0x75, 0x67, 0x6f, 0x2e, 0x56, 0x65, 0x6c, 0x6f, 0x63, 0x69, 0x74, 0x79, 0x52, 0x08,
	0x76, 0x65, 0x6c, 0x6f, 0x63, 0x69, 0x74, 0x79, 0x12, 0x24, 0x0a, 0x06, 0x68, 0x6f, 0x6c, 0x64,
	0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x6c, 0x75, 0x67, 0x6f, 0x2e,
	0x50, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x52, 0x06, 0x68, 0x6f, 0x6c, 0x64, 0x65, 0x72, 0x22, 0xba,
	0x01, 0x0a, 0x0d, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
	0x12, 0x32, 0x0a, 0x04, 0x63, 0x6f, 0x64, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1e,
	0x2e, 0x6c, 0x75, 0x67, 0x6f, 0x2e, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f,
	0x6e, 0x73, 0x65, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x43, 0x6f, 0x64, 0x65, 0x52, 0x04,
	0x63, 0x6f, 0x64, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18,
	0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x22, 0x5b,
	0x0a, 0x0a, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x43, 0x6f, 0x64, 0x65, 0x12, 0x0b, 0x0a, 0x07,
	0x53, 0x55, 0x43, 0x43, 0x45, 0x53, 0x53, 0x10, 0x00, 0x12, 0x12, 0x0a, 0x0e, 0x55, 0x4e, 0x4b,
	0x4e, 0x4f, 0x57, 0x4e, 0x5f, 0x50, 0x4c, 0x41, 0x59, 0x45, 0x52, 0x10, 0x01, 0x12, 0x11, 0x0a,
	0x0d, 0x4e, 0x4f, 0x54, 0x5f, 0x4c, 0x49, 0x53, 0x54, 0x45, 0x4e, 0x49, 0x4e, 0x47, 0x10, 0x02,
	0x12, 0x0e, 0x0a, 0x0a, 0x57, 0x52, 0x4f, 0x4e, 0x47, 0x5f, 0x54, 0x55, 0x52, 0x4e, 0x10, 0x03,
	0x12, 0x09, 0x0a, 0x05, 0x4f, 0x54, 0x48, 0x45, 0x52, 0x10, 0x63, 0x22, 0x68, 0x0a, 0x08, 0x4f,
	0x72, 0x64, 0x65, 0x72, 0x53, 0x65, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x75, 0x72, 0x6e, 0x18,
	0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x04, 0x74, 0x75, 0x72, 0x6e, 0x12, 0x23, 0x0a, 0x06, 0x6f,
	0x72, 0x64, 0x65, 0x72, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0b, 0x2e, 0x6c, 0x75,
	0x67, 0x6f, 0x2e, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x52, 0x06, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x73,
	0x12, 0x23, 0x0a, 0x0d, 0x64, 0x65, 0x62, 0x75, 0x67, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
	0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x64, 0x65, 0x62, 0x75, 0x67, 0x4d, 0x65,
	0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x9c, 0x01, 0x0a, 0x05, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x12,
	0x20, 0x0a, 0x04, 0x6d, 0x6f, 0x76, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0a, 0x2e,
	0x6c, 0x75, 0x67, 0x6f, 0x2e, 0x4d, 0x6f, 0x76, 0x65, 0x48, 0x00, 0x52, 0x04, 0x6d, 0x6f, 0x76,
	0x65, 0x12, 0x23, 0x0a, 0x05, 0x63, 0x61, 0x74, 0x63, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b,
	0x32, 0x0b, 0x2e, 0x6c, 0x75, 0x67, 0x6f, 0x2e, 0x43, 0x61, 0x74, 0x63, 0x68, 0x48, 0x00, 0x52,
	0x05, 0x63, 0x61, 0x74, 0x63, 0x68, 0x12, 0x20, 0x0a, 0x04, 0x6b, 0x69, 0x63, 0x6b, 0x18, 0x03,
	0x20, 0x01, 0x28, 0x0b, 0x32, 0x0a, 0x2e, 0x6c, 0x75, 0x67, 0x6f, 0x2e, 0x4b, 0x69, 0x63, 0x6b,
	0x48, 0x00, 0x52, 0x04, 0x6b, 0x69, 0x63, 0x6b, 0x12, 0x20, 0x0a, 0x04, 0x6a, 0x75, 0x6d, 0x70,
	0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0a, 0x2e, 0x6c, 0x75, 0x67, 0x6f, 0x2e, 0x4a, 0x75,
	0x6d, 0x70, 0x48, 0x00, 0x52, 0x04, 0x6a, 0x75, 0x6d, 0x70, 0x42, 0x08, 0x0a, 0x06, 0x61, 0x63,
	0x74, 0x69, 0x6f, 0x6e, 0x22, 0x32, 0x0a, 0x04, 0x4d, 0x6f, 0x76, 0x65, 0x12, 0x2a, 0x0a, 0x08,
	0x76, 0x65, 0x6c, 0x6f, 0x63, 0x69, 0x74, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0e,
	0x2e, 0x6c, 0x75, 0x67, 0x6f, 0x2e, 0x56, 0x65, 0x6c, 0x6f, 0x63, 0x69, 0x74, 0x79, 0x52, 0x08,
	0x76, 0x65, 0x6c, 0x6f, 0x63, 0x69, 0x74, 0x79, 0x22, 0x07, 0x0a, 0x05, 0x43, 0x61, 0x74, 0x63,
	0x68, 0x22, 0x32, 0x0a, 0x04, 0x4b, 0x69, 0x63, 0x6b, 0x12, 0x2a, 0x0a, 0x08, 0x76, 0x65, 0x6c,
	0x6f, 0x63, 0x69, 0x74, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x6c, 0x75,
	0x67, 0x6f, 0x2e, 0x56, 0x65, 0x6c, 0x6f, 0x63, 0x69, 0x74, 0x79, 0x52, 0x08, 0x76, 0x65, 0x6c,
	0x6f, 0x63, 0x69, 0x74, 0x79, 0x22, 0x32, 0x0a, 0x04, 0x4a, 0x75, 0x6d, 0x70, 0x12, 0x2a, 0x0a,
	0x08, 0x76, 0x65, 0x6c, 0x6f, 0x63, 0x69, 0x74, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32,
	0x0e, 0x2e, 0x6c, 0x75, 0x67, 0x6f, 0x2e, 0x56, 0x65, 0x6c, 0x6f, 0x63, 0x69, 0x74, 0x79, 0x52,
	0x08, 0x76, 0x65, 0x6c, 0x6f, 0x63, 0x69, 0x74, 0x79, 0x32, 0x6f, 0x0a, 0x04, 0x47, 0x61, 0x6d,
	0x65, 0x12, 0x34, 0x0a, 0x09, 0x4a, 0x6f, 0x69, 0x6e, 0x41, 0x54, 0x65, 0x61, 0x6d, 0x12, 0x11,
	0x2e, 0x6c, 0x75, 0x67, 0x6f, 0x2e, 0x4a, 0x6f, 0x69, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
	0x74, 0x1a, 0x12, 0x2e, 0x6c, 0x75, 0x67, 0x6f, 0x2e, 0x47, 0x61, 0x6d, 0x65, 0x53, 0x6e, 0x61,
	0x70, 0x73, 0x68, 0x6f, 0x74, 0x30, 0x01, 0x12, 0x31, 0x0a, 0x0a, 0x53, 0x65, 0x6e, 0x64, 0x4f,
	0x72, 0x64, 0x65, 0x72, 0x73, 0x12, 0x0e, 0x2e, 0x6c, 0x75, 0x67, 0x6f, 0x2e, 0x4f, 0x72, 0x64,
	0x65, 0x72, 0x53, 0x65, 0x74, 0x1a, 0x13, 0x2e, 0x6c, 0x75, 0x67, 0x6f, 0x2e, 0x4f, 0x72, 0x64,
	0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x42, 0x23, 0x5a, 0x21, 0x67, 0x69,
	0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x6c, 0x75, 0x67, 0x6f, 0x62, 0x6f, 0x74,
	0x73, 0x2f, 0x6c, 0x75, 0x67, 0x6f, 0x34, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
	0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
}

var (
	file_server_proto_rawDescOnce sync.Once
	file_server_proto_rawDescData = file_server_proto_rawDesc
)

func file_server_proto_rawDescGZIP() []byte {
	file_server_proto_rawDescOnce.Do(func() {
		file_server_proto_rawDescData = protoimpl.X.CompressGZIP(file_server_proto_rawDescData)
	})
	return file_server_proto_rawDescData
}

var file_server_proto_enumTypes = make([]protoimpl.EnumInfo, 3)
var file_server_proto_msgTypes = make([]protoimpl.MessageInfo, 13)
var file_server_proto_goTypes = []interface{}{
	(GameSnapshot_State)(0),       // 0: lugo.GameSnapshot.State
	(Team_Side)(0),                // 1: lugo.Team.Side
	(OrderResponse_StatusCode)(0), // 2: lugo.OrderResponse.StatusCode
	(*JoinRequest)(nil),           // 3: lugo.JoinRequest
	(*GameSnapshot)(nil),          // 4: lugo.GameSnapshot
	(*Team)(nil),                  // 5: lugo.Team
	(*ShotClock)(nil),             // 6: lugo.ShotClock
	(*Player)(nil),                // 7: lugo.Player
	(*Ball)(nil),                  // 8: lugo.Ball
	(*OrderResponse)(nil),         // 9: lugo.OrderResponse
	(*OrderSet)(nil),              // 10: lugo.OrderSet
	(*Order)(nil),                 // 11: lugo.Order
	(*Move)(nil),                  // 12: lugo.Move
	(*Catch)(nil),                 // 13: lugo.Catch
	(*Kick)(nil),                  // 14: lugo.Kick
	(*Jump)(nil),                  // 15: lugo.Jump
	(*Point)(nil),                 // 16: lugo.Point
	(*Velocity)(nil),              // 17: lugo.Velocity
}
var file_server_proto_depIdxs = []int32{
	1,  // 0: lugo.JoinRequest.team_side:type_name -> lugo.Team.Side
	16, // 1: lugo.JoinRequest.init_position:type_name -> lugo.Point
	0,  // 2: lugo.GameSnapshot.state:type_name -> lugo.GameSnapshot.State
	5,  // 3: lugo.GameSnapshot.home_team:type_name -> lugo.Team
	5,  // 4: lugo.GameSnapshot.away_team:type_name -> lugo.Team
	8,  // 5: lugo.GameSnapshot.ball:type_name -> lugo.Ball
	6,  // 6: lugo.GameSnapshot.shot_clock:type_name -> lugo.ShotClock
	7,  // 7: lugo.Team.players:type_name -> lugo.Player
	1,  // 8: lugo.Team.side:type_name -> lugo.Team.Side
	1,  // 9: lugo.ShotClock.team_side:type_name -> lugo.Team.Side
	16, // 10: lugo.Player.position:type_name -> lugo.Point
	17, // 11: lugo.Player.velocity:type_name -> lugo.Velocity
	1,  // 12: lugo.Player.team_side:type_name -> lugo.Team.Side
	16, // 13: lugo.Player.init_position:type_name -> lugo.Point
	16, // 14: lugo.Ball.position:type_name -> lugo.Point
	17, // 15: lugo.Ball.velocity:type_name -> lugo.Velocity
	7,  // 16: lugo.Ball.holder:type_name -> lugo.Player
	2,  // 17: lugo.OrderResponse.code:type_name -> lugo.OrderResponse.StatusCode
	11, // 18: lugo.OrderSet.orders:type_name -> lugo.Order
	12, // 19: lugo.Order.move:type_name -> lugo.Move
	13, // 20: lugo.Order.catch:type_name -> lugo.Catch
	14, // 21: lugo.Order.kick:type_name -> lugo.Kick
	15, // 22: lugo.Order.jump:type_name -> lugo.Jump
	17, // 23: lugo.Move.velocity:type_name -> lugo.Velocity
	17, // 24: lugo.Kick.velocity:type_name -> lugo.Velocity
	17, // 25: lugo.Jump.velocity:type_name -> lugo.Velocity
	3,  // 26: lugo.Game.JoinATeam:input_type -> lugo.JoinRequest
	10, // 27: lugo.Game.SendOrders:input_type -> lugo.OrderSet
	4,  // 28: lugo.Game.JoinATeam:output_type -> lugo.GameSnapshot
	9,  // 29: lugo.Game.SendOrders:output_type -> lugo.OrderResponse
	28, // [28:30] is the sub-list for method output_type
	26, // [26:28] 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_server_proto_init() }
func file_server_proto_init() {
	if File_server_proto != nil {
		return
	}
	file_physics_proto_init()
	if !protoimpl.UnsafeEnabled {
		file_server_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*JoinRequest); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_server_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*GameSnapshot); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_server_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*Team); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_server_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*ShotClock); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_server_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*Player); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_server_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*Ball); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_server_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*OrderResponse); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_server_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*OrderSet); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_server_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*Order); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_server_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*Move); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_server_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*Catch); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_server_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*Kick); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_server_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*Jump); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
	}
	file_server_proto_msgTypes[8].OneofWrappers = []interface{}{
		(*Order_Move)(nil),
		(*Order_Catch)(nil),
		(*Order_Kick)(nil),
		(*Order_Jump)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: file_server_proto_rawDesc,
			NumEnums:      3,
			NumMessages:   13,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_server_proto_goTypes,
		DependencyIndexes: file_server_proto_depIdxs,
		EnumInfos:         file_server_proto_enumTypes,
		MessageInfos:      file_server_proto_msgTypes,
	}.Build()
	File_server_proto = out.File
	file_server_proto_rawDesc = nil
	file_server_proto_goTypes = nil
	file_server_proto_depIdxs = nil
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConnInterface

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion6

// GameClient is the client API for Game service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type GameClient interface {
	// JoinATeam allows the player to listen the server during the match.
	JoinATeam(ctx context.Context, in *JoinRequest, opts ...grpc.CallOption) (Game_JoinATeamClient, error)
	// SendOrders allows the player to send others to the server when the game is on listening state.
	SendOrders(ctx context.Context, in *OrderSet, opts ...grpc.CallOption) (*OrderResponse, error)
}

type gameClient struct {
	cc grpc.ClientConnInterface
}

func NewGameClient(cc grpc.ClientConnInterface) GameClient {
	return &gameClient{cc}
}

func (c *gameClient) JoinATeam(ctx context.Context, in *JoinRequest, opts ...grpc.CallOption) (Game_JoinATeamClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Game_serviceDesc.Streams[0], "/lugo.Game/JoinATeam", opts...)
	if err != nil {
		return nil, err
	}
	x := &gameJoinATeamClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type Game_JoinATeamClient interface {
	Recv() (*GameSnapshot, error)
	grpc.ClientStream
}

type gameJoinATeamClient struct {
	grpc.ClientStream
}

func (x *gameJoinATeamClient) Recv() (*GameSnapshot, error) {
	m := new(GameSnapshot)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *gameClient) SendOrders(ctx context.Context, in *OrderSet, opts ...grpc.CallOption) (*OrderResponse, error) {
	out := new(OrderResponse)
	err := c.cc.Invoke(ctx, "/lugo.Game/SendOrders", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// GameServer is the server API for Game service.
type GameServer interface {
	// JoinATeam allows the player to listen the server during the match.
	JoinATeam(*JoinRequest, Game_JoinATeamServer) error
	// SendOrders allows the player to send others to the server when the game is on listening state.
	SendOrders(context.Context, *OrderSet) (*OrderResponse, error)
}

// UnimplementedGameServer can be embedded to have forward compatible implementations.
type UnimplementedGameServer struct {
}

func (*UnimplementedGameServer) JoinATeam(*JoinRequest, Game_JoinATeamServer) error {
	return status.Errorf(codes.Unimplemented, "method JoinATeam not implemented")
}
func (*UnimplementedGameServer) SendOrders(context.Context, *OrderSet) (*OrderResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SendOrders not implemented")
}

func RegisterGameServer(s *grpc.Server, srv GameServer) {
	s.RegisterService(&_Game_serviceDesc, srv)
}

func _Game_JoinATeam_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(JoinRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(GameServer).JoinATeam(m, &gameJoinATeamServer{stream})
}

type Game_JoinATeamServer interface {
	Send(*GameSnapshot) error
	grpc.ServerStream
}

type gameJoinATeamServer struct {
	grpc.ServerStream
}

func (x *gameJoinATeamServer) Send(m *GameSnapshot) error {
	return x.ServerStream.SendMsg(m)
}

func _Game_SendOrders_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(OrderSet)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GameServer).SendOrders(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/lugo.Game/SendOrders",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GameServer).SendOrders(ctx, req.(*OrderSet))
	}
	return interceptor(ctx, in, info, handler)
}

var _Game_serviceDesc = grpc.ServiceDesc{
	ServiceName: "lugo.Game",
	HandlerType: (*GameServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "SendOrders",
			Handler:    _Game_SendOrders_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "JoinATeam",
			Handler:       _Game_JoinATeam_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "server.proto",
}