smmdb 1.4.2

// This file is generated by rust-protobuf 2.18.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 `Tile.proto`

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

#[derive(PartialEq,Clone,Default)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct Tile {
    // message oneof groups
    pub payload: ::std::option::Option<Tile_oneof_payload>,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub cached_size: ::protobuf::CachedSize,
}

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

#[derive(Clone,PartialEq,Debug)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub enum Tile_oneof_payload {
    tile_data(::bytes::Bytes),
    tile_details(Tile_TileDetails),
}

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

    // bytes tile_data = 1;


    pub fn get_tile_data(&self) -> &[u8] {
        match self.payload {
            ::std::option::Option::Some(Tile_oneof_payload::tile_data(ref v)) => v,
            _ => &[],
        }
    }
    pub fn clear_tile_data(&mut self) {
        self.payload = ::std::option::Option::None;
    }

    pub fn has_tile_data(&self) -> bool {
        match self.payload {
            ::std::option::Option::Some(Tile_oneof_payload::tile_data(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_tile_data(&mut self, v: ::bytes::Bytes) {
        self.payload = ::std::option::Option::Some(Tile_oneof_payload::tile_data(v))
    }

    // Mutable pointer to the field.
    pub fn mut_tile_data(&mut self) -> &mut ::bytes::Bytes {
        if let ::std::option::Option::Some(Tile_oneof_payload::tile_data(_)) = self.payload {
        } else {
            self.payload = ::std::option::Option::Some(Tile_oneof_payload::tile_data(::bytes::Bytes::new()));
        }
        match self.payload {
            ::std::option::Option::Some(Tile_oneof_payload::tile_data(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_tile_data(&mut self) -> ::bytes::Bytes {
        if self.has_tile_data() {
            match self.payload.take() {
                ::std::option::Option::Some(Tile_oneof_payload::tile_data(v)) => v,
                _ => panic!(),
            }
        } else {
            ::bytes::Bytes::new()
        }
    }

    // .smmdb.Tile.TileDetails tile_details = 2;


    pub fn get_tile_details(&self) -> &Tile_TileDetails {
        match self.payload {
            ::std::option::Option::Some(Tile_oneof_payload::tile_details(ref v)) => v,
            _ => <Tile_TileDetails as ::protobuf::Message>::default_instance(),
        }
    }
    pub fn clear_tile_details(&mut self) {
        self.payload = ::std::option::Option::None;
    }

    pub fn has_tile_details(&self) -> bool {
        match self.payload {
            ::std::option::Option::Some(Tile_oneof_payload::tile_details(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_tile_details(&mut self, v: Tile_TileDetails) {
        self.payload = ::std::option::Option::Some(Tile_oneof_payload::tile_details(v))
    }

    // Mutable pointer to the field.
    pub fn mut_tile_details(&mut self) -> &mut Tile_TileDetails {
        if let ::std::option::Option::Some(Tile_oneof_payload::tile_details(_)) = self.payload {
        } else {
            self.payload = ::std::option::Option::Some(Tile_oneof_payload::tile_details(Tile_TileDetails::new()));
        }
        match self.payload {
            ::std::option::Option::Some(Tile_oneof_payload::tile_details(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_tile_details(&mut self) -> Tile_TileDetails {
        if self.has_tile_details() {
            match self.payload.take() {
                ::std::option::Option::Some(Tile_oneof_payload::tile_details(v)) => v,
                _ => panic!(),
            }
        } else {
            Tile_TileDetails::new()
        }
    }
}

impl ::protobuf::Message for Tile {
    fn is_initialized(&self) -> bool {
        if let Some(Tile_oneof_payload::tile_details(ref v)) = self.payload {
            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::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.payload = ::std::option::Option::Some(Tile_oneof_payload::tile_data(is.read_carllerche_bytes()?));
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.payload = ::std::option::Option::Some(Tile_oneof_payload::tile_details(is.read_message()?));
                },
                _ => {
                    ::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 ::std::option::Option::Some(ref v) = self.payload {
            match v {
                &Tile_oneof_payload::tile_data(ref v) => {
                    my_size += ::protobuf::rt::bytes_size(1, &v);
                },
                &Tile_oneof_payload::tile_details(ref v) => {
                    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 ::std::option::Option::Some(ref v) = self.payload {
            match v {
                &Tile_oneof_payload::tile_data(ref v) => {
                    os.write_bytes(1, v)?;
                },
                &Tile_oneof_payload::tile_details(ref v) => {
                    os.write_tag(2, ::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() -> Tile {
        Tile::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_singular_bytes_accessor::<_>(
                "tile_data",
                Tile::has_tile_data,
                Tile::get_tile_data,
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, Tile_TileDetails>(
                "tile_details",
                Tile::has_tile_details,
                Tile::get_tile_details,
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<Tile>(
                "Tile",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for Tile {
    fn clear(&mut self) {
        self.payload = ::std::option::Option::None;
        self.payload = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for Tile {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for Tile {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct Tile_TileDetails {
    // message fields
    pub x: f32,
    pub y: f32,
    pub dim_x: u32,
    pub dim_y: u32,
    pub orientation: u32,
    pub z_index: u32,
    pub tile_type: Tile_TileDetails_TileType,
    pub entity_type: Tile_TileDetails_EntityType,
    pub link: u32,
    pub id: u32,
    pub costume: u32,
    pub container: u32,
    pub inknown_0: u32,
    pub unknown_1: u32,
    pub unknown_2: u32,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // float x = 1;


    pub fn get_x(&self) -> f32 {
        self.x
    }
    pub fn clear_x(&mut self) {
        self.x = 0.;
    }

    // Param is passed by value, moved
    pub fn set_x(&mut self, v: f32) {
        self.x = v;
    }

    // float y = 2;


    pub fn get_y(&self) -> f32 {
        self.y
    }
    pub fn clear_y(&mut self) {
        self.y = 0.;
    }

    // Param is passed by value, moved
    pub fn set_y(&mut self, v: f32) {
        self.y = v;
    }

    // uint32 dim_x = 3;


    pub fn get_dim_x(&self) -> u32 {
        self.dim_x
    }
    pub fn clear_dim_x(&mut self) {
        self.dim_x = 0;
    }

    // Param is passed by value, moved
    pub fn set_dim_x(&mut self, v: u32) {
        self.dim_x = v;
    }

    // uint32 dim_y = 4;


    pub fn get_dim_y(&self) -> u32 {
        self.dim_y
    }
    pub fn clear_dim_y(&mut self) {
        self.dim_y = 0;
    }

    // Param is passed by value, moved
    pub fn set_dim_y(&mut self, v: u32) {
        self.dim_y = v;
    }

    // uint32 orientation = 5;


    pub fn get_orientation(&self) -> u32 {
        self.orientation
    }
    pub fn clear_orientation(&mut self) {
        self.orientation = 0;
    }

    // Param is passed by value, moved
    pub fn set_orientation(&mut self, v: u32) {
        self.orientation = v;
    }

    // uint32 z_index = 6;


    pub fn get_z_index(&self) -> u32 {
        self.z_index
    }
    pub fn clear_z_index(&mut self) {
        self.z_index = 0;
    }

    // Param is passed by value, moved
    pub fn set_z_index(&mut self, v: u32) {
        self.z_index = v;
    }

    // .smmdb.Tile.TileDetails.TileType tile_type = 7;


    pub fn get_tile_type(&self) -> Tile_TileDetails_TileType {
        self.tile_type
    }
    pub fn clear_tile_type(&mut self) {
        self.tile_type = Tile_TileDetails_TileType::UNKNOWN;
    }

    // Param is passed by value, moved
    pub fn set_tile_type(&mut self, v: Tile_TileDetails_TileType) {
        self.tile_type = v;
    }

    // .smmdb.Tile.TileDetails.EntityType entity_type = 8;


    pub fn get_entity_type(&self) -> Tile_TileDetails_EntityType {
        self.entity_type
    }
    pub fn clear_entity_type(&mut self) {
        self.entity_type = Tile_TileDetails_EntityType::STATIC;
    }

    // Param is passed by value, moved
    pub fn set_entity_type(&mut self, v: Tile_TileDetails_EntityType) {
        self.entity_type = v;
    }

    // uint32 link = 9;


    pub fn get_link(&self) -> u32 {
        self.link
    }
    pub fn clear_link(&mut self) {
        self.link = 0;
    }

    // Param is passed by value, moved
    pub fn set_link(&mut self, v: u32) {
        self.link = v;
    }

    // uint32 id = 10;


    pub fn get_id(&self) -> u32 {
        self.id
    }
    pub fn clear_id(&mut self) {
        self.id = 0;
    }

    // Param is passed by value, moved
    pub fn set_id(&mut self, v: u32) {
        self.id = v;
    }

    // uint32 costume = 11;


    pub fn get_costume(&self) -> u32 {
        self.costume
    }
    pub fn clear_costume(&mut self) {
        self.costume = 0;
    }

    // Param is passed by value, moved
    pub fn set_costume(&mut self, v: u32) {
        self.costume = v;
    }

    // uint32 container = 12;


    pub fn get_container(&self) -> u32 {
        self.container
    }
    pub fn clear_container(&mut self) {
        self.container = 0;
    }

    // Param is passed by value, moved
    pub fn set_container(&mut self, v: u32) {
        self.container = v;
    }

    // uint32 inknown_0 = 13;


    pub fn get_inknown_0(&self) -> u32 {
        self.inknown_0
    }
    pub fn clear_inknown_0(&mut self) {
        self.inknown_0 = 0;
    }

    // Param is passed by value, moved
    pub fn set_inknown_0(&mut self, v: u32) {
        self.inknown_0 = v;
    }

    // uint32 unknown_1 = 14;


    pub fn get_unknown_1(&self) -> u32 {
        self.unknown_1
    }
    pub fn clear_unknown_1(&mut self) {
        self.unknown_1 = 0;
    }

    // Param is passed by value, moved
    pub fn set_unknown_1(&mut self, v: u32) {
        self.unknown_1 = v;
    }

    // uint32 unknown_2 = 15;


    pub fn get_unknown_2(&self) -> u32 {
        self.unknown_2
    }
    pub fn clear_unknown_2(&mut self) {
        self.unknown_2 = 0;
    }

    // Param is passed by value, moved
    pub fn set_unknown_2(&mut self, v: u32) {
        self.unknown_2 = v;
    }
}

impl ::protobuf::Message for Tile_TileDetails {
    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.x = 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.y = tmp;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.dim_x = tmp;
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.dim_y = tmp;
                },
                5 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.orientation = tmp;
                },
                6 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.z_index = tmp;
                },
                7 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.tile_type, 7, &mut self.unknown_fields)?
                },
                8 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.entity_type, 8, &mut self.unknown_fields)?
                },
                9 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.link = tmp;
                },
                10 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.id = tmp;
                },
                11 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.costume = tmp;
                },
                12 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.container = tmp;
                },
                13 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.inknown_0 = tmp;
                },
                14 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.unknown_1 = tmp;
                },
                15 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.unknown_2 = 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 self.x != 0. {
            my_size += 5;
        }
        if self.y != 0. {
            my_size += 5;
        }
        if self.dim_x != 0 {
            my_size += ::protobuf::rt::value_size(3, self.dim_x, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.dim_y != 0 {
            my_size += ::protobuf::rt::value_size(4, self.dim_y, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.orientation != 0 {
            my_size += ::protobuf::rt::value_size(5, self.orientation, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.z_index != 0 {
            my_size += ::protobuf::rt::value_size(6, self.z_index, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.tile_type != Tile_TileDetails_TileType::UNKNOWN {
            my_size += ::protobuf::rt::enum_size(7, self.tile_type);
        }
        if self.entity_type != Tile_TileDetails_EntityType::STATIC {
            my_size += ::protobuf::rt::enum_size(8, self.entity_type);
        }
        if self.link != 0 {
            my_size += ::protobuf::rt::value_size(9, self.link, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.id != 0 {
            my_size += ::protobuf::rt::value_size(10, self.id, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.costume != 0 {
            my_size += ::protobuf::rt::value_size(11, self.costume, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.container != 0 {
            my_size += ::protobuf::rt::value_size(12, self.container, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.inknown_0 != 0 {
            my_size += ::protobuf::rt::value_size(13, self.inknown_0, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.unknown_1 != 0 {
            my_size += ::protobuf::rt::value_size(14, self.unknown_1, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.unknown_2 != 0 {
            my_size += ::protobuf::rt::value_size(15, self.unknown_2, ::protobuf::wire_format::WireTypeVarint);
        }
        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 self.x != 0. {
            os.write_float(1, self.x)?;
        }
        if self.y != 0. {
            os.write_float(2, self.y)?;
        }
        if self.dim_x != 0 {
            os.write_uint32(3, self.dim_x)?;
        }
        if self.dim_y != 0 {
            os.write_uint32(4, self.dim_y)?;
        }
        if self.orientation != 0 {
            os.write_uint32(5, self.orientation)?;
        }
        if self.z_index != 0 {
            os.write_uint32(6, self.z_index)?;
        }
        if self.tile_type != Tile_TileDetails_TileType::UNKNOWN {
            os.write_enum(7, ::protobuf::ProtobufEnum::value(&self.tile_type))?;
        }
        if self.entity_type != Tile_TileDetails_EntityType::STATIC {
            os.write_enum(8, ::protobuf::ProtobufEnum::value(&self.entity_type))?;
        }
        if self.link != 0 {
            os.write_uint32(9, self.link)?;
        }
        if self.id != 0 {
            os.write_uint32(10, self.id)?;
        }
        if self.costume != 0 {
            os.write_uint32(11, self.costume)?;
        }
        if self.container != 0 {
            os.write_uint32(12, self.container)?;
        }
        if self.inknown_0 != 0 {
            os.write_uint32(13, self.inknown_0)?;
        }
        if self.unknown_1 != 0 {
            os.write_uint32(14, self.unknown_1)?;
        }
        if self.unknown_2 != 0 {
            os.write_uint32(15, self.unknown_2)?;
        }
        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() -> Tile_TileDetails {
        Tile_TileDetails::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_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
                "x",
                |m: &Tile_TileDetails| { &m.x },
                |m: &mut Tile_TileDetails| { &mut m.x },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
                "y",
                |m: &Tile_TileDetails| { &m.y },
                |m: &mut Tile_TileDetails| { &mut m.y },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "dim_x",
                |m: &Tile_TileDetails| { &m.dim_x },
                |m: &mut Tile_TileDetails| { &mut m.dim_x },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "dim_y",
                |m: &Tile_TileDetails| { &m.dim_y },
                |m: &mut Tile_TileDetails| { &mut m.dim_y },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "orientation",
                |m: &Tile_TileDetails| { &m.orientation },
                |m: &mut Tile_TileDetails| { &mut m.orientation },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "z_index",
                |m: &Tile_TileDetails| { &m.z_index },
                |m: &mut Tile_TileDetails| { &mut m.z_index },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<Tile_TileDetails_TileType>>(
                "tile_type",
                |m: &Tile_TileDetails| { &m.tile_type },
                |m: &mut Tile_TileDetails| { &mut m.tile_type },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<Tile_TileDetails_EntityType>>(
                "entity_type",
                |m: &Tile_TileDetails| { &m.entity_type },
                |m: &mut Tile_TileDetails| { &mut m.entity_type },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "link",
                |m: &Tile_TileDetails| { &m.link },
                |m: &mut Tile_TileDetails| { &mut m.link },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "id",
                |m: &Tile_TileDetails| { &m.id },
                |m: &mut Tile_TileDetails| { &mut m.id },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "costume",
                |m: &Tile_TileDetails| { &m.costume },
                |m: &mut Tile_TileDetails| { &mut m.costume },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "container",
                |m: &Tile_TileDetails| { &m.container },
                |m: &mut Tile_TileDetails| { &mut m.container },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "inknown_0",
                |m: &Tile_TileDetails| { &m.inknown_0 },
                |m: &mut Tile_TileDetails| { &mut m.inknown_0 },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "unknown_1",
                |m: &Tile_TileDetails| { &m.unknown_1 },
                |m: &mut Tile_TileDetails| { &mut m.unknown_1 },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "unknown_2",
                |m: &Tile_TileDetails| { &m.unknown_2 },
                |m: &mut Tile_TileDetails| { &mut m.unknown_2 },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<Tile_TileDetails>(
                "Tile.TileDetails",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for Tile_TileDetails {
    fn clear(&mut self) {
        self.x = 0.;
        self.y = 0.;
        self.dim_x = 0;
        self.dim_y = 0;
        self.orientation = 0;
        self.z_index = 0;
        self.tile_type = Tile_TileDetails_TileType::UNKNOWN;
        self.entity_type = Tile_TileDetails_EntityType::STATIC;
        self.link = 0;
        self.id = 0;
        self.costume = 0;
        self.container = 0;
        self.inknown_0 = 0;
        self.unknown_1 = 0;
        self.unknown_2 = 0;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for Tile_TileDetails {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for Tile_TileDetails {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub enum Tile_TileDetails_TileType {
    UNKNOWN = 0,
    NORMAL = 4,
    QUESTIONMARK = 5,
    HARD = 6,
    GROUND = 7,
    COIN = 8,
    PIPE = 9,
    BACKGROUND = 16,
    MUSHROOM = 20,
    FALLING = 21,
    CLOUD = 22,
    NOTE = 23,
    FINISH_PLATFORM = 26,
    FINISH = 27,
    KAIZO = 29,
    STAR = 35,
    START_PLATFORM = 37,
    WOODEN_ARROW = 38,
    BOO = 41,
    SPIKE = 43,
    SPECIAL = 44,
    FINISH_LINE = 49,
    TRACK = 59,
    ICE = 63,
    START = 69,
}

impl ::protobuf::ProtobufEnum for Tile_TileDetails_TileType {
    fn value(&self) -> i32 {
        *self as i32
    }

    fn from_i32(value: i32) -> ::std::option::Option<Tile_TileDetails_TileType> {
        match value {
            0 => ::std::option::Option::Some(Tile_TileDetails_TileType::UNKNOWN),
            4 => ::std::option::Option::Some(Tile_TileDetails_TileType::NORMAL),
            5 => ::std::option::Option::Some(Tile_TileDetails_TileType::QUESTIONMARK),
            6 => ::std::option::Option::Some(Tile_TileDetails_TileType::HARD),
            7 => ::std::option::Option::Some(Tile_TileDetails_TileType::GROUND),
            8 => ::std::option::Option::Some(Tile_TileDetails_TileType::COIN),
            9 => ::std::option::Option::Some(Tile_TileDetails_TileType::PIPE),
            16 => ::std::option::Option::Some(Tile_TileDetails_TileType::BACKGROUND),
            20 => ::std::option::Option::Some(Tile_TileDetails_TileType::MUSHROOM),
            21 => ::std::option::Option::Some(Tile_TileDetails_TileType::FALLING),
            22 => ::std::option::Option::Some(Tile_TileDetails_TileType::CLOUD),
            23 => ::std::option::Option::Some(Tile_TileDetails_TileType::NOTE),
            26 => ::std::option::Option::Some(Tile_TileDetails_TileType::FINISH_PLATFORM),
            27 => ::std::option::Option::Some(Tile_TileDetails_TileType::FINISH),
            29 => ::std::option::Option::Some(Tile_TileDetails_TileType::KAIZO),
            35 => ::std::option::Option::Some(Tile_TileDetails_TileType::STAR),
            37 => ::std::option::Option::Some(Tile_TileDetails_TileType::START_PLATFORM),
            38 => ::std::option::Option::Some(Tile_TileDetails_TileType::WOODEN_ARROW),
            41 => ::std::option::Option::Some(Tile_TileDetails_TileType::BOO),
            43 => ::std::option::Option::Some(Tile_TileDetails_TileType::SPIKE),
            44 => ::std::option::Option::Some(Tile_TileDetails_TileType::SPECIAL),
            49 => ::std::option::Option::Some(Tile_TileDetails_TileType::FINISH_LINE),
            59 => ::std::option::Option::Some(Tile_TileDetails_TileType::TRACK),
            63 => ::std::option::Option::Some(Tile_TileDetails_TileType::ICE),
            69 => ::std::option::Option::Some(Tile_TileDetails_TileType::START),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [Tile_TileDetails_TileType] = &[
            Tile_TileDetails_TileType::UNKNOWN,
            Tile_TileDetails_TileType::NORMAL,
            Tile_TileDetails_TileType::QUESTIONMARK,
            Tile_TileDetails_TileType::HARD,
            Tile_TileDetails_TileType::GROUND,
            Tile_TileDetails_TileType::COIN,
            Tile_TileDetails_TileType::PIPE,
            Tile_TileDetails_TileType::BACKGROUND,
            Tile_TileDetails_TileType::MUSHROOM,
            Tile_TileDetails_TileType::FALLING,
            Tile_TileDetails_TileType::CLOUD,
            Tile_TileDetails_TileType::NOTE,
            Tile_TileDetails_TileType::FINISH_PLATFORM,
            Tile_TileDetails_TileType::FINISH,
            Tile_TileDetails_TileType::KAIZO,
            Tile_TileDetails_TileType::STAR,
            Tile_TileDetails_TileType::START_PLATFORM,
            Tile_TileDetails_TileType::WOODEN_ARROW,
            Tile_TileDetails_TileType::BOO,
            Tile_TileDetails_TileType::SPIKE,
            Tile_TileDetails_TileType::SPECIAL,
            Tile_TileDetails_TileType::FINISH_LINE,
            Tile_TileDetails_TileType::TRACK,
            Tile_TileDetails_TileType::ICE,
            Tile_TileDetails_TileType::START,
        ];
        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::<Tile_TileDetails_TileType>("Tile.TileDetails.TileType", file_descriptor_proto())
        })
    }
}

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

impl ::std::default::Default for Tile_TileDetails_TileType {
    fn default() -> Self {
        Tile_TileDetails_TileType::UNKNOWN
    }
}

impl ::protobuf::reflect::ProtobufValue for Tile_TileDetails_TileType {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
    }
}

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub enum Tile_TileDetails_EntityType {
    STATIC = 0,
    LIVING = 1,
    PLATFORM = 65535,
}

impl ::protobuf::ProtobufEnum for Tile_TileDetails_EntityType {
    fn value(&self) -> i32 {
        *self as i32
    }

    fn from_i32(value: i32) -> ::std::option::Option<Tile_TileDetails_EntityType> {
        match value {
            0 => ::std::option::Option::Some(Tile_TileDetails_EntityType::STATIC),
            1 => ::std::option::Option::Some(Tile_TileDetails_EntityType::LIVING),
            65535 => ::std::option::Option::Some(Tile_TileDetails_EntityType::PLATFORM),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [Tile_TileDetails_EntityType] = &[
            Tile_TileDetails_EntityType::STATIC,
            Tile_TileDetails_EntityType::LIVING,
            Tile_TileDetails_EntityType::PLATFORM,
        ];
        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::<Tile_TileDetails_EntityType>("Tile.TileDetails.EntityType", file_descriptor_proto())
        })
    }
}

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

impl ::std::default::Default for Tile_TileDetails_EntityType {
    fn default() -> Self {
        Tile_TileDetails_EntityType::STATIC
    }
}

impl ::protobuf::reflect::ProtobufValue for Tile_TileDetails_EntityType {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
    }
}

static file_descriptor_proto_data: &'static [u8] = b"\
    \n\nTile.proto\x12\x05smmdb\"\xe5\x07\n\x04Tile\x12\x1f\n\ttile_data\x18\
    \x01\x20\x01(\x0cH\0R\x08tileDataB\0\x12>\n\x0ctile_details\x18\x02\x20\
    \x01(\x0b2\x17.smmdb.Tile.TileDetailsH\0R\x0btileDetailsB\0\x1a\xee\x06\
    \n\x0bTileDetails\x12\x0e\n\x01x\x18\x01\x20\x01(\x02R\x01xB\0\x12\x0e\n\
    \x01y\x18\x02\x20\x01(\x02R\x01yB\0\x12\x15\n\x05dim_x\x18\x03\x20\x01(\
    \rR\x04dimXB\0\x12\x15\n\x05dim_y\x18\x04\x20\x01(\rR\x04dimYB\0\x12\"\n\
    \x0borientation\x18\x05\x20\x01(\rR\x0borientationB\0\x12\x19\n\x07z_ind\
    ex\x18\x06\x20\x01(\rR\x06zIndexB\0\x12?\n\ttile_type\x18\x07\x20\x01(\
    \x0e2\x20.smmdb.Tile.TileDetails.TileTypeR\x08tileTypeB\0\x12E\n\x0benti\
    ty_type\x18\x08\x20\x01(\x0e2\".smmdb.Tile.TileDetails.EntityTypeR\nenti\
    tyTypeB\0\x12\x14\n\x04link\x18\t\x20\x01(\rR\x04linkB\0\x12\x10\n\x02id\
    \x18\n\x20\x01(\rR\x02idB\0\x12\x1a\n\x07costume\x18\x0b\x20\x01(\rR\x07\
    costumeB\0\x12\x1e\n\tcontainer\x18\x0c\x20\x01(\rR\tcontainerB\0\x12\
    \x1d\n\tinknown_0\x18\r\x20\x01(\rR\x08inknown0B\0\x12\x1d\n\tunknown_1\
    \x18\x0e\x20\x01(\rR\x08unknown1B\0\x12\x1d\n\tunknown_2\x18\x0f\x20\x01\
    (\rR\x08unknown2B\0\"\xce\x02\n\x08TileType\x12\x0b\n\x07UNKNOWN\x10\0\
    \x12\n\n\x06NORMAL\x10\x04\x12\x10\n\x0cQUESTIONMARK\x10\x05\x12\x08\n\
    \x04HARD\x10\x06\x12\n\n\x06GROUND\x10\x07\x12\x08\n\x04COIN\x10\x08\x12\
    \x08\n\x04PIPE\x10\t\x12\x0e\n\nBACKGROUND\x10\x10\x12\x0c\n\x08MUSHROOM\
    \x10\x14\x12\x0b\n\x07FALLING\x10\x15\x12\t\n\x05CLOUD\x10\x16\x12\x08\n\
    \x04NOTE\x10\x17\x12\x13\n\x0fFINISH_PLATFORM\x10\x1a\x12\n\n\x06FINISH\
    \x10\x1b\x12\t\n\x05KAIZO\x10\x1d\x12\x08\n\x04STAR\x10#\x12\x12\n\x0eST\
    ART_PLATFORM\x10%\x12\x10\n\x0cWOODEN_ARROW\x10&\x12\x07\n\x03BOO\x10)\
    \x12\t\n\x05SPIKE\x10+\x12\x0b\n\x07SPECIAL\x10,\x12\x0f\n\x0bFINISH_LIN\
    E\x101\x12\t\n\x05TRACK\x10;\x12\x07\n\x03ICE\x10?\x12\t\n\x05START\x10E\
    \x1a\0\"6\n\nEntityType\x12\n\n\x06STATIC\x10\0\x12\n\n\x06LIVING\x10\
    \x01\x12\x0e\n\x08PLATFORM\x10\xff\xff\x03\x1a\0:\0B\t\n\x07payload:\0B\
    \0b\x06proto3\
";

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

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 {
    file_descriptor_proto_lazy.get(|| {
        parse_descriptor_proto()
    })
}