// Code generated by protoc-gen-go. DO NOT EDIT.
// source: model/sailing.proto

package proto

import (
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	math "math"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package

type SailingRole struct {
	EventType              int32         `protobuf:"varint,1,opt,name=event_type,json=eventType,proto3" json:"event_type,omitempty"`
	Enemy                  *SailingEnemy `protobuf:"bytes,2,opt,name=enemy,proto3" json:"enemy,omitempty"`
	LastCheckedSailingArea int32         `protobuf:"varint,3,opt,name=last_checked_sailing_area,json=lastCheckedSailingArea,proto3" json:"last_checked_sailing_area,omitempty"`
	CheckedArea            int32         `protobuf:"varint,4,opt,name=checked_area,json=checkedArea,proto3" json:"checked_area,omitempty"`
	XXX_NoUnkeyedLiteral   struct{}      `json:"-"`
	XXX_unrecognized       []byte        `json:"-"`
	XXX_sizecache          int32         `json:"-"`
}

func (m *SailingRole) Reset()         { *m = SailingRole{} }
func (m *SailingRole) String() string { return proto.CompactTextString(m) }
func (*SailingRole) ProtoMessage()    {}
func (*SailingRole) Descriptor() ([]byte, []int) {
	return fileDescriptor_d382a067d04dcdec, []int{0}
}

func (m *SailingRole) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SailingRole.Unmarshal(m, b)
}
func (m *SailingRole) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SailingRole.Marshal(b, m, deterministic)
}
func (m *SailingRole) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SailingRole.Merge(m, src)
}
func (m *SailingRole) XXX_Size() int {
	return xxx_messageInfo_SailingRole.Size(m)
}
func (m *SailingRole) XXX_DiscardUnknown() {
	xxx_messageInfo_SailingRole.DiscardUnknown(m)
}

var xxx_messageInfo_SailingRole proto.InternalMessageInfo

func (m *SailingRole) GetEventType() int32 {
	if m != nil {
		return m.EventType
	}
	return 0
}

func (m *SailingRole) GetEnemy() *SailingEnemy {
	if m != nil {
		return m.Enemy
	}
	return nil
}

func (m *SailingRole) GetLastCheckedSailingArea() int32 {
	if m != nil {
		return m.LastCheckedSailingArea
	}
	return 0
}

func (m *SailingRole) GetCheckedArea() int32 {
	if m != nil {
		return m.CheckedArea
	}
	return 0
}

type SailingArea struct {
	Current              int32    `protobuf:"varint,1,opt,name=current,proto3" json:"current,omitempty"`
	UnlockedMaxArea      int32    `protobuf:"varint,2,opt,name=unlocked_max_area,json=unlockedMaxArea,proto3" json:"unlocked_max_area,omitempty"`
	ArrivedMaxArea       int32    `protobuf:"varint,3,opt,name=arrived_max_area,json=arrivedMaxArea,proto3" json:"arrived_max_area,omitempty"`
	MaxAreaStar          int32    `protobuf:"varint,4,opt,name=max_area_star,json=maxAreaStar,proto3" json:"max_area_star,omitempty"`
	NextSailingTime      int64    `protobuf:"varint,5,opt,name=next_sailing_time,json=nextSailingTime,proto3" json:"next_sailing_time,omitempty"`
	StarChangedArea      int32    `protobuf:"varint,6,opt,name=star_changed_area,json=starChangedArea,proto3" json:"star_changed_area,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *SailingArea) Reset()         { *m = SailingArea{} }
func (m *SailingArea) String() string { return proto.CompactTextString(m) }
func (*SailingArea) ProtoMessage()    {}
func (*SailingArea) Descriptor() ([]byte, []int) {
	return fileDescriptor_d382a067d04dcdec, []int{1}
}

func (m *SailingArea) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SailingArea.Unmarshal(m, b)
}
func (m *SailingArea) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SailingArea.Marshal(b, m, deterministic)
}
func (m *SailingArea) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SailingArea.Merge(m, src)
}
func (m *SailingArea) XXX_Size() int {
	return xxx_messageInfo_SailingArea.Size(m)
}
func (m *SailingArea) XXX_DiscardUnknown() {
	xxx_messageInfo_SailingArea.DiscardUnknown(m)
}

var xxx_messageInfo_SailingArea proto.InternalMessageInfo

func (m *SailingArea) GetCurrent() int32 {
	if m != nil {
		return m.Current
	}
	return 0
}

func (m *SailingArea) GetUnlockedMaxArea() int32 {
	if m != nil {
		return m.UnlockedMaxArea
	}
	return 0
}

func (m *SailingArea) GetArrivedMaxArea() int32 {
	if m != nil {
		return m.ArrivedMaxArea
	}
	return 0
}

func (m *SailingArea) GetMaxAreaStar() int32 {
	if m != nil {
		return m.MaxAreaStar
	}
	return 0
}

func (m *SailingArea) GetNextSailingTime() int64 {
	if m != nil {
		return m.NextSailingTime
	}
	return 0
}

func (m *SailingArea) GetStarChangedArea() int32 {
	if m != nil {
		return m.StarChangedArea
	}
	return 0
}

type SailingMark struct {
	Id                   string        `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	FinderName           string        `protobuf:"bytes,2,opt,name=finder_name,json=finderName,proto3" json:"finder_name,omitempty"`
	MarkTime             int64         `protobuf:"varint,3,opt,name=mark_time,json=markTime,proto3" json:"mark_time,omitempty"`
	Attacking            bool          `protobuf:"varint,4,opt,name=attacking,proto3" json:"attacking,omitempty"`
	Enemy                *SailingEnemy `protobuf:"bytes,5,opt,name=enemy,proto3" json:"enemy,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

func (m *SailingMark) Reset()         { *m = SailingMark{} }
func (m *SailingMark) String() string { return proto.CompactTextString(m) }
func (*SailingMark) ProtoMessage()    {}
func (*SailingMark) Descriptor() ([]byte, []int) {
	return fileDescriptor_d382a067d04dcdec, []int{2}
}

func (m *SailingMark) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SailingMark.Unmarshal(m, b)
}
func (m *SailingMark) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SailingMark.Marshal(b, m, deterministic)
}
func (m *SailingMark) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SailingMark.Merge(m, src)
}
func (m *SailingMark) XXX_Size() int {
	return xxx_messageInfo_SailingMark.Size(m)
}
func (m *SailingMark) XXX_DiscardUnknown() {
	xxx_messageInfo_SailingMark.DiscardUnknown(m)
}

var xxx_messageInfo_SailingMark proto.InternalMessageInfo

func (m *SailingMark) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *SailingMark) GetFinderName() string {
	if m != nil {
		return m.FinderName
	}
	return ""
}

func (m *SailingMark) GetMarkTime() int64 {
	if m != nil {
		return m.MarkTime
	}
	return 0
}

func (m *SailingMark) GetAttacking() bool {
	if m != nil {
		return m.Attacking
	}
	return false
}

func (m *SailingMark) GetEnemy() *SailingEnemy {
	if m != nil {
		return m.Enemy
	}
	return nil
}

type SailingAssist struct {
	Id                   string             `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	EnemyId              int32              `protobuf:"varint,2,opt,name=enemy_id,json=enemyId,proto3" json:"enemy_id,omitempty"`
	IsAssisted           bool               `protobuf:"varint,3,opt,name=is_assisted,json=isAssisted,proto3" json:"is_assisted,omitempty"`
	Reward               []*GameObjectCount `protobuf:"bytes,4,rep,name=reward,proto3" json:"reward,omitempty"`
	BoxReward            []*GameObjectCount `protobuf:"bytes,5,rep,name=box_reward,json=boxReward,proto3" json:"box_reward,omitempty"`
	GenerateTime         int64              `protobuf:"varint,6,opt,name=generate_time,json=generateTime,proto3" json:"generate_time,omitempty"`
	Received             bool               `protobuf:"varint,7,opt,name=received,proto3" json:"received,omitempty"`
	AssistTimesLimit     bool               `protobuf:"varint,8,opt,name=assist_times_limit,json=assistTimesLimit,proto3" json:"assist_times_limit,omitempty"`
	FinderName           string             `protobuf:"bytes,9,opt,name=finder_name,json=finderName,proto3" json:"finder_name,omitempty"`
	KillerName           string             `protobuf:"bytes,10,opt,name=killer_name,json=killerName,proto3" json:"killer_name,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

func (m *SailingAssist) Reset()         { *m = SailingAssist{} }
func (m *SailingAssist) String() string { return proto.CompactTextString(m) }
func (*SailingAssist) ProtoMessage()    {}
func (*SailingAssist) Descriptor() ([]byte, []int) {
	return fileDescriptor_d382a067d04dcdec, []int{3}
}

func (m *SailingAssist) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SailingAssist.Unmarshal(m, b)
}
func (m *SailingAssist) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SailingAssist.Marshal(b, m, deterministic)
}
func (m *SailingAssist) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SailingAssist.Merge(m, src)
}
func (m *SailingAssist) XXX_Size() int {
	return xxx_messageInfo_SailingAssist.Size(m)
}
func (m *SailingAssist) XXX_DiscardUnknown() {
	xxx_messageInfo_SailingAssist.DiscardUnknown(m)
}

var xxx_messageInfo_SailingAssist proto.InternalMessageInfo

func (m *SailingAssist) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *SailingAssist) GetEnemyId() int32 {
	if m != nil {
		return m.EnemyId
	}
	return 0
}

func (m *SailingAssist) GetIsAssisted() bool {
	if m != nil {
		return m.IsAssisted
	}
	return false
}

func (m *SailingAssist) GetReward() []*GameObjectCount {
	if m != nil {
		return m.Reward
	}
	return nil
}

func (m *SailingAssist) GetBoxReward() []*GameObjectCount {
	if m != nil {
		return m.BoxReward
	}
	return nil
}

func (m *SailingAssist) GetGenerateTime() int64 {
	if m != nil {
		return m.GenerateTime
	}
	return 0
}

func (m *SailingAssist) GetReceived() bool {
	if m != nil {
		return m.Received
	}
	return false
}

func (m *SailingAssist) GetAssistTimesLimit() bool {
	if m != nil {
		return m.AssistTimesLimit
	}
	return false
}

func (m *SailingAssist) GetFinderName() string {
	if m != nil {
		return m.FinderName
	}
	return ""
}

func (m *SailingAssist) GetKillerName() string {
	if m != nil {
		return m.KillerName
	}
	return ""
}

type SailingStrength struct {
	Remain               int32    `protobuf:"varint,1,opt,name=remain,proto3" json:"remain,omitempty"`
	RestoreTime          int64    `protobuf:"varint,2,opt,name=restore_time,json=restoreTime,proto3" json:"restore_time,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *SailingStrength) Reset()         { *m = SailingStrength{} }
func (m *SailingStrength) String() string { return proto.CompactTextString(m) }
func (*SailingStrength) ProtoMessage()    {}
func (*SailingStrength) Descriptor() ([]byte, []int) {
	return fileDescriptor_d382a067d04dcdec, []int{4}
}

func (m *SailingStrength) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SailingStrength.Unmarshal(m, b)
}
func (m *SailingStrength) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SailingStrength.Marshal(b, m, deterministic)
}
func (m *SailingStrength) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SailingStrength.Merge(m, src)
}
func (m *SailingStrength) XXX_Size() int {
	return xxx_messageInfo_SailingStrength.Size(m)
}
func (m *SailingStrength) XXX_DiscardUnknown() {
	xxx_messageInfo_SailingStrength.DiscardUnknown(m)
}

var xxx_messageInfo_SailingStrength proto.InternalMessageInfo

func (m *SailingStrength) GetRemain() int32 {
	if m != nil {
		return m.Remain
	}
	return 0
}

func (m *SailingStrength) GetRestoreTime() int64 {
	if m != nil {
		return m.RestoreTime
	}
	return 0
}

type SailingEnemy struct {
	Id                   int32    `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	TotalHp              int64    `protobuf:"varint,2,opt,name=total_hp,json=totalHp,proto3" json:"total_hp,omitempty"`
	CurHp                int64    `protobuf:"varint,3,opt,name=cur_hp,json=curHp,proto3" json:"cur_hp,omitempty"`
	NextAttackTime       int64    `protobuf:"varint,4,opt,name=next_attack_time,json=nextAttackTime,proto3" json:"next_attack_time,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *SailingEnemy) Reset()         { *m = SailingEnemy{} }
func (m *SailingEnemy) String() string { return proto.CompactTextString(m) }
func (*SailingEnemy) ProtoMessage()    {}
func (*SailingEnemy) Descriptor() ([]byte, []int) {
	return fileDescriptor_d382a067d04dcdec, []int{5}
}

func (m *SailingEnemy) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SailingEnemy.Unmarshal(m, b)
}
func (m *SailingEnemy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SailingEnemy.Marshal(b, m, deterministic)
}
func (m *SailingEnemy) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SailingEnemy.Merge(m, src)
}
func (m *SailingEnemy) XXX_Size() int {
	return xxx_messageInfo_SailingEnemy.Size(m)
}
func (m *SailingEnemy) XXX_DiscardUnknown() {
	xxx_messageInfo_SailingEnemy.DiscardUnknown(m)
}

var xxx_messageInfo_SailingEnemy proto.InternalMessageInfo

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

func (m *SailingEnemy) GetTotalHp() int64 {
	if m != nil {
		return m.TotalHp
	}
	return 0
}

func (m *SailingEnemy) GetCurHp() int64 {
	if m != nil {
		return m.CurHp
	}
	return 0
}

func (m *SailingEnemy) GetNextAttackTime() int64 {
	if m != nil {
		return m.NextAttackTime
	}
	return 0
}

// 奖励事件配置
type SailingActivityRewardEvent struct {
	Events               []*SailingActivityRewardEvent_Event `protobuf:"bytes,1,rep,name=events,proto3" json:"events,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                            `json:"-"`
	XXX_unrecognized     []byte                              `json:"-"`
	XXX_sizecache        int32                               `json:"-"`
}

func (m *SailingActivityRewardEvent) Reset()         { *m = SailingActivityRewardEvent{} }
func (m *SailingActivityRewardEvent) String() string { return proto.CompactTextString(m) }
func (*SailingActivityRewardEvent) ProtoMessage()    {}
func (*SailingActivityRewardEvent) Descriptor() ([]byte, []int) {
	return fileDescriptor_d382a067d04dcdec, []int{6}
}

func (m *SailingActivityRewardEvent) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SailingActivityRewardEvent.Unmarshal(m, b)
}
func (m *SailingActivityRewardEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SailingActivityRewardEvent.Marshal(b, m, deterministic)
}
func (m *SailingActivityRewardEvent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SailingActivityRewardEvent.Merge(m, src)
}
func (m *SailingActivityRewardEvent) XXX_Size() int {
	return xxx_messageInfo_SailingActivityRewardEvent.Size(m)
}
func (m *SailingActivityRewardEvent) XXX_DiscardUnknown() {
	xxx_messageInfo_SailingActivityRewardEvent.DiscardUnknown(m)
}

var xxx_messageInfo_SailingActivityRewardEvent proto.InternalMessageInfo

func (m *SailingActivityRewardEvent) GetEvents() []*SailingActivityRewardEvent_Event {
	if m != nil {
		return m.Events
	}
	return nil
}

type SailingActivityRewardEvent_Event struct {
	No                   int32              `protobuf:"varint,1,opt,name=no,proto3" json:"no,omitempty"`
	Area                 int32              `protobuf:"varint,2,opt,name=area,proto3" json:"area,omitempty"`
	Typ                  int32              `protobuf:"varint,3,opt,name=typ,proto3" json:"typ,omitempty"`
	Award                []*GameObjectCount `protobuf:"bytes,4,rep,name=award,proto3" json:"award,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

func (m *SailingActivityRewardEvent_Event) Reset()         { *m = SailingActivityRewardEvent_Event{} }
func (m *SailingActivityRewardEvent_Event) String() string { return proto.CompactTextString(m) }
func (*SailingActivityRewardEvent_Event) ProtoMessage()    {}
func (*SailingActivityRewardEvent_Event) Descriptor() ([]byte, []int) {
	return fileDescriptor_d382a067d04dcdec, []int{6, 0}
}

func (m *SailingActivityRewardEvent_Event) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SailingActivityRewardEvent_Event.Unmarshal(m, b)
}
func (m *SailingActivityRewardEvent_Event) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SailingActivityRewardEvent_Event.Marshal(b, m, deterministic)
}
func (m *SailingActivityRewardEvent_Event) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SailingActivityRewardEvent_Event.Merge(m, src)
}
func (m *SailingActivityRewardEvent_Event) XXX_Size() int {
	return xxx_messageInfo_SailingActivityRewardEvent_Event.Size(m)
}
func (m *SailingActivityRewardEvent_Event) XXX_DiscardUnknown() {
	xxx_messageInfo_SailingActivityRewardEvent_Event.DiscardUnknown(m)
}

var xxx_messageInfo_SailingActivityRewardEvent_Event proto.InternalMessageInfo

func (m *SailingActivityRewardEvent_Event) GetNo() int32 {
	if m != nil {
		return m.No
	}
	return 0
}

func (m *SailingActivityRewardEvent_Event) GetArea() int32 {
	if m != nil {
		return m.Area
	}
	return 0
}

func (m *SailingActivityRewardEvent_Event) GetTyp() int32 {
	if m != nil {
		return m.Typ
	}
	return 0
}

func (m *SailingActivityRewardEvent_Event) GetAward() []*GameObjectCount {
	if m != nil {
		return m.Award
	}
	return nil
}

// 敌人事件奖励配置
type SailingActivityEnemyLevel struct {
	Level                []*SailingActivityEnemyLevel_Level `protobuf:"bytes,1,rep,name=level,proto3" json:"level,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                           `json:"-"`
	XXX_unrecognized     []byte                             `json:"-"`
	XXX_sizecache        int32                              `json:"-"`
}

func (m *SailingActivityEnemyLevel) Reset()         { *m = SailingActivityEnemyLevel{} }
func (m *SailingActivityEnemyLevel) String() string { return proto.CompactTextString(m) }
func (*SailingActivityEnemyLevel) ProtoMessage()    {}
func (*SailingActivityEnemyLevel) Descriptor() ([]byte, []int) {
	return fileDescriptor_d382a067d04dcdec, []int{7}
}

func (m *SailingActivityEnemyLevel) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SailingActivityEnemyLevel.Unmarshal(m, b)
}
func (m *SailingActivityEnemyLevel) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SailingActivityEnemyLevel.Marshal(b, m, deterministic)
}
func (m *SailingActivityEnemyLevel) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SailingActivityEnemyLevel.Merge(m, src)
}
func (m *SailingActivityEnemyLevel) XXX_Size() int {
	return xxx_messageInfo_SailingActivityEnemyLevel.Size(m)
}
func (m *SailingActivityEnemyLevel) XXX_DiscardUnknown() {
	xxx_messageInfo_SailingActivityEnemyLevel.DiscardUnknown(m)
}

var xxx_messageInfo_SailingActivityEnemyLevel proto.InternalMessageInfo

func (m *SailingActivityEnemyLevel) GetLevel() []*SailingActivityEnemyLevel_Level {
	if m != nil {
		return m.Level
	}
	return nil
}

type SailingActivityEnemyLevel_Level struct {
	Level                int32              `protobuf:"varint,1,opt,name=level,proto3" json:"level,omitempty"`
	GuaranteeAward       []*GameObjectCount `protobuf:"bytes,2,rep,name=guarantee_award,json=guaranteeAward,proto3" json:"guarantee_award,omitempty"`
	NotGuaranteeAward    []*GameObjectCount `protobuf:"bytes,3,rep,name=not_guarantee_award,json=notGuaranteeAward,proto3" json:"not_guarantee_award,omitempty"`
	ChestAward           []*GameObjectCount `protobuf:"bytes,4,rep,name=chest_award,json=chestAward,proto3" json:"chest_award,omitempty"`
	Score                int64              `protobuf:"varint,5,opt,name=score,proto3" json:"score,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

func (m *SailingActivityEnemyLevel_Level) Reset()         { *m = SailingActivityEnemyLevel_Level{} }
func (m *SailingActivityEnemyLevel_Level) String() string { return proto.CompactTextString(m) }
func (*SailingActivityEnemyLevel_Level) ProtoMessage()    {}
func (*SailingActivityEnemyLevel_Level) Descriptor() ([]byte, []int) {
	return fileDescriptor_d382a067d04dcdec, []int{7, 0}
}

func (m *SailingActivityEnemyLevel_Level) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SailingActivityEnemyLevel_Level.Unmarshal(m, b)
}
func (m *SailingActivityEnemyLevel_Level) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SailingActivityEnemyLevel_Level.Marshal(b, m, deterministic)
}
func (m *SailingActivityEnemyLevel_Level) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SailingActivityEnemyLevel_Level.Merge(m, src)
}
func (m *SailingActivityEnemyLevel_Level) XXX_Size() int {
	return xxx_messageInfo_SailingActivityEnemyLevel_Level.Size(m)
}
func (m *SailingActivityEnemyLevel_Level) XXX_DiscardUnknown() {
	xxx_messageInfo_SailingActivityEnemyLevel_Level.DiscardUnknown(m)
}

var xxx_messageInfo_SailingActivityEnemyLevel_Level proto.InternalMessageInfo

func (m *SailingActivityEnemyLevel_Level) GetLevel() int32 {
	if m != nil {
		return m.Level
	}
	return 0
}

func (m *SailingActivityEnemyLevel_Level) GetGuaranteeAward() []*GameObjectCount {
	if m != nil {
		return m.GuaranteeAward
	}
	return nil
}

func (m *SailingActivityEnemyLevel_Level) GetNotGuaranteeAward() []*GameObjectCount {
	if m != nil {
		return m.NotGuaranteeAward
	}
	return nil
}

func (m *SailingActivityEnemyLevel_Level) GetChestAward() []*GameObjectCount {
	if m != nil {
		return m.ChestAward
	}
	return nil
}

func (m *SailingActivityEnemyLevel_Level) GetScore() int64 {
	if m != nil {
		return m.Score
	}
	return 0
}

// 海域
type SailingActivityArea struct {
	Areas                []*SailingActivityArea_Area `protobuf:"bytes,1,rep,name=areas,proto3" json:"areas,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                    `json:"-"`
	XXX_unrecognized     []byte                      `json:"-"`
	XXX_sizecache        int32                       `json:"-"`
}

func (m *SailingActivityArea) Reset()         { *m = SailingActivityArea{} }
func (m *SailingActivityArea) String() string { return proto.CompactTextString(m) }
func (*SailingActivityArea) ProtoMessage()    {}
func (*SailingActivityArea) Descriptor() ([]byte, []int) {
	return fileDescriptor_d382a067d04dcdec, []int{8}
}

func (m *SailingActivityArea) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SailingActivityArea.Unmarshal(m, b)
}
func (m *SailingActivityArea) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SailingActivityArea.Marshal(b, m, deterministic)
}
func (m *SailingActivityArea) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SailingActivityArea.Merge(m, src)
}
func (m *SailingActivityArea) XXX_Size() int {
	return xxx_messageInfo_SailingActivityArea.Size(m)
}
func (m *SailingActivityArea) XXX_DiscardUnknown() {
	xxx_messageInfo_SailingActivityArea.DiscardUnknown(m)
}

var xxx_messageInfo_SailingActivityArea proto.InternalMessageInfo

func (m *SailingActivityArea) GetAreas() []*SailingActivityArea_Area {
	if m != nil {
		return m.Areas
	}
	return nil
}

type SailingActivityArea_Area struct {
	Area                 int32    `protobuf:"varint,1,opt,name=area,proto3" json:"area,omitempty"`
	Level                []int32  `protobuf:"varint,2,rep,packed,name=level,proto3" json:"level,omitempty"`
	CompleteStars        int32    `protobuf:"varint,3,opt,name=complete_stars,json=completeStars,proto3" json:"complete_stars,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *SailingActivityArea_Area) Reset()         { *m = SailingActivityArea_Area{} }
func (m *SailingActivityArea_Area) String() string { return proto.CompactTextString(m) }
func (*SailingActivityArea_Area) ProtoMessage()    {}
func (*SailingActivityArea_Area) Descriptor() ([]byte, []int) {
	return fileDescriptor_d382a067d04dcdec, []int{8, 0}
}

func (m *SailingActivityArea_Area) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SailingActivityArea_Area.Unmarshal(m, b)
}
func (m *SailingActivityArea_Area) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SailingActivityArea_Area.Marshal(b, m, deterministic)
}
func (m *SailingActivityArea_Area) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SailingActivityArea_Area.Merge(m, src)
}
func (m *SailingActivityArea_Area) XXX_Size() int {
	return xxx_messageInfo_SailingActivityArea_Area.Size(m)
}
func (m *SailingActivityArea_Area) XXX_DiscardUnknown() {
	xxx_messageInfo_SailingActivityArea_Area.DiscardUnknown(m)
}

var xxx_messageInfo_SailingActivityArea_Area proto.InternalMessageInfo

func (m *SailingActivityArea_Area) GetArea() int32 {
	if m != nil {
		return m.Area
	}
	return 0
}

func (m *SailingActivityArea_Area) GetLevel() []int32 {
	if m != nil {
		return m.Level
	}
	return nil
}

func (m *SailingActivityArea_Area) GetCompleteStars() int32 {
	if m != nil {
		return m.CompleteStars
	}
	return 0
}

func init() {
	proto.RegisterType((*SailingRole)(nil), "proto.SailingRole")
	proto.RegisterType((*SailingArea)(nil), "proto.SailingArea")
	proto.RegisterType((*SailingMark)(nil), "proto.SailingMark")
	proto.RegisterType((*SailingAssist)(nil), "proto.SailingAssist")
	proto.RegisterType((*SailingStrength)(nil), "proto.SailingStrength")
	proto.RegisterType((*SailingEnemy)(nil), "proto.SailingEnemy")
	proto.RegisterType((*SailingActivityRewardEvent)(nil), "proto.SailingActivityRewardEvent")
	proto.RegisterType((*SailingActivityRewardEvent_Event)(nil), "proto.SailingActivityRewardEvent.Event")
	proto.RegisterType((*SailingActivityEnemyLevel)(nil), "proto.SailingActivityEnemyLevel")
	proto.RegisterType((*SailingActivityEnemyLevel_Level)(nil), "proto.SailingActivityEnemyLevel.Level")
	proto.RegisterType((*SailingActivityArea)(nil), "proto.SailingActivityArea")
	proto.RegisterType((*SailingActivityArea_Area)(nil), "proto.SailingActivityArea.Area")
}

func init() { proto.RegisterFile("model/sailing.proto", fileDescriptor_d382a067d04dcdec) }

var fileDescriptor_d382a067d04dcdec = []byte{
	// 886 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x55, 0x5f, 0x6f, 0x1b, 0x45,
	0x10, 0xd7, 0x9d, 0x7d, 0x8e, 0x3d, 0x4e, 0x9c, 0x74, 0x53, 0xc2, 0xc5, 0x80, 0x12, 0x8c, 0x00,
	0x83, 0x2a, 0x23, 0x15, 0x55, 0x08, 0x09, 0xa9, 0x8a, 0xa2, 0xd2, 0x22, 0xa5, 0x20, 0x5d, 0x2a,
	0xf1, 0x78, 0xda, 0x9c, 0x07, 0x67, 0xf1, 0xdd, 0xee, 0x69, 0x6f, 0x1d, 0x6c, 0x3e, 0x0f, 0x7c,
	0x04, 0xbe, 0x04, 0x6f, 0x7c, 0x16, 0xc4, 0x03, 0x6f, 0x68, 0x67, 0x77, 0x6d, 0x37, 0x8d, 0x42,
	0x5f, 0xce, 0xb7, 0x33, 0xbf, 0xf9, 0xdd, 0x6f, 0xfe, 0xec, 0x18, 0x0e, 0x2b, 0x35, 0xc5, 0xf2,
	0x8b, 0x86, 0x8b, 0x52, 0xc8, 0xd9, 0xa4, 0xd6, 0xca, 0x28, 0x96, 0xd0, 0xcf, 0xf0, 0x5d, 0xe7,
	0x9b, 0xf1, 0x0a, 0x73, 0x75, 0xf5, 0x33, 0x16, 0xc6, 0xf9, 0x47, 0x7f, 0x44, 0xd0, 0xbf, 0x74,
	0x11, 0x99, 0x2a, 0x91, 0x7d, 0x00, 0x80, 0x37, 0x28, 0x4d, 0x6e, 0x56, 0x35, 0xa6, 0xd1, 0x69,
	0x34, 0x4e, 0xb2, 0x1e, 0x59, 0x5e, 0xad, 0x6a, 0x64, 0x9f, 0x41, 0x82, 0x12, 0xab, 0x55, 0x1a,
	0x9f, 0x46, 0xe3, 0xfe, 0xe3, 0x43, 0xc7, 0x32, 0xf1, 0x0c, 0xcf, 0xac, 0x2b, 0x73, 0x08, 0xf6,
	0x35, 0x1c, 0x97, 0xbc, 0x31, 0x79, 0x71, 0x8d, 0xc5, 0x1c, 0xa7, 0xb9, 0xd7, 0x95, 0x73, 0x8d,
	0x3c, 0x6d, 0x11, 0xf1, 0x91, 0x05, 0x9c, 0x3b, 0xbf, 0xa7, 0x38, 0xd3, 0xc8, 0xd9, 0x87, 0xb0,
	0x1b, 0xa2, 0x08, 0xdd, 0x26, 0x74, 0xdf, 0xdb, 0x2c, 0x64, 0xf4, 0xef, 0x46, 0x37, 0x85, 0xa4,
	0xb0, 0x53, 0x2c, 0xb4, 0x46, 0x69, 0xbc, 0xe8, 0x70, 0x64, 0x9f, 0xc3, 0x83, 0x85, 0x2c, 0x15,
	0xb1, 0x55, 0x7c, 0xe9, 0x18, 0x63, 0xc2, 0xec, 0x07, 0xc7, 0x4b, 0xbe, 0x24, 0x96, 0x31, 0x1c,
	0x70, 0xad, 0xc5, 0xcd, 0x36, 0xd4, 0x49, 0x1d, 0x78, 0x7b, 0x40, 0x8e, 0x60, 0x2f, 0x20, 0xf2,
	0xc6, 0x70, 0x1d, 0x34, 0x56, 0xce, 0x7f, 0x69, 0xb8, 0xb6, 0x5f, 0x96, 0xb8, 0x34, 0xeb, 0xcc,
	0x8d, 0xa8, 0x30, 0x4d, 0x4e, 0xa3, 0x71, 0x2b, 0xdb, 0xb7, 0x0e, 0xaf, 0xff, 0x95, 0xa8, 0xd0,
	0x62, 0x2d, 0x4d, 0x5e, 0x5c, 0x73, 0x39, 0x0b, 0x79, 0x77, 0x9c, 0x4a, 0xeb, 0x38, 0x77, 0x76,
	0xca, 0xfd, 0xb7, 0x4d, 0xee, 0x2f, 0xb9, 0x9e, 0xb3, 0x01, 0xc4, 0x62, 0x4a, 0x69, 0xf7, 0xb2,
	0x58, 0x4c, 0xd9, 0x09, 0xf4, 0x7f, 0x12, 0x72, 0x8a, 0x3a, 0x97, 0xbc, 0x42, 0xca, 0xb5, 0x97,
	0x81, 0x33, 0x7d, 0xcf, 0x2b, 0x64, 0xef, 0x41, 0xaf, 0xe2, 0x7a, 0xee, 0x04, 0xb5, 0x48, 0x50,
	0xd7, 0x1a, 0x48, 0xc9, 0xfb, 0xd0, 0xe3, 0xc6, 0xf0, 0x62, 0x2e, 0xe4, 0x8c, 0xb2, 0xea, 0x66,
	0x1b, 0xc3, 0x66, 0x00, 0x92, 0xff, 0x1b, 0x80, 0xd1, 0xdf, 0x31, 0xec, 0x85, 0x16, 0x35, 0x8d,
	0x68, 0xcc, 0x1b, 0x42, 0x8f, 0xa1, 0x4b, 0xd0, 0x5c, 0x4c, 0x7d, 0x47, 0x76, 0xe8, 0xfc, 0x1d,
	0xe5, 0x20, 0x9a, 0x9c, 0x53, 0x1c, 0x4e, 0x49, 0x64, 0x37, 0x03, 0xd1, 0x9c, 0x79, 0x0b, 0x9b,
	0x40, 0x47, 0xe3, 0x2f, 0x5c, 0x4f, 0xd3, 0xf6, 0x69, 0x6b, 0xdc, 0x7f, 0x7c, 0xe4, 0x95, 0x3c,
	0xe7, 0x15, 0xfe, 0x40, 0x13, 0x7e, 0xae, 0x16, 0xd2, 0x64, 0x1e, 0xc5, 0x9e, 0x00, 0x5c, 0xa9,
	0x65, 0xee, 0x63, 0x92, 0x7b, 0x63, 0x7a, 0x57, 0x6a, 0x99, 0xb9, 0xb0, 0x8f, 0x60, 0x6f, 0x86,
	0x12, 0x35, 0x37, 0xe8, 0xca, 0xd5, 0xa1, 0x72, 0xed, 0x06, 0x23, 0x95, 0x6c, 0x08, 0x5d, 0x8d,
	0x05, 0xda, 0xf9, 0x48, 0x77, 0x48, 0xe9, 0xfa, 0xcc, 0x1e, 0x01, 0x73, 0x59, 0x50, 0x78, 0x93,
	0x97, 0xa2, 0x12, 0x26, 0xed, 0x12, 0xea, 0xc0, 0x79, 0x2c, 0x47, 0x73, 0x61, 0xed, 0xb7, 0x5b,
	0xd7, 0x7b, 0xa3, 0x75, 0x27, 0xd0, 0x9f, 0x8b, 0xb2, 0x0c, 0x00, 0x70, 0x00, 0x67, 0xb2, 0x80,
	0xd1, 0x05, 0xec, 0xfb, 0xa2, 0x5f, 0x1a, 0x8d, 0x72, 0x66, 0xae, 0xd9, 0x91, 0x2d, 0x55, 0xc5,
	0x85, 0xf4, 0x57, 0xc3, 0x9f, 0xec, 0x35, 0xd3, 0xd8, 0x18, 0xa5, 0x7d, 0x6a, 0x31, 0xa5, 0xd6,
	0xf7, 0x36, 0xab, 0x6a, 0xf4, 0x2b, 0xec, 0x6e, 0xb7, 0x76, 0xab, 0x83, 0x49, 0xe8, 0xa0, 0x51,
	0x86, 0x97, 0xf9, 0x75, 0xed, 0xc3, 0x77, 0xe8, 0xfc, 0xa2, 0x66, 0xef, 0x40, 0xa7, 0x58, 0x68,
	0xeb, 0x70, 0x13, 0x96, 0x14, 0x0b, 0xfd, 0xa2, 0xb6, 0x57, 0x8c, 0x2e, 0x85, 0x1b, 0x29, 0xf7,
	0xe1, 0x36, 0x01, 0x06, 0xd6, 0x7e, 0x46, 0x66, 0xfa, 0xf6, 0x9f, 0x11, 0x0c, 0xc3, 0xfc, 0x14,
	0x46, 0xdc, 0x08, 0xb3, 0x72, 0x4d, 0x79, 0x66, 0xd7, 0x11, 0x7b, 0x0a, 0x1d, 0xda, 0x4b, 0x4d,
	0x1a, 0x51, 0x33, 0x3f, 0x7d, 0x7d, 0x14, 0xef, 0x08, 0x99, 0xd0, 0x33, 0xf3, 0x61, 0xc3, 0x39,
	0x24, 0x8e, 0x69, 0x00, 0xb1, 0x54, 0x21, 0x29, 0xa9, 0x18, 0x83, 0xf6, 0xd6, 0x92, 0xa0, 0x77,
	0x76, 0x00, 0x2d, 0xb3, 0xaa, 0xfd, 0x32, 0xb0, 0xaf, 0xec, 0x11, 0x24, 0xfc, 0x2d, 0xe6, 0xcf,
	0x81, 0x46, 0x7f, 0xc5, 0x70, 0x7c, 0x4b, 0x19, 0x55, 0xf4, 0x02, 0x6f, 0xb0, 0x64, 0xdf, 0x40,
	0x52, 0xda, 0x17, 0x9f, 0xca, 0x27, 0x77, 0xa7, 0xb2, 0x09, 0x98, 0xd0, 0x33, 0x73, 0x41, 0xc3,
	0x7f, 0x22, 0x48, 0x1c, 0xcf, 0xc3, 0x0d, 0x8f, 0xd5, 0xe9, 0x0e, 0xec, 0x29, 0xec, 0xcf, 0x16,
	0x5c, 0x73, 0x69, 0x10, 0x73, 0xa7, 0x39, 0xbe, 0x57, 0xf3, 0x60, 0x0d, 0x3f, 0xa3, 0x4b, 0xf0,
	0x2d, 0x1c, 0x4a, 0x65, 0xf2, 0xdb, 0x24, 0xad, 0x7b, 0x49, 0x1e, 0x48, 0x65, 0x9e, 0xbf, 0xce,
	0xf3, 0x15, 0xd8, 0x1d, 0xde, 0x98, 0xfc, 0x6d, 0x0a, 0x07, 0x04, 0x75, 0x81, 0x0f, 0x21, 0x69,
	0x0a, 0xa5, 0xc3, 0xf6, 0x74, 0x87, 0xd1, 0xef, 0x11, 0x1c, 0xde, 0x2a, 0x11, 0xed, 0xe6, 0x27,
	0x90, 0xd8, 0x9e, 0x85, 0xc1, 0x38, 0xb9, 0xbb, 0x9a, 0x16, 0x3a, 0xb1, 0x8f, 0xcc, 0xa1, 0x87,
	0x3f, 0x42, 0x9b, 0xc2, 0x43, 0xfb, 0xa3, 0xad, 0xf6, 0xaf, 0x0b, 0x6b, 0x0b, 0xb7, 0x2e, 0xec,
	0xc7, 0x30, 0x28, 0x54, 0x55, 0x97, 0x68, 0x90, 0xfe, 0x04, 0x1a, 0x3f, 0x1f, 0x7b, 0xc1, 0x6a,
	0xff, 0x06, 0x9a, 0xab, 0x0e, 0x7d, 0xff, 0xcb, 0xff, 0x02, 0x00, 0x00, 0xff, 0xff, 0x2c, 0x3f,
	0xfd, 0x68, 0xa1, 0x07, 0x00, 0x00,
}
