// Code generated by protoc-gen-go.
// source: networkbasetypes.proto
// DO NOT EDIT!

package dota

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

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

type NET_Messages int32

const (
	NET_Messages_net_NOP                        NET_Messages = 0
	NET_Messages_net_Disconnect                 NET_Messages = 1
	NET_Messages_net_SplitScreenUser            NET_Messages = 3
	NET_Messages_net_Tick                       NET_Messages = 4
	NET_Messages_net_StringCmd                  NET_Messages = 5
	NET_Messages_net_SetConVar                  NET_Messages = 6
	NET_Messages_net_SignonState                NET_Messages = 7
	NET_Messages_net_SpawnGroup_Load            NET_Messages = 8
	NET_Messages_net_SpawnGroup_ManifestUpdate  NET_Messages = 9
	NET_Messages_net_SpawnGroup_SetCreationTick NET_Messages = 11
	NET_Messages_net_SpawnGroup_Unload          NET_Messages = 12
	NET_Messages_net_SpawnGroup_LoadCompleted   NET_Messages = 13
)

var NET_Messages_name = map[int32]string{
	0:  "net_NOP",
	1:  "net_Disconnect",
	3:  "net_SplitScreenUser",
	4:  "net_Tick",
	5:  "net_StringCmd",
	6:  "net_SetConVar",
	7:  "net_SignonState",
	8:  "net_SpawnGroup_Load",
	9:  "net_SpawnGroup_ManifestUpdate",
	11: "net_SpawnGroup_SetCreationTick",
	12: "net_SpawnGroup_Unload",
	13: "net_SpawnGroup_LoadCompleted",
}
var NET_Messages_value = map[string]int32{
	"net_NOP":                        0,
	"net_Disconnect":                 1,
	"net_SplitScreenUser":            3,
	"net_Tick":                       4,
	"net_StringCmd":                  5,
	"net_SetConVar":                  6,
	"net_SignonState":                7,
	"net_SpawnGroup_Load":            8,
	"net_SpawnGroup_ManifestUpdate":  9,
	"net_SpawnGroup_SetCreationTick": 11,
	"net_SpawnGroup_Unload":          12,
	"net_SpawnGroup_LoadCompleted":   13,
}

func (x NET_Messages) Enum() *NET_Messages {
	p := new(NET_Messages)
	*p = x
	return p
}
func (x NET_Messages) String() string {
	return proto.EnumName(NET_Messages_name, int32(x))
}
func (x *NET_Messages) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(NET_Messages_value, data, "NET_Messages")
	if err != nil {
		return err
	}
	*x = NET_Messages(value)
	return nil
}
func (NET_Messages) EnumDescriptor() ([]byte, []int) { return fileDescriptor31, []int{0} }

type SpawnGroupFlagsT int32

const (
	SpawnGroupFlagsT_SPAWN_GROUP_LOAD_ENTITIES_FROM_SAVE     SpawnGroupFlagsT = 1
	SpawnGroupFlagsT_SPAWN_GROUP_DONT_SPAWN_ENTITIES         SpawnGroupFlagsT = 2
	SpawnGroupFlagsT_SPAWN_GROUP_SYNCHRONOUS_SPAWN           SpawnGroupFlagsT = 4
	SpawnGroupFlagsT_SPAWN_GROUP_IS_INITIAL_SPAWN_GROUP      SpawnGroupFlagsT = 8
	SpawnGroupFlagsT_SPAWN_GROUP_CREATE_CLIENT_ONLY_ENTITIES SpawnGroupFlagsT = 16
	SpawnGroupFlagsT_SPAWN_GROUP_SAVE_ENTITIES               SpawnGroupFlagsT = 32
	SpawnGroupFlagsT_SPAWN_GROUP_BLOCK_UNTIL_LOADED          SpawnGroupFlagsT = 64
	SpawnGroupFlagsT_SPAWN_GROUP_LOAD_STREAMING_DATA         SpawnGroupFlagsT = 128
	SpawnGroupFlagsT_SPAWN_GROUP_CREATE_NEW_SCENE_WORLD      SpawnGroupFlagsT = 256
)

var SpawnGroupFlagsT_name = map[int32]string{
	1:   "SPAWN_GROUP_LOAD_ENTITIES_FROM_SAVE",
	2:   "SPAWN_GROUP_DONT_SPAWN_ENTITIES",
	4:   "SPAWN_GROUP_SYNCHRONOUS_SPAWN",
	8:   "SPAWN_GROUP_IS_INITIAL_SPAWN_GROUP",
	16:  "SPAWN_GROUP_CREATE_CLIENT_ONLY_ENTITIES",
	32:  "SPAWN_GROUP_SAVE_ENTITIES",
	64:  "SPAWN_GROUP_BLOCK_UNTIL_LOADED",
	128: "SPAWN_GROUP_LOAD_STREAMING_DATA",
	256: "SPAWN_GROUP_CREATE_NEW_SCENE_WORLD",
}
var SpawnGroupFlagsT_value = map[string]int32{
	"SPAWN_GROUP_LOAD_ENTITIES_FROM_SAVE":     1,
	"SPAWN_GROUP_DONT_SPAWN_ENTITIES":         2,
	"SPAWN_GROUP_SYNCHRONOUS_SPAWN":           4,
	"SPAWN_GROUP_IS_INITIAL_SPAWN_GROUP":      8,
	"SPAWN_GROUP_CREATE_CLIENT_ONLY_ENTITIES": 16,
	"SPAWN_GROUP_SAVE_ENTITIES":               32,
	"SPAWN_GROUP_BLOCK_UNTIL_LOADED":          64,
	"SPAWN_GROUP_LOAD_STREAMING_DATA":         128,
	"SPAWN_GROUP_CREATE_NEW_SCENE_WORLD":      256,
}

func (x SpawnGroupFlagsT) Enum() *SpawnGroupFlagsT {
	p := new(SpawnGroupFlagsT)
	*p = x
	return p
}
func (x SpawnGroupFlagsT) String() string {
	return proto.EnumName(SpawnGroupFlagsT_name, int32(x))
}
func (x *SpawnGroupFlagsT) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(SpawnGroupFlagsT_value, data, "SpawnGroupFlagsT")
	if err != nil {
		return err
	}
	*x = SpawnGroupFlagsT(value)
	return nil
}
func (SpawnGroupFlagsT) EnumDescriptor() ([]byte, []int) { return fileDescriptor31, []int{1} }

type CMsgVector struct {
	X                *float32 `protobuf:"fixed32,1,opt,name=x" json:"x,omitempty"`
	Y                *float32 `protobuf:"fixed32,2,opt,name=y" json:"y,omitempty"`
	Z                *float32 `protobuf:"fixed32,3,opt,name=z" json:"z,omitempty"`
	XXX_unrecognized []byte   `json:"-"`
}

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

func (m *CMsgVector) GetX() float32 {
	if m != nil && m.X != nil {
		return *m.X
	}
	return 0
}

func (m *CMsgVector) GetY() float32 {
	if m != nil && m.Y != nil {
		return *m.Y
	}
	return 0
}

func (m *CMsgVector) GetZ() float32 {
	if m != nil && m.Z != nil {
		return *m.Z
	}
	return 0
}

type CMsgVector2D struct {
	X                *float32 `protobuf:"fixed32,1,opt,name=x" json:"x,omitempty"`
	Y                *float32 `protobuf:"fixed32,2,opt,name=y" json:"y,omitempty"`
	XXX_unrecognized []byte   `json:"-"`
}

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

func (m *CMsgVector2D) GetX() float32 {
	if m != nil && m.X != nil {
		return *m.X
	}
	return 0
}

func (m *CMsgVector2D) GetY() float32 {
	if m != nil && m.Y != nil {
		return *m.Y
	}
	return 0
}

type CMsgQAngle struct {
	X                *float32 `protobuf:"fixed32,1,opt,name=x" json:"x,omitempty"`
	Y                *float32 `protobuf:"fixed32,2,opt,name=y" json:"y,omitempty"`
	Z                *float32 `protobuf:"fixed32,3,opt,name=z" json:"z,omitempty"`
	XXX_unrecognized []byte   `json:"-"`
}

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

func (m *CMsgQAngle) GetX() float32 {
	if m != nil && m.X != nil {
		return *m.X
	}
	return 0
}

func (m *CMsgQAngle) GetY() float32 {
	if m != nil && m.Y != nil {
		return *m.Y
	}
	return 0
}

func (m *CMsgQAngle) GetZ() float32 {
	if m != nil && m.Z != nil {
		return *m.Z
	}
	return 0
}

type CMsgPlayerInfo struct {
	Name             *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
	Xuid             *uint64 `protobuf:"fixed64,2,opt,name=xuid" json:"xuid,omitempty"`
	Userid           *int32  `protobuf:"varint,3,opt,name=userid" json:"userid,omitempty"`
	Steamid          *uint64 `protobuf:"fixed64,4,opt,name=steamid" json:"steamid,omitempty"`
	Fakeplayer       *bool   `protobuf:"varint,5,opt,name=fakeplayer" json:"fakeplayer,omitempty"`
	Ishltv           *bool   `protobuf:"varint,6,opt,name=ishltv" json:"ishltv,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

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

func (m *CMsgPlayerInfo) GetName() string {
	if m != nil && m.Name != nil {
		return *m.Name
	}
	return ""
}

func (m *CMsgPlayerInfo) GetXuid() uint64 {
	if m != nil && m.Xuid != nil {
		return *m.Xuid
	}
	return 0
}

func (m *CMsgPlayerInfo) GetUserid() int32 {
	if m != nil && m.Userid != nil {
		return *m.Userid
	}
	return 0
}

func (m *CMsgPlayerInfo) GetSteamid() uint64 {
	if m != nil && m.Steamid != nil {
		return *m.Steamid
	}
	return 0
}

func (m *CMsgPlayerInfo) GetFakeplayer() bool {
	if m != nil && m.Fakeplayer != nil {
		return *m.Fakeplayer
	}
	return false
}

func (m *CMsgPlayerInfo) GetIshltv() bool {
	if m != nil && m.Ishltv != nil {
		return *m.Ishltv
	}
	return false
}

type CMsg_CVars struct {
	Cvars            []*CMsg_CVars_CVar `protobuf:"bytes,1,rep,name=cvars" json:"cvars,omitempty"`
	XXX_unrecognized []byte             `json:"-"`
}

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

func (m *CMsg_CVars) GetCvars() []*CMsg_CVars_CVar {
	if m != nil {
		return m.Cvars
	}
	return nil
}

type CMsg_CVars_CVar struct {
	Name             *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
	Value            *string `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

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

func (m *CMsg_CVars_CVar) GetName() string {
	if m != nil && m.Name != nil {
		return *m.Name
	}
	return ""
}

func (m *CMsg_CVars_CVar) GetValue() string {
	if m != nil && m.Value != nil {
		return *m.Value
	}
	return ""
}

type CNETMsg_NOP struct {
	XXX_unrecognized []byte `json:"-"`
}

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

type CNETMsg_SplitScreenUser struct {
	Slot             *int32 `protobuf:"varint,1,opt,name=slot" json:"slot,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

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

func (m *CNETMsg_SplitScreenUser) GetSlot() int32 {
	if m != nil && m.Slot != nil {
		return *m.Slot
	}
	return 0
}

type CNETMsg_Disconnect struct {
	Reason           *ENetworkDisconnectionReason `protobuf:"varint,2,opt,name=reason,enum=dota.ENetworkDisconnectionReason,def=0" json:"reason,omitempty"`
	XXX_unrecognized []byte                       `json:"-"`
}

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

const Default_CNETMsg_Disconnect_Reason ENetworkDisconnectionReason = ENetworkDisconnectionReason_NETWORK_DISCONNECT_INVALID

func (m *CNETMsg_Disconnect) GetReason() ENetworkDisconnectionReason {
	if m != nil && m.Reason != nil {
		return *m.Reason
	}
	return Default_CNETMsg_Disconnect_Reason
}

type CNETMsg_Tick struct {
	Tick                            *uint32 `protobuf:"varint,1,opt,name=tick" json:"tick,omitempty"`
	HostFrametime                   *uint32 `protobuf:"varint,2,opt,name=host_frametime" json:"host_frametime,omitempty"`
	HostFrametimeStdDeviation       *uint32 `protobuf:"varint,3,opt,name=host_frametime_std_deviation" json:"host_frametime_std_deviation,omitempty"`
	HostComputationtime             *uint32 `protobuf:"varint,4,opt,name=host_computationtime" json:"host_computationtime,omitempty"`
	HostComputationtimeStdDeviation *uint32 `protobuf:"varint,5,opt,name=host_computationtime_std_deviation" json:"host_computationtime_std_deviation,omitempty"`
	HostFramestarttimeStdDeviation  *uint32 `protobuf:"varint,6,opt,name=host_framestarttime_std_deviation" json:"host_framestarttime_std_deviation,omitempty"`
	XXX_unrecognized                []byte  `json:"-"`
}

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

func (m *CNETMsg_Tick) GetTick() uint32 {
	if m != nil && m.Tick != nil {
		return *m.Tick
	}
	return 0
}

func (m *CNETMsg_Tick) GetHostFrametime() uint32 {
	if m != nil && m.HostFrametime != nil {
		return *m.HostFrametime
	}
	return 0
}

func (m *CNETMsg_Tick) GetHostFrametimeStdDeviation() uint32 {
	if m != nil && m.HostFrametimeStdDeviation != nil {
		return *m.HostFrametimeStdDeviation
	}
	return 0
}

func (m *CNETMsg_Tick) GetHostComputationtime() uint32 {
	if m != nil && m.HostComputationtime != nil {
		return *m.HostComputationtime
	}
	return 0
}

func (m *CNETMsg_Tick) GetHostComputationtimeStdDeviation() uint32 {
	if m != nil && m.HostComputationtimeStdDeviation != nil {
		return *m.HostComputationtimeStdDeviation
	}
	return 0
}

func (m *CNETMsg_Tick) GetHostFramestarttimeStdDeviation() uint32 {
	if m != nil && m.HostFramestarttimeStdDeviation != nil {
		return *m.HostFramestarttimeStdDeviation
	}
	return 0
}

type CNETMsg_StringCmd struct {
	Command          *string `protobuf:"bytes,1,opt,name=command" json:"command,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *CNETMsg_StringCmd) Reset()                    { *m = CNETMsg_StringCmd{} }
func (m *CNETMsg_StringCmd) String() string            { return proto.CompactTextString(m) }
func (*CNETMsg_StringCmd) ProtoMessage()               {}
func (*CNETMsg_StringCmd) Descriptor() ([]byte, []int) { return fileDescriptor31, []int{9} }

func (m *CNETMsg_StringCmd) GetCommand() string {
	if m != nil && m.Command != nil {
		return *m.Command
	}
	return ""
}

type CNETMsg_SetConVar struct {
	Convars          *CMsg_CVars `protobuf:"bytes,1,opt,name=convars" json:"convars,omitempty"`
	XXX_unrecognized []byte      `json:"-"`
}

func (m *CNETMsg_SetConVar) Reset()                    { *m = CNETMsg_SetConVar{} }
func (m *CNETMsg_SetConVar) String() string            { return proto.CompactTextString(m) }
func (*CNETMsg_SetConVar) ProtoMessage()               {}
func (*CNETMsg_SetConVar) Descriptor() ([]byte, []int) { return fileDescriptor31, []int{10} }

func (m *CNETMsg_SetConVar) GetConvars() *CMsg_CVars {
	if m != nil {
		return m.Convars
	}
	return nil
}

type CNETMsg_SignonState struct {
	SignonState       *uint32  `protobuf:"varint,1,opt,name=signon_state" json:"signon_state,omitempty"`
	SpawnCount        *uint32  `protobuf:"varint,2,opt,name=spawn_count" json:"spawn_count,omitempty"`
	NumServerPlayers  *uint32  `protobuf:"varint,3,opt,name=num_server_players" json:"num_server_players,omitempty"`
	PlayersNetworkids []string `protobuf:"bytes,4,rep,name=players_networkids" json:"players_networkids,omitempty"`
	MapName           *string  `protobuf:"bytes,5,opt,name=map_name" json:"map_name,omitempty"`
	XXX_unrecognized  []byte   `json:"-"`
}

func (m *CNETMsg_SignonState) Reset()                    { *m = CNETMsg_SignonState{} }
func (m *CNETMsg_SignonState) String() string            { return proto.CompactTextString(m) }
func (*CNETMsg_SignonState) ProtoMessage()               {}
func (*CNETMsg_SignonState) Descriptor() ([]byte, []int) { return fileDescriptor31, []int{11} }

func (m *CNETMsg_SignonState) GetSignonState() uint32 {
	if m != nil && m.SignonState != nil {
		return *m.SignonState
	}
	return 0
}

func (m *CNETMsg_SignonState) GetSpawnCount() uint32 {
	if m != nil && m.SpawnCount != nil {
		return *m.SpawnCount
	}
	return 0
}

func (m *CNETMsg_SignonState) GetNumServerPlayers() uint32 {
	if m != nil && m.NumServerPlayers != nil {
		return *m.NumServerPlayers
	}
	return 0
}

func (m *CNETMsg_SignonState) GetPlayersNetworkids() []string {
	if m != nil {
		return m.PlayersNetworkids
	}
	return nil
}

func (m *CNETMsg_SignonState) GetMapName() string {
	if m != nil && m.MapName != nil {
		return *m.MapName
	}
	return ""
}

type CSVCMsg_GameEvent struct {
	EventName        *string                  `protobuf:"bytes,1,opt,name=event_name" json:"event_name,omitempty"`
	Eventid          *int32                   `protobuf:"varint,2,opt,name=eventid" json:"eventid,omitempty"`
	Keys             []*CSVCMsg_GameEventKeyT `protobuf:"bytes,3,rep,name=keys" json:"keys,omitempty"`
	XXX_unrecognized []byte                   `json:"-"`
}

func (m *CSVCMsg_GameEvent) Reset()                    { *m = CSVCMsg_GameEvent{} }
func (m *CSVCMsg_GameEvent) String() string            { return proto.CompactTextString(m) }
func (*CSVCMsg_GameEvent) ProtoMessage()               {}
func (*CSVCMsg_GameEvent) Descriptor() ([]byte, []int) { return fileDescriptor31, []int{12} }

func (m *CSVCMsg_GameEvent) GetEventName() string {
	if m != nil && m.EventName != nil {
		return *m.EventName
	}
	return ""
}

func (m *CSVCMsg_GameEvent) GetEventid() int32 {
	if m != nil && m.Eventid != nil {
		return *m.Eventid
	}
	return 0
}

func (m *CSVCMsg_GameEvent) GetKeys() []*CSVCMsg_GameEventKeyT {
	if m != nil {
		return m.Keys
	}
	return nil
}

type CSVCMsg_GameEventKeyT struct {
	Type             *int32   `protobuf:"varint,1,opt,name=type" json:"type,omitempty"`
	ValString        *string  `protobuf:"bytes,2,opt,name=val_string" json:"val_string,omitempty"`
	ValFloat         *float32 `protobuf:"fixed32,3,opt,name=val_float" json:"val_float,omitempty"`
	ValLong          *int32   `protobuf:"varint,4,opt,name=val_long" json:"val_long,omitempty"`
	ValShort         *int32   `protobuf:"varint,5,opt,name=val_short" json:"val_short,omitempty"`
	ValByte          *int32   `protobuf:"varint,6,opt,name=val_byte" json:"val_byte,omitempty"`
	ValBool          *bool    `protobuf:"varint,7,opt,name=val_bool" json:"val_bool,omitempty"`
	ValUint64        *uint64  `protobuf:"varint,8,opt,name=val_uint64" json:"val_uint64,omitempty"`
	XXX_unrecognized []byte   `json:"-"`
}

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

func (m *CSVCMsg_GameEventKeyT) GetType() int32 {
	if m != nil && m.Type != nil {
		return *m.Type
	}
	return 0
}

func (m *CSVCMsg_GameEventKeyT) GetValString() string {
	if m != nil && m.ValString != nil {
		return *m.ValString
	}
	return ""
}

func (m *CSVCMsg_GameEventKeyT) GetValFloat() float32 {
	if m != nil && m.ValFloat != nil {
		return *m.ValFloat
	}
	return 0
}

func (m *CSVCMsg_GameEventKeyT) GetValLong() int32 {
	if m != nil && m.ValLong != nil {
		return *m.ValLong
	}
	return 0
}

func (m *CSVCMsg_GameEventKeyT) GetValShort() int32 {
	if m != nil && m.ValShort != nil {
		return *m.ValShort
	}
	return 0
}

func (m *CSVCMsg_GameEventKeyT) GetValByte() int32 {
	if m != nil && m.ValByte != nil {
		return *m.ValByte
	}
	return 0
}

func (m *CSVCMsg_GameEventKeyT) GetValBool() bool {
	if m != nil && m.ValBool != nil {
		return *m.ValBool
	}
	return false
}

func (m *CSVCMsg_GameEventKeyT) GetValUint64() uint64 {
	if m != nil && m.ValUint64 != nil {
		return *m.ValUint64
	}
	return 0
}

type CSVCMsgList_GameEvents struct {
	Events           []*CSVCMsgList_GameEventsEventT `protobuf:"bytes,1,rep,name=events" json:"events,omitempty"`
	XXX_unrecognized []byte                          `json:"-"`
}

func (m *CSVCMsgList_GameEvents) Reset()                    { *m = CSVCMsgList_GameEvents{} }
func (m *CSVCMsgList_GameEvents) String() string            { return proto.CompactTextString(m) }
func (*CSVCMsgList_GameEvents) ProtoMessage()               {}
func (*CSVCMsgList_GameEvents) Descriptor() ([]byte, []int) { return fileDescriptor31, []int{13} }

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

type CSVCMsgList_GameEventsEventT struct {
	Tick             *int32             `protobuf:"varint,1,opt,name=tick" json:"tick,omitempty"`
	Event            *CSVCMsg_GameEvent `protobuf:"bytes,2,opt,name=event" json:"event,omitempty"`
	XXX_unrecognized []byte             `json:"-"`
}

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

func (m *CSVCMsgList_GameEventsEventT) GetTick() int32 {
	if m != nil && m.Tick != nil {
		return *m.Tick
	}
	return 0
}

func (m *CSVCMsgList_GameEventsEventT) GetEvent() *CSVCMsg_GameEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type CSVCMsg_UserMessage struct {
	MsgType          *int32 `protobuf:"varint,1,opt,name=msg_type" json:"msg_type,omitempty"`
	MsgData          []byte `protobuf:"bytes,2,opt,name=msg_data" json:"msg_data,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

func (m *CSVCMsg_UserMessage) Reset()                    { *m = CSVCMsg_UserMessage{} }
func (m *CSVCMsg_UserMessage) String() string            { return proto.CompactTextString(m) }
func (*CSVCMsg_UserMessage) ProtoMessage()               {}
func (*CSVCMsg_UserMessage) Descriptor() ([]byte, []int) { return fileDescriptor31, []int{14} }

func (m *CSVCMsg_UserMessage) GetMsgType() int32 {
	if m != nil && m.MsgType != nil {
		return *m.MsgType
	}
	return 0
}

func (m *CSVCMsg_UserMessage) GetMsgData() []byte {
	if m != nil {
		return m.MsgData
	}
	return nil
}

type CSVCMsgList_UserMessages struct {
	Usermsgs         []*CSVCMsgList_UserMessagesUsermsgT `protobuf:"bytes,1,rep,name=usermsgs" json:"usermsgs,omitempty"`
	XXX_unrecognized []byte                              `json:"-"`
}

func (m *CSVCMsgList_UserMessages) Reset()                    { *m = CSVCMsgList_UserMessages{} }
func (m *CSVCMsgList_UserMessages) String() string            { return proto.CompactTextString(m) }
func (*CSVCMsgList_UserMessages) ProtoMessage()               {}
func (*CSVCMsgList_UserMessages) Descriptor() ([]byte, []int) { return fileDescriptor31, []int{15} }

func (m *CSVCMsgList_UserMessages) GetUsermsgs() []*CSVCMsgList_UserMessagesUsermsgT {
	if m != nil {
		return m.Usermsgs
	}
	return nil
}

type CSVCMsgList_UserMessagesUsermsgT struct {
	Tick             *int32               `protobuf:"varint,1,opt,name=tick" json:"tick,omitempty"`
	Msg              *CSVCMsg_UserMessage `protobuf:"bytes,2,opt,name=msg" json:"msg,omitempty"`
	XXX_unrecognized []byte               `json:"-"`
}

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

func (m *CSVCMsgList_UserMessagesUsermsgT) GetTick() int32 {
	if m != nil && m.Tick != nil {
		return *m.Tick
	}
	return 0
}

func (m *CSVCMsgList_UserMessagesUsermsgT) GetMsg() *CSVCMsg_UserMessage {
	if m != nil {
		return m.Msg
	}
	return nil
}

type CNETMsg_SpawnGroup_Load struct {
	Worldname             *string     `protobuf:"bytes,1,opt,name=worldname" json:"worldname,omitempty"`
	Entitylumpname        *string     `protobuf:"bytes,2,opt,name=entitylumpname" json:"entitylumpname,omitempty"`
	Entityfiltername      *string     `protobuf:"bytes,3,opt,name=entityfiltername" json:"entityfiltername,omitempty"`
	Spawngrouphandle      *uint32     `protobuf:"varint,4,opt,name=spawngrouphandle" json:"spawngrouphandle,omitempty"`
	Spawngroupownerhandle *uint32     `protobuf:"varint,5,opt,name=spawngroupownerhandle" json:"spawngroupownerhandle,omitempty"`
	WorldOffsetPos        *CMsgVector `protobuf:"bytes,6,opt,name=world_offset_pos" json:"world_offset_pos,omitempty"`
	WorldOffsetAngle      *CMsgQAngle `protobuf:"bytes,7,opt,name=world_offset_angle" json:"world_offset_angle,omitempty"`
	Spawngroupmanifest    []byte      `protobuf:"bytes,8,opt,name=spawngroupmanifest" json:"spawngroupmanifest,omitempty"`
	Flags                 *uint32     `protobuf:"varint,9,opt,name=flags" json:"flags,omitempty"`
	Tickcount             *int32      `protobuf:"varint,10,opt,name=tickcount" json:"tickcount,omitempty"`
	Manifestincomplete    *bool       `protobuf:"varint,11,opt,name=manifestincomplete" json:"manifestincomplete,omitempty"`
	Localnamefixup        *string     `protobuf:"bytes,12,opt,name=localnamefixup" json:"localnamefixup,omitempty"`
	Parentnamefixup       *string     `protobuf:"bytes,13,opt,name=parentnamefixup" json:"parentnamefixup,omitempty"`
	Manifestloadpriority  *int32      `protobuf:"varint,14,opt,name=manifestloadpriority" json:"manifestloadpriority,omitempty"`
	Worldgroupid          *uint32     `protobuf:"varint,15,opt,name=worldgroupid" json:"worldgroupid,omitempty"`
	Creationsequence      *uint32     `protobuf:"varint,16,opt,name=creationsequence" json:"creationsequence,omitempty"`
	Savegamefilename      *string     `protobuf:"bytes,17,opt,name=savegamefilename" json:"savegamefilename,omitempty"`
	XXX_unrecognized      []byte      `json:"-"`
}

func (m *CNETMsg_SpawnGroup_Load) Reset()                    { *m = CNETMsg_SpawnGroup_Load{} }
func (m *CNETMsg_SpawnGroup_Load) String() string            { return proto.CompactTextString(m) }
func (*CNETMsg_SpawnGroup_Load) ProtoMessage()               {}
func (*CNETMsg_SpawnGroup_Load) Descriptor() ([]byte, []int) { return fileDescriptor31, []int{16} }

func (m *CNETMsg_SpawnGroup_Load) GetWorldname() string {
	if m != nil && m.Worldname != nil {
		return *m.Worldname
	}
	return ""
}

func (m *CNETMsg_SpawnGroup_Load) GetEntitylumpname() string {
	if m != nil && m.Entitylumpname != nil {
		return *m.Entitylumpname
	}
	return ""
}

func (m *CNETMsg_SpawnGroup_Load) GetEntityfiltername() string {
	if m != nil && m.Entityfiltername != nil {
		return *m.Entityfiltername
	}
	return ""
}

func (m *CNETMsg_SpawnGroup_Load) GetSpawngrouphandle() uint32 {
	if m != nil && m.Spawngrouphandle != nil {
		return *m.Spawngrouphandle
	}
	return 0
}

func (m *CNETMsg_SpawnGroup_Load) GetSpawngroupownerhandle() uint32 {
	if m != nil && m.Spawngroupownerhandle != nil {
		return *m.Spawngroupownerhandle
	}
	return 0
}

func (m *CNETMsg_SpawnGroup_Load) GetWorldOffsetPos() *CMsgVector {
	if m != nil {
		return m.WorldOffsetPos
	}
	return nil
}

func (m *CNETMsg_SpawnGroup_Load) GetWorldOffsetAngle() *CMsgQAngle {
	if m != nil {
		return m.WorldOffsetAngle
	}
	return nil
}

func (m *CNETMsg_SpawnGroup_Load) GetSpawngroupmanifest() []byte {
	if m != nil {
		return m.Spawngroupmanifest
	}
	return nil
}

func (m *CNETMsg_SpawnGroup_Load) GetFlags() uint32 {
	if m != nil && m.Flags != nil {
		return *m.Flags
	}
	return 0
}

func (m *CNETMsg_SpawnGroup_Load) GetTickcount() int32 {
	if m != nil && m.Tickcount != nil {
		return *m.Tickcount
	}
	return 0
}

func (m *CNETMsg_SpawnGroup_Load) GetManifestincomplete() bool {
	if m != nil && m.Manifestincomplete != nil {
		return *m.Manifestincomplete
	}
	return false
}

func (m *CNETMsg_SpawnGroup_Load) GetLocalnamefixup() string {
	if m != nil && m.Localnamefixup != nil {
		return *m.Localnamefixup
	}
	return ""
}

func (m *CNETMsg_SpawnGroup_Load) GetParentnamefixup() string {
	if m != nil && m.Parentnamefixup != nil {
		return *m.Parentnamefixup
	}
	return ""
}

func (m *CNETMsg_SpawnGroup_Load) GetManifestloadpriority() int32 {
	if m != nil && m.Manifestloadpriority != nil {
		return *m.Manifestloadpriority
	}
	return 0
}

func (m *CNETMsg_SpawnGroup_Load) GetWorldgroupid() uint32 {
	if m != nil && m.Worldgroupid != nil {
		return *m.Worldgroupid
	}
	return 0
}

func (m *CNETMsg_SpawnGroup_Load) GetCreationsequence() uint32 {
	if m != nil && m.Creationsequence != nil {
		return *m.Creationsequence
	}
	return 0
}

func (m *CNETMsg_SpawnGroup_Load) GetSavegamefilename() string {
	if m != nil && m.Savegamefilename != nil {
		return *m.Savegamefilename
	}
	return ""
}

type CNETMsg_SpawnGroup_ManifestUpdate struct {
	Spawngrouphandle   *uint32 `protobuf:"varint,1,opt,name=spawngrouphandle" json:"spawngrouphandle,omitempty"`
	Spawngroupmanifest []byte  `protobuf:"bytes,2,opt,name=spawngroupmanifest" json:"spawngroupmanifest,omitempty"`
	Manifestincomplete *bool   `protobuf:"varint,3,opt,name=manifestincomplete" json:"manifestincomplete,omitempty"`
	XXX_unrecognized   []byte  `json:"-"`
}

func (m *CNETMsg_SpawnGroup_ManifestUpdate) Reset()         { *m = CNETMsg_SpawnGroup_ManifestUpdate{} }
func (m *CNETMsg_SpawnGroup_ManifestUpdate) String() string { return proto.CompactTextString(m) }
func (*CNETMsg_SpawnGroup_ManifestUpdate) ProtoMessage()    {}
func (*CNETMsg_SpawnGroup_ManifestUpdate) Descriptor() ([]byte, []int) {
	return fileDescriptor31, []int{17}
}

func (m *CNETMsg_SpawnGroup_ManifestUpdate) GetSpawngrouphandle() uint32 {
	if m != nil && m.Spawngrouphandle != nil {
		return *m.Spawngrouphandle
	}
	return 0
}

func (m *CNETMsg_SpawnGroup_ManifestUpdate) GetSpawngroupmanifest() []byte {
	if m != nil {
		return m.Spawngroupmanifest
	}
	return nil
}

func (m *CNETMsg_SpawnGroup_ManifestUpdate) GetManifestincomplete() bool {
	if m != nil && m.Manifestincomplete != nil {
		return *m.Manifestincomplete
	}
	return false
}

type CNETMsg_SpawnGroup_SetCreationTick struct {
	Spawngrouphandle *uint32 `protobuf:"varint,1,opt,name=spawngrouphandle" json:"spawngrouphandle,omitempty"`
	Tickcount        *int32  `protobuf:"varint,2,opt,name=tickcount" json:"tickcount,omitempty"`
	Creationsequence *uint32 `protobuf:"varint,3,opt,name=creationsequence" json:"creationsequence,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *CNETMsg_SpawnGroup_SetCreationTick) Reset()         { *m = CNETMsg_SpawnGroup_SetCreationTick{} }
func (m *CNETMsg_SpawnGroup_SetCreationTick) String() string { return proto.CompactTextString(m) }
func (*CNETMsg_SpawnGroup_SetCreationTick) ProtoMessage()    {}
func (*CNETMsg_SpawnGroup_SetCreationTick) Descriptor() ([]byte, []int) {
	return fileDescriptor31, []int{18}
}

func (m *CNETMsg_SpawnGroup_SetCreationTick) GetSpawngrouphandle() uint32 {
	if m != nil && m.Spawngrouphandle != nil {
		return *m.Spawngrouphandle
	}
	return 0
}

func (m *CNETMsg_SpawnGroup_SetCreationTick) GetTickcount() int32 {
	if m != nil && m.Tickcount != nil {
		return *m.Tickcount
	}
	return 0
}

func (m *CNETMsg_SpawnGroup_SetCreationTick) GetCreationsequence() uint32 {
	if m != nil && m.Creationsequence != nil {
		return *m.Creationsequence
	}
	return 0
}

type CNETMsg_SpawnGroup_Unload struct {
	Spawngrouphandle *uint32 `protobuf:"varint,1,opt,name=spawngrouphandle" json:"spawngrouphandle,omitempty"`
	Flags            *uint32 `protobuf:"varint,2,opt,name=flags" json:"flags,omitempty"`
	Tickcount        *int32  `protobuf:"varint,3,opt,name=tickcount" json:"tickcount,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *CNETMsg_SpawnGroup_Unload) Reset()                    { *m = CNETMsg_SpawnGroup_Unload{} }
func (m *CNETMsg_SpawnGroup_Unload) String() string            { return proto.CompactTextString(m) }
func (*CNETMsg_SpawnGroup_Unload) ProtoMessage()               {}
func (*CNETMsg_SpawnGroup_Unload) Descriptor() ([]byte, []int) { return fileDescriptor31, []int{19} }

func (m *CNETMsg_SpawnGroup_Unload) GetSpawngrouphandle() uint32 {
	if m != nil && m.Spawngrouphandle != nil {
		return *m.Spawngrouphandle
	}
	return 0
}

func (m *CNETMsg_SpawnGroup_Unload) GetFlags() uint32 {
	if m != nil && m.Flags != nil {
		return *m.Flags
	}
	return 0
}

func (m *CNETMsg_SpawnGroup_Unload) GetTickcount() int32 {
	if m != nil && m.Tickcount != nil {
		return *m.Tickcount
	}
	return 0
}

type CNETMsg_SpawnGroup_LoadCompleted struct {
	Spawngrouphandle *uint32 `protobuf:"varint,1,opt,name=spawngrouphandle" json:"spawngrouphandle,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *CNETMsg_SpawnGroup_LoadCompleted) Reset()         { *m = CNETMsg_SpawnGroup_LoadCompleted{} }
func (m *CNETMsg_SpawnGroup_LoadCompleted) String() string { return proto.CompactTextString(m) }
func (*CNETMsg_SpawnGroup_LoadCompleted) ProtoMessage()    {}
func (*CNETMsg_SpawnGroup_LoadCompleted) Descriptor() ([]byte, []int) {
	return fileDescriptor31, []int{20}
}

func (m *CNETMsg_SpawnGroup_LoadCompleted) GetSpawngrouphandle() uint32 {
	if m != nil && m.Spawngrouphandle != nil {
		return *m.Spawngrouphandle
	}
	return 0
}

type CSVCMsg_GameSessionConfiguration struct {
	IsMultiplayer    *bool   `protobuf:"varint,1,opt,name=is_multiplayer" json:"is_multiplayer,omitempty"`
	IsLoadsavegame   *bool   `protobuf:"varint,2,opt,name=is_loadsavegame" json:"is_loadsavegame,omitempty"`
	IsBackgroundMap  *bool   `protobuf:"varint,3,opt,name=is_background_map" json:"is_background_map,omitempty"`
	IsHeadless       *bool   `protobuf:"varint,4,opt,name=is_headless" json:"is_headless,omitempty"`
	MinClientLimit   *uint32 `protobuf:"varint,5,opt,name=min_client_limit" json:"min_client_limit,omitempty"`
	MaxClientLimit   *uint32 `protobuf:"varint,6,opt,name=max_client_limit" json:"max_client_limit,omitempty"`
	MaxClients       *uint32 `protobuf:"varint,7,opt,name=max_clients" json:"max_clients,omitempty"`
	TickInterval     *uint32 `protobuf:"fixed32,8,opt,name=tick_interval" json:"tick_interval,omitempty"`
	Hostname         *string `protobuf:"bytes,9,opt,name=hostname" json:"hostname,omitempty"`
	Savegamename     *string `protobuf:"bytes,10,opt,name=savegamename" json:"savegamename,omitempty"`
	S1Mapname        *string `protobuf:"bytes,11,opt,name=s1_mapname" json:"s1_mapname,omitempty"`
	Gamemode         *string `protobuf:"bytes,12,opt,name=gamemode" json:"gamemode,omitempty"`
	ServerIpAddress  *string `protobuf:"bytes,13,opt,name=server_ip_address" json:"server_ip_address,omitempty"`
	Data             []byte  `protobuf:"bytes,14,opt,name=data" json:"data,omitempty"`
	IsLocalonly      *bool   `protobuf:"varint,15,opt,name=is_localonly" json:"is_localonly,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *CSVCMsg_GameSessionConfiguration) Reset()         { *m = CSVCMsg_GameSessionConfiguration{} }
func (m *CSVCMsg_GameSessionConfiguration) String() string { return proto.CompactTextString(m) }
func (*CSVCMsg_GameSessionConfiguration) ProtoMessage()    {}
func (*CSVCMsg_GameSessionConfiguration) Descriptor() ([]byte, []int) {
	return fileDescriptor31, []int{21}
}

func (m *CSVCMsg_GameSessionConfiguration) GetIsMultiplayer() bool {
	if m != nil && m.IsMultiplayer != nil {
		return *m.IsMultiplayer
	}
	return false
}

func (m *CSVCMsg_GameSessionConfiguration) GetIsLoadsavegame() bool {
	if m != nil && m.IsLoadsavegame != nil {
		return *m.IsLoadsavegame
	}
	return false
}

func (m *CSVCMsg_GameSessionConfiguration) GetIsBackgroundMap() bool {
	if m != nil && m.IsBackgroundMap != nil {
		return *m.IsBackgroundMap
	}
	return false
}

func (m *CSVCMsg_GameSessionConfiguration) GetIsHeadless() bool {
	if m != nil && m.IsHeadless != nil {
		return *m.IsHeadless
	}
	return false
}

func (m *CSVCMsg_GameSessionConfiguration) GetMinClientLimit() uint32 {
	if m != nil && m.MinClientLimit != nil {
		return *m.MinClientLimit
	}
	return 0
}

func (m *CSVCMsg_GameSessionConfiguration) GetMaxClientLimit() uint32 {
	if m != nil && m.MaxClientLimit != nil {
		return *m.MaxClientLimit
	}
	return 0
}

func (m *CSVCMsg_GameSessionConfiguration) GetMaxClients() uint32 {
	if m != nil && m.MaxClients != nil {
		return *m.MaxClients
	}
	return 0
}

func (m *CSVCMsg_GameSessionConfiguration) GetTickInterval() uint32 {
	if m != nil && m.TickInterval != nil {
		return *m.TickInterval
	}
	return 0
}

func (m *CSVCMsg_GameSessionConfiguration) GetHostname() string {
	if m != nil && m.Hostname != nil {
		return *m.Hostname
	}
	return ""
}

func (m *CSVCMsg_GameSessionConfiguration) GetSavegamename() string {
	if m != nil && m.Savegamename != nil {
		return *m.Savegamename
	}
	return ""
}

func (m *CSVCMsg_GameSessionConfiguration) GetS1Mapname() string {
	if m != nil && m.S1Mapname != nil {
		return *m.S1Mapname
	}
	return ""
}

func (m *CSVCMsg_GameSessionConfiguration) GetGamemode() string {
	if m != nil && m.Gamemode != nil {
		return *m.Gamemode
	}
	return ""
}

func (m *CSVCMsg_GameSessionConfiguration) GetServerIpAddress() string {
	if m != nil && m.ServerIpAddress != nil {
		return *m.ServerIpAddress
	}
	return ""
}

func (m *CSVCMsg_GameSessionConfiguration) GetData() []byte {
	if m != nil {
		return m.Data
	}
	return nil
}

func (m *CSVCMsg_GameSessionConfiguration) GetIsLocalonly() bool {
	if m != nil && m.IsLocalonly != nil {
		return *m.IsLocalonly
	}
	return false
}

func init() {
	proto.RegisterType((*CMsgVector)(nil), "dota.CMsgVector")
	proto.RegisterType((*CMsgVector2D)(nil), "dota.CMsgVector2D")
	proto.RegisterType((*CMsgQAngle)(nil), "dota.CMsgQAngle")
	proto.RegisterType((*CMsgPlayerInfo)(nil), "dota.CMsgPlayerInfo")
	proto.RegisterType((*CMsg_CVars)(nil), "dota.CMsg_CVars")
	proto.RegisterType((*CMsg_CVars_CVar)(nil), "dota.CMsg_CVars.CVar")
	proto.RegisterType((*CNETMsg_NOP)(nil), "dota.CNETMsg_NOP")
	proto.RegisterType((*CNETMsg_SplitScreenUser)(nil), "dota.CNETMsg_SplitScreenUser")
	proto.RegisterType((*CNETMsg_Disconnect)(nil), "dota.CNETMsg_Disconnect")
	proto.RegisterType((*CNETMsg_Tick)(nil), "dota.CNETMsg_Tick")
	proto.RegisterType((*CNETMsg_StringCmd)(nil), "dota.CNETMsg_StringCmd")
	proto.RegisterType((*CNETMsg_SetConVar)(nil), "dota.CNETMsg_SetConVar")
	proto.RegisterType((*CNETMsg_SignonState)(nil), "dota.CNETMsg_SignonState")
	proto.RegisterType((*CSVCMsg_GameEvent)(nil), "dota.CSVCMsg_GameEvent")
	proto.RegisterType((*CSVCMsg_GameEventKeyT)(nil), "dota.CSVCMsg_GameEvent.key_t")
	proto.RegisterType((*CSVCMsgList_GameEvents)(nil), "dota.CSVCMsgList_GameEvents")
	proto.RegisterType((*CSVCMsgList_GameEventsEventT)(nil), "dota.CSVCMsgList_GameEvents.event_t")
	proto.RegisterType((*CSVCMsg_UserMessage)(nil), "dota.CSVCMsg_UserMessage")
	proto.RegisterType((*CSVCMsgList_UserMessages)(nil), "dota.CSVCMsgList_UserMessages")
	proto.RegisterType((*CSVCMsgList_UserMessagesUsermsgT)(nil), "dota.CSVCMsgList_UserMessages.usermsg_t")
	proto.RegisterType((*CNETMsg_SpawnGroup_Load)(nil), "dota.CNETMsg_SpawnGroup_Load")
	proto.RegisterType((*CNETMsg_SpawnGroup_ManifestUpdate)(nil), "dota.CNETMsg_SpawnGroup_ManifestUpdate")
	proto.RegisterType((*CNETMsg_SpawnGroup_SetCreationTick)(nil), "dota.CNETMsg_SpawnGroup_SetCreationTick")
	proto.RegisterType((*CNETMsg_SpawnGroup_Unload)(nil), "dota.CNETMsg_SpawnGroup_Unload")
	proto.RegisterType((*CNETMsg_SpawnGroup_LoadCompleted)(nil), "dota.CNETMsg_SpawnGroup_LoadCompleted")
	proto.RegisterType((*CSVCMsg_GameSessionConfiguration)(nil), "dota.CSVCMsg_GameSessionConfiguration")
	proto.RegisterEnum("dota.NET_Messages", NET_Messages_name, NET_Messages_value)
	proto.RegisterEnum("dota.SpawnGroupFlagsT", SpawnGroupFlagsT_name, SpawnGroupFlagsT_value)
}

func init() { proto.RegisterFile("networkbasetypes.proto", fileDescriptor31) }

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