broadcast.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.23.0
// 	protoc        v3.19.4
// source: broadcast.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 GameSetup_StartingMode int32

const (
	// start the game as soon as all players are connected
	GameSetup_NO_WAIT GameSetup_StartingMode = 0
	// do not start until the master watcher request (gRPC call to Broadcast service)
	GameSetup_WAIT GameSetup_StartingMode = 1
)

// Enum value maps for GameSetup_StartingMode.
var (
	GameSetup_StartingMode_name = map[int32]string{
		0: "NO_WAIT",
		1: "WAIT",
	}
	GameSetup_StartingMode_value = map[string]int32{
		"NO_WAIT": 0,
		"WAIT":    1,
	}
)

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

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

func (GameSetup_StartingMode) Descriptor() protoreflect.EnumDescriptor {
	return file_broadcast_proto_enumTypes[0].Descriptor()
}

func (GameSetup_StartingMode) Type() protoreflect.EnumType {
	return &file_broadcast_proto_enumTypes[0]
}

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

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

type GameSetup_ListeningMode int32

const (
	// respect the timer defined by listening duration
	GameSetup_TIMER GameSetup_ListeningMode = 0
	// immediately after all orders
	GameSetup_RUSH GameSetup_ListeningMode = 1
	// wait external remote control (dev only)
	GameSetup_REMOTE GameSetup_ListeningMode = 2
)

// Enum value maps for GameSetup_ListeningMode.
var (
	GameSetup_ListeningMode_name = map[int32]string{
		0: "TIMER",
		1: "RUSH",
		2: "REMOTE",
	}
	GameSetup_ListeningMode_value = map[string]int32{
		"TIMER":  0,
		"RUSH":   1,
		"REMOTE": 2,
	}
)

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

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

func (GameSetup_ListeningMode) Descriptor() protoreflect.EnumDescriptor {
	return file_broadcast_proto_enumTypes[1].Descriptor()
}

func (GameSetup_ListeningMode) Type() protoreflect.EnumType {
	return &file_broadcast_proto_enumTypes[1]
}

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

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

type EventDebugBreakpoint_Breakpoint int32

const (
	// Breakpoint that breaks the game before each player orders set be processed during the "Playing" state
	// Each player's order set will be processed at once, so the breakpoint controls the process based on
	// players, not on orders.
	EventDebugBreakpoint_ORDERS EventDebugBreakpoint_Breakpoint = 0
	// Breakpoint that breaks the game before each player turn be processed during the "Playing" state
	EventDebugBreakpoint_TURN EventDebugBreakpoint_Breakpoint = 1
)

// Enum value maps for EventDebugBreakpoint_Breakpoint.
var (
	EventDebugBreakpoint_Breakpoint_name = map[int32]string{
		0: "ORDERS",
		1: "TURN",
	}
	EventDebugBreakpoint_Breakpoint_value = map[string]int32{
		"ORDERS": 0,
		"TURN":   1,
	}
)

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

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

func (EventDebugBreakpoint_Breakpoint) Descriptor() protoreflect.EnumDescriptor {
	return file_broadcast_proto_enumTypes[2].Descriptor()
}

func (EventDebugBreakpoint_Breakpoint) Type() protoreflect.EnumType {
	return &file_broadcast_proto_enumTypes[2]
}

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

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

type WatcherRequest struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// Not used on localhost
	Uuid string `protobuf:"bytes,1,opt,name=uuid,proto3" json:"uuid,omitempty"`
}

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

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

func (*WatcherRequest) ProtoMessage() {}

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

func (x *WatcherRequest) GetUuid() string {
	if x != nil {
		return x.Uuid
	}
	return ""
}

type StartRequest struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// Not used on localhost
	WatcherUuid string `protobuf:"bytes,1,opt,name=watcher_uuid,json=watcherUuid,proto3" json:"watcher_uuid,omitempty"`
}

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

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

func (*StartRequest) ProtoMessage() {}

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

func (x *StartRequest) GetWatcherUuid() string {
	if x != nil {
		return x.WatcherUuid
	}
	return ""
}

// Brings the game snapshot and the event in a specialised format.
type GameEvent struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// Game snapshot after the event has happened.
	GameSnapshot *GameSnapshot `protobuf:"bytes,1,opt,name=game_snapshot,json=gameSnapshot,proto3" json:"game_snapshot,omitempty"`
	// Types that are assignable to Event:
	//	*GameEvent_NewPlayer
	//	*GameEvent_LostPlayer
	//	*GameEvent_StateChange
	//	*GameEvent_Goal
	//	*GameEvent_GameOver
	//	*GameEvent_Breakpoint
	//	*GameEvent_DebugReleased
	Event isGameEvent_Event `protobuf_oneof:"event"`
}

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

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

func (*GameEvent) ProtoMessage() {}

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

func (x *GameEvent) GetGameSnapshot() *GameSnapshot {
	if x != nil {
		return x.GameSnapshot
	}
	return nil
}

func (m *GameEvent) GetEvent() isGameEvent_Event {
	if m != nil {
		return m.Event
	}
	return nil
}

func (x *GameEvent) GetNewPlayer() *EventNewPlayer {
	if x, ok := x.GetEvent().(*GameEvent_NewPlayer); ok {
		return x.NewPlayer
	}
	return nil
}

func (x *GameEvent) GetLostPlayer() *EventLostPlayer {
	if x, ok := x.GetEvent().(*GameEvent_LostPlayer); ok {
		return x.LostPlayer
	}
	return nil
}

func (x *GameEvent) GetStateChange() *EventStateChange {
	if x, ok := x.GetEvent().(*GameEvent_StateChange); ok {
		return x.StateChange
	}
	return nil
}

func (x *GameEvent) GetGoal() *EventGoal {
	if x, ok := x.GetEvent().(*GameEvent_Goal); ok {
		return x.Goal
	}
	return nil
}

func (x *GameEvent) GetGameOver() *EventGameOver {
	if x, ok := x.GetEvent().(*GameEvent_GameOver); ok {
		return x.GameOver
	}
	return nil
}

func (x *GameEvent) GetBreakpoint() *EventDebugBreakpoint {
	if x, ok := x.GetEvent().(*GameEvent_Breakpoint); ok {
		return x.Breakpoint
	}
	return nil
}

func (x *GameEvent) GetDebugReleased() *EventDebugReleased {
	if x, ok := x.GetEvent().(*GameEvent_DebugReleased); ok {
		return x.DebugReleased
	}
	return nil
}

type isGameEvent_Event interface {
	isGameEvent_Event()
}

type GameEvent_NewPlayer struct {
	NewPlayer *EventNewPlayer `protobuf:"bytes,2,opt,name=new_player,json=newPlayer,proto3,oneof"`
}

type GameEvent_LostPlayer struct {
	LostPlayer *EventLostPlayer `protobuf:"bytes,3,opt,name=lost_player,json=lostPlayer,proto3,oneof"`
}

type GameEvent_StateChange struct {
	StateChange *EventStateChange `protobuf:"bytes,4,opt,name=state_change,json=stateChange,proto3,oneof"`
}

type GameEvent_Goal struct {
	Goal *EventGoal `protobuf:"bytes,5,opt,name=goal,proto3,oneof"`
}

type GameEvent_GameOver struct {
	GameOver *EventGameOver `protobuf:"bytes,6,opt,name=game_over,json=gameOver,proto3,oneof"`
}

type GameEvent_Breakpoint struct {
	Breakpoint *EventDebugBreakpoint `protobuf:"bytes,7,opt,name=breakpoint,proto3,oneof"`
}

type GameEvent_DebugReleased struct {
	DebugReleased *EventDebugReleased `protobuf:"bytes,8,opt,name=debug_released,json=debugReleased,proto3,oneof"`
}

func (*GameEvent_NewPlayer) isGameEvent_Event() {}

func (*GameEvent_LostPlayer) isGameEvent_Event() {}

func (*GameEvent_StateChange) isGameEvent_Event() {}

func (*GameEvent_Goal) isGameEvent_Event() {}

func (*GameEvent_GameOver) isGameEvent_Event() {}

func (*GameEvent_Breakpoint) isGameEvent_Event() {}

func (*GameEvent_DebugReleased) isGameEvent_Event() {}

type GameSetup struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// Defines the communication protocol version between the players and the game server.
	// The players also inform to the server what protocol they will use. If incompatible, the server will reject the player.
	ProtocolVersion string                  `protobuf:"bytes,1,opt,name=protocol_version,json=protocolVersion,proto3" json:"protocol_version,omitempty"`
	DevMode         bool                    `protobuf:"varint,2,opt,name=dev_mode,json=devMode,proto3" json:"dev_mode,omitempty"`
	StartMode       GameSetup_StartingMode  `protobuf:"varint,3,opt,name=start_mode,json=startMode,proto3,enum=lugo.GameSetup_StartingMode" json:"start_mode,omitempty"`
	ListeningMode   GameSetup_ListeningMode `protobuf:"varint,4,opt,name=listening_mode,json=listeningMode,proto3,enum=lugo.GameSetup_ListeningMode" json:"listening_mode,omitempty"`
	// in milliseconds
	ListeningDuration uint32        `protobuf:"varint,5,opt,name=listening_duration,json=listeningDuration,proto3" json:"listening_duration,omitempty"`
	GameDuration      uint32        `protobuf:"varint,6,opt,name=game_duration,json=gameDuration,proto3" json:"game_duration,omitempty"`
	HomeTeam          *TeamSettings `protobuf:"bytes,8,opt,name=home_team,json=homeTeam,proto3" json:"home_team,omitempty"`
	AwayTeam          *TeamSettings `protobuf:"bytes,9,opt,name=away_team,json=awayTeam,proto3" json:"away_team,omitempty"`
}

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

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

func (*GameSetup) ProtoMessage() {}

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

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

func (x *GameSetup) GetDevMode() bool {
	if x != nil {
		return x.DevMode
	}
	return false
}

func (x *GameSetup) GetStartMode() GameSetup_StartingMode {
	if x != nil {
		return x.StartMode
	}
	return GameSetup_NO_WAIT
}

func (x *GameSetup) GetListeningMode() GameSetup_ListeningMode {
	if x != nil {
		return x.ListeningMode
	}
	return GameSetup_TIMER
}

func (x *GameSetup) GetListeningDuration() uint32 {
	if x != nil {
		return x.ListeningDuration
	}
	return 0
}

func (x *GameSetup) GetGameDuration() uint32 {
	if x != nil {
		return x.GameDuration
	}
	return 0
}

func (x *GameSetup) GetHomeTeam() *TeamSettings {
	if x != nil {
		return x.HomeTeam
	}
	return nil
}

func (x *GameSetup) GetAwayTeam() *TeamSettings {
	if x != nil {
		return x.AwayTeam
	}
	return nil
}

type TeamSettings struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	Name   string      `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Avatar string      `protobuf:"bytes,2,opt,name=avatar,proto3" json:"avatar,omitempty"`
	Colors *TeamColors `protobuf:"bytes,3,opt,name=colors,proto3" json:"colors,omitempty"`
}

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

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

func (*TeamSettings) ProtoMessage() {}

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

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

func (x *TeamSettings) GetAvatar() string {
	if x != nil {
		return x.Avatar
	}
	return ""
}

func (x *TeamSettings) GetColors() *TeamColors {
	if x != nil {
		return x.Colors
	}
	return nil
}

type TeamColors struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	Primary   *TeamColor `protobuf:"bytes,1,opt,name=primary,proto3" json:"primary,omitempty"`
	Secondary *TeamColor `protobuf:"bytes,2,opt,name=secondary,proto3" json:"secondary,omitempty"`
}

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

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

func (*TeamColors) ProtoMessage() {}

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

func (x *TeamColors) GetPrimary() *TeamColor {
	if x != nil {
		return x.Primary
	}
	return nil
}

func (x *TeamColors) GetSecondary() *TeamColor {
	if x != nil {
		return x.Secondary
	}
	return nil
}

type TeamColor struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	Red   uint32 `protobuf:"varint,1,opt,name=red,proto3" json:"red,omitempty"`
	Green uint32 `protobuf:"varint,2,opt,name=green,proto3" json:"green,omitempty"`
	Blue  uint32 `protobuf:"varint,4,opt,name=blue,proto3" json:"blue,omitempty"`
}

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

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

func (*TeamColor) ProtoMessage() {}

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

func (x *TeamColor) GetRed() uint32 {
	if x != nil {
		return x.Red
	}
	return 0
}

func (x *TeamColor) GetGreen() uint32 {
	if x != nil {
		return x.Green
	}
	return 0
}

func (x *TeamColor) GetBlue() uint32 {
	if x != nil {
		return x.Blue
	}
	return 0
}

// Represents the event of having a new player connected to the game.
type EventNewPlayer struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// Player that has connected to the game.
	Player *Player `protobuf:"bytes,1,opt,name=player,proto3" json:"player,omitempty"`
}

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

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

func (*EventNewPlayer) ProtoMessage() {}

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

func (x *EventNewPlayer) GetPlayer() *Player {
	if x != nil {
		return x.Player
	}
	return nil
}

// Represents the event of having a player disconnected from the game.
type EventLostPlayer struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// Player that has disconnected from the game.
	Player *Player `protobuf:"bytes,1,opt,name=player,proto3" json:"player,omitempty"`
}

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

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

func (*EventLostPlayer) ProtoMessage() {}

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

func (x *EventLostPlayer) GetPlayer() *Player {
	if x != nil {
		return x.Player
	}
	return nil
}

// Represents the event of having the game state changed (e.g. from Waiting to GetReady).
type EventStateChange struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// State of the game before the event.
	PreviousState GameSnapshot_State `protobuf:"varint,1,opt,name=previous_state,json=previousState,proto3,enum=lugo.GameSnapshot_State" json:"previous_state,omitempty"`
	// State of the game after the event.
	NewState GameSnapshot_State `protobuf:"varint,2,opt,name=new_state,json=newState,proto3,enum=lugo.GameSnapshot_State" json:"new_state,omitempty"`
}

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

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

func (*EventStateChange) ProtoMessage() {}

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

func (x *EventStateChange) GetPreviousState() GameSnapshot_State {
	if x != nil {
		return x.PreviousState
	}
	return GameSnapshot_WAITING
}

func (x *EventStateChange) GetNewState() GameSnapshot_State {
	if x != nil {
		return x.NewState
	}
	return GameSnapshot_WAITING
}

// Represents the event of having a goal during the match
type EventGoal struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// Side of the team that changed the score.
	Side Team_Side `protobuf:"varint,1,opt,name=side,proto3,enum=lugo.Team_Side" json:"side,omitempty"` // @todo implementing the player who scored.
}

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

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

func (*EventGoal) ProtoMessage() {}

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

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

// Represents the event of having the game ended.
type EventGameOver struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields
}

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

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

func (*EventGameOver) ProtoMessage() {}

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

// (only available dev mode) Represents the event of having a breakpoint reached.
type EventDebugBreakpoint struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// Type of the breakpoint reached.
	Breakpoint EventDebugBreakpoint_Breakpoint `protobuf:"varint,1,opt,name=breakpoint,proto3,enum=lugo.EventDebugBreakpoint_Breakpoint" json:"breakpoint,omitempty"`
}

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

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

func (*EventDebugBreakpoint) ProtoMessage() {}

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

func (x *EventDebugBreakpoint) GetBreakpoint() EventDebugBreakpoint_Breakpoint {
	if x != nil {
		return x.Breakpoint
	}
	return EventDebugBreakpoint_ORDERS
}

// (only available dev mode) Represents the event of having a breakpoint released.
type EventDebugReleased struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields
}

func (x *EventDebugReleased) Reset() {
	*x = EventDebugReleased{}
	if protoimpl.UnsafeEnabled {
		mi := &file_broadcast_proto_msgTypes[13]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*EventDebugReleased) ProtoMessage() {}

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

var File_broadcast_proto protoreflect.FileDescriptor

var file_broadcast_proto_rawDesc = []byte{
	0x0a, 0x0f, 0x62, 0x72, 0x6f, 0x61, 0x64, 0x63, 0x61, 0x73, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74,
	0x6f, 0x12, 0x04, 0x6c, 0x75, 0x67, 0x6f, 0x1a, 0x0c, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e,
	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x24, 0x0a, 0x0e, 0x57, 0x61, 0x74, 0x63, 0x68, 0x65, 0x72,
	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x75, 0x75, 0x69, 0x64, 0x18,
	0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x75, 0x75, 0x69, 0x64, 0x22, 0x31, 0x0a, 0x0c, 0x53,
	0x74, 0x61, 0x72, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x77,
	0x61, 0x74, 0x63, 0x68, 0x65, 0x72, 0x5f, 0x75, 0x75, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28,
	0x09, 0x52, 0x0b, 0x77, 0x61, 0x74, 0x63, 0x68, 0x65, 0x72, 0x55, 0x75, 0x69, 0x64, 0x22, 0xd7,
	0x03, 0x0a, 0x09, 0x47, 0x61, 0x6d, 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x37, 0x0a, 0x0d,
	0x67, 0x61, 0x6d, 0x65, 0x5f, 0x73, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x18, 0x01, 0x20,
	0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x6c, 0x75, 0x67, 0x6f, 0x2e, 0x47, 0x61, 0x6d, 0x65, 0x53,
	0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x52, 0x0c, 0x67, 0x61, 0x6d, 0x65, 0x53, 0x6e, 0x61,
	0x70, 0x73, 0x68, 0x6f, 0x74, 0x12, 0x35, 0x0a, 0x0a, 0x6e, 0x65, 0x77, 0x5f, 0x70, 0x6c, 0x61,
	0x79, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x6c, 0x75, 0x67, 0x6f,
	0x2e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x4e, 0x65, 0x77, 0x50, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x48,
	0x00, 0x52, 0x09, 0x6e, 0x65, 0x77, 0x50, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x12, 0x38, 0x0a, 0x0b,
	0x6c, 0x6f, 0x73, 0x74, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28,
	0x0b, 0x32, 0x15, 0x2e, 0x6c, 0x75, 0x67, 0x6f, 0x2e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x4c, 0x6f,
	0x73, 0x74, 0x50, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x48, 0x00, 0x52, 0x0a, 0x6c, 0x6f, 0x73, 0x74,
	0x50, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x12, 0x3b, 0x0a, 0x0c, 0x73, 0x74, 0x61, 0x74, 0x65, 0x5f,
	0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x6c,
	0x75, 0x67, 0x6f, 0x2e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x65, 0x43, 0x68,
	0x61, 0x6e, 0x67, 0x65, 0x48, 0x00, 0x52, 0x0b, 0x73, 0x74, 0x61, 0x74, 0x65, 0x43, 0x68, 0x61,
	0x6e, 0x67, 0x65, 0x12, 0x25, 0x0a, 0x04, 0x67, 0x6f, 0x61, 0x6c, 0x18, 0x05, 0x20, 0x01, 0x28,
	0x0b, 0x32, 0x0f, 0x2e, 0x6c, 0x75, 0x67, 0x6f, 0x2e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x47, 0x6f,
	0x61, 0x6c, 0x48, 0x00, 0x52, 0x04, 0x67, 0x6f, 0x61, 0x6c, 0x12, 0x32, 0x0a, 0x09, 0x67, 0x61,
	0x6d, 0x65, 0x5f, 0x6f, 0x76, 0x65, 0x72, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e,
	0x6c, 0x75, 0x67, 0x6f, 0x2e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x47, 0x61, 0x6d, 0x65, 0x4f, 0x76,
	0x65, 0x72, 0x48, 0x00, 0x52, 0x08, 0x67, 0x61, 0x6d, 0x65, 0x4f, 0x76, 0x65, 0x72, 0x12, 0x3c,
	0x0a, 0x0a, 0x62, 0x72, 0x65, 0x61, 0x6b, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x07, 0x20, 0x01,
	0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x6c, 0x75, 0x67, 0x6f, 0x2e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x44,
	0x65, 0x62, 0x75, 0x67, 0x42, 0x72, 0x65, 0x61, 0x6b, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x48, 0x00,
	0x52, 0x0a, 0x62, 0x72, 0x65, 0x61, 0x6b, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x41, 0x0a, 0x0e,
	0x64, 0x65, 0x62, 0x75, 0x67, 0x5f, 0x72, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x64, 0x18, 0x08,
	0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x6c, 0x75, 0x67, 0x6f, 0x2e, 0x45, 0x76, 0x65, 0x6e,
	0x74, 0x44, 0x65, 0x62, 0x75, 0x67, 0x52, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x64, 0x48, 0x00,
	0x52, 0x0d, 0x64, 0x65, 0x62, 0x75, 0x67, 0x52, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x64, 0x42,
	0x07, 0x0a, 0x05, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x22, 0xe3, 0x03, 0x0a, 0x09, 0x47, 0x61, 0x6d,
	0x65, 0x53, 0x65, 0x74, 0x75, 0x70, 0x12, 0x29, 0x0a, 0x10, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63,
	0x6f, 0x6c, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
	0x52, 0x0f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f,
	0x6e, 0x12, 0x19, 0x0a, 0x08, 0x64, 0x65, 0x76, 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x18, 0x02, 0x20,
	0x01, 0x28, 0x08, 0x52, 0x07, 0x64, 0x65, 0x76, 0x4d, 0x6f, 0x64, 0x65, 0x12, 0x3b, 0x0a, 0x0a,
	0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e,
	0x32, 0x1c, 0x2e, 0x6c, 0x75, 0x67, 0x6f, 0x2e, 0x47, 0x61, 0x6d, 0x65, 0x53, 0x65, 0x74, 0x75,
	0x70, 0x2e, 0x53, 0x74, 0x61, 0x72, 0x74, 0x69, 0x6e, 0x67, 0x4d, 0x6f, 0x64, 0x65, 0x52, 0x09,
	0x73, 0x74, 0x61, 0x72, 0x74, 0x4d, 0x6f, 0x64, 0x65, 0x12, 0x44, 0x0a, 0x0e, 0x6c, 0x69, 0x73,
	0x74, 0x65, 0x6e, 0x69, 0x6e, 0x67, 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28,
	0x0e, 0x32, 0x1d, 0x2e, 0x6c, 0x75, 0x67, 0x6f, 0x2e, 0x47, 0x61, 0x6d, 0x65, 0x53, 0x65, 0x74,
	0x75, 0x70, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x69, 0x6e, 0x67, 0x4d, 0x6f, 0x64, 0x65,
	0x52, 0x0d, 0x6c, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x69, 0x6e, 0x67, 0x4d, 0x6f, 0x64, 0x65, 0x12,
	0x2d, 0x0a, 0x12, 0x6c, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x69, 0x6e, 0x67, 0x5f, 0x64, 0x75, 0x72,
	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x11, 0x6c, 0x69, 0x73,
	0x74, 0x65, 0x6e, 0x69, 0x6e, 0x67, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x23,
	0x0a, 0x0d, 0x67, 0x61, 0x6d, 0x65, 0x5f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18,
	0x06, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0c, 0x67, 0x61, 0x6d, 0x65, 0x44, 0x75, 0x72, 0x61, 0x74,
	0x69, 0x6f, 0x6e, 0x12, 0x2f, 0x0a, 0x09, 0x68, 0x6f, 0x6d, 0x65, 0x5f, 0x74, 0x65, 0x61, 0x6d,
	0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x6c, 0x75, 0x67, 0x6f, 0x2e, 0x54, 0x65,
	0x61, 0x6d, 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x52, 0x08, 0x68, 0x6f, 0x6d, 0x65,
	0x54, 0x65, 0x61, 0x6d, 0x12, 0x2f, 0x0a, 0x09, 0x61, 0x77, 0x61, 0x79, 0x5f, 0x74, 0x65, 0x61,
	0x6d, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x6c, 0x75, 0x67, 0x6f, 0x2e, 0x54,
	0x65, 0x61, 0x6d, 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x52, 0x08, 0x61, 0x77, 0x61,
	0x79, 0x54, 0x65, 0x61, 0x6d, 0x22, 0x25, 0x0a, 0x0c, 0x53, 0x74, 0x61, 0x72, 0x74, 0x69, 0x6e,
	0x67, 0x4d, 0x6f, 0x64, 0x65, 0x12, 0x0b, 0x0a, 0x07, 0x4e, 0x4f, 0x5f, 0x57, 0x41, 0x49, 0x54,
	0x10, 0x00, 0x12, 0x08, 0x0a, 0x04, 0x57, 0x41, 0x49, 0x54, 0x10, 0x01, 0x22, 0x30, 0x0a, 0x0d,
	0x4c, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x69, 0x6e, 0x67, 0x4d, 0x6f, 0x64, 0x65, 0x12, 0x09, 0x0a,
	0x05, 0x54, 0x49, 0x4d, 0x45, 0x52, 0x10, 0x00, 0x12, 0x08, 0x0a, 0x04, 0x52, 0x55, 0x53, 0x48,
	0x10, 0x01, 0x12, 0x0a, 0x0a, 0x06, 0x52, 0x45, 0x4d, 0x4f, 0x54, 0x45, 0x10, 0x02, 0x22, 0x64,
	0x0a, 0x0c, 0x54, 0x65, 0x61, 0x6d, 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x12, 0x12,
	0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61,
	0x6d, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x76, 0x61, 0x74, 0x61, 0x72, 0x18, 0x02, 0x20, 0x01,
	0x28, 0x09, 0x52, 0x06, 0x61, 0x76, 0x61, 0x74, 0x61, 0x72, 0x12, 0x28, 0x0a, 0x06, 0x63, 0x6f,
	0x6c, 0x6f, 0x72, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x6c, 0x75, 0x67,
	0x6f, 0x2e, 0x54, 0x65, 0x61, 0x6d, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x73, 0x52, 0x06, 0x63, 0x6f,
	0x6c, 0x6f, 0x72, 0x73, 0x22, 0x66, 0x0a, 0x0a, 0x54, 0x65, 0x61, 0x6d, 0x43, 0x6f, 0x6c, 0x6f,
	0x72, 0x73, 0x12, 0x29, 0x0a, 0x07, 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x18, 0x01, 0x20,
	0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x6c, 0x75, 0x67, 0x6f, 0x2e, 0x54, 0x65, 0x61, 0x6d, 0x43,
	0x6f, 0x6c, 0x6f, 0x72, 0x52, 0x07, 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x12, 0x2d, 0x0a,
	0x09, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x61, 0x72, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b,
	0x32, 0x0f, 0x2e, 0x6c, 0x75, 0x67, 0x6f, 0x2e, 0x54, 0x65, 0x61, 0x6d, 0x43, 0x6f, 0x6c, 0x6f,
	0x72, 0x52, 0x09, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x61, 0x72, 0x79, 0x22, 0x47, 0x0a, 0x09,
	0x54, 0x65, 0x61, 0x6d, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x12, 0x10, 0x0a, 0x03, 0x72, 0x65, 0x64,
	0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x03, 0x72, 0x65, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x67,
	0x72, 0x65, 0x65, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x05, 0x67, 0x72, 0x65, 0x65,
	0x6e, 0x12, 0x12, 0x0a, 0x04, 0x62, 0x6c, 0x75, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0d, 0x52,
	0x04, 0x62, 0x6c, 0x75, 0x65, 0x22, 0x36, 0x0a, 0x0e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x4e, 0x65,
	0x77, 0x50, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x12, 0x24, 0x0a, 0x06, 0x70, 0x6c, 0x61, 0x79, 0x65,
	0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x6c, 0x75, 0x67, 0x6f, 0x2e, 0x50,
	0x6c, 0x61, 0x79, 0x65, 0x72, 0x52, 0x06, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x22, 0x37, 0x0a,
	0x0f, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x4c, 0x6f, 0x73, 0x74, 0x50, 0x6c, 0x61, 0x79, 0x65, 0x72,
	0x12, 0x24, 0x0a, 0x06, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b,
	0x32, 0x0c, 0x2e, 0x6c, 0x75, 0x67, 0x6f, 0x2e, 0x50, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x52, 0x06,
	0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x22, 0x8a, 0x01, 0x0a, 0x10, 0x45, 0x76, 0x65, 0x6e, 0x74,
	0x53, 0x74, 0x61, 0x74, 0x65, 0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x3f, 0x0a, 0x0e, 0x70,
	0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x5f, 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, 0x0d, 0x70,
	0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x35, 0x0a, 0x09,
	0x6e, 0x65, 0x77, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x02, 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, 0x08, 0x6e, 0x65, 0x77, 0x53, 0x74,
	0x61, 0x74, 0x65, 0x22, 0x30, 0x0a, 0x09, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x47, 0x6f, 0x61, 0x6c,
	0x12, 0x23, 0x0a, 0x04, 0x73, 0x69, 0x64, 0x65, 0x18, 0x01, 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, 0x0f, 0x0a, 0x0d, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x47, 0x61,
	0x6d, 0x65, 0x4f, 0x76, 0x65, 0x72, 0x22, 0x81, 0x01, 0x0a, 0x14, 0x45, 0x76, 0x65, 0x6e, 0x74,
	0x44, 0x65, 0x62, 0x75, 0x67, 0x42, 0x72, 0x65, 0x61, 0x6b, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x12,
	0x45, 0x0a, 0x0a, 0x62, 0x72, 0x65, 0x61, 0x6b, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x01, 0x20,
	0x01, 0x28, 0x0e, 0x32, 0x25, 0x2e, 0x6c, 0x75, 0x67, 0x6f, 0x2e, 0x45, 0x76, 0x65, 0x6e, 0x74,
	0x44, 0x65, 0x62, 0x75, 0x67, 0x42, 0x72, 0x65, 0x61, 0x6b, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x2e,
	0x42, 0x72, 0x65, 0x61, 0x6b, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x52, 0x0a, 0x62, 0x72, 0x65, 0x61,
	0x6b, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x22, 0x22, 0x0a, 0x0a, 0x42, 0x72, 0x65, 0x61, 0x6b, 0x70,
	0x6f, 0x69, 0x6e, 0x74, 0x12, 0x0a, 0x0a, 0x06, 0x4f, 0x52, 0x44, 0x45, 0x52, 0x53, 0x10, 0x00,
	0x12, 0x08, 0x0a, 0x04, 0x54, 0x55, 0x52, 0x4e, 0x10, 0x01, 0x22, 0x14, 0x0a, 0x12, 0x45, 0x76,
	0x65, 0x6e, 0x74, 0x44, 0x65, 0x62, 0x75, 0x67, 0x52, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x64,
	0x32, 0xa8, 0x01, 0x0a, 0x09, 0x42, 0x72, 0x6f, 0x61, 0x64, 0x63, 0x61, 0x73, 0x74, 0x12, 0x32,
	0x0a, 0x07, 0x4f, 0x6e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x14, 0x2e, 0x6c, 0x75, 0x67, 0x6f,
	0x2e, 0x57, 0x61, 0x74, 0x63, 0x68, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a,
	0x0f, 0x2e, 0x6c, 0x75, 0x67, 0x6f, 0x2e, 0x47, 0x61, 0x6d, 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74,
	0x30, 0x01, 0x12, 0x35, 0x0a, 0x0c, 0x47, 0x65, 0x74, 0x47, 0x61, 0x6d, 0x65, 0x53, 0x65, 0x74,
	0x75, 0x70, 0x12, 0x14, 0x2e, 0x6c, 0x75, 0x67, 0x6f, 0x2e, 0x57, 0x61, 0x74, 0x63, 0x68, 0x65,
	0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x0f, 0x2e, 0x6c, 0x75, 0x67, 0x6f, 0x2e,
	0x47, 0x61, 0x6d, 0x65, 0x53, 0x65, 0x74, 0x75, 0x70, 0x12, 0x30, 0x0a, 0x09, 0x53, 0x74, 0x61,
	0x72, 0x74, 0x47, 0x61, 0x6d, 0x65, 0x12, 0x12, 0x2e, 0x6c, 0x75, 0x67, 0x6f, 0x2e, 0x53, 0x74,
	0x61, 0x72, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x0f, 0x2e, 0x6c, 0x75, 0x67,
	0x6f, 0x2e, 0x47, 0x61, 0x6d, 0x65, 0x53, 0x65, 0x74, 0x75, 0x70, 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_broadcast_proto_rawDescOnce sync.Once
	file_broadcast_proto_rawDescData = file_broadcast_proto_rawDesc
)

func file_broadcast_proto_rawDescGZIP() []byte {
	file_broadcast_proto_rawDescOnce.Do(func() {
		file_broadcast_proto_rawDescData = protoimpl.X.CompressGZIP(file_broadcast_proto_rawDescData)
	})
	return file_broadcast_proto_rawDescData
}

var file_broadcast_proto_enumTypes = make([]protoimpl.EnumInfo, 3)
var file_broadcast_proto_msgTypes = make([]protoimpl.MessageInfo, 14)
var file_broadcast_proto_goTypes = []interface{}{
	(GameSetup_StartingMode)(0),          // 0: lugo.GameSetup.StartingMode
	(GameSetup_ListeningMode)(0),         // 1: lugo.GameSetup.ListeningMode
	(EventDebugBreakpoint_Breakpoint)(0), // 2: lugo.EventDebugBreakpoint.Breakpoint
	(*WatcherRequest)(nil),               // 3: lugo.WatcherRequest
	(*StartRequest)(nil),                 // 4: lugo.StartRequest
	(*GameEvent)(nil),                    // 5: lugo.GameEvent
	(*GameSetup)(nil),                    // 6: lugo.GameSetup
	(*TeamSettings)(nil),                 // 7: lugo.TeamSettings
	(*TeamColors)(nil),                   // 8: lugo.TeamColors
	(*TeamColor)(nil),                    // 9: lugo.TeamColor
	(*EventNewPlayer)(nil),               // 10: lugo.EventNewPlayer
	(*EventLostPlayer)(nil),              // 11: lugo.EventLostPlayer
	(*EventStateChange)(nil),             // 12: lugo.EventStateChange
	(*EventGoal)(nil),                    // 13: lugo.EventGoal
	(*EventGameOver)(nil),                // 14: lugo.EventGameOver
	(*EventDebugBreakpoint)(nil),         // 15: lugo.EventDebugBreakpoint
	(*EventDebugReleased)(nil),           // 16: lugo.EventDebugReleased
	(*GameSnapshot)(nil),                 // 17: lugo.GameSnapshot
	(*Player)(nil),                       // 18: lugo.Player
	(GameSnapshot_State)(0),              // 19: lugo.GameSnapshot.State
	(Team_Side)(0),                       // 20: lugo.Team.Side
}
var file_broadcast_proto_depIdxs = []int32{
	17, // 0: lugo.GameEvent.game_snapshot:type_name -> lugo.GameSnapshot
	10, // 1: lugo.GameEvent.new_player:type_name -> lugo.EventNewPlayer
	11, // 2: lugo.GameEvent.lost_player:type_name -> lugo.EventLostPlayer
	12, // 3: lugo.GameEvent.state_change:type_name -> lugo.EventStateChange
	13, // 4: lugo.GameEvent.goal:type_name -> lugo.EventGoal
	14, // 5: lugo.GameEvent.game_over:type_name -> lugo.EventGameOver
	15, // 6: lugo.GameEvent.breakpoint:type_name -> lugo.EventDebugBreakpoint
	16, // 7: lugo.GameEvent.debug_released:type_name -> lugo.EventDebugReleased
	0,  // 8: lugo.GameSetup.start_mode:type_name -> lugo.GameSetup.StartingMode
	1,  // 9: lugo.GameSetup.listening_mode:type_name -> lugo.GameSetup.ListeningMode
	7,  // 10: lugo.GameSetup.home_team:type_name -> lugo.TeamSettings
	7,  // 11: lugo.GameSetup.away_team:type_name -> lugo.TeamSettings
	8,  // 12: lugo.TeamSettings.colors:type_name -> lugo.TeamColors
	9,  // 13: lugo.TeamColors.primary:type_name -> lugo.TeamColor
	9,  // 14: lugo.TeamColors.secondary:type_name -> lugo.TeamColor
	18, // 15: lugo.EventNewPlayer.player:type_name -> lugo.Player
	18, // 16: lugo.EventLostPlayer.player:type_name -> lugo.Player
	19, // 17: lugo.EventStateChange.previous_state:type_name -> lugo.GameSnapshot.State
	19, // 18: lugo.EventStateChange.new_state:type_name -> lugo.GameSnapshot.State
	20, // 19: lugo.EventGoal.side:type_name -> lugo.Team.Side
	2,  // 20: lugo.EventDebugBreakpoint.breakpoint:type_name -> lugo.EventDebugBreakpoint.Breakpoint
	3,  // 21: lugo.Broadcast.OnEvent:input_type -> lugo.WatcherRequest
	3,  // 22: lugo.Broadcast.GetGameSetup:input_type -> lugo.WatcherRequest
	4,  // 23: lugo.Broadcast.StartGame:input_type -> lugo.StartRequest
	5,  // 24: lugo.Broadcast.OnEvent:output_type -> lugo.GameEvent
	6,  // 25: lugo.Broadcast.GetGameSetup:output_type -> lugo.GameSetup
	6,  // 26: lugo.Broadcast.StartGame:output_type -> lugo.GameSetup
	24, // [24:27] is the sub-list for method output_type
	21, // [21:24] is the sub-list for method input_type
	21, // [21:21] is the sub-list for extension type_name
	21, // [21:21] is the sub-list for extension extendee
	0,  // [0:21] is the sub-list for field type_name
}

func init() { file_broadcast_proto_init() }
func file_broadcast_proto_init() {
	if File_broadcast_proto != nil {
		return
	}
	file_server_proto_init()
	if !protoimpl.UnsafeEnabled {
		file_broadcast_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*WatcherRequest); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_broadcast_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*StartRequest); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_broadcast_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*GameEvent); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_broadcast_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*GameSetup); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_broadcast_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*TeamSettings); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_broadcast_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*TeamColors); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_broadcast_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*TeamColor); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_broadcast_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*EventNewPlayer); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_broadcast_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*EventLostPlayer); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_broadcast_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*EventStateChange); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_broadcast_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*EventGoal); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_broadcast_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*EventGameOver); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_broadcast_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*EventDebugBreakpoint); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_broadcast_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*EventDebugReleased); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
	}
	file_broadcast_proto_msgTypes[2].OneofWrappers = []interface{}{
		(*GameEvent_NewPlayer)(nil),
		(*GameEvent_LostPlayer)(nil),
		(*GameEvent_StateChange)(nil),
		(*GameEvent_Goal)(nil),
		(*GameEvent_GameOver)(nil),
		(*GameEvent_Breakpoint)(nil),
		(*GameEvent_DebugReleased)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: file_broadcast_proto_rawDesc,
			NumEnums:      3,
			NumMessages:   14,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_broadcast_proto_goTypes,
		DependencyIndexes: file_broadcast_proto_depIdxs,
		EnumInfos:         file_broadcast_proto_enumTypes,
		MessageInfos:      file_broadcast_proto_msgTypes,
	}.Build()
	File_broadcast_proto = out.File
	file_broadcast_proto_rawDesc = nil
	file_broadcast_proto_goTypes = nil
	file_broadcast_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

// BroadcastClient is the client API for Broadcast service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type BroadcastClient interface {
	// Keep an open stream that publish all important events in the match.
	OnEvent(ctx context.Context, in *WatcherRequest, opts ...grpc.CallOption) (Broadcast_OnEventClient, error)
	// Returns the game setup configuration.
	GetGameSetup(ctx context.Context, in *WatcherRequest, opts ...grpc.CallOption) (*GameSetup, error)
	// StartGame allows the master watcher to start the match.
	// See the Game Server starting mode to understand how it works.
	StartGame(ctx context.Context, in *StartRequest, opts ...grpc.CallOption) (*GameSetup, error)
}

type broadcastClient struct {
	cc grpc.ClientConnInterface
}

func NewBroadcastClient(cc grpc.ClientConnInterface) BroadcastClient {
	return &broadcastClient{cc}
}

func (c *broadcastClient) OnEvent(ctx context.Context, in *WatcherRequest, opts ...grpc.CallOption) (Broadcast_OnEventClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Broadcast_serviceDesc.Streams[0], "/lugo.Broadcast/OnEvent", opts...)
	if err != nil {
		return nil, err
	}
	x := &broadcastOnEventClient{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 Broadcast_OnEventClient interface {
	Recv() (*GameEvent, error)
	grpc.ClientStream
}

type broadcastOnEventClient struct {
	grpc.ClientStream
}

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

func (c *broadcastClient) GetGameSetup(ctx context.Context, in *WatcherRequest, opts ...grpc.CallOption) (*GameSetup, error) {
	out := new(GameSetup)
	err := c.cc.Invoke(ctx, "/lugo.Broadcast/GetGameSetup", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *broadcastClient) StartGame(ctx context.Context, in *StartRequest, opts ...grpc.CallOption) (*GameSetup, error) {
	out := new(GameSetup)
	err := c.cc.Invoke(ctx, "/lugo.Broadcast/StartGame", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// BroadcastServer is the server API for Broadcast service.
type BroadcastServer interface {
	// Keep an open stream that publish all important events in the match.
	OnEvent(*WatcherRequest, Broadcast_OnEventServer) error
	// Returns the game setup configuration.
	GetGameSetup(context.Context, *WatcherRequest) (*GameSetup, error)
	// StartGame allows the master watcher to start the match.
	// See the Game Server starting mode to understand how it works.
	StartGame(context.Context, *StartRequest) (*GameSetup, error)
}

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

func (*UnimplementedBroadcastServer) OnEvent(*WatcherRequest, Broadcast_OnEventServer) error {
	return status.Errorf(codes.Unimplemented, "method OnEvent not implemented")
}
func (*UnimplementedBroadcastServer) GetGameSetup(context.Context, *WatcherRequest) (*GameSetup, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetGameSetup not implemented")
}
func (*UnimplementedBroadcastServer) StartGame(context.Context, *StartRequest) (*GameSetup, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StartGame not implemented")
}

func RegisterBroadcastServer(s *grpc.Server, srv BroadcastServer) {
	s.RegisterService(&_Broadcast_serviceDesc, srv)
}

func _Broadcast_OnEvent_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(WatcherRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(BroadcastServer).OnEvent(m, &broadcastOnEventServer{stream})
}

type Broadcast_OnEventServer interface {
	Send(*GameEvent) error
	grpc.ServerStream
}

type broadcastOnEventServer struct {
	grpc.ServerStream
}

func (x *broadcastOnEventServer) Send(m *GameEvent) error {
	return x.ServerStream.SendMsg(m)
}

func _Broadcast_GetGameSetup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(WatcherRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BroadcastServer).GetGameSetup(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/lugo.Broadcast/GetGameSetup",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BroadcastServer).GetGameSetup(ctx, req.(*WatcherRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Broadcast_StartGame_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StartRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BroadcastServer).StartGame(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/lugo.Broadcast/StartGame",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BroadcastServer).StartGame(ctx, req.(*StartRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Broadcast_serviceDesc = grpc.ServiceDesc{
	ServiceName: "lugo.Broadcast",
	HandlerType: (*BroadcastServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetGameSetup",
			Handler:    _Broadcast_GetGameSetup_Handler,
		},
		{
			MethodName: "StartGame",
			Handler:    _Broadcast_StartGame_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "OnEvent",
			Handler:       _Broadcast_OnEvent_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "broadcast.proto",
}