// This file is generated by rust-protobuf 2.20.0. Do not edit
// @generated

// https://github.com/rust-lang/rust-clippy/issues/702
#![allow(unknown_lints)]
#![allow(clippy::all)]

#![allow(unused_attributes)]
#![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(unused_imports)]
#![allow(unused_results)]
//! Generated file from `s2clientprotocol/score.proto`

/// Generated files are compatible only with the same version
/// of protobuf runtime.
// const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_20_0;

#[derive(PartialEq,Clone,Default)]
pub struct Score {
    // message fields
    pub score_type: ::std::option::Option<Score_ScoreType>,
    pub score: ::std::option::Option<i32>,
    pub score_details: ::protobuf::SingularPtrField<ScoreDetails>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a Score {
    fn default() -> &'a Score {
        <Score as ::protobuf::Message>::default_instance()
    }
}

impl Score {
    pub fn new() -> Score {
        ::std::default::Default::default()
    }

    // optional .SC2APIProtocol.Score.ScoreType score_type = 6;


    pub fn get_score_type(&self) -> Score_ScoreType {
        self.score_type.unwrap_or(Score_ScoreType::Curriculum)
    }
    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()
    }

    // Param is passed by value, moved
    pub fn set_score_type(&mut self, v: Score_ScoreType) {
        self.score_type = ::std::option::Option::Some(v);
    }

    // optional int32 score = 7;


    pub fn get_score(&self) -> i32 {
        self.score.unwrap_or(0)
    }
    pub fn clear_score(&mut self) {
        self.score = ::std::option::Option::None;
    }

    pub fn has_score(&self) -> bool {
        self.score.is_some()
    }

    // Param is passed by value, moved
    pub fn set_score(&mut self, v: i32) {
        self.score = ::std::option::Option::Some(v);
    }

    // optional .SC2APIProtocol.ScoreDetails score_details = 8;


    pub fn get_score_details(&self) -> &ScoreDetails {
        self.score_details.as_ref().unwrap_or_else(|| <ScoreDetails as ::protobuf::Message>::default_instance())
    }
    pub fn clear_score_details(&mut self) {
        self.score_details.clear();
    }

    pub fn has_score_details(&self) -> bool {
        self.score_details.is_some()
    }

    // Param is passed by value, moved
    pub fn set_score_details(&mut self, v: ScoreDetails) {
        self.score_details = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    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()
    }

    // Take field
    pub fn take_score_details(&mut self) -> ScoreDetails {
        self.score_details.take().unwrap_or_else(|| ScoreDetails::new())
    }
}

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

    // Compute sizes of nested messages
    #[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, ::protobuf::ProtobufEnum::value(&v))?;
        }
        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) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::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 descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        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_pb_name::<Score>(
                "Score",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static Score {
        static instance: ::protobuf::rt::LazyV2<Score> = ::protobuf::rt::LazyV2::INIT;
        instance.get(Score::new)
    }
}

impl ::protobuf::Clear for Score {
    fn clear(&mut self) {
        self.score_type = ::std::option::Option::None;
        self.score = ::std::option::Option::None;
        self.score_details.clear();
        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::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::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 descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            ::protobuf::reflect::EnumDescriptor::new_pb_name::<Score_ScoreType>("Score.ScoreType", file_descriptor_proto())
        })
    }
}

impl ::std::marker::Copy for Score_ScoreType {
}

// Note, `Default` is implemented although default value is not 0
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::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CategoryScoreDetails {
    // message fields
    pub none: ::std::option::Option<f32>,
    pub army: ::std::option::Option<f32>,
    pub economy: ::std::option::Option<f32>,
    pub technology: ::std::option::Option<f32>,
    pub upgrade: ::std::option::Option<f32>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a CategoryScoreDetails {
    fn default() -> &'a CategoryScoreDetails {
        <CategoryScoreDetails as ::protobuf::Message>::default_instance()
    }
}

impl CategoryScoreDetails {
    pub fn new() -> CategoryScoreDetails {
        ::std::default::Default::default()
    }

    // optional float none = 1;


    pub fn get_none(&self) -> f32 {
        self.none.unwrap_or(0.)
    }
    pub fn clear_none(&mut self) {
        self.none = ::std::option::Option::None;
    }

    pub fn has_none(&self) -> bool {
        self.none.is_some()
    }

    // Param is passed by value, moved
    pub fn set_none(&mut self, v: f32) {
        self.none = ::std::option::Option::Some(v);
    }

    // optional float army = 2;


    pub fn get_army(&self) -> f32 {
        self.army.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()
    }

    // Param is passed by value, moved
    pub fn set_army(&mut self, v: f32) {
        self.army = ::std::option::Option::Some(v);
    }

    // optional float economy = 3;


    pub fn get_economy(&self) -> f32 {
        self.economy.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()
    }

    // Param is passed by value, moved
    pub fn set_economy(&mut self, v: f32) {
        self.economy = ::std::option::Option::Some(v);
    }

    // optional float technology = 4;


    pub fn get_technology(&self) -> f32 {
        self.technology.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()
    }

    // Param is passed by value, moved
    pub fn set_technology(&mut self, v: f32) {
        self.technology = ::std::option::Option::Some(v);
    }

    // optional float upgrade = 5;


    pub fn get_upgrade(&self) -> f32 {
        self.upgrade.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()
    }

    // Param is passed by value, moved
    pub fn set_upgrade(&mut self, v: f32) {
        self.upgrade = ::std::option::Option::Some(v);
    }
}

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

    // Compute sizes of nested messages
    #[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) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::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 descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        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_pb_name::<CategoryScoreDetails>(
                "CategoryScoreDetails",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CategoryScoreDetails {
        static instance: ::protobuf::rt::LazyV2<CategoryScoreDetails> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CategoryScoreDetails::new)
    }
}

impl ::protobuf::Clear for CategoryScoreDetails {
    fn clear(&mut self) {
        self.none = ::std::option::Option::None;
        self.army = ::std::option::Option::None;
        self.economy = ::std::option::Option::None;
        self.technology = ::std::option::Option::None;
        self.upgrade = ::std::option::Option::None;
        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::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct VitalScoreDetails {
    // message fields
    pub life: ::std::option::Option<f32>,
    pub shields: ::std::option::Option<f32>,
    pub energy: ::std::option::Option<f32>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a VitalScoreDetails {
    fn default() -> &'a VitalScoreDetails {
        <VitalScoreDetails as ::protobuf::Message>::default_instance()
    }
}

impl VitalScoreDetails {
    pub fn new() -> VitalScoreDetails {
        ::std::default::Default::default()
    }

    // optional float life = 1;


    pub fn get_life(&self) -> f32 {
        self.life.unwrap_or(0.)
    }
    pub fn clear_life(&mut self) {
        self.life = ::std::option::Option::None;
    }

    pub fn has_life(&self) -> bool {
        self.life.is_some()
    }

    // Param is passed by value, moved
    pub fn set_life(&mut self, v: f32) {
        self.life = ::std::option::Option::Some(v);
    }

    // optional float shields = 2;


    pub fn get_shields(&self) -> f32 {
        self.shields.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()
    }

    // Param is passed by value, moved
    pub fn set_shields(&mut self, v: f32) {
        self.shields = ::std::option::Option::Some(v);
    }

    // optional float energy = 3;


    pub fn get_energy(&self) -> f32 {
        self.energy.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()
    }

    // Param is passed by value, moved
    pub fn set_energy(&mut self, v: f32) {
        self.energy = ::std::option::Option::Some(v);
    }
}

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

    // Compute sizes of nested messages
    #[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) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::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 descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        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_pb_name::<VitalScoreDetails>(
                "VitalScoreDetails",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static VitalScoreDetails {
        static instance: ::protobuf::rt::LazyV2<VitalScoreDetails> = ::protobuf::rt::LazyV2::INIT;
        instance.get(VitalScoreDetails::new)
    }
}

impl ::protobuf::Clear for VitalScoreDetails {
    fn clear(&mut self) {
        self.life = ::std::option::Option::None;
        self.shields = ::std::option::Option::None;
        self.energy = ::std::option::Option::None;
        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::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct ScoreDetails {
    // message fields
    pub idle_production_time: ::std::option::Option<f32>,
    pub idle_worker_time: ::std::option::Option<f32>,
    pub total_value_units: ::std::option::Option<f32>,
    pub total_value_structures: ::std::option::Option<f32>,
    pub killed_value_units: ::std::option::Option<f32>,
    pub killed_value_structures: ::std::option::Option<f32>,
    pub collected_minerals: ::std::option::Option<f32>,
    pub collected_vespene: ::std::option::Option<f32>,
    pub collection_rate_minerals: ::std::option::Option<f32>,
    pub collection_rate_vespene: ::std::option::Option<f32>,
    pub spent_minerals: ::std::option::Option<f32>,
    pub spent_vespene: ::std::option::Option<f32>,
    pub food_used: ::protobuf::SingularPtrField<CategoryScoreDetails>,
    pub killed_minerals: ::protobuf::SingularPtrField<CategoryScoreDetails>,
    pub killed_vespene: ::protobuf::SingularPtrField<CategoryScoreDetails>,
    pub lost_minerals: ::protobuf::SingularPtrField<CategoryScoreDetails>,
    pub lost_vespene: ::protobuf::SingularPtrField<CategoryScoreDetails>,
    pub friendly_fire_minerals: ::protobuf::SingularPtrField<CategoryScoreDetails>,
    pub friendly_fire_vespene: ::protobuf::SingularPtrField<CategoryScoreDetails>,
    pub used_minerals: ::protobuf::SingularPtrField<CategoryScoreDetails>,
    pub used_vespene: ::protobuf::SingularPtrField<CategoryScoreDetails>,
    pub total_used_minerals: ::protobuf::SingularPtrField<CategoryScoreDetails>,
    pub total_used_vespene: ::protobuf::SingularPtrField<CategoryScoreDetails>,
    pub total_damage_dealt: ::protobuf::SingularPtrField<VitalScoreDetails>,
    pub total_damage_taken: ::protobuf::SingularPtrField<VitalScoreDetails>,
    pub total_healed: ::protobuf::SingularPtrField<VitalScoreDetails>,
    pub current_apm: ::std::option::Option<f32>,
    pub current_effective_apm: ::std::option::Option<f32>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a ScoreDetails {
    fn default() -> &'a ScoreDetails {
        <ScoreDetails as ::protobuf::Message>::default_instance()
    }
}

impl ScoreDetails {
    pub fn new() -> ScoreDetails {
        ::std::default::Default::default()
    }

    // optional float idle_production_time = 1;


    pub fn get_idle_production_time(&self) -> f32 {
        self.idle_production_time.unwrap_or(0.)
    }
    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()
    }

    // Param is passed by value, moved
    pub fn set_idle_production_time(&mut self, v: f32) {
        self.idle_production_time = ::std::option::Option::Some(v);
    }

    // optional float idle_worker_time = 2;


    pub fn get_idle_worker_time(&self) -> f32 {
        self.idle_worker_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()
    }

    // Param is passed by value, moved
    pub fn set_idle_worker_time(&mut self, v: f32) {
        self.idle_worker_time = ::std::option::Option::Some(v);
    }

    // optional float total_value_units = 3;


    pub fn get_total_value_units(&self) -> f32 {
        self.total_value_units.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()
    }

    // Param is passed by value, moved
    pub fn set_total_value_units(&mut self, v: f32) {
        self.total_value_units = ::std::option::Option::Some(v);
    }

    // optional float total_value_structures = 4;


    pub fn get_total_value_structures(&self) -> f32 {
        self.total_value_structures.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()
    }

    // Param is passed by value, moved
    pub fn set_total_value_structures(&mut self, v: f32) {
        self.total_value_structures = ::std::option::Option::Some(v);
    }

    // optional float killed_value_units = 5;


    pub fn get_killed_value_units(&self) -> f32 {
        self.killed_value_units.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()
    }

    // Param is passed by value, moved
    pub fn set_killed_value_units(&mut self, v: f32) {
        self.killed_value_units = ::std::option::Option::Some(v);
    }

    // optional float killed_value_structures = 6;


    pub fn get_killed_value_structures(&self) -> f32 {
        self.killed_value_structures.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()
    }

    // Param is passed by value, moved
    pub fn set_killed_value_structures(&mut self, v: f32) {
        self.killed_value_structures = ::std::option::Option::Some(v);
    }

    // optional float collected_minerals = 7;


    pub fn get_collected_minerals(&self) -> f32 {
        self.collected_minerals.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()
    }

    // Param is passed by value, moved
    pub fn set_collected_minerals(&mut self, v: f32) {
        self.collected_minerals = ::std::option::Option::Some(v);
    }

    // optional float collected_vespene = 8;


    pub fn get_collected_vespene(&self) -> f32 {
        self.collected_vespene.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()
    }

    // Param is passed by value, moved
    pub fn set_collected_vespene(&mut self, v: f32) {
        self.collected_vespene = ::std::option::Option::Some(v);
    }

    // optional float collection_rate_minerals = 9;


    pub fn get_collection_rate_minerals(&self) -> f32 {
        self.collection_rate_minerals.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()
    }

    // Param is passed by value, moved
    pub fn set_collection_rate_minerals(&mut self, v: f32) {
        self.collection_rate_minerals = ::std::option::Option::Some(v);
    }

    // optional float collection_rate_vespene = 10;


    pub fn get_collection_rate_vespene(&self) -> f32 {
        self.collection_rate_vespene.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()
    }

    // Param is passed by value, moved
    pub fn set_collection_rate_vespene(&mut self, v: f32) {
        self.collection_rate_vespene = ::std::option::Option::Some(v);
    }

    // optional float spent_minerals = 11;


    pub fn get_spent_minerals(&self) -> f32 {
        self.spent_minerals.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()
    }

    // Param is passed by value, moved
    pub fn set_spent_minerals(&mut self, v: f32) {
        self.spent_minerals = ::std::option::Option::Some(v);
    }

    // optional float spent_vespene = 12;


    pub fn get_spent_vespene(&self) -> f32 {
        self.spent_vespene.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()
    }

    // Param is passed by value, moved
    pub fn set_spent_vespene(&mut self, v: f32) {
        self.spent_vespene = ::std::option::Option::Some(v);
    }

    // optional .SC2APIProtocol.CategoryScoreDetails food_used = 13;


    pub fn get_food_used(&self) -> &CategoryScoreDetails {
        self.food_used.as_ref().unwrap_or_else(|| <CategoryScoreDetails as ::protobuf::Message>::default_instance())
    }
    pub fn clear_food_used(&mut self) {
        self.food_used.clear();
    }

    pub fn has_food_used(&self) -> bool {
        self.food_used.is_some()
    }

    // Param is passed by value, moved
    pub fn set_food_used(&mut self, v: CategoryScoreDetails) {
        self.food_used = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    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()
    }

    // Take field
    pub fn take_food_used(&mut self) -> CategoryScoreDetails {
        self.food_used.take().unwrap_or_else(|| CategoryScoreDetails::new())
    }

    // optional .SC2APIProtocol.CategoryScoreDetails killed_minerals = 14;


    pub fn get_killed_minerals(&self) -> &CategoryScoreDetails {
        self.killed_minerals.as_ref().unwrap_or_else(|| <CategoryScoreDetails as ::protobuf::Message>::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()
    }

    // Param is passed by value, moved
    pub fn set_killed_minerals(&mut self, v: CategoryScoreDetails) {
        self.killed_minerals = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    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()
    }

    // Take field
    pub fn take_killed_minerals(&mut self) -> CategoryScoreDetails {
        self.killed_minerals.take().unwrap_or_else(|| CategoryScoreDetails::new())
    }

    // optional .SC2APIProtocol.CategoryScoreDetails killed_vespene = 15;


    pub fn get_killed_vespene(&self) -> &CategoryScoreDetails {
        self.killed_vespene.as_ref().unwrap_or_else(|| <CategoryScoreDetails as ::protobuf::Message>::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()
    }

    // Param is passed by value, moved
    pub fn set_killed_vespene(&mut self, v: CategoryScoreDetails) {
        self.killed_vespene = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    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()
    }

    // Take field
    pub fn take_killed_vespene(&mut self) -> CategoryScoreDetails {
        self.killed_vespene.take().unwrap_or_else(|| CategoryScoreDetails::new())
    }

    // optional .SC2APIProtocol.CategoryScoreDetails lost_minerals = 16;


    pub fn get_lost_minerals(&self) -> &CategoryScoreDetails {
        self.lost_minerals.as_ref().unwrap_or_else(|| <CategoryScoreDetails as ::protobuf::Message>::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()
    }

    // Param is passed by value, moved
    pub fn set_lost_minerals(&mut self, v: CategoryScoreDetails) {
        self.lost_minerals = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    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()
    }

    // Take field
    pub fn take_lost_minerals(&mut self) -> CategoryScoreDetails {
        self.lost_minerals.take().unwrap_or_else(|| CategoryScoreDetails::new())
    }

    // optional .SC2APIProtocol.CategoryScoreDetails lost_vespene = 17;


    pub fn get_lost_vespene(&self) -> &CategoryScoreDetails {
        self.lost_vespene.as_ref().unwrap_or_else(|| <CategoryScoreDetails as ::protobuf::Message>::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()
    }

    // Param is passed by value, moved
    pub fn set_lost_vespene(&mut self, v: CategoryScoreDetails) {
        self.lost_vespene = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    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()
    }

    // Take field
    pub fn take_lost_vespene(&mut self) -> CategoryScoreDetails {
        self.lost_vespene.take().unwrap_or_else(|| CategoryScoreDetails::new())
    }

    // optional .SC2APIProtocol.CategoryScoreDetails friendly_fire_minerals = 18;


    pub fn get_friendly_fire_minerals(&self) -> &CategoryScoreDetails {
        self.friendly_fire_minerals.as_ref().unwrap_or_else(|| <CategoryScoreDetails as ::protobuf::Message>::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()
    }

    // Param is passed by value, moved
    pub fn set_friendly_fire_minerals(&mut self, v: CategoryScoreDetails) {
        self.friendly_fire_minerals = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    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()
    }

    // Take field
    pub fn take_friendly_fire_minerals(&mut self) -> CategoryScoreDetails {
        self.friendly_fire_minerals.take().unwrap_or_else(|| CategoryScoreDetails::new())
    }

    // optional .SC2APIProtocol.CategoryScoreDetails friendly_fire_vespene = 19;


    pub fn get_friendly_fire_vespene(&self) -> &CategoryScoreDetails {
        self.friendly_fire_vespene.as_ref().unwrap_or_else(|| <CategoryScoreDetails as ::protobuf::Message>::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()
    }

    // Param is passed by value, moved
    pub fn set_friendly_fire_vespene(&mut self, v: CategoryScoreDetails) {
        self.friendly_fire_vespene = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    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()
    }

    // Take field
    pub fn take_friendly_fire_vespene(&mut self) -> CategoryScoreDetails {
        self.friendly_fire_vespene.take().unwrap_or_else(|| CategoryScoreDetails::new())
    }

    // optional .SC2APIProtocol.CategoryScoreDetails used_minerals = 20;


    pub fn get_used_minerals(&self) -> &CategoryScoreDetails {
        self.used_minerals.as_ref().unwrap_or_else(|| <CategoryScoreDetails as ::protobuf::Message>::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()
    }

    // Param is passed by value, moved
    pub fn set_used_minerals(&mut self, v: CategoryScoreDetails) {
        self.used_minerals = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    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()
    }

    // Take field
    pub fn take_used_minerals(&mut self) -> CategoryScoreDetails {
        self.used_minerals.take().unwrap_or_else(|| CategoryScoreDetails::new())
    }

    // optional .SC2APIProtocol.CategoryScoreDetails used_vespene = 21;


    pub fn get_used_vespene(&self) -> &CategoryScoreDetails {
        self.used_vespene.as_ref().unwrap_or_else(|| <CategoryScoreDetails as ::protobuf::Message>::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()
    }

    // Param is passed by value, moved
    pub fn set_used_vespene(&mut self, v: CategoryScoreDetails) {
        self.used_vespene = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    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()
    }

    // Take field
    pub fn take_used_vespene(&mut self) -> CategoryScoreDetails {
        self.used_vespene.take().unwrap_or_else(|| CategoryScoreDetails::new())
    }

    // optional .SC2APIProtocol.CategoryScoreDetails total_used_minerals = 22;


    pub fn get_total_used_minerals(&self) -> &CategoryScoreDetails {
        self.total_used_minerals.as_ref().unwrap_or_else(|| <CategoryScoreDetails as ::protobuf::Message>::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()
    }

    // Param is passed by value, moved
    pub fn set_total_used_minerals(&mut self, v: CategoryScoreDetails) {
        self.total_used_minerals = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    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()
    }

    // Take field
    pub fn take_total_used_minerals(&mut self) -> CategoryScoreDetails {
        self.total_used_minerals.take().unwrap_or_else(|| CategoryScoreDetails::new())
    }

    // optional .SC2APIProtocol.CategoryScoreDetails total_used_vespene = 23;


    pub fn get_total_used_vespene(&self) -> &CategoryScoreDetails {
        self.total_used_vespene.as_ref().unwrap_or_else(|| <CategoryScoreDetails as ::protobuf::Message>::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()
    }

    // Param is passed by value, moved
    pub fn set_total_used_vespene(&mut self, v: CategoryScoreDetails) {
        self.total_used_vespene = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    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()
    }

    // Take field
    pub fn take_total_used_vespene(&mut self) -> CategoryScoreDetails {
        self.total_used_vespene.take().unwrap_or_else(|| CategoryScoreDetails::new())
    }

    // optional .SC2APIProtocol.VitalScoreDetails total_damage_dealt = 24;


    pub fn get_total_damage_dealt(&self) -> &VitalScoreDetails {
        self.total_damage_dealt.as_ref().unwrap_or_else(|| <VitalScoreDetails as ::protobuf::Message>::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()
    }

    // Param is passed by value, moved
    pub fn set_total_damage_dealt(&mut self, v: VitalScoreDetails) {
        self.total_damage_dealt = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    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()
    }

    // Take field
    pub fn take_total_damage_dealt(&mut self) -> VitalScoreDetails {
        self.total_damage_dealt.take().unwrap_or_else(|| VitalScoreDetails::new())
    }

    // optional .SC2APIProtocol.VitalScoreDetails total_damage_taken = 25;


    pub fn get_total_damage_taken(&self) -> &VitalScoreDetails {
        self.total_damage_taken.as_ref().unwrap_or_else(|| <VitalScoreDetails as ::protobuf::Message>::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()
    }

    // Param is passed by value, moved
    pub fn set_total_damage_taken(&mut self, v: VitalScoreDetails) {
        self.total_damage_taken = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    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()
    }

    // Take field
    pub fn take_total_damage_taken(&mut self) -> VitalScoreDetails {
        self.total_damage_taken.take().unwrap_or_else(|| VitalScoreDetails::new())
    }

    // optional .SC2APIProtocol.VitalScoreDetails total_healed = 26;


    pub fn get_total_healed(&self) -> &VitalScoreDetails {
        self.total_healed.as_ref().unwrap_or_else(|| <VitalScoreDetails as ::protobuf::Message>::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()
    }

    // Param is passed by value, moved
    pub fn set_total_healed(&mut self, v: VitalScoreDetails) {
        self.total_healed = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    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()
    }

    // Take field
    pub fn take_total_healed(&mut self) -> VitalScoreDetails {
        self.total_healed.take().unwrap_or_else(|| VitalScoreDetails::new())
    }

    // optional float current_apm = 27;


    pub fn get_current_apm(&self) -> f32 {
        self.current_apm.unwrap_or(0.)
    }
    pub fn clear_current_apm(&mut self) {
        self.current_apm = ::std::option::Option::None;
    }

    pub fn has_current_apm(&self) -> bool {
        self.current_apm.is_some()
    }

    // Param is passed by value, moved
    pub fn set_current_apm(&mut self, v: f32) {
        self.current_apm = ::std::option::Option::Some(v);
    }

    // optional float current_effective_apm = 28;


    pub fn get_current_effective_apm(&self) -> f32 {
        self.current_effective_apm.unwrap_or(0.)
    }
    pub fn clear_current_effective_apm(&mut self) {
        self.current_effective_apm = ::std::option::Option::None;
    }

    pub fn has_current_effective_apm(&self) -> bool {
        self.current_effective_apm.is_some()
    }

    // Param is passed by value, moved
    pub fn set_current_effective_apm(&mut self, v: f32) {
        self.current_effective_apm = ::std::option::Option::Some(v);
    }
}

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)?;
                },
                27 => {
                    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.current_apm = ::std::option::Option::Some(tmp);
                },
                28 => {
                    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.current_effective_apm = ::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(())
    }

    // Compute sizes of nested messages
    #[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;
        }
        if let Some(v) = self.current_apm {
            my_size += 6;
        }
        if let Some(v) = self.current_effective_apm {
            my_size += 6;
        }
        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)?;
        }
        if let Some(v) = self.current_apm {
            os.write_float(27, v)?;
        }
        if let Some(v) = self.current_effective_apm {
            os.write_float(28, 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) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::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 descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        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 },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
                "current_apm",
                |m: &ScoreDetails| { &m.current_apm },
                |m: &mut ScoreDetails| { &mut m.current_apm },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
                "current_effective_apm",
                |m: &ScoreDetails| { &m.current_effective_apm },
                |m: &mut ScoreDetails| { &mut m.current_effective_apm },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ScoreDetails>(
                "ScoreDetails",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static ScoreDetails {
        static instance: ::protobuf::rt::LazyV2<ScoreDetails> = ::protobuf::rt::LazyV2::INIT;
        instance.get(ScoreDetails::new)
    }
}

impl ::protobuf::Clear for ScoreDetails {
    fn clear(&mut self) {
        self.idle_production_time = ::std::option::Option::None;
        self.idle_worker_time = ::std::option::Option::None;
        self.total_value_units = ::std::option::Option::None;
        self.total_value_structures = ::std::option::Option::None;
        self.killed_value_units = ::std::option::Option::None;
        self.killed_value_structures = ::std::option::Option::None;
        self.collected_minerals = ::std::option::Option::None;
        self.collected_vespene = ::std::option::Option::None;
        self.collection_rate_minerals = ::std::option::Option::None;
        self.collection_rate_vespene = ::std::option::Option::None;
        self.spent_minerals = ::std::option::Option::None;
        self.spent_vespene = ::std::option::Option::None;
        self.food_used.clear();
        self.killed_minerals.clear();
        self.killed_vespene.clear();
        self.lost_minerals.clear();
        self.lost_vespene.clear();
        self.friendly_fire_minerals.clear();
        self.friendly_fire_vespene.clear();
        self.used_minerals.clear();
        self.used_vespene.clear();
        self.total_used_minerals.clear();
        self.total_used_vespene.clear();
        self.total_damage_dealt.clear();
        self.total_damage_taken.clear();
        self.total_healed.clear();
        self.current_apm = ::std::option::Option::None;
        self.current_effective_apm = ::std::option::Option::None;
        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::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::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\"\xf0\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\x12\x1f\n\x0bcurrent_\
    apm\x18\x1b\x20\x01(\x02R\ncurrentApm\x122\n\x15current_effective_apm\
    \x18\x1c\x20\x01(\x02R\x13currentEffectiveApm\
";

static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT;

fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
    ::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
}

pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
    file_descriptor_proto_lazy.get(|| {
        parse_descriptor_proto()
    })
}
