#![allow(unknown_lints)]
#![allow(clippy)]
#![cfg_attr(rustfmt, rustfmt_skip)]
#![allow(box_pointers)]
#![allow(dead_code)]
#![allow(missing_docs)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(trivial_casts)]
#![allow(unsafe_code)]
#![allow(unused_imports)]
#![allow(unused_results)]
use protobuf::Message as Message_imported_for_functions;
use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions;
#[derive(PartialEq,Clone,Default)]
pub struct Score {
score_type: ::std::option::Option<Score_ScoreType>,
score: ::std::option::Option<i32>,
score_details: ::protobuf::SingularPtrField<ScoreDetails>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl Score {
pub fn new() -> Score {
::std::default::Default::default()
}
pub fn clear_score_type(&mut self) {
self.score_type = ::std::option::Option::None;
}
pub fn has_score_type(&self) -> bool {
self.score_type.is_some()
}
pub fn set_score_type(&mut self, v: Score_ScoreType) {
self.score_type = ::std::option::Option::Some(v);
}
pub fn get_score_type(&self) -> Score_ScoreType {
self.score_type.unwrap_or(Score_ScoreType::Curriculum)
}
pub fn clear_score(&mut self) {
self.score = ::std::option::Option::None;
}
pub fn has_score(&self) -> bool {
self.score.is_some()
}
pub fn set_score(&mut self, v: i32) {
self.score = ::std::option::Option::Some(v);
}
pub fn get_score(&self) -> i32 {
self.score.unwrap_or(0)
}
pub fn clear_score_details(&mut self) {
self.score_details.clear();
}
pub fn has_score_details(&self) -> bool {
self.score_details.is_some()
}
pub fn set_score_details(&mut self, v: ScoreDetails) {
self.score_details = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_score_details(&mut self) -> &mut ScoreDetails {
if self.score_details.is_none() {
self.score_details.set_default();
}
self.score_details.as_mut().unwrap()
}
pub fn take_score_details(&mut self) -> ScoreDetails {
self.score_details.take().unwrap_or_else(|| ScoreDetails::new())
}
pub fn get_score_details(&self) -> &ScoreDetails {
self.score_details.as_ref().unwrap_or_else(|| ScoreDetails::default_instance())
}
}
impl ::protobuf::Message for Score {
fn is_initialized(&self) -> bool {
for v in &self.score_details {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
6 => {
::protobuf::rt::read_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.score_type, 6, &mut self.unknown_fields)?
},
7 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_int32()?;
self.score = ::std::option::Option::Some(tmp);
},
8 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.score_details)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(v) = self.score_type {
my_size += ::protobuf::rt::enum_size(6, v);
}
if let Some(v) = self.score {
my_size += ::protobuf::rt::value_size(7, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(ref v) = self.score_details.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(v) = self.score_type {
os.write_enum(6, v.value())?;
}
if let Some(v) = self.score {
os.write_int32(7, v)?;
}
if let Some(ref v) = self.score_details.as_ref() {
os.write_tag(8, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &::std::any::Any {
self as &::std::any::Any
}
fn as_any_mut(&mut self) -> &mut ::std::any::Any {
self as &mut ::std::any::Any
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> Score {
Score::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum<Score_ScoreType>>(
"score_type",
|m: &Score| { &m.score_type },
|m: &mut Score| { &mut m.score_type },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
"score",
|m: &Score| { &m.score },
|m: &mut Score| { &mut m.score },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<ScoreDetails>>(
"score_details",
|m: &Score| { &m.score_details },
|m: &mut Score| { &mut m.score_details },
));
::protobuf::reflect::MessageDescriptor::new::<Score>(
"Score",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static Score {
static mut instance: ::protobuf::lazy::Lazy<Score> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const Score,
};
unsafe {
instance.get(Score::new)
}
}
}
impl ::protobuf::Clear for Score {
fn clear(&mut self) {
self.clear_score_type();
self.clear_score();
self.clear_score_details();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for Score {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for Score {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum Score_ScoreType {
Curriculum = 1,
Melee = 2,
}
impl ::protobuf::ProtobufEnum for Score_ScoreType {
fn value(&self) -> i32 {
*self as i32
}
fn from_i32(value: i32) -> ::std::option::Option<Score_ScoreType> {
match value {
1 => ::std::option::Option::Some(Score_ScoreType::Curriculum),
2 => ::std::option::Option::Some(Score_ScoreType::Melee),
_ => ::std::option::Option::None
}
}
fn values() -> &'static [Self] {
static values: &'static [Score_ScoreType] = &[
Score_ScoreType::Curriculum,
Score_ScoreType::Melee,
];
values
}
fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::EnumDescriptor,
};
unsafe {
descriptor.get(|| {
::protobuf::reflect::EnumDescriptor::new("Score_ScoreType", file_descriptor_proto())
})
}
}
}
impl ::std::marker::Copy for Score_ScoreType {
}
impl ::std::default::Default for Score_ScoreType {
fn default() -> Self {
Score_ScoreType::Curriculum
}
}
impl ::protobuf::reflect::ProtobufValue for Score_ScoreType {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Enum(self.descriptor())
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CategoryScoreDetails {
none: ::std::option::Option<f32>,
army: ::std::option::Option<f32>,
economy: ::std::option::Option<f32>,
technology: ::std::option::Option<f32>,
upgrade: ::std::option::Option<f32>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl CategoryScoreDetails {
pub fn new() -> CategoryScoreDetails {
::std::default::Default::default()
}
pub fn clear_none(&mut self) {
self.none = ::std::option::Option::None;
}
pub fn has_none(&self) -> bool {
self.none.is_some()
}
pub fn set_none(&mut self, v: f32) {
self.none = ::std::option::Option::Some(v);
}
pub fn get_none(&self) -> f32 {
self.none.unwrap_or(0.)
}
pub fn clear_army(&mut self) {
self.army = ::std::option::Option::None;
}
pub fn has_army(&self) -> bool {
self.army.is_some()
}
pub fn set_army(&mut self, v: f32) {
self.army = ::std::option::Option::Some(v);
}
pub fn get_army(&self) -> f32 {
self.army.unwrap_or(0.)
}
pub fn clear_economy(&mut self) {
self.economy = ::std::option::Option::None;
}
pub fn has_economy(&self) -> bool {
self.economy.is_some()
}
pub fn set_economy(&mut self, v: f32) {
self.economy = ::std::option::Option::Some(v);
}
pub fn get_economy(&self) -> f32 {
self.economy.unwrap_or(0.)
}
pub fn clear_technology(&mut self) {
self.technology = ::std::option::Option::None;
}
pub fn has_technology(&self) -> bool {
self.technology.is_some()
}
pub fn set_technology(&mut self, v: f32) {
self.technology = ::std::option::Option::Some(v);
}
pub fn get_technology(&self) -> f32 {
self.technology.unwrap_or(0.)
}
pub fn clear_upgrade(&mut self) {
self.upgrade = ::std::option::Option::None;
}
pub fn has_upgrade(&self) -> bool {
self.upgrade.is_some()
}
pub fn set_upgrade(&mut self, v: f32) {
self.upgrade = ::std::option::Option::Some(v);
}
pub fn get_upgrade(&self) -> f32 {
self.upgrade.unwrap_or(0.)
}
}
impl ::protobuf::Message for CategoryScoreDetails {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_float()?;
self.none = ::std::option::Option::Some(tmp);
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_float()?;
self.army = ::std::option::Option::Some(tmp);
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_float()?;
self.economy = ::std::option::Option::Some(tmp);
},
4 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_float()?;
self.technology = ::std::option::Option::Some(tmp);
},
5 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_float()?;
self.upgrade = ::std::option::Option::Some(tmp);
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(v) = self.none {
my_size += 5;
}
if let Some(v) = self.army {
my_size += 5;
}
if let Some(v) = self.economy {
my_size += 5;
}
if let Some(v) = self.technology {
my_size += 5;
}
if let Some(v) = self.upgrade {
my_size += 5;
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(v) = self.none {
os.write_float(1, v)?;
}
if let Some(v) = self.army {
os.write_float(2, v)?;
}
if let Some(v) = self.economy {
os.write_float(3, v)?;
}
if let Some(v) = self.technology {
os.write_float(4, v)?;
}
if let Some(v) = self.upgrade {
os.write_float(5, v)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &::std::any::Any {
self as &::std::any::Any
}
fn as_any_mut(&mut self) -> &mut ::std::any::Any {
self as &mut ::std::any::Any
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CategoryScoreDetails {
CategoryScoreDetails::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
"none",
|m: &CategoryScoreDetails| { &m.none },
|m: &mut CategoryScoreDetails| { &mut m.none },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
"army",
|m: &CategoryScoreDetails| { &m.army },
|m: &mut CategoryScoreDetails| { &mut m.army },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
"economy",
|m: &CategoryScoreDetails| { &m.economy },
|m: &mut CategoryScoreDetails| { &mut m.economy },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
"technology",
|m: &CategoryScoreDetails| { &m.technology },
|m: &mut CategoryScoreDetails| { &mut m.technology },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
"upgrade",
|m: &CategoryScoreDetails| { &m.upgrade },
|m: &mut CategoryScoreDetails| { &mut m.upgrade },
));
::protobuf::reflect::MessageDescriptor::new::<CategoryScoreDetails>(
"CategoryScoreDetails",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static CategoryScoreDetails {
static mut instance: ::protobuf::lazy::Lazy<CategoryScoreDetails> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const CategoryScoreDetails,
};
unsafe {
instance.get(CategoryScoreDetails::new)
}
}
}
impl ::protobuf::Clear for CategoryScoreDetails {
fn clear(&mut self) {
self.clear_none();
self.clear_army();
self.clear_economy();
self.clear_technology();
self.clear_upgrade();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CategoryScoreDetails {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CategoryScoreDetails {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct VitalScoreDetails {
life: ::std::option::Option<f32>,
shields: ::std::option::Option<f32>,
energy: ::std::option::Option<f32>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl VitalScoreDetails {
pub fn new() -> VitalScoreDetails {
::std::default::Default::default()
}
pub fn clear_life(&mut self) {
self.life = ::std::option::Option::None;
}
pub fn has_life(&self) -> bool {
self.life.is_some()
}
pub fn set_life(&mut self, v: f32) {
self.life = ::std::option::Option::Some(v);
}
pub fn get_life(&self) -> f32 {
self.life.unwrap_or(0.)
}
pub fn clear_shields(&mut self) {
self.shields = ::std::option::Option::None;
}
pub fn has_shields(&self) -> bool {
self.shields.is_some()
}
pub fn set_shields(&mut self, v: f32) {
self.shields = ::std::option::Option::Some(v);
}
pub fn get_shields(&self) -> f32 {
self.shields.unwrap_or(0.)
}
pub fn clear_energy(&mut self) {
self.energy = ::std::option::Option::None;
}
pub fn has_energy(&self) -> bool {
self.energy.is_some()
}
pub fn set_energy(&mut self, v: f32) {
self.energy = ::std::option::Option::Some(v);
}
pub fn get_energy(&self) -> f32 {
self.energy.unwrap_or(0.)
}
}
impl ::protobuf::Message for VitalScoreDetails {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_float()?;
self.life = ::std::option::Option::Some(tmp);
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_float()?;
self.shields = ::std::option::Option::Some(tmp);
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_float()?;
self.energy = ::std::option::Option::Some(tmp);
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(v) = self.life {
my_size += 5;
}
if let Some(v) = self.shields {
my_size += 5;
}
if let Some(v) = self.energy {
my_size += 5;
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(v) = self.life {
os.write_float(1, v)?;
}
if let Some(v) = self.shields {
os.write_float(2, v)?;
}
if let Some(v) = self.energy {
os.write_float(3, v)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &::std::any::Any {
self as &::std::any::Any
}
fn as_any_mut(&mut self) -> &mut ::std::any::Any {
self as &mut ::std::any::Any
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> VitalScoreDetails {
VitalScoreDetails::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
"life",
|m: &VitalScoreDetails| { &m.life },
|m: &mut VitalScoreDetails| { &mut m.life },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
"shields",
|m: &VitalScoreDetails| { &m.shields },
|m: &mut VitalScoreDetails| { &mut m.shields },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
"energy",
|m: &VitalScoreDetails| { &m.energy },
|m: &mut VitalScoreDetails| { &mut m.energy },
));
::protobuf::reflect::MessageDescriptor::new::<VitalScoreDetails>(
"VitalScoreDetails",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static VitalScoreDetails {
static mut instance: ::protobuf::lazy::Lazy<VitalScoreDetails> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const VitalScoreDetails,
};
unsafe {
instance.get(VitalScoreDetails::new)
}
}
}
impl ::protobuf::Clear for VitalScoreDetails {
fn clear(&mut self) {
self.clear_life();
self.clear_shields();
self.clear_energy();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for VitalScoreDetails {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for VitalScoreDetails {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct ScoreDetails {
idle_production_time: ::std::option::Option<f32>,
idle_worker_time: ::std::option::Option<f32>,
total_value_units: ::std::option::Option<f32>,
total_value_structures: ::std::option::Option<f32>,
killed_value_units: ::std::option::Option<f32>,
killed_value_structures: ::std::option::Option<f32>,
collected_minerals: ::std::option::Option<f32>,
collected_vespene: ::std::option::Option<f32>,
collection_rate_minerals: ::std::option::Option<f32>,
collection_rate_vespene: ::std::option::Option<f32>,
spent_minerals: ::std::option::Option<f32>,
spent_vespene: ::std::option::Option<f32>,
food_used: ::protobuf::SingularPtrField<CategoryScoreDetails>,
killed_minerals: ::protobuf::SingularPtrField<CategoryScoreDetails>,
killed_vespene: ::protobuf::SingularPtrField<CategoryScoreDetails>,
lost_minerals: ::protobuf::SingularPtrField<CategoryScoreDetails>,
lost_vespene: ::protobuf::SingularPtrField<CategoryScoreDetails>,
friendly_fire_minerals: ::protobuf::SingularPtrField<CategoryScoreDetails>,
friendly_fire_vespene: ::protobuf::SingularPtrField<CategoryScoreDetails>,
used_minerals: ::protobuf::SingularPtrField<CategoryScoreDetails>,
used_vespene: ::protobuf::SingularPtrField<CategoryScoreDetails>,
total_used_minerals: ::protobuf::SingularPtrField<CategoryScoreDetails>,
total_used_vespene: ::protobuf::SingularPtrField<CategoryScoreDetails>,
total_damage_dealt: ::protobuf::SingularPtrField<VitalScoreDetails>,
total_damage_taken: ::protobuf::SingularPtrField<VitalScoreDetails>,
total_healed: ::protobuf::SingularPtrField<VitalScoreDetails>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl ScoreDetails {
pub fn new() -> ScoreDetails {
::std::default::Default::default()
}
pub fn clear_idle_production_time(&mut self) {
self.idle_production_time = ::std::option::Option::None;
}
pub fn has_idle_production_time(&self) -> bool {
self.idle_production_time.is_some()
}
pub fn set_idle_production_time(&mut self, v: f32) {
self.idle_production_time = ::std::option::Option::Some(v);
}
pub fn get_idle_production_time(&self) -> f32 {
self.idle_production_time.unwrap_or(0.)
}
pub fn clear_idle_worker_time(&mut self) {
self.idle_worker_time = ::std::option::Option::None;
}
pub fn has_idle_worker_time(&self) -> bool {
self.idle_worker_time.is_some()
}
pub fn set_idle_worker_time(&mut self, v: f32) {
self.idle_worker_time = ::std::option::Option::Some(v);
}
pub fn get_idle_worker_time(&self) -> f32 {
self.idle_worker_time.unwrap_or(0.)
}
pub fn clear_total_value_units(&mut self) {
self.total_value_units = ::std::option::Option::None;
}
pub fn has_total_value_units(&self) -> bool {
self.total_value_units.is_some()
}
pub fn set_total_value_units(&mut self, v: f32) {
self.total_value_units = ::std::option::Option::Some(v);
}
pub fn get_total_value_units(&self) -> f32 {
self.total_value_units.unwrap_or(0.)
}
pub fn clear_total_value_structures(&mut self) {
self.total_value_structures = ::std::option::Option::None;
}
pub fn has_total_value_structures(&self) -> bool {
self.total_value_structures.is_some()
}
pub fn set_total_value_structures(&mut self, v: f32) {
self.total_value_structures = ::std::option::Option::Some(v);
}
pub fn get_total_value_structures(&self) -> f32 {
self.total_value_structures.unwrap_or(0.)
}
pub fn clear_killed_value_units(&mut self) {
self.killed_value_units = ::std::option::Option::None;
}
pub fn has_killed_value_units(&self) -> bool {
self.killed_value_units.is_some()
}
pub fn set_killed_value_units(&mut self, v: f32) {
self.killed_value_units = ::std::option::Option::Some(v);
}
pub fn get_killed_value_units(&self) -> f32 {
self.killed_value_units.unwrap_or(0.)
}
pub fn clear_killed_value_structures(&mut self) {
self.killed_value_structures = ::std::option::Option::None;
}
pub fn has_killed_value_structures(&self) -> bool {
self.killed_value_structures.is_some()
}
pub fn set_killed_value_structures(&mut self, v: f32) {
self.killed_value_structures = ::std::option::Option::Some(v);
}
pub fn get_killed_value_structures(&self) -> f32 {
self.killed_value_structures.unwrap_or(0.)
}
pub fn clear_collected_minerals(&mut self) {
self.collected_minerals = ::std::option::Option::None;
}
pub fn has_collected_minerals(&self) -> bool {
self.collected_minerals.is_some()
}
pub fn set_collected_minerals(&mut self, v: f32) {
self.collected_minerals = ::std::option::Option::Some(v);
}
pub fn get_collected_minerals(&self) -> f32 {
self.collected_minerals.unwrap_or(0.)
}
pub fn clear_collected_vespene(&mut self) {
self.collected_vespene = ::std::option::Option::None;
}
pub fn has_collected_vespene(&self) -> bool {
self.collected_vespene.is_some()
}
pub fn set_collected_vespene(&mut self, v: f32) {
self.collected_vespene = ::std::option::Option::Some(v);
}
pub fn get_collected_vespene(&self) -> f32 {
self.collected_vespene.unwrap_or(0.)
}
pub fn clear_collection_rate_minerals(&mut self) {
self.collection_rate_minerals = ::std::option::Option::None;
}
pub fn has_collection_rate_minerals(&self) -> bool {
self.collection_rate_minerals.is_some()
}
pub fn set_collection_rate_minerals(&mut self, v: f32) {
self.collection_rate_minerals = ::std::option::Option::Some(v);
}
pub fn get_collection_rate_minerals(&self) -> f32 {
self.collection_rate_minerals.unwrap_or(0.)
}
pub fn clear_collection_rate_vespene(&mut self) {
self.collection_rate_vespene = ::std::option::Option::None;
}
pub fn has_collection_rate_vespene(&self) -> bool {
self.collection_rate_vespene.is_some()
}
pub fn set_collection_rate_vespene(&mut self, v: f32) {
self.collection_rate_vespene = ::std::option::Option::Some(v);
}
pub fn get_collection_rate_vespene(&self) -> f32 {
self.collection_rate_vespene.unwrap_or(0.)
}
pub fn clear_spent_minerals(&mut self) {
self.spent_minerals = ::std::option::Option::None;
}
pub fn has_spent_minerals(&self) -> bool {
self.spent_minerals.is_some()
}
pub fn set_spent_minerals(&mut self, v: f32) {
self.spent_minerals = ::std::option::Option::Some(v);
}
pub fn get_spent_minerals(&self) -> f32 {
self.spent_minerals.unwrap_or(0.)
}
pub fn clear_spent_vespene(&mut self) {
self.spent_vespene = ::std::option::Option::None;
}
pub fn has_spent_vespene(&self) -> bool {
self.spent_vespene.is_some()
}
pub fn set_spent_vespene(&mut self, v: f32) {
self.spent_vespene = ::std::option::Option::Some(v);
}
pub fn get_spent_vespene(&self) -> f32 {
self.spent_vespene.unwrap_or(0.)
}
pub fn clear_food_used(&mut self) {
self.food_used.clear();
}
pub fn has_food_used(&self) -> bool {
self.food_used.is_some()
}
pub fn set_food_used(&mut self, v: CategoryScoreDetails) {
self.food_used = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_food_used(&mut self) -> &mut CategoryScoreDetails {
if self.food_used.is_none() {
self.food_used.set_default();
}
self.food_used.as_mut().unwrap()
}
pub fn take_food_used(&mut self) -> CategoryScoreDetails {
self.food_used.take().unwrap_or_else(|| CategoryScoreDetails::new())
}
pub fn get_food_used(&self) -> &CategoryScoreDetails {
self.food_used.as_ref().unwrap_or_else(|| CategoryScoreDetails::default_instance())
}
pub fn clear_killed_minerals(&mut self) {
self.killed_minerals.clear();
}
pub fn has_killed_minerals(&self) -> bool {
self.killed_minerals.is_some()
}
pub fn set_killed_minerals(&mut self, v: CategoryScoreDetails) {
self.killed_minerals = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_killed_minerals(&mut self) -> &mut CategoryScoreDetails {
if self.killed_minerals.is_none() {
self.killed_minerals.set_default();
}
self.killed_minerals.as_mut().unwrap()
}
pub fn take_killed_minerals(&mut self) -> CategoryScoreDetails {
self.killed_minerals.take().unwrap_or_else(|| CategoryScoreDetails::new())
}
pub fn get_killed_minerals(&self) -> &CategoryScoreDetails {
self.killed_minerals.as_ref().unwrap_or_else(|| CategoryScoreDetails::default_instance())
}
pub fn clear_killed_vespene(&mut self) {
self.killed_vespene.clear();
}
pub fn has_killed_vespene(&self) -> bool {
self.killed_vespene.is_some()
}
pub fn set_killed_vespene(&mut self, v: CategoryScoreDetails) {
self.killed_vespene = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_killed_vespene(&mut self) -> &mut CategoryScoreDetails {
if self.killed_vespene.is_none() {
self.killed_vespene.set_default();
}
self.killed_vespene.as_mut().unwrap()
}
pub fn take_killed_vespene(&mut self) -> CategoryScoreDetails {
self.killed_vespene.take().unwrap_or_else(|| CategoryScoreDetails::new())
}
pub fn get_killed_vespene(&self) -> &CategoryScoreDetails {
self.killed_vespene.as_ref().unwrap_or_else(|| CategoryScoreDetails::default_instance())
}
pub fn clear_lost_minerals(&mut self) {
self.lost_minerals.clear();
}
pub fn has_lost_minerals(&self) -> bool {
self.lost_minerals.is_some()
}
pub fn set_lost_minerals(&mut self, v: CategoryScoreDetails) {
self.lost_minerals = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_lost_minerals(&mut self) -> &mut CategoryScoreDetails {
if self.lost_minerals.is_none() {
self.lost_minerals.set_default();
}
self.lost_minerals.as_mut().unwrap()
}
pub fn take_lost_minerals(&mut self) -> CategoryScoreDetails {
self.lost_minerals.take().unwrap_or_else(|| CategoryScoreDetails::new())
}
pub fn get_lost_minerals(&self) -> &CategoryScoreDetails {
self.lost_minerals.as_ref().unwrap_or_else(|| CategoryScoreDetails::default_instance())
}
pub fn clear_lost_vespene(&mut self) {
self.lost_vespene.clear();
}
pub fn has_lost_vespene(&self) -> bool {
self.lost_vespene.is_some()
}
pub fn set_lost_vespene(&mut self, v: CategoryScoreDetails) {
self.lost_vespene = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_lost_vespene(&mut self) -> &mut CategoryScoreDetails {
if self.lost_vespene.is_none() {
self.lost_vespene.set_default();
}
self.lost_vespene.as_mut().unwrap()
}
pub fn take_lost_vespene(&mut self) -> CategoryScoreDetails {
self.lost_vespene.take().unwrap_or_else(|| CategoryScoreDetails::new())
}
pub fn get_lost_vespene(&self) -> &CategoryScoreDetails {
self.lost_vespene.as_ref().unwrap_or_else(|| CategoryScoreDetails::default_instance())
}
pub fn clear_friendly_fire_minerals(&mut self) {
self.friendly_fire_minerals.clear();
}
pub fn has_friendly_fire_minerals(&self) -> bool {
self.friendly_fire_minerals.is_some()
}
pub fn set_friendly_fire_minerals(&mut self, v: CategoryScoreDetails) {
self.friendly_fire_minerals = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_friendly_fire_minerals(&mut self) -> &mut CategoryScoreDetails {
if self.friendly_fire_minerals.is_none() {
self.friendly_fire_minerals.set_default();
}
self.friendly_fire_minerals.as_mut().unwrap()
}
pub fn take_friendly_fire_minerals(&mut self) -> CategoryScoreDetails {
self.friendly_fire_minerals.take().unwrap_or_else(|| CategoryScoreDetails::new())
}
pub fn get_friendly_fire_minerals(&self) -> &CategoryScoreDetails {
self.friendly_fire_minerals.as_ref().unwrap_or_else(|| CategoryScoreDetails::default_instance())
}
pub fn clear_friendly_fire_vespene(&mut self) {
self.friendly_fire_vespene.clear();
}
pub fn has_friendly_fire_vespene(&self) -> bool {
self.friendly_fire_vespene.is_some()
}
pub fn set_friendly_fire_vespene(&mut self, v: CategoryScoreDetails) {
self.friendly_fire_vespene = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_friendly_fire_vespene(&mut self) -> &mut CategoryScoreDetails {
if self.friendly_fire_vespene.is_none() {
self.friendly_fire_vespene.set_default();
}
self.friendly_fire_vespene.as_mut().unwrap()
}
pub fn take_friendly_fire_vespene(&mut self) -> CategoryScoreDetails {
self.friendly_fire_vespene.take().unwrap_or_else(|| CategoryScoreDetails::new())
}
pub fn get_friendly_fire_vespene(&self) -> &CategoryScoreDetails {
self.friendly_fire_vespene.as_ref().unwrap_or_else(|| CategoryScoreDetails::default_instance())
}
pub fn clear_used_minerals(&mut self) {
self.used_minerals.clear();
}
pub fn has_used_minerals(&self) -> bool {
self.used_minerals.is_some()
}
pub fn set_used_minerals(&mut self, v: CategoryScoreDetails) {
self.used_minerals = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_used_minerals(&mut self) -> &mut CategoryScoreDetails {
if self.used_minerals.is_none() {
self.used_minerals.set_default();
}
self.used_minerals.as_mut().unwrap()
}
pub fn take_used_minerals(&mut self) -> CategoryScoreDetails {
self.used_minerals.take().unwrap_or_else(|| CategoryScoreDetails::new())
}
pub fn get_used_minerals(&self) -> &CategoryScoreDetails {
self.used_minerals.as_ref().unwrap_or_else(|| CategoryScoreDetails::default_instance())
}
pub fn clear_used_vespene(&mut self) {
self.used_vespene.clear();
}
pub fn has_used_vespene(&self) -> bool {
self.used_vespene.is_some()
}
pub fn set_used_vespene(&mut self, v: CategoryScoreDetails) {
self.used_vespene = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_used_vespene(&mut self) -> &mut CategoryScoreDetails {
if self.used_vespene.is_none() {
self.used_vespene.set_default();
}
self.used_vespene.as_mut().unwrap()
}
pub fn take_used_vespene(&mut self) -> CategoryScoreDetails {
self.used_vespene.take().unwrap_or_else(|| CategoryScoreDetails::new())
}
pub fn get_used_vespene(&self) -> &CategoryScoreDetails {
self.used_vespene.as_ref().unwrap_or_else(|| CategoryScoreDetails::default_instance())
}
pub fn clear_total_used_minerals(&mut self) {
self.total_used_minerals.clear();
}
pub fn has_total_used_minerals(&self) -> bool {
self.total_used_minerals.is_some()
}
pub fn set_total_used_minerals(&mut self, v: CategoryScoreDetails) {
self.total_used_minerals = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_total_used_minerals(&mut self) -> &mut CategoryScoreDetails {
if self.total_used_minerals.is_none() {
self.total_used_minerals.set_default();
}
self.total_used_minerals.as_mut().unwrap()
}
pub fn take_total_used_minerals(&mut self) -> CategoryScoreDetails {
self.total_used_minerals.take().unwrap_or_else(|| CategoryScoreDetails::new())
}
pub fn get_total_used_minerals(&self) -> &CategoryScoreDetails {
self.total_used_minerals.as_ref().unwrap_or_else(|| CategoryScoreDetails::default_instance())
}
pub fn clear_total_used_vespene(&mut self) {
self.total_used_vespene.clear();
}
pub fn has_total_used_vespene(&self) -> bool {
self.total_used_vespene.is_some()
}
pub fn set_total_used_vespene(&mut self, v: CategoryScoreDetails) {
self.total_used_vespene = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_total_used_vespene(&mut self) -> &mut CategoryScoreDetails {
if self.total_used_vespene.is_none() {
self.total_used_vespene.set_default();
}
self.total_used_vespene.as_mut().unwrap()
}
pub fn take_total_used_vespene(&mut self) -> CategoryScoreDetails {
self.total_used_vespene.take().unwrap_or_else(|| CategoryScoreDetails::new())
}
pub fn get_total_used_vespene(&self) -> &CategoryScoreDetails {
self.total_used_vespene.as_ref().unwrap_or_else(|| CategoryScoreDetails::default_instance())
}
pub fn clear_total_damage_dealt(&mut self) {
self.total_damage_dealt.clear();
}
pub fn has_total_damage_dealt(&self) -> bool {
self.total_damage_dealt.is_some()
}
pub fn set_total_damage_dealt(&mut self, v: VitalScoreDetails) {
self.total_damage_dealt = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_total_damage_dealt(&mut self) -> &mut VitalScoreDetails {
if self.total_damage_dealt.is_none() {
self.total_damage_dealt.set_default();
}
self.total_damage_dealt.as_mut().unwrap()
}
pub fn take_total_damage_dealt(&mut self) -> VitalScoreDetails {
self.total_damage_dealt.take().unwrap_or_else(|| VitalScoreDetails::new())
}
pub fn get_total_damage_dealt(&self) -> &VitalScoreDetails {
self.total_damage_dealt.as_ref().unwrap_or_else(|| VitalScoreDetails::default_instance())
}
pub fn clear_total_damage_taken(&mut self) {
self.total_damage_taken.clear();
}
pub fn has_total_damage_taken(&self) -> bool {
self.total_damage_taken.is_some()
}
pub fn set_total_damage_taken(&mut self, v: VitalScoreDetails) {
self.total_damage_taken = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_total_damage_taken(&mut self) -> &mut VitalScoreDetails {
if self.total_damage_taken.is_none() {
self.total_damage_taken.set_default();
}
self.total_damage_taken.as_mut().unwrap()
}
pub fn take_total_damage_taken(&mut self) -> VitalScoreDetails {
self.total_damage_taken.take().unwrap_or_else(|| VitalScoreDetails::new())
}
pub fn get_total_damage_taken(&self) -> &VitalScoreDetails {
self.total_damage_taken.as_ref().unwrap_or_else(|| VitalScoreDetails::default_instance())
}
pub fn clear_total_healed(&mut self) {
self.total_healed.clear();
}
pub fn has_total_healed(&self) -> bool {
self.total_healed.is_some()
}
pub fn set_total_healed(&mut self, v: VitalScoreDetails) {
self.total_healed = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_total_healed(&mut self) -> &mut VitalScoreDetails {
if self.total_healed.is_none() {
self.total_healed.set_default();
}
self.total_healed.as_mut().unwrap()
}
pub fn take_total_healed(&mut self) -> VitalScoreDetails {
self.total_healed.take().unwrap_or_else(|| VitalScoreDetails::new())
}
pub fn get_total_healed(&self) -> &VitalScoreDetails {
self.total_healed.as_ref().unwrap_or_else(|| VitalScoreDetails::default_instance())
}
}
impl ::protobuf::Message for ScoreDetails {
fn is_initialized(&self) -> bool {
for v in &self.food_used {
if !v.is_initialized() {
return false;
}
};
for v in &self.killed_minerals {
if !v.is_initialized() {
return false;
}
};
for v in &self.killed_vespene {
if !v.is_initialized() {
return false;
}
};
for v in &self.lost_minerals {
if !v.is_initialized() {
return false;
}
};
for v in &self.lost_vespene {
if !v.is_initialized() {
return false;
}
};
for v in &self.friendly_fire_minerals {
if !v.is_initialized() {
return false;
}
};
for v in &self.friendly_fire_vespene {
if !v.is_initialized() {
return false;
}
};
for v in &self.used_minerals {
if !v.is_initialized() {
return false;
}
};
for v in &self.used_vespene {
if !v.is_initialized() {
return false;
}
};
for v in &self.total_used_minerals {
if !v.is_initialized() {
return false;
}
};
for v in &self.total_used_vespene {
if !v.is_initialized() {
return false;
}
};
for v in &self.total_damage_dealt {
if !v.is_initialized() {
return false;
}
};
for v in &self.total_damage_taken {
if !v.is_initialized() {
return false;
}
};
for v in &self.total_healed {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_float()?;
self.idle_production_time = ::std::option::Option::Some(tmp);
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_float()?;
self.idle_worker_time = ::std::option::Option::Some(tmp);
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_float()?;
self.total_value_units = ::std::option::Option::Some(tmp);
},
4 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_float()?;
self.total_value_structures = ::std::option::Option::Some(tmp);
},
5 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_float()?;
self.killed_value_units = ::std::option::Option::Some(tmp);
},
6 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_float()?;
self.killed_value_structures = ::std::option::Option::Some(tmp);
},
7 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_float()?;
self.collected_minerals = ::std::option::Option::Some(tmp);
},
8 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_float()?;
self.collected_vespene = ::std::option::Option::Some(tmp);
},
9 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_float()?;
self.collection_rate_minerals = ::std::option::Option::Some(tmp);
},
10 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_float()?;
self.collection_rate_vespene = ::std::option::Option::Some(tmp);
},
11 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_float()?;
self.spent_minerals = ::std::option::Option::Some(tmp);
},
12 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_float()?;
self.spent_vespene = ::std::option::Option::Some(tmp);
},
13 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.food_used)?;
},
14 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.killed_minerals)?;
},
15 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.killed_vespene)?;
},
16 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.lost_minerals)?;
},
17 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.lost_vespene)?;
},
18 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.friendly_fire_minerals)?;
},
19 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.friendly_fire_vespene)?;
},
20 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.used_minerals)?;
},
21 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.used_vespene)?;
},
22 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.total_used_minerals)?;
},
23 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.total_used_vespene)?;
},
24 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.total_damage_dealt)?;
},
25 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.total_damage_taken)?;
},
26 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.total_healed)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(v) = self.idle_production_time {
my_size += 5;
}
if let Some(v) = self.idle_worker_time {
my_size += 5;
}
if let Some(v) = self.total_value_units {
my_size += 5;
}
if let Some(v) = self.total_value_structures {
my_size += 5;
}
if let Some(v) = self.killed_value_units {
my_size += 5;
}
if let Some(v) = self.killed_value_structures {
my_size += 5;
}
if let Some(v) = self.collected_minerals {
my_size += 5;
}
if let Some(v) = self.collected_vespene {
my_size += 5;
}
if let Some(v) = self.collection_rate_minerals {
my_size += 5;
}
if let Some(v) = self.collection_rate_vespene {
my_size += 5;
}
if let Some(v) = self.spent_minerals {
my_size += 5;
}
if let Some(v) = self.spent_vespene {
my_size += 5;
}
if let Some(ref v) = self.food_used.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.killed_minerals.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.killed_vespene.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.lost_minerals.as_ref() {
let len = v.compute_size();
my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.lost_vespene.as_ref() {
let len = v.compute_size();
my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.friendly_fire_minerals.as_ref() {
let len = v.compute_size();
my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.friendly_fire_vespene.as_ref() {
let len = v.compute_size();
my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.used_minerals.as_ref() {
let len = v.compute_size();
my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.used_vespene.as_ref() {
let len = v.compute_size();
my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.total_used_minerals.as_ref() {
let len = v.compute_size();
my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.total_used_vespene.as_ref() {
let len = v.compute_size();
my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.total_damage_dealt.as_ref() {
let len = v.compute_size();
my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.total_damage_taken.as_ref() {
let len = v.compute_size();
my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.total_healed.as_ref() {
let len = v.compute_size();
my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(v) = self.idle_production_time {
os.write_float(1, v)?;
}
if let Some(v) = self.idle_worker_time {
os.write_float(2, v)?;
}
if let Some(v) = self.total_value_units {
os.write_float(3, v)?;
}
if let Some(v) = self.total_value_structures {
os.write_float(4, v)?;
}
if let Some(v) = self.killed_value_units {
os.write_float(5, v)?;
}
if let Some(v) = self.killed_value_structures {
os.write_float(6, v)?;
}
if let Some(v) = self.collected_minerals {
os.write_float(7, v)?;
}
if let Some(v) = self.collected_vespene {
os.write_float(8, v)?;
}
if let Some(v) = self.collection_rate_minerals {
os.write_float(9, v)?;
}
if let Some(v) = self.collection_rate_vespene {
os.write_float(10, v)?;
}
if let Some(v) = self.spent_minerals {
os.write_float(11, v)?;
}
if let Some(v) = self.spent_vespene {
os.write_float(12, v)?;
}
if let Some(ref v) = self.food_used.as_ref() {
os.write_tag(13, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.killed_minerals.as_ref() {
os.write_tag(14, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.killed_vespene.as_ref() {
os.write_tag(15, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.lost_minerals.as_ref() {
os.write_tag(16, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.lost_vespene.as_ref() {
os.write_tag(17, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.friendly_fire_minerals.as_ref() {
os.write_tag(18, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.friendly_fire_vespene.as_ref() {
os.write_tag(19, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.used_minerals.as_ref() {
os.write_tag(20, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.used_vespene.as_ref() {
os.write_tag(21, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.total_used_minerals.as_ref() {
os.write_tag(22, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.total_used_vespene.as_ref() {
os.write_tag(23, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.total_damage_dealt.as_ref() {
os.write_tag(24, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.total_damage_taken.as_ref() {
os.write_tag(25, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.total_healed.as_ref() {
os.write_tag(26, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &::std::any::Any {
self as &::std::any::Any
}
fn as_any_mut(&mut self) -> &mut ::std::any::Any {
self as &mut ::std::any::Any
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> ScoreDetails {
ScoreDetails::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
"idle_production_time",
|m: &ScoreDetails| { &m.idle_production_time },
|m: &mut ScoreDetails| { &mut m.idle_production_time },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
"idle_worker_time",
|m: &ScoreDetails| { &m.idle_worker_time },
|m: &mut ScoreDetails| { &mut m.idle_worker_time },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
"total_value_units",
|m: &ScoreDetails| { &m.total_value_units },
|m: &mut ScoreDetails| { &mut m.total_value_units },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
"total_value_structures",
|m: &ScoreDetails| { &m.total_value_structures },
|m: &mut ScoreDetails| { &mut m.total_value_structures },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
"killed_value_units",
|m: &ScoreDetails| { &m.killed_value_units },
|m: &mut ScoreDetails| { &mut m.killed_value_units },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
"killed_value_structures",
|m: &ScoreDetails| { &m.killed_value_structures },
|m: &mut ScoreDetails| { &mut m.killed_value_structures },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
"collected_minerals",
|m: &ScoreDetails| { &m.collected_minerals },
|m: &mut ScoreDetails| { &mut m.collected_minerals },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
"collected_vespene",
|m: &ScoreDetails| { &m.collected_vespene },
|m: &mut ScoreDetails| { &mut m.collected_vespene },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
"collection_rate_minerals",
|m: &ScoreDetails| { &m.collection_rate_minerals },
|m: &mut ScoreDetails| { &mut m.collection_rate_minerals },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
"collection_rate_vespene",
|m: &ScoreDetails| { &m.collection_rate_vespene },
|m: &mut ScoreDetails| { &mut m.collection_rate_vespene },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
"spent_minerals",
|m: &ScoreDetails| { &m.spent_minerals },
|m: &mut ScoreDetails| { &mut m.spent_minerals },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
"spent_vespene",
|m: &ScoreDetails| { &m.spent_vespene },
|m: &mut ScoreDetails| { &mut m.spent_vespene },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CategoryScoreDetails>>(
"food_used",
|m: &ScoreDetails| { &m.food_used },
|m: &mut ScoreDetails| { &mut m.food_used },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CategoryScoreDetails>>(
"killed_minerals",
|m: &ScoreDetails| { &m.killed_minerals },
|m: &mut ScoreDetails| { &mut m.killed_minerals },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CategoryScoreDetails>>(
"killed_vespene",
|m: &ScoreDetails| { &m.killed_vespene },
|m: &mut ScoreDetails| { &mut m.killed_vespene },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CategoryScoreDetails>>(
"lost_minerals",
|m: &ScoreDetails| { &m.lost_minerals },
|m: &mut ScoreDetails| { &mut m.lost_minerals },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CategoryScoreDetails>>(
"lost_vespene",
|m: &ScoreDetails| { &m.lost_vespene },
|m: &mut ScoreDetails| { &mut m.lost_vespene },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CategoryScoreDetails>>(
"friendly_fire_minerals",
|m: &ScoreDetails| { &m.friendly_fire_minerals },
|m: &mut ScoreDetails| { &mut m.friendly_fire_minerals },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CategoryScoreDetails>>(
"friendly_fire_vespene",
|m: &ScoreDetails| { &m.friendly_fire_vespene },
|m: &mut ScoreDetails| { &mut m.friendly_fire_vespene },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CategoryScoreDetails>>(
"used_minerals",
|m: &ScoreDetails| { &m.used_minerals },
|m: &mut ScoreDetails| { &mut m.used_minerals },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CategoryScoreDetails>>(
"used_vespene",
|m: &ScoreDetails| { &m.used_vespene },
|m: &mut ScoreDetails| { &mut m.used_vespene },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CategoryScoreDetails>>(
"total_used_minerals",
|m: &ScoreDetails| { &m.total_used_minerals },
|m: &mut ScoreDetails| { &mut m.total_used_minerals },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CategoryScoreDetails>>(
"total_used_vespene",
|m: &ScoreDetails| { &m.total_used_vespene },
|m: &mut ScoreDetails| { &mut m.total_used_vespene },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<VitalScoreDetails>>(
"total_damage_dealt",
|m: &ScoreDetails| { &m.total_damage_dealt },
|m: &mut ScoreDetails| { &mut m.total_damage_dealt },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<VitalScoreDetails>>(
"total_damage_taken",
|m: &ScoreDetails| { &m.total_damage_taken },
|m: &mut ScoreDetails| { &mut m.total_damage_taken },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<VitalScoreDetails>>(
"total_healed",
|m: &ScoreDetails| { &m.total_healed },
|m: &mut ScoreDetails| { &mut m.total_healed },
));
::protobuf::reflect::MessageDescriptor::new::<ScoreDetails>(
"ScoreDetails",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static ScoreDetails {
static mut instance: ::protobuf::lazy::Lazy<ScoreDetails> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ScoreDetails,
};
unsafe {
instance.get(ScoreDetails::new)
}
}
}
impl ::protobuf::Clear for ScoreDetails {
fn clear(&mut self) {
self.clear_idle_production_time();
self.clear_idle_worker_time();
self.clear_total_value_units();
self.clear_total_value_structures();
self.clear_killed_value_units();
self.clear_killed_value_structures();
self.clear_collected_minerals();
self.clear_collected_vespene();
self.clear_collection_rate_minerals();
self.clear_collection_rate_vespene();
self.clear_spent_minerals();
self.clear_spent_vespene();
self.clear_food_used();
self.clear_killed_minerals();
self.clear_killed_vespene();
self.clear_lost_minerals();
self.clear_lost_vespene();
self.clear_friendly_fire_minerals();
self.clear_friendly_fire_vespene();
self.clear_used_minerals();
self.clear_used_vespene();
self.clear_total_used_minerals();
self.clear_total_used_vespene();
self.clear_total_damage_dealt();
self.clear_total_damage_taken();
self.clear_total_healed();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for ScoreDetails {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for ScoreDetails {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
static file_descriptor_proto_data: &'static [u8] = b"\
\n\x1cs2clientprotocol/score.proto\x12\x0eSC2APIProtocol\"\xc8\x01\n\x05\
Score\x12>\n\nscore_type\x18\x06\x20\x01(\x0e2\x1f.SC2APIProtocol.Score.\
ScoreTypeR\tscoreType\x12\x14\n\x05score\x18\x07\x20\x01(\x05R\x05score\
\x12A\n\rscore_details\x18\x08\x20\x01(\x0b2\x1c.SC2APIProtocol.ScoreDet\
ailsR\x0cscoreDetails\"&\n\tScoreType\x12\x0e\n\nCurriculum\x10\x01\x12\
\t\n\x05Melee\x10\x02\"\x92\x01\n\x14CategoryScoreDetails\x12\x12\n\x04n\
one\x18\x01\x20\x01(\x02R\x04none\x12\x12\n\x04army\x18\x02\x20\x01(\x02\
R\x04army\x12\x18\n\x07economy\x18\x03\x20\x01(\x02R\x07economy\x12\x1e\
\n\ntechnology\x18\x04\x20\x01(\x02R\ntechnology\x12\x18\n\x07upgrade\
\x18\x05\x20\x01(\x02R\x07upgrade\"Y\n\x11VitalScoreDetails\x12\x12\n\
\x04life\x18\x01\x20\x01(\x02R\x04life\x12\x18\n\x07shields\x18\x02\x20\
\x01(\x02R\x07shields\x12\x16\n\x06energy\x18\x03\x20\x01(\x02R\x06energ\
y\"\x9b\r\n\x0cScoreDetails\x120\n\x14idle_production_time\x18\x01\x20\
\x01(\x02R\x12idleProductionTime\x12(\n\x10idle_worker_time\x18\x02\x20\
\x01(\x02R\x0eidleWorkerTime\x12*\n\x11total_value_units\x18\x03\x20\x01\
(\x02R\x0ftotalValueUnits\x124\n\x16total_value_structures\x18\x04\x20\
\x01(\x02R\x14totalValueStructures\x12,\n\x12killed_value_units\x18\x05\
\x20\x01(\x02R\x10killedValueUnits\x126\n\x17killed_value_structures\x18\
\x06\x20\x01(\x02R\x15killedValueStructures\x12-\n\x12collected_minerals\
\x18\x07\x20\x01(\x02R\x11collectedMinerals\x12+\n\x11collected_vespene\
\x18\x08\x20\x01(\x02R\x10collectedVespene\x128\n\x18collection_rate_min\
erals\x18\t\x20\x01(\x02R\x16collectionRateMinerals\x126\n\x17collection\
_rate_vespene\x18\n\x20\x01(\x02R\x15collectionRateVespene\x12%\n\x0espe\
nt_minerals\x18\x0b\x20\x01(\x02R\rspentMinerals\x12#\n\rspent_vespene\
\x18\x0c\x20\x01(\x02R\x0cspentVespene\x12A\n\tfood_used\x18\r\x20\x01(\
\x0b2$.SC2APIProtocol.CategoryScoreDetailsR\x08foodUsed\x12M\n\x0fkilled\
_minerals\x18\x0e\x20\x01(\x0b2$.SC2APIProtocol.CategoryScoreDetailsR\
\x0ekilledMinerals\x12K\n\x0ekilled_vespene\x18\x0f\x20\x01(\x0b2$.SC2AP\
IProtocol.CategoryScoreDetailsR\rkilledVespene\x12I\n\rlost_minerals\x18\
\x10\x20\x01(\x0b2$.SC2APIProtocol.CategoryScoreDetailsR\x0clostMinerals\
\x12G\n\x0clost_vespene\x18\x11\x20\x01(\x0b2$.SC2APIProtocol.CategorySc\
oreDetailsR\x0blostVespene\x12Z\n\x16friendly_fire_minerals\x18\x12\x20\
\x01(\x0b2$.SC2APIProtocol.CategoryScoreDetailsR\x14friendlyFireMinerals\
\x12X\n\x15friendly_fire_vespene\x18\x13\x20\x01(\x0b2$.SC2APIProtocol.C\
ategoryScoreDetailsR\x13friendlyFireVespene\x12I\n\rused_minerals\x18\
\x14\x20\x01(\x0b2$.SC2APIProtocol.CategoryScoreDetailsR\x0cusedMinerals\
\x12G\n\x0cused_vespene\x18\x15\x20\x01(\x0b2$.SC2APIProtocol.CategorySc\
oreDetailsR\x0busedVespene\x12T\n\x13total_used_minerals\x18\x16\x20\x01\
(\x0b2$.SC2APIProtocol.CategoryScoreDetailsR\x11totalUsedMinerals\x12R\n\
\x12total_used_vespene\x18\x17\x20\x01(\x0b2$.SC2APIProtocol.CategorySco\
reDetailsR\x10totalUsedVespene\x12O\n\x12total_damage_dealt\x18\x18\x20\
\x01(\x0b2!.SC2APIProtocol.VitalScoreDetailsR\x10totalDamageDealt\x12O\n\
\x12total_damage_taken\x18\x19\x20\x01(\x0b2!.SC2APIProtocol.VitalScoreD\
etailsR\x10totalDamageTaken\x12D\n\x0ctotal_healed\x18\x1a\x20\x01(\x0b2\
!.SC2APIProtocol.VitalScoreDetailsR\x0btotalHealed\
";
static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto,
};
fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap()
}
pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
unsafe {
file_descriptor_proto_lazy.get(|| {
parse_descriptor_proto()
})
}
}