dfhack_proto/generated/messages/

remote_fortress_reader.rs

// This file is @generated by prost-build.
#[derive(serde::Serialize)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Coord {
    #[prost(int32, optional, tag = "1")]
    pub x: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "2")]
    pub y: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "3")]
    pub z: ::core::option::Option<i32>,
}
impl ::prost::Name for Coord {
    const NAME: &'static str = "Coord";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.Coord".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.Coord".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Tiletype {
    #[prost(int32, required, tag = "1")]
    pub id: i32,
    #[prost(string, optional, tag = "2")]
    pub name: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(string, optional, tag = "3")]
    pub caption: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(enumeration = "TiletypeShape", optional, tag = "4")]
    pub shape: ::core::option::Option<i32>,
    #[prost(enumeration = "TiletypeSpecial", optional, tag = "5")]
    pub special: ::core::option::Option<i32>,
    #[prost(enumeration = "TiletypeMaterial", optional, tag = "6")]
    pub material: ::core::option::Option<i32>,
    #[prost(enumeration = "TiletypeVariant", optional, tag = "7")]
    pub variant: ::core::option::Option<i32>,
    #[prost(string, optional, tag = "8")]
    pub direction: ::core::option::Option<::prost::alloc::string::String>,
}
impl ::prost::Name for Tiletype {
    const NAME: &'static str = "Tiletype";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.Tiletype".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.Tiletype".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TiletypeList {
    #[prost(message, repeated, tag = "1")]
    pub tiletype_list: ::prost::alloc::vec::Vec<Tiletype>,
}
impl ::prost::Name for TiletypeList {
    const NAME: &'static str = "TiletypeList";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.TiletypeList".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.TiletypeList".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct BuildingExtents {
    #[prost(int32, required, tag = "1")]
    pub pos_x: i32,
    #[prost(int32, required, tag = "2")]
    pub pos_y: i32,
    #[prost(int32, required, tag = "3")]
    pub width: i32,
    #[prost(int32, required, tag = "4")]
    pub height: i32,
    #[prost(int32, repeated, packed = "false", tag = "5")]
    pub extents: ::prost::alloc::vec::Vec<i32>,
}
impl ::prost::Name for BuildingExtents {
    const NAME: &'static str = "BuildingExtents";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.BuildingExtents".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.BuildingExtents".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BuildingItem {
    #[prost(message, optional, tag = "1")]
    pub item: ::core::option::Option<Item>,
    #[prost(int32, optional, tag = "2")]
    pub mode: ::core::option::Option<i32>,
}
impl ::prost::Name for BuildingItem {
    const NAME: &'static str = "BuildingItem";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.BuildingItem".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.BuildingItem".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BuildingInstance {
    #[prost(int32, required, tag = "1")]
    pub index: i32,
    #[prost(int32, optional, tag = "2")]
    pub pos_x_min: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "3")]
    pub pos_y_min: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "4")]
    pub pos_z_min: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "5")]
    pub pos_x_max: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "6")]
    pub pos_y_max: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "7")]
    pub pos_z_max: ::core::option::Option<i32>,
    #[prost(message, optional, tag = "8")]
    pub building_type: ::core::option::Option<BuildingType>,
    #[prost(message, optional, tag = "9")]
    pub material: ::core::option::Option<MatPair>,
    #[prost(uint32, optional, tag = "10")]
    pub building_flags: ::core::option::Option<u32>,
    #[prost(bool, optional, tag = "11")]
    pub is_room: ::core::option::Option<bool>,
    #[prost(message, optional, tag = "12")]
    pub room: ::core::option::Option<BuildingExtents>,
    /// Doesn't mean anything for most buildings
    #[prost(enumeration = "BuildingDirection", optional, tag = "13")]
    pub direction: ::core::option::Option<i32>,
    #[prost(message, repeated, tag = "14")]
    pub items: ::prost::alloc::vec::Vec<BuildingItem>,
    #[prost(int32, optional, tag = "15")]
    pub active: ::core::option::Option<i32>,
}
impl ::prost::Name for BuildingInstance {
    const NAME: &'static str = "BuildingInstance";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.BuildingInstance".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.BuildingInstance".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RiverEdge {
    #[prost(int32, optional, tag = "1")]
    pub min_pos: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "2")]
    pub max_pos: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "3")]
    pub active: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "4")]
    pub elevation: ::core::option::Option<i32>,
}
impl ::prost::Name for RiverEdge {
    const NAME: &'static str = "RiverEdge";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.RiverEdge".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.RiverEdge".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RiverTile {
    #[prost(message, optional, tag = "1")]
    pub north: ::core::option::Option<RiverEdge>,
    #[prost(message, optional, tag = "2")]
    pub south: ::core::option::Option<RiverEdge>,
    #[prost(message, optional, tag = "3")]
    pub east: ::core::option::Option<RiverEdge>,
    #[prost(message, optional, tag = "4")]
    pub west: ::core::option::Option<RiverEdge>,
}
impl ::prost::Name for RiverTile {
    const NAME: &'static str = "RiverTile";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.RiverTile".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.RiverTile".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Spatter {
    #[prost(message, optional, tag = "1")]
    pub material: ::core::option::Option<MatPair>,
    #[prost(int32, optional, tag = "2")]
    pub amount: ::core::option::Option<i32>,
    #[prost(enumeration = "MatterState", optional, tag = "3")]
    pub state: ::core::option::Option<i32>,
    #[prost(message, optional, tag = "4")]
    pub item: ::core::option::Option<MatPair>,
}
impl ::prost::Name for Spatter {
    const NAME: &'static str = "Spatter";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.Spatter".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.Spatter".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SpatterPile {
    #[prost(message, repeated, tag = "1")]
    pub spatters: ::prost::alloc::vec::Vec<Spatter>,
}
impl ::prost::Name for SpatterPile {
    const NAME: &'static str = "SpatterPile";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.SpatterPile".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.SpatterPile".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Item {
    #[prost(int32, optional, tag = "1")]
    pub id: ::core::option::Option<i32>,
    #[prost(message, optional, tag = "2")]
    pub pos: ::core::option::Option<Coord>,
    #[prost(uint32, optional, tag = "3")]
    pub flags1: ::core::option::Option<u32>,
    #[prost(uint32, optional, tag = "4")]
    pub flags2: ::core::option::Option<u32>,
    #[prost(message, optional, tag = "5")]
    pub r#type: ::core::option::Option<MatPair>,
    #[prost(message, optional, tag = "6")]
    pub material: ::core::option::Option<MatPair>,
    #[prost(message, optional, tag = "7")]
    pub dye: ::core::option::Option<ColorDefinition>,
    #[prost(int32, optional, tag = "8")]
    pub stack_size: ::core::option::Option<i32>,
    #[prost(float, optional, tag = "9")]
    pub subpos_x: ::core::option::Option<f32>,
    #[prost(float, optional, tag = "10")]
    pub subpos_y: ::core::option::Option<f32>,
    #[prost(float, optional, tag = "11")]
    pub subpos_z: ::core::option::Option<f32>,
    #[prost(bool, optional, tag = "12")]
    pub projectile: ::core::option::Option<bool>,
    #[prost(float, optional, tag = "13")]
    pub velocity_x: ::core::option::Option<f32>,
    #[prost(float, optional, tag = "14")]
    pub velocity_y: ::core::option::Option<f32>,
    #[prost(float, optional, tag = "15")]
    pub velocity_z: ::core::option::Option<f32>,
    #[prost(int32, optional, tag = "16")]
    pub volume: ::core::option::Option<i32>,
    #[prost(message, repeated, tag = "17")]
    pub improvements: ::prost::alloc::vec::Vec<ItemImprovement>,
    #[prost(message, optional, tag = "18")]
    pub image: ::core::option::Option<ArtImage>,
}
impl ::prost::Name for Item {
    const NAME: &'static str = "Item";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.Item".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.Item".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct PlantTile {
    #[prost(bool, optional, tag = "1")]
    pub trunk: ::core::option::Option<bool>,
    #[prost(bool, optional, tag = "2")]
    pub connection_east: ::core::option::Option<bool>,
    #[prost(bool, optional, tag = "3")]
    pub connection_south: ::core::option::Option<bool>,
    #[prost(bool, optional, tag = "4")]
    pub connection_west: ::core::option::Option<bool>,
    #[prost(bool, optional, tag = "5")]
    pub connection_north: ::core::option::Option<bool>,
    #[prost(bool, optional, tag = "6")]
    pub branches: ::core::option::Option<bool>,
    #[prost(bool, optional, tag = "7")]
    pub twigs: ::core::option::Option<bool>,
    #[prost(enumeration = "TiletypeSpecial", optional, tag = "8")]
    pub tile_type: ::core::option::Option<i32>,
}
impl ::prost::Name for PlantTile {
    const NAME: &'static str = "PlantTile";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.PlantTile".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.PlantTile".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TreeInfo {
    #[prost(message, optional, tag = "1")]
    pub size: ::core::option::Option<Coord>,
    #[prost(message, repeated, tag = "2")]
    pub tiles: ::prost::alloc::vec::Vec<PlantTile>,
}
impl ::prost::Name for TreeInfo {
    const NAME: &'static str = "TreeInfo";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.TreeInfo".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.TreeInfo".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PlantInstance {
    #[prost(int32, optional, tag = "1")]
    pub plant_type: ::core::option::Option<i32>,
    #[prost(message, optional, tag = "2")]
    pub pos: ::core::option::Option<Coord>,
    #[prost(message, optional, tag = "3")]
    pub tree_info: ::core::option::Option<TreeInfo>,
}
impl ::prost::Name for PlantInstance {
    const NAME: &'static str = "PlantInstance";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.PlantInstance".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.PlantInstance".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MapBlock {
    #[prost(int32, required, tag = "1")]
    pub map_x: i32,
    #[prost(int32, required, tag = "2")]
    pub map_y: i32,
    #[prost(int32, required, tag = "3")]
    pub map_z: i32,
    #[prost(int32, repeated, packed = "false", tag = "4")]
    pub tiles: ::prost::alloc::vec::Vec<i32>,
    #[prost(message, repeated, tag = "5")]
    pub materials: ::prost::alloc::vec::Vec<MatPair>,
    #[prost(message, repeated, tag = "6")]
    pub layer_materials: ::prost::alloc::vec::Vec<MatPair>,
    #[prost(message, repeated, tag = "7")]
    pub vein_materials: ::prost::alloc::vec::Vec<MatPair>,
    #[prost(message, repeated, tag = "8")]
    pub base_materials: ::prost::alloc::vec::Vec<MatPair>,
    #[prost(int32, repeated, packed = "false", tag = "9")]
    pub magma: ::prost::alloc::vec::Vec<i32>,
    #[prost(int32, repeated, packed = "false", tag = "10")]
    pub water: ::prost::alloc::vec::Vec<i32>,
    #[prost(bool, repeated, packed = "false", tag = "11")]
    pub hidden: ::prost::alloc::vec::Vec<bool>,
    #[prost(bool, repeated, packed = "false", tag = "12")]
    pub light: ::prost::alloc::vec::Vec<bool>,
    #[prost(bool, repeated, packed = "false", tag = "13")]
    pub subterranean: ::prost::alloc::vec::Vec<bool>,
    #[prost(bool, repeated, packed = "false", tag = "14")]
    pub outside: ::prost::alloc::vec::Vec<bool>,
    #[prost(bool, repeated, packed = "false", tag = "15")]
    pub aquifer: ::prost::alloc::vec::Vec<bool>,
    #[prost(bool, repeated, packed = "false", tag = "16")]
    pub water_stagnant: ::prost::alloc::vec::Vec<bool>,
    #[prost(bool, repeated, packed = "false", tag = "17")]
    pub water_salt: ::prost::alloc::vec::Vec<bool>,
    #[prost(message, repeated, tag = "18")]
    pub construction_items: ::prost::alloc::vec::Vec<MatPair>,
    #[prost(message, repeated, tag = "19")]
    pub buildings: ::prost::alloc::vec::Vec<BuildingInstance>,
    #[prost(int32, repeated, packed = "false", tag = "20")]
    pub tree_percent: ::prost::alloc::vec::Vec<i32>,
    #[prost(int32, repeated, packed = "false", tag = "21")]
    pub tree_x: ::prost::alloc::vec::Vec<i32>,
    #[prost(int32, repeated, packed = "false", tag = "22")]
    pub tree_y: ::prost::alloc::vec::Vec<i32>,
    #[prost(int32, repeated, packed = "false", tag = "23")]
    pub tree_z: ::prost::alloc::vec::Vec<i32>,
    #[prost(enumeration = "TileDigDesignation", repeated, packed = "false", tag = "24")]
    pub tile_dig_designation: ::prost::alloc::vec::Vec<i32>,
    #[prost(message, repeated, tag = "25")]
    pub spatter_pile: ::prost::alloc::vec::Vec<SpatterPile>,
    #[prost(message, repeated, tag = "26")]
    pub items: ::prost::alloc::vec::Vec<Item>,
    #[prost(bool, repeated, packed = "false", tag = "27")]
    pub tile_dig_designation_marker: ::prost::alloc::vec::Vec<bool>,
    #[prost(bool, repeated, packed = "false", tag = "28")]
    pub tile_dig_designation_auto: ::prost::alloc::vec::Vec<bool>,
    #[prost(int32, repeated, packed = "false", tag = "29")]
    pub grass_percent: ::prost::alloc::vec::Vec<i32>,
    #[prost(message, repeated, tag = "30")]
    pub flows: ::prost::alloc::vec::Vec<FlowInfo>,
}
impl ::prost::Name for MapBlock {
    const NAME: &'static str = "MapBlock";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.MapBlock".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.MapBlock".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct MatPair {
    #[prost(int32, required, tag = "1")]
    pub mat_type: i32,
    #[prost(int32, required, tag = "2")]
    pub mat_index: i32,
}
impl ::prost::Name for MatPair {
    const NAME: &'static str = "MatPair";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.MatPair".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.MatPair".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ColorDefinition {
    #[prost(int32, required, tag = "1")]
    pub red: i32,
    #[prost(int32, required, tag = "2")]
    pub green: i32,
    #[prost(int32, required, tag = "3")]
    pub blue: i32,
}
impl ::prost::Name for ColorDefinition {
    const NAME: &'static str = "ColorDefinition";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.ColorDefinition".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.ColorDefinition".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MaterialDefinition {
    #[prost(message, required, tag = "1")]
    pub mat_pair: MatPair,
    #[prost(string, optional, tag = "2")]
    pub id: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(bytes = "vec", optional, tag = "3")]
    pub name: ::core::option::Option<::prost::alloc::vec::Vec<u8>>,
    /// Simplifying colors to assume room temperature.
    #[prost(message, optional, tag = "4")]
    pub state_color: ::core::option::Option<ColorDefinition>,
    #[prost(message, optional, tag = "5")]
    pub instrument: ::core::option::Option<super::itemdef_instrument::InstrumentDef>,
    #[prost(int32, optional, tag = "6")]
    pub up_step: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "7")]
    pub down_step: ::core::option::Option<i32>,
    #[prost(enumeration = "ArmorLayer", optional, tag = "8")]
    pub layer: ::core::option::Option<i32>,
}
impl ::prost::Name for MaterialDefinition {
    const NAME: &'static str = "MaterialDefinition";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.MaterialDefinition".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.MaterialDefinition".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct BuildingType {
    #[prost(int32, required, tag = "1")]
    pub building_type: i32,
    #[prost(int32, required, tag = "2")]
    pub building_subtype: i32,
    #[prost(int32, required, tag = "3")]
    pub building_custom: i32,
}
impl ::prost::Name for BuildingType {
    const NAME: &'static str = "BuildingType";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.BuildingType".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.BuildingType".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct BuildingDefinition {
    #[prost(message, required, tag = "1")]
    pub building_type: BuildingType,
    #[prost(string, optional, tag = "2")]
    pub id: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(string, optional, tag = "3")]
    pub name: ::core::option::Option<::prost::alloc::string::String>,
}
impl ::prost::Name for BuildingDefinition {
    const NAME: &'static str = "BuildingDefinition";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.BuildingDefinition".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.BuildingDefinition".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BuildingList {
    #[prost(message, repeated, tag = "1")]
    pub building_list: ::prost::alloc::vec::Vec<BuildingDefinition>,
}
impl ::prost::Name for BuildingList {
    const NAME: &'static str = "BuildingList";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.BuildingList".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.BuildingList".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MaterialList {
    #[prost(message, repeated, tag = "1")]
    pub material_list: ::prost::alloc::vec::Vec<MaterialDefinition>,
}
impl ::prost::Name for MaterialList {
    const NAME: &'static str = "MaterialList";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.MaterialList".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.MaterialList".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Hair {
    #[prost(int32, optional, tag = "1")]
    pub length: ::core::option::Option<i32>,
    #[prost(enumeration = "HairStyle", optional, tag = "2")]
    pub style: ::core::option::Option<i32>,
}
impl ::prost::Name for Hair {
    const NAME: &'static str = "Hair";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.Hair".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.Hair".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct BodySizeInfo {
    #[prost(int32, optional, tag = "1")]
    pub size_cur: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "2")]
    pub size_base: ::core::option::Option<i32>,
    /// !< size_cur^0.666
    #[prost(int32, optional, tag = "3")]
    pub area_cur: ::core::option::Option<i32>,
    /// !< size_base^0.666
    #[prost(int32, optional, tag = "4")]
    pub area_base: ::core::option::Option<i32>,
    /// !< (size_cur*10000)^0.333
    #[prost(int32, optional, tag = "5")]
    pub length_cur: ::core::option::Option<i32>,
    /// !< (size_base*10000)^0.333
    #[prost(int32, optional, tag = "6")]
    pub length_base: ::core::option::Option<i32>,
}
impl ::prost::Name for BodySizeInfo {
    const NAME: &'static str = "BodySizeInfo";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.BodySizeInfo".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.BodySizeInfo".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct UnitAppearance {
    #[prost(int32, repeated, packed = "false", tag = "1")]
    pub body_modifiers: ::prost::alloc::vec::Vec<i32>,
    #[prost(int32, repeated, packed = "false", tag = "2")]
    pub bp_modifiers: ::prost::alloc::vec::Vec<i32>,
    #[prost(int32, optional, tag = "3")]
    pub size_modifier: ::core::option::Option<i32>,
    #[prost(int32, repeated, packed = "false", tag = "4")]
    pub colors: ::prost::alloc::vec::Vec<i32>,
    #[prost(message, optional, tag = "5")]
    pub hair: ::core::option::Option<Hair>,
    #[prost(message, optional, tag = "6")]
    pub beard: ::core::option::Option<Hair>,
    #[prost(message, optional, tag = "7")]
    pub moustache: ::core::option::Option<Hair>,
    #[prost(message, optional, tag = "8")]
    pub sideburns: ::core::option::Option<Hair>,
    #[prost(string, optional, tag = "9")]
    pub physical_description: ::core::option::Option<::prost::alloc::string::String>,
}
impl ::prost::Name for UnitAppearance {
    const NAME: &'static str = "UnitAppearance";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.UnitAppearance".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.UnitAppearance".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct InventoryItem {
    #[prost(enumeration = "InventoryMode", optional, tag = "1")]
    pub mode: ::core::option::Option<i32>,
    #[prost(message, optional, tag = "2")]
    pub item: ::core::option::Option<Item>,
    #[prost(int32, optional, tag = "3")]
    pub body_part_id: ::core::option::Option<i32>,
}
impl ::prost::Name for InventoryItem {
    const NAME: &'static str = "InventoryItem";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.InventoryItem".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.InventoryItem".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct WoundPart {
    #[prost(int32, optional, tag = "1")]
    pub global_layer_idx: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "2")]
    pub body_part_id: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "3")]
    pub layer_idx: ::core::option::Option<i32>,
}
impl ::prost::Name for WoundPart {
    const NAME: &'static str = "WoundPart";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.WoundPart".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.WoundPart".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UnitWound {
    #[prost(message, repeated, tag = "1")]
    pub parts: ::prost::alloc::vec::Vec<WoundPart>,
    #[prost(bool, optional, tag = "2")]
    pub severed_part: ::core::option::Option<bool>,
}
impl ::prost::Name for UnitWound {
    const NAME: &'static str = "UnitWound";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.UnitWound".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.UnitWound".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UnitDefinition {
    #[prost(int32, required, tag = "1")]
    pub id: i32,
    #[prost(bool, optional, tag = "2")]
    pub is_valid: ::core::option::Option<bool>,
    #[prost(int32, optional, tag = "3")]
    pub pos_x: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "4")]
    pub pos_y: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "5")]
    pub pos_z: ::core::option::Option<i32>,
    #[prost(message, optional, tag = "6")]
    pub race: ::core::option::Option<MatPair>,
    #[prost(message, optional, tag = "7")]
    pub profession_color: ::core::option::Option<ColorDefinition>,
    #[prost(uint32, optional, tag = "8")]
    pub flags1: ::core::option::Option<u32>,
    #[prost(uint32, optional, tag = "9")]
    pub flags2: ::core::option::Option<u32>,
    #[prost(uint32, optional, tag = "10")]
    pub flags3: ::core::option::Option<u32>,
    #[prost(bool, optional, tag = "11")]
    pub is_soldier: ::core::option::Option<bool>,
    #[prost(message, optional, tag = "12")]
    pub size_info: ::core::option::Option<BodySizeInfo>,
    #[prost(string, optional, tag = "13")]
    pub name: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(int32, optional, tag = "14")]
    pub blood_max: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "15")]
    pub blood_count: ::core::option::Option<i32>,
    #[prost(message, optional, tag = "16")]
    pub appearance: ::core::option::Option<UnitAppearance>,
    #[prost(int32, optional, tag = "17")]
    pub profession_id: ::core::option::Option<i32>,
    #[prost(string, repeated, tag = "18")]
    pub noble_positions: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    #[prost(int32, optional, tag = "19")]
    pub rider_id: ::core::option::Option<i32>,
    #[prost(message, repeated, tag = "20")]
    pub inventory: ::prost::alloc::vec::Vec<InventoryItem>,
    #[prost(float, optional, tag = "21")]
    pub subpos_x: ::core::option::Option<f32>,
    #[prost(float, optional, tag = "22")]
    pub subpos_y: ::core::option::Option<f32>,
    #[prost(float, optional, tag = "23")]
    pub subpos_z: ::core::option::Option<f32>,
    #[prost(message, optional, tag = "24")]
    pub facing: ::core::option::Option<Coord>,
    #[prost(int32, optional, tag = "25")]
    pub age: ::core::option::Option<i32>,
    #[prost(message, repeated, tag = "26")]
    pub wounds: ::prost::alloc::vec::Vec<UnitWound>,
}
impl ::prost::Name for UnitDefinition {
    const NAME: &'static str = "UnitDefinition";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.UnitDefinition".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.UnitDefinition".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UnitList {
    #[prost(message, repeated, tag = "1")]
    pub creature_list: ::prost::alloc::vec::Vec<UnitDefinition>,
}
impl ::prost::Name for UnitList {
    const NAME: &'static str = "UnitList";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.UnitList".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.UnitList".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct BlockRequest {
    #[prost(int32, optional, tag = "1")]
    pub blocks_needed: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "2")]
    pub min_x: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "3")]
    pub max_x: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "4")]
    pub min_y: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "5")]
    pub max_y: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "6")]
    pub min_z: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "7")]
    pub max_z: ::core::option::Option<i32>,
    #[prost(bool, optional, tag = "8")]
    pub force_reload: ::core::option::Option<bool>,
}
impl ::prost::Name for BlockRequest {
    const NAME: &'static str = "BlockRequest";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.BlockRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.BlockRequest".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BlockList {
    #[prost(message, repeated, tag = "1")]
    pub map_blocks: ::prost::alloc::vec::Vec<MapBlock>,
    #[prost(int32, optional, tag = "2")]
    pub map_x: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "3")]
    pub map_y: ::core::option::Option<i32>,
    #[prost(message, repeated, tag = "4")]
    pub engravings: ::prost::alloc::vec::Vec<Engraving>,
    #[prost(message, repeated, tag = "5")]
    pub ocean_waves: ::prost::alloc::vec::Vec<Wave>,
}
impl ::prost::Name for BlockList {
    const NAME: &'static str = "BlockList";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.BlockList".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.BlockList".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct PlantDef {
    #[prost(int32, required, tag = "1")]
    pub pos_x: i32,
    #[prost(int32, required, tag = "2")]
    pub pos_y: i32,
    #[prost(int32, required, tag = "3")]
    pub pos_z: i32,
    #[prost(int32, required, tag = "4")]
    pub index: i32,
}
impl ::prost::Name for PlantDef {
    const NAME: &'static str = "PlantDef";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.PlantDef".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.PlantDef".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PlantList {
    #[prost(message, repeated, tag = "1")]
    pub plant_list: ::prost::alloc::vec::Vec<PlantDef>,
}
impl ::prost::Name for PlantList {
    const NAME: &'static str = "PlantList";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.PlantList".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.PlantList".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ViewInfo {
    #[prost(int32, optional, tag = "1")]
    pub view_pos_x: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "2")]
    pub view_pos_y: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "3")]
    pub view_pos_z: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "4")]
    pub view_size_x: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "5")]
    pub view_size_y: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "6")]
    pub cursor_pos_x: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "7")]
    pub cursor_pos_y: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "8")]
    pub cursor_pos_z: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "9", default = "-1")]
    pub follow_unit_id: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "10", default = "-1")]
    pub follow_item_id: ::core::option::Option<i32>,
}
impl ::prost::Name for ViewInfo {
    const NAME: &'static str = "ViewInfo";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.ViewInfo".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.ViewInfo".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct MapInfo {
    #[prost(int32, optional, tag = "1")]
    pub block_size_x: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "2")]
    pub block_size_y: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "3")]
    pub block_size_z: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "4")]
    pub block_pos_x: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "5")]
    pub block_pos_y: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "6")]
    pub block_pos_z: ::core::option::Option<i32>,
    #[prost(string, optional, tag = "7")]
    pub world_name: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(string, optional, tag = "8")]
    pub world_name_english: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(string, optional, tag = "9")]
    pub save_name: ::core::option::Option<::prost::alloc::string::String>,
}
impl ::prost::Name for MapInfo {
    const NAME: &'static str = "MapInfo";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.MapInfo".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.MapInfo".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Cloud {
    #[prost(enumeration = "FrontType", optional, tag = "1")]
    pub front: ::core::option::Option<i32>,
    #[prost(enumeration = "CumulusType", optional, tag = "2")]
    pub cumulus: ::core::option::Option<i32>,
    #[prost(bool, optional, tag = "3")]
    pub cirrus: ::core::option::Option<bool>,
    #[prost(enumeration = "StratusType", optional, tag = "4")]
    pub stratus: ::core::option::Option<i32>,
    #[prost(enumeration = "FogType", optional, tag = "5")]
    pub fog: ::core::option::Option<i32>,
}
impl ::prost::Name for Cloud {
    const NAME: &'static str = "Cloud";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.Cloud".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.Cloud".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct WorldMap {
    #[prost(int32, required, tag = "1")]
    pub world_width: i32,
    #[prost(int32, required, tag = "2")]
    pub world_height: i32,
    #[prost(bytes = "vec", optional, tag = "3")]
    pub name: ::core::option::Option<::prost::alloc::vec::Vec<u8>>,
    #[prost(string, optional, tag = "4")]
    pub name_english: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(int32, repeated, packed = "false", tag = "5")]
    pub elevation: ::prost::alloc::vec::Vec<i32>,
    #[prost(int32, repeated, packed = "false", tag = "6")]
    pub rainfall: ::prost::alloc::vec::Vec<i32>,
    #[prost(int32, repeated, packed = "false", tag = "7")]
    pub vegetation: ::prost::alloc::vec::Vec<i32>,
    #[prost(int32, repeated, packed = "false", tag = "8")]
    pub temperature: ::prost::alloc::vec::Vec<i32>,
    #[prost(int32, repeated, packed = "false", tag = "9")]
    pub evilness: ::prost::alloc::vec::Vec<i32>,
    #[prost(int32, repeated, packed = "false", tag = "10")]
    pub drainage: ::prost::alloc::vec::Vec<i32>,
    #[prost(int32, repeated, packed = "false", tag = "11")]
    pub volcanism: ::prost::alloc::vec::Vec<i32>,
    #[prost(int32, repeated, packed = "false", tag = "12")]
    pub savagery: ::prost::alloc::vec::Vec<i32>,
    #[prost(message, repeated, tag = "13")]
    pub clouds: ::prost::alloc::vec::Vec<Cloud>,
    #[prost(int32, repeated, packed = "false", tag = "14")]
    pub salinity: ::prost::alloc::vec::Vec<i32>,
    #[prost(int32, optional, tag = "15")]
    pub map_x: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "16")]
    pub map_y: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "17")]
    pub center_x: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "18")]
    pub center_y: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "19")]
    pub center_z: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "20")]
    pub cur_year: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "21")]
    pub cur_year_tick: ::core::option::Option<i32>,
    #[prost(enumeration = "WorldPoles", optional, tag = "22")]
    pub world_poles: ::core::option::Option<i32>,
    #[prost(message, repeated, tag = "23")]
    pub river_tiles: ::prost::alloc::vec::Vec<RiverTile>,
    #[prost(int32, repeated, packed = "false", tag = "24")]
    pub water_elevation: ::prost::alloc::vec::Vec<i32>,
    #[prost(message, repeated, tag = "25")]
    pub region_tiles: ::prost::alloc::vec::Vec<RegionTile>,
}
impl ::prost::Name for WorldMap {
    const NAME: &'static str = "WorldMap";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.WorldMap".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.WorldMap".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SiteRealizationBuildingWall {
    #[prost(int32, optional, tag = "1")]
    pub start_x: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "2")]
    pub start_y: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "3")]
    pub start_z: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "4")]
    pub end_x: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "5")]
    pub end_y: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "6")]
    pub end_z: ::core::option::Option<i32>,
}
impl ::prost::Name for SiteRealizationBuildingWall {
    const NAME: &'static str = "SiteRealizationBuildingWall";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.SiteRealizationBuildingWall".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.SiteRealizationBuildingWall".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SiteRealizationBuildingTower {
    #[prost(int32, optional, tag = "1")]
    pub roof_z: ::core::option::Option<i32>,
    #[prost(bool, optional, tag = "2")]
    pub round: ::core::option::Option<bool>,
    #[prost(bool, optional, tag = "3")]
    pub goblin: ::core::option::Option<bool>,
}
impl ::prost::Name for SiteRealizationBuildingTower {
    const NAME: &'static str = "SiteRealizationBuildingTower";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.SiteRealizationBuildingTower".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.SiteRealizationBuildingTower".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct TrenchSpoke {
    #[prost(int32, optional, tag = "1")]
    pub mound_start: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "2")]
    pub trench_start: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "3")]
    pub trench_end: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "4")]
    pub mound_end: ::core::option::Option<i32>,
}
impl ::prost::Name for TrenchSpoke {
    const NAME: &'static str = "TrenchSpoke";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.TrenchSpoke".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.TrenchSpoke".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SiteRealizationBuildingTrenches {
    #[prost(message, repeated, tag = "1")]
    pub spokes: ::prost::alloc::vec::Vec<TrenchSpoke>,
}
impl ::prost::Name for SiteRealizationBuildingTrenches {
    const NAME: &'static str = "SiteRealizationBuildingTrenches";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.SiteRealizationBuildingTrenches".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.SiteRealizationBuildingTrenches".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SiteRealizationBuilding {
    #[prost(int32, optional, tag = "1")]
    pub id: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "3")]
    pub min_x: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "4")]
    pub min_y: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "5")]
    pub max_x: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "6")]
    pub max_y: ::core::option::Option<i32>,
    #[prost(message, optional, tag = "7")]
    pub material: ::core::option::Option<MatPair>,
    #[prost(message, optional, tag = "8")]
    pub wall_info: ::core::option::Option<SiteRealizationBuildingWall>,
    #[prost(message, optional, tag = "9")]
    pub tower_info: ::core::option::Option<SiteRealizationBuildingTower>,
    #[prost(message, optional, tag = "10")]
    pub trench_info: ::core::option::Option<SiteRealizationBuildingTrenches>,
    #[prost(int32, optional, tag = "11")]
    pub r#type: ::core::option::Option<i32>,
}
impl ::prost::Name for SiteRealizationBuilding {
    const NAME: &'static str = "SiteRealizationBuilding";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.SiteRealizationBuilding".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.SiteRealizationBuilding".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RegionTile {
    #[prost(int32, optional, tag = "1")]
    pub elevation: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "2")]
    pub rainfall: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "3")]
    pub vegetation: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "4")]
    pub temperature: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "5")]
    pub evilness: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "6")]
    pub drainage: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "7")]
    pub volcanism: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "8")]
    pub savagery: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "9")]
    pub salinity: ::core::option::Option<i32>,
    #[prost(message, optional, tag = "10")]
    pub river_tiles: ::core::option::Option<RiverTile>,
    #[prost(int32, optional, tag = "11")]
    pub water_elevation: ::core::option::Option<i32>,
    #[prost(message, optional, tag = "12")]
    pub surface_material: ::core::option::Option<MatPair>,
    #[prost(message, repeated, tag = "13")]
    pub plant_materials: ::prost::alloc::vec::Vec<MatPair>,
    #[prost(message, repeated, tag = "14")]
    pub buildings: ::prost::alloc::vec::Vec<SiteRealizationBuilding>,
    #[prost(message, repeated, tag = "15")]
    pub stone_materials: ::prost::alloc::vec::Vec<MatPair>,
    #[prost(message, repeated, tag = "16")]
    pub tree_materials: ::prost::alloc::vec::Vec<MatPair>,
    #[prost(int32, optional, tag = "17")]
    pub snow: ::core::option::Option<i32>,
}
impl ::prost::Name for RegionTile {
    const NAME: &'static str = "RegionTile";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.RegionTile".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.RegionTile".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RegionMap {
    #[prost(int32, optional, tag = "1")]
    pub map_x: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "2")]
    pub map_y: ::core::option::Option<i32>,
    #[prost(string, optional, tag = "3")]
    pub name: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(string, optional, tag = "4")]
    pub name_english: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, repeated, tag = "5")]
    pub tiles: ::prost::alloc::vec::Vec<RegionTile>,
}
impl ::prost::Name for RegionMap {
    const NAME: &'static str = "RegionMap";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.RegionMap".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.RegionMap".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RegionMaps {
    #[prost(message, repeated, tag = "1")]
    pub world_maps: ::prost::alloc::vec::Vec<WorldMap>,
    #[prost(message, repeated, tag = "2")]
    pub region_maps: ::prost::alloc::vec::Vec<RegionMap>,
}
impl ::prost::Name for RegionMaps {
    const NAME: &'static str = "RegionMaps";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.RegionMaps".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.RegionMaps".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PatternDescriptor {
    #[prost(string, optional, tag = "1")]
    pub id: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, repeated, tag = "2")]
    pub colors: ::prost::alloc::vec::Vec<ColorDefinition>,
    #[prost(enumeration = "PatternType", optional, tag = "3")]
    pub pattern: ::core::option::Option<i32>,
}
impl ::prost::Name for PatternDescriptor {
    const NAME: &'static str = "PatternDescriptor";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.PatternDescriptor".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.PatternDescriptor".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ColorModifierRaw {
    #[prost(message, repeated, tag = "1")]
    pub patterns: ::prost::alloc::vec::Vec<PatternDescriptor>,
    #[prost(int32, repeated, packed = "false", tag = "2")]
    pub body_part_id: ::prost::alloc::vec::Vec<i32>,
    #[prost(int32, repeated, packed = "false", tag = "3")]
    pub tissue_layer_id: ::prost::alloc::vec::Vec<i32>,
    #[prost(int32, optional, tag = "4")]
    pub start_date: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "5")]
    pub end_date: ::core::option::Option<i32>,
    #[prost(string, optional, tag = "6")]
    pub part: ::core::option::Option<::prost::alloc::string::String>,
}
impl ::prost::Name for ColorModifierRaw {
    const NAME: &'static str = "ColorModifierRaw";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.ColorModifierRaw".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.ColorModifierRaw".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct BodyPartLayerRaw {
    #[prost(string, optional, tag = "1")]
    pub layer_name: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(int32, optional, tag = "2")]
    pub tissue_id: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "3")]
    pub layer_depth: ::core::option::Option<i32>,
    #[prost(int32, repeated, packed = "false", tag = "4")]
    pub bp_modifiers: ::prost::alloc::vec::Vec<i32>,
}
impl ::prost::Name for BodyPartLayerRaw {
    const NAME: &'static str = "BodyPartLayerRaw";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.BodyPartLayerRaw".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.BodyPartLayerRaw".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BodyPartRaw {
    #[prost(string, optional, tag = "1")]
    pub token: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(string, optional, tag = "2")]
    pub category: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(int32, optional, tag = "3")]
    pub parent: ::core::option::Option<i32>,
    #[prost(bool, repeated, packed = "false", tag = "4")]
    pub flags: ::prost::alloc::vec::Vec<bool>,
    #[prost(message, repeated, tag = "5")]
    pub layers: ::prost::alloc::vec::Vec<BodyPartLayerRaw>,
    #[prost(int32, optional, tag = "6")]
    pub relsize: ::core::option::Option<i32>,
}
impl ::prost::Name for BodyPartRaw {
    const NAME: &'static str = "BodyPartRaw";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.BodyPartRaw".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.BodyPartRaw".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct BpAppearanceModifier {
    #[prost(string, optional, tag = "1")]
    pub r#type: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(int32, optional, tag = "2")]
    pub mod_min: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "3")]
    pub mod_max: ::core::option::Option<i32>,
}
impl ::prost::Name for BpAppearanceModifier {
    const NAME: &'static str = "BpAppearanceModifier";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.BpAppearanceModifier".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.BpAppearanceModifier".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct TissueRaw {
    #[prost(string, optional, tag = "1")]
    pub id: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(string, optional, tag = "2")]
    pub name: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "3")]
    pub material: ::core::option::Option<MatPair>,
    #[prost(string, optional, tag = "4")]
    pub subordinate_to_tissue: ::core::option::Option<::prost::alloc::string::String>,
}
impl ::prost::Name for TissueRaw {
    const NAME: &'static str = "TissueRaw";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.TissueRaw".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.TissueRaw".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CasteRaw {
    #[prost(int32, optional, tag = "1")]
    pub index: ::core::option::Option<i32>,
    #[prost(string, optional, tag = "2")]
    pub caste_id: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(string, repeated, tag = "3")]
    pub caste_name: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    #[prost(string, repeated, tag = "4")]
    pub baby_name: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    #[prost(string, repeated, tag = "5")]
    pub child_name: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    #[prost(int32, optional, tag = "6")]
    pub gender: ::core::option::Option<i32>,
    #[prost(message, repeated, tag = "7")]
    pub body_parts: ::prost::alloc::vec::Vec<BodyPartRaw>,
    #[prost(int32, optional, tag = "8")]
    pub total_relsize: ::core::option::Option<i32>,
    #[prost(message, repeated, tag = "9")]
    pub modifiers: ::prost::alloc::vec::Vec<BpAppearanceModifier>,
    #[prost(int32, repeated, packed = "false", tag = "10")]
    pub modifier_idx: ::prost::alloc::vec::Vec<i32>,
    #[prost(int32, repeated, packed = "false", tag = "11")]
    pub part_idx: ::prost::alloc::vec::Vec<i32>,
    #[prost(int32, repeated, packed = "false", tag = "12")]
    pub layer_idx: ::prost::alloc::vec::Vec<i32>,
    #[prost(message, repeated, tag = "13")]
    pub body_appearance_modifiers: ::prost::alloc::vec::Vec<BpAppearanceModifier>,
    #[prost(message, repeated, tag = "14")]
    pub color_modifiers: ::prost::alloc::vec::Vec<ColorModifierRaw>,
    #[prost(string, optional, tag = "15")]
    pub description: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(int32, optional, tag = "16")]
    pub adult_size: ::core::option::Option<i32>,
}
impl ::prost::Name for CasteRaw {
    const NAME: &'static str = "CasteRaw";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.CasteRaw".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.CasteRaw".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreatureRaw {
    #[prost(int32, optional, tag = "1")]
    pub index: ::core::option::Option<i32>,
    #[prost(string, optional, tag = "2")]
    pub creature_id: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(string, repeated, tag = "3")]
    pub name: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    #[prost(string, repeated, tag = "4")]
    pub general_baby_name: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    #[prost(string, repeated, tag = "5")]
    pub general_child_name: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    #[prost(int32, optional, tag = "6")]
    pub creature_tile: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "7")]
    pub creature_soldier_tile: ::core::option::Option<i32>,
    #[prost(message, optional, tag = "8")]
    pub color: ::core::option::Option<ColorDefinition>,
    #[prost(int32, optional, tag = "9")]
    pub adultsize: ::core::option::Option<i32>,
    #[prost(message, repeated, tag = "10")]
    pub caste: ::prost::alloc::vec::Vec<CasteRaw>,
    #[prost(message, repeated, tag = "11")]
    pub tissues: ::prost::alloc::vec::Vec<TissueRaw>,
    #[prost(bool, repeated, packed = "false", tag = "12")]
    pub flags: ::prost::alloc::vec::Vec<bool>,
}
impl ::prost::Name for CreatureRaw {
    const NAME: &'static str = "CreatureRaw";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.CreatureRaw".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.CreatureRaw".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreatureRawList {
    #[prost(message, repeated, tag = "1")]
    pub creature_raws: ::prost::alloc::vec::Vec<CreatureRaw>,
}
impl ::prost::Name for CreatureRawList {
    const NAME: &'static str = "CreatureRawList";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.CreatureRawList".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.CreatureRawList".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Army {
    #[prost(int32, optional, tag = "1")]
    pub id: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "2")]
    pub pos_x: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "3")]
    pub pos_y: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "4")]
    pub pos_z: ::core::option::Option<i32>,
    #[prost(message, optional, tag = "5")]
    pub leader: ::core::option::Option<UnitDefinition>,
    #[prost(message, repeated, tag = "6")]
    pub members: ::prost::alloc::vec::Vec<UnitDefinition>,
    #[prost(uint32, optional, tag = "7")]
    pub flags: ::core::option::Option<u32>,
}
impl ::prost::Name for Army {
    const NAME: &'static str = "Army";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.Army".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.Army".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ArmyList {
    #[prost(message, repeated, tag = "1")]
    pub armies: ::prost::alloc::vec::Vec<Army>,
}
impl ::prost::Name for ArmyList {
    const NAME: &'static str = "ArmyList";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.ArmyList".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.ArmyList".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GrowthPrint {
    #[prost(int32, optional, tag = "1")]
    pub priority: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "2")]
    pub color: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "3")]
    pub timing_start: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "4")]
    pub timing_end: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "5")]
    pub tile: ::core::option::Option<i32>,
}
impl ::prost::Name for GrowthPrint {
    const NAME: &'static str = "GrowthPrint";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.GrowthPrint".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.GrowthPrint".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TreeGrowth {
    #[prost(int32, optional, tag = "1")]
    pub index: ::core::option::Option<i32>,
    #[prost(string, optional, tag = "2")]
    pub id: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(string, optional, tag = "3")]
    pub name: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "4")]
    pub mat: ::core::option::Option<MatPair>,
    #[prost(message, repeated, tag = "5")]
    pub prints: ::prost::alloc::vec::Vec<GrowthPrint>,
    #[prost(int32, optional, tag = "6")]
    pub timing_start: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "7")]
    pub timing_end: ::core::option::Option<i32>,
    #[prost(bool, optional, tag = "8")]
    pub twigs: ::core::option::Option<bool>,
    #[prost(bool, optional, tag = "9")]
    pub light_branches: ::core::option::Option<bool>,
    #[prost(bool, optional, tag = "10")]
    pub heavy_branches: ::core::option::Option<bool>,
    #[prost(bool, optional, tag = "11")]
    pub trunk: ::core::option::Option<bool>,
    #[prost(bool, optional, tag = "12")]
    pub roots: ::core::option::Option<bool>,
    #[prost(bool, optional, tag = "13")]
    pub cap: ::core::option::Option<bool>,
    #[prost(bool, optional, tag = "14")]
    pub sapling: ::core::option::Option<bool>,
    #[prost(int32, optional, tag = "15")]
    pub trunk_height_start: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "16")]
    pub trunk_height_end: ::core::option::Option<i32>,
}
impl ::prost::Name for TreeGrowth {
    const NAME: &'static str = "TreeGrowth";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.TreeGrowth".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.TreeGrowth".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PlantRaw {
    #[prost(int32, optional, tag = "1")]
    pub index: ::core::option::Option<i32>,
    #[prost(string, optional, tag = "2")]
    pub id: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(string, optional, tag = "3")]
    pub name: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, repeated, tag = "4")]
    pub growths: ::prost::alloc::vec::Vec<TreeGrowth>,
    #[prost(int32, optional, tag = "5")]
    pub tile: ::core::option::Option<i32>,
}
impl ::prost::Name for PlantRaw {
    const NAME: &'static str = "PlantRaw";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.PlantRaw".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.PlantRaw".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PlantRawList {
    #[prost(message, repeated, tag = "1")]
    pub plant_raws: ::prost::alloc::vec::Vec<PlantRaw>,
}
impl ::prost::Name for PlantRawList {
    const NAME: &'static str = "PlantRawList";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.PlantRawList".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.PlantRawList".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ScreenTile {
    #[prost(uint32, optional, tag = "1")]
    pub character: ::core::option::Option<u32>,
    #[prost(uint32, optional, tag = "2")]
    pub foreground: ::core::option::Option<u32>,
    #[prost(uint32, optional, tag = "3")]
    pub background: ::core::option::Option<u32>,
}
impl ::prost::Name for ScreenTile {
    const NAME: &'static str = "ScreenTile";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.ScreenTile".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.ScreenTile".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ScreenCapture {
    #[prost(uint32, optional, tag = "1")]
    pub width: ::core::option::Option<u32>,
    #[prost(uint32, optional, tag = "2")]
    pub height: ::core::option::Option<u32>,
    #[prost(message, repeated, tag = "3")]
    pub tiles: ::prost::alloc::vec::Vec<ScreenTile>,
}
impl ::prost::Name for ScreenCapture {
    const NAME: &'static str = "ScreenCapture";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.ScreenCapture".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.ScreenCapture".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct KeyboardEvent {
    #[prost(uint32, optional, tag = "1")]
    pub r#type: ::core::option::Option<u32>,
    #[prost(uint32, optional, tag = "2")]
    pub which: ::core::option::Option<u32>,
    #[prost(uint32, optional, tag = "3")]
    pub state: ::core::option::Option<u32>,
    #[prost(uint32, optional, tag = "4")]
    pub scancode: ::core::option::Option<u32>,
    #[prost(uint32, optional, tag = "5")]
    pub sym: ::core::option::Option<u32>,
    #[prost(uint32, optional, tag = "6")]
    pub r#mod: ::core::option::Option<u32>,
    #[prost(uint32, optional, tag = "7")]
    pub unicode: ::core::option::Option<u32>,
}
impl ::prost::Name for KeyboardEvent {
    const NAME: &'static str = "KeyboardEvent";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.KeyboardEvent".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.KeyboardEvent".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DigCommand {
    #[prost(enumeration = "TileDigDesignation", optional, tag = "1")]
    pub designation: ::core::option::Option<i32>,
    #[prost(message, repeated, tag = "2")]
    pub locations: ::prost::alloc::vec::Vec<Coord>,
}
impl ::prost::Name for DigCommand {
    const NAME: &'static str = "DigCommand";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.DigCommand".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.DigCommand".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SingleBool {
    #[prost(bool, optional, tag = "1")]
    pub value: ::core::option::Option<bool>,
}
impl ::prost::Name for SingleBool {
    const NAME: &'static str = "SingleBool";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.SingleBool".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.SingleBool".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct VersionInfo {
    #[prost(string, optional, tag = "1")]
    pub dwarf_fortress_version: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(string, optional, tag = "2")]
    pub dfhack_version: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(string, optional, tag = "3")]
    pub remote_fortress_reader_version: ::core::option::Option<
        ::prost::alloc::string::String,
    >,
}
impl ::prost::Name for VersionInfo {
    const NAME: &'static str = "VersionInfo";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.VersionInfo".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.VersionInfo".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListRequest {
    #[prost(int32, optional, tag = "1")]
    pub list_start: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "2")]
    pub list_end: ::core::option::Option<i32>,
}
impl ::prost::Name for ListRequest {
    const NAME: &'static str = "ListRequest";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.ListRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.ListRequest".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Report {
    #[prost(int32, optional, tag = "1")]
    pub r#type: ::core::option::Option<i32>,
    #[prost(string, optional, tag = "2")]
    pub text: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "3")]
    pub color: ::core::option::Option<ColorDefinition>,
    #[prost(int32, optional, tag = "4")]
    pub duration: ::core::option::Option<i32>,
    #[prost(bool, optional, tag = "5")]
    pub continuation: ::core::option::Option<bool>,
    #[prost(bool, optional, tag = "6")]
    pub unconscious: ::core::option::Option<bool>,
    #[prost(bool, optional, tag = "7")]
    pub announcement: ::core::option::Option<bool>,
    #[prost(int32, optional, tag = "8")]
    pub repeat_count: ::core::option::Option<i32>,
    #[prost(message, optional, tag = "9")]
    pub pos: ::core::option::Option<Coord>,
    #[prost(int32, optional, tag = "10")]
    pub id: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "11")]
    pub year: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "12")]
    pub time: ::core::option::Option<i32>,
}
impl ::prost::Name for Report {
    const NAME: &'static str = "Report";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.Report".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.Report".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Status {
    #[prost(message, repeated, tag = "1")]
    pub reports: ::prost::alloc::vec::Vec<Report>,
}
impl ::prost::Name for Status {
    const NAME: &'static str = "Status";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.Status".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.Status".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ShapeDescriptior {
    #[prost(string, optional, tag = "1")]
    pub id: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(int32, optional, tag = "2")]
    pub tile: ::core::option::Option<i32>,
}
impl ::prost::Name for ShapeDescriptior {
    const NAME: &'static str = "ShapeDescriptior";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.ShapeDescriptior".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.ShapeDescriptior".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Language {
    #[prost(message, repeated, tag = "1")]
    pub shapes: ::prost::alloc::vec::Vec<ShapeDescriptior>,
}
impl ::prost::Name for Language {
    const NAME: &'static str = "Language";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.Language".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.Language".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ItemImprovement {
    #[prost(message, optional, tag = "1")]
    pub material: ::core::option::Option<MatPair>,
    #[prost(int32, optional, tag = "3")]
    pub shape: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "4")]
    pub specific_type: ::core::option::Option<i32>,
    #[prost(message, optional, tag = "5")]
    pub image: ::core::option::Option<ArtImage>,
    #[prost(int32, optional, tag = "6")]
    pub r#type: ::core::option::Option<i32>,
}
impl ::prost::Name for ItemImprovement {
    const NAME: &'static str = "ItemImprovement";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.ItemImprovement".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.ItemImprovement".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ArtImageElement {
    #[prost(int32, optional, tag = "1")]
    pub count: ::core::option::Option<i32>,
    #[prost(enumeration = "ArtImageElementType", optional, tag = "2")]
    pub r#type: ::core::option::Option<i32>,
    #[prost(message, optional, tag = "3")]
    pub creature_item: ::core::option::Option<MatPair>,
    #[prost(message, optional, tag = "5")]
    pub material: ::core::option::Option<MatPair>,
    #[prost(int32, optional, tag = "6")]
    pub id: ::core::option::Option<i32>,
}
impl ::prost::Name for ArtImageElement {
    const NAME: &'static str = "ArtImageElement";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.ArtImageElement".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.ArtImageElement".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ArtImageProperty {
    #[prost(int32, optional, tag = "1")]
    pub subject: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "2")]
    pub object: ::core::option::Option<i32>,
    #[prost(enumeration = "ArtImageVerb", optional, tag = "3")]
    pub verb: ::core::option::Option<i32>,
    #[prost(enumeration = "ArtImagePropertyType", optional, tag = "4")]
    pub r#type: ::core::option::Option<i32>,
}
impl ::prost::Name for ArtImageProperty {
    const NAME: &'static str = "ArtImageProperty";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.ArtImageProperty".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.ArtImageProperty".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ArtImage {
    #[prost(message, repeated, tag = "1")]
    pub elements: ::prost::alloc::vec::Vec<ArtImageElement>,
    #[prost(message, optional, tag = "2")]
    pub id: ::core::option::Option<MatPair>,
    #[prost(message, repeated, tag = "3")]
    pub properties: ::prost::alloc::vec::Vec<ArtImageProperty>,
}
impl ::prost::Name for ArtImage {
    const NAME: &'static str = "ArtImage";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.ArtImage".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.ArtImage".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Engraving {
    #[prost(message, optional, tag = "1")]
    pub pos: ::core::option::Option<Coord>,
    #[prost(int32, optional, tag = "2")]
    pub quality: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "3")]
    pub tile: ::core::option::Option<i32>,
    #[prost(message, optional, tag = "4")]
    pub image: ::core::option::Option<ArtImage>,
    #[prost(bool, optional, tag = "5")]
    pub floor: ::core::option::Option<bool>,
    #[prost(bool, optional, tag = "6")]
    pub west: ::core::option::Option<bool>,
    #[prost(bool, optional, tag = "7")]
    pub east: ::core::option::Option<bool>,
    #[prost(bool, optional, tag = "8")]
    pub north: ::core::option::Option<bool>,
    #[prost(bool, optional, tag = "9")]
    pub south: ::core::option::Option<bool>,
    #[prost(bool, optional, tag = "10")]
    pub hidden: ::core::option::Option<bool>,
    #[prost(bool, optional, tag = "11")]
    pub northwest: ::core::option::Option<bool>,
    #[prost(bool, optional, tag = "12")]
    pub northeast: ::core::option::Option<bool>,
    #[prost(bool, optional, tag = "13")]
    pub southwest: ::core::option::Option<bool>,
    #[prost(bool, optional, tag = "14")]
    pub southeast: ::core::option::Option<bool>,
}
impl ::prost::Name for Engraving {
    const NAME: &'static str = "Engraving";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.Engraving".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.Engraving".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct FlowInfo {
    #[prost(int32, optional, tag = "1")]
    pub index: ::core::option::Option<i32>,
    #[prost(enumeration = "FlowType", optional, tag = "2")]
    pub r#type: ::core::option::Option<i32>,
    #[prost(int32, optional, tag = "3")]
    pub density: ::core::option::Option<i32>,
    #[prost(message, optional, tag = "4")]
    pub pos: ::core::option::Option<Coord>,
    #[prost(message, optional, tag = "5")]
    pub dest: ::core::option::Option<Coord>,
    #[prost(bool, optional, tag = "6")]
    pub expanding: ::core::option::Option<bool>,
    #[deprecated]
    #[prost(bool, optional, tag = "7")]
    pub reuse: ::core::option::Option<bool>,
    #[prost(int32, optional, tag = "8")]
    pub guide_id: ::core::option::Option<i32>,
    #[prost(message, optional, tag = "9")]
    pub material: ::core::option::Option<MatPair>,
    #[prost(message, optional, tag = "10")]
    pub item: ::core::option::Option<MatPair>,
    #[prost(bool, optional, tag = "11")]
    pub dead: ::core::option::Option<bool>,
    #[prost(bool, optional, tag = "12")]
    pub fast: ::core::option::Option<bool>,
    #[prost(bool, optional, tag = "13")]
    pub creeping: ::core::option::Option<bool>,
}
impl ::prost::Name for FlowInfo {
    const NAME: &'static str = "FlowInfo";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.FlowInfo".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.FlowInfo".into()
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Wave {
    #[prost(message, optional, tag = "1")]
    pub dest: ::core::option::Option<Coord>,
    #[prost(message, optional, tag = "2")]
    pub pos: ::core::option::Option<Coord>,
}
impl ::prost::Name for Wave {
    const NAME: &'static str = "Wave";
    const PACKAGE: &'static str = "RemoteFortressReader";
    fn full_name() -> ::prost::alloc::string::String {
        "RemoteFortressReader.Wave".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RemoteFortressReader.Wave".into()
    }
}
/// We use shapes, etc, because the actual tiletypes may differ between DF versions.
#[derive(serde::Serialize)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum TiletypeShape {
    NoShape = -1,
    Empty = 0,
    Floor = 1,
    Boulder = 2,
    Pebbles = 3,
    Wall = 4,
    Fortification = 5,
    StairUp = 6,
    StairDown = 7,
    StairUpdown = 8,
    Ramp = 9,
    RampTop = 10,
    BrookBed = 11,
    BrookTop = 12,
    TreeShape = 13,
    Sapling = 14,
    Shrub = 15,
    EndlessPit = 16,
    Branch = 17,
    TrunkBranch = 18,
    Twig = 19,
}
impl TiletypeShape {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::NoShape => "NO_SHAPE",
            Self::Empty => "EMPTY",
            Self::Floor => "FLOOR",
            Self::Boulder => "BOULDER",
            Self::Pebbles => "PEBBLES",
            Self::Wall => "WALL",
            Self::Fortification => "FORTIFICATION",
            Self::StairUp => "STAIR_UP",
            Self::StairDown => "STAIR_DOWN",
            Self::StairUpdown => "STAIR_UPDOWN",
            Self::Ramp => "RAMP",
            Self::RampTop => "RAMP_TOP",
            Self::BrookBed => "BROOK_BED",
            Self::BrookTop => "BROOK_TOP",
            Self::TreeShape => "TREE_SHAPE",
            Self::Sapling => "SAPLING",
            Self::Shrub => "SHRUB",
            Self::EndlessPit => "ENDLESS_PIT",
            Self::Branch => "BRANCH",
            Self::TrunkBranch => "TRUNK_BRANCH",
            Self::Twig => "TWIG",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "NO_SHAPE" => Some(Self::NoShape),
            "EMPTY" => Some(Self::Empty),
            "FLOOR" => Some(Self::Floor),
            "BOULDER" => Some(Self::Boulder),
            "PEBBLES" => Some(Self::Pebbles),
            "WALL" => Some(Self::Wall),
            "FORTIFICATION" => Some(Self::Fortification),
            "STAIR_UP" => Some(Self::StairUp),
            "STAIR_DOWN" => Some(Self::StairDown),
            "STAIR_UPDOWN" => Some(Self::StairUpdown),
            "RAMP" => Some(Self::Ramp),
            "RAMP_TOP" => Some(Self::RampTop),
            "BROOK_BED" => Some(Self::BrookBed),
            "BROOK_TOP" => Some(Self::BrookTop),
            "TREE_SHAPE" => Some(Self::TreeShape),
            "SAPLING" => Some(Self::Sapling),
            "SHRUB" => Some(Self::Shrub),
            "ENDLESS_PIT" => Some(Self::EndlessPit),
            "BRANCH" => Some(Self::Branch),
            "TRUNK_BRANCH" => Some(Self::TrunkBranch),
            "TWIG" => Some(Self::Twig),
            _ => None,
        }
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum TiletypeSpecial {
    NoSpecial = -1,
    Normal = 0,
    RiverSource = 1,
    Waterfall = 2,
    Smooth = 3,
    Furrowed = 4,
    Wet = 5,
    Dead = 6,
    Worn1 = 7,
    Worn2 = 8,
    Worn3 = 9,
    Track = 10,
    SmoothDead = 11,
}
impl TiletypeSpecial {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::NoSpecial => "NO_SPECIAL",
            Self::Normal => "NORMAL",
            Self::RiverSource => "RIVER_SOURCE",
            Self::Waterfall => "WATERFALL",
            Self::Smooth => "SMOOTH",
            Self::Furrowed => "FURROWED",
            Self::Wet => "WET",
            Self::Dead => "DEAD",
            Self::Worn1 => "WORN_1",
            Self::Worn2 => "WORN_2",
            Self::Worn3 => "WORN_3",
            Self::Track => "TRACK",
            Self::SmoothDead => "SMOOTH_DEAD",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "NO_SPECIAL" => Some(Self::NoSpecial),
            "NORMAL" => Some(Self::Normal),
            "RIVER_SOURCE" => Some(Self::RiverSource),
            "WATERFALL" => Some(Self::Waterfall),
            "SMOOTH" => Some(Self::Smooth),
            "FURROWED" => Some(Self::Furrowed),
            "WET" => Some(Self::Wet),
            "DEAD" => Some(Self::Dead),
            "WORN_1" => Some(Self::Worn1),
            "WORN_2" => Some(Self::Worn2),
            "WORN_3" => Some(Self::Worn3),
            "TRACK" => Some(Self::Track),
            "SMOOTH_DEAD" => Some(Self::SmoothDead),
            _ => None,
        }
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum TiletypeMaterial {
    NoMaterial = -1,
    Air = 0,
    Soil = 1,
    Stone = 2,
    Feature = 3,
    LavaStone = 4,
    Mineral = 5,
    FrozenLiquid = 6,
    Construction = 7,
    GrassLight = 8,
    GrassDark = 9,
    GrassDry = 10,
    GrassDead = 11,
    Plant = 12,
    Hfs = 13,
    Campfire = 14,
    Fire = 15,
    Ashes = 16,
    Magma = 17,
    Driftwood = 18,
    Pool = 19,
    Brook = 20,
    River = 21,
    Root = 22,
    TreeMaterial = 23,
    Mushroom = 24,
    UnderworldGate = 25,
}
impl TiletypeMaterial {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::NoMaterial => "NO_MATERIAL",
            Self::Air => "AIR",
            Self::Soil => "SOIL",
            Self::Stone => "STONE",
            Self::Feature => "FEATURE",
            Self::LavaStone => "LAVA_STONE",
            Self::Mineral => "MINERAL",
            Self::FrozenLiquid => "FROZEN_LIQUID",
            Self::Construction => "CONSTRUCTION",
            Self::GrassLight => "GRASS_LIGHT",
            Self::GrassDark => "GRASS_DARK",
            Self::GrassDry => "GRASS_DRY",
            Self::GrassDead => "GRASS_DEAD",
            Self::Plant => "PLANT",
            Self::Hfs => "HFS",
            Self::Campfire => "CAMPFIRE",
            Self::Fire => "FIRE",
            Self::Ashes => "ASHES",
            Self::Magma => "MAGMA",
            Self::Driftwood => "DRIFTWOOD",
            Self::Pool => "POOL",
            Self::Brook => "BROOK",
            Self::River => "RIVER",
            Self::Root => "ROOT",
            Self::TreeMaterial => "TREE_MATERIAL",
            Self::Mushroom => "MUSHROOM",
            Self::UnderworldGate => "UNDERWORLD_GATE",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "NO_MATERIAL" => Some(Self::NoMaterial),
            "AIR" => Some(Self::Air),
            "SOIL" => Some(Self::Soil),
            "STONE" => Some(Self::Stone),
            "FEATURE" => Some(Self::Feature),
            "LAVA_STONE" => Some(Self::LavaStone),
            "MINERAL" => Some(Self::Mineral),
            "FROZEN_LIQUID" => Some(Self::FrozenLiquid),
            "CONSTRUCTION" => Some(Self::Construction),
            "GRASS_LIGHT" => Some(Self::GrassLight),
            "GRASS_DARK" => Some(Self::GrassDark),
            "GRASS_DRY" => Some(Self::GrassDry),
            "GRASS_DEAD" => Some(Self::GrassDead),
            "PLANT" => Some(Self::Plant),
            "HFS" => Some(Self::Hfs),
            "CAMPFIRE" => Some(Self::Campfire),
            "FIRE" => Some(Self::Fire),
            "ASHES" => Some(Self::Ashes),
            "MAGMA" => Some(Self::Magma),
            "DRIFTWOOD" => Some(Self::Driftwood),
            "POOL" => Some(Self::Pool),
            "BROOK" => Some(Self::Brook),
            "RIVER" => Some(Self::River),
            "ROOT" => Some(Self::Root),
            "TREE_MATERIAL" => Some(Self::TreeMaterial),
            "MUSHROOM" => Some(Self::Mushroom),
            "UNDERWORLD_GATE" => Some(Self::UnderworldGate),
            _ => None,
        }
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum TiletypeVariant {
    NoVariant = -1,
    Var1 = 0,
    Var2 = 1,
    Var3 = 2,
    Var4 = 3,
}
impl TiletypeVariant {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::NoVariant => "NO_VARIANT",
            Self::Var1 => "VAR_1",
            Self::Var2 => "VAR_2",
            Self::Var3 => "VAR_3",
            Self::Var4 => "VAR_4",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "NO_VARIANT" => Some(Self::NoVariant),
            "VAR_1" => Some(Self::Var1),
            "VAR_2" => Some(Self::Var2),
            "VAR_3" => Some(Self::Var3),
            "VAR_4" => Some(Self::Var4),
            _ => None,
        }
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum WorldPoles {
    NoPoles = 0,
    NorthPole = 1,
    SouthPole = 2,
    BothPoles = 3,
}
impl WorldPoles {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::NoPoles => "NO_POLES",
            Self::NorthPole => "NORTH_POLE",
            Self::SouthPole => "SOUTH_POLE",
            Self::BothPoles => "BOTH_POLES",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "NO_POLES" => Some(Self::NoPoles),
            "NORTH_POLE" => Some(Self::NorthPole),
            "SOUTH_POLE" => Some(Self::SouthPole),
            "BOTH_POLES" => Some(Self::BothPoles),
            _ => None,
        }
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum BuildingDirection {
    North = 0,
    East = 1,
    South = 2,
    West = 3,
    Northeast = 4,
    Southeast = 5,
    Southwest = 6,
    Northwest = 7,
    None = 8,
}
impl BuildingDirection {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::North => "NORTH",
            Self::East => "EAST",
            Self::South => "SOUTH",
            Self::West => "WEST",
            Self::Northeast => "NORTHEAST",
            Self::Southeast => "SOUTHEAST",
            Self::Southwest => "SOUTHWEST",
            Self::Northwest => "NORTHWEST",
            Self::None => "NONE",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "NORTH" => Some(Self::North),
            "EAST" => Some(Self::East),
            "SOUTH" => Some(Self::South),
            "WEST" => Some(Self::West),
            "NORTHEAST" => Some(Self::Northeast),
            "SOUTHEAST" => Some(Self::Southeast),
            "SOUTHWEST" => Some(Self::Southwest),
            "NORTHWEST" => Some(Self::Northwest),
            "NONE" => Some(Self::None),
            _ => None,
        }
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum TileDigDesignation {
    /// *
    /// no designation
    NoDig = 0,
    /// *
    /// dig walls, remove stairs and ramps, gather plants, fell trees
    DefaultDig = 1,
    UpDownStairDig = 2,
    ChannelDig = 3,
    RampDig = 4,
    DownStairDig = 5,
    UpStairDig = 6,
}
impl TileDigDesignation {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::NoDig => "NO_DIG",
            Self::DefaultDig => "DEFAULT_DIG",
            Self::UpDownStairDig => "UP_DOWN_STAIR_DIG",
            Self::ChannelDig => "CHANNEL_DIG",
            Self::RampDig => "RAMP_DIG",
            Self::DownStairDig => "DOWN_STAIR_DIG",
            Self::UpStairDig => "UP_STAIR_DIG",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "NO_DIG" => Some(Self::NoDig),
            "DEFAULT_DIG" => Some(Self::DefaultDig),
            "UP_DOWN_STAIR_DIG" => Some(Self::UpDownStairDig),
            "CHANNEL_DIG" => Some(Self::ChannelDig),
            "RAMP_DIG" => Some(Self::RampDig),
            "DOWN_STAIR_DIG" => Some(Self::DownStairDig),
            "UP_STAIR_DIG" => Some(Self::UpStairDig),
            _ => None,
        }
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum HairStyle {
    Unkempt = -1,
    NeatlyCombed = 0,
    Braided = 1,
    DoubleBraid = 2,
    PonyTails = 3,
    CleanShaven = 4,
}
impl HairStyle {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unkempt => "UNKEMPT",
            Self::NeatlyCombed => "NEATLY_COMBED",
            Self::Braided => "BRAIDED",
            Self::DoubleBraid => "DOUBLE_BRAID",
            Self::PonyTails => "PONY_TAILS",
            Self::CleanShaven => "CLEAN_SHAVEN",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "UNKEMPT" => Some(Self::Unkempt),
            "NEATLY_COMBED" => Some(Self::NeatlyCombed),
            "BRAIDED" => Some(Self::Braided),
            "DOUBLE_BRAID" => Some(Self::DoubleBraid),
            "PONY_TAILS" => Some(Self::PonyTails),
            "CLEAN_SHAVEN" => Some(Self::CleanShaven),
            _ => None,
        }
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum InventoryMode {
    Hauled = 0,
    /// *
    /// also shield, crutch
    Weapon = 1,
    /// *
    /// quiver
    Worn = 2,
    Piercing = 3,
    /// *
    /// attached to clothing
    Flask = 4,
    /// *
    /// e.g. bandage
    WrappedAround = 5,
    StuckIn = 6,
    /// *
    /// string descr like Worn
    InMouth = 7,
    /// *
    /// Left shoulder, right shoulder, or head, selected randomly using pet_seed
    Pet = 8,
    SewnInto = 9,
    Strapped = 10,
}
impl InventoryMode {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Hauled => "Hauled",
            Self::Weapon => "Weapon",
            Self::Worn => "Worn",
            Self::Piercing => "Piercing",
            Self::Flask => "Flask",
            Self::WrappedAround => "WrappedAround",
            Self::StuckIn => "StuckIn",
            Self::InMouth => "InMouth",
            Self::Pet => "Pet",
            Self::SewnInto => "SewnInto",
            Self::Strapped => "Strapped",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "Hauled" => Some(Self::Hauled),
            "Weapon" => Some(Self::Weapon),
            "Worn" => Some(Self::Worn),
            "Piercing" => Some(Self::Piercing),
            "Flask" => Some(Self::Flask),
            "WrappedAround" => Some(Self::WrappedAround),
            "StuckIn" => Some(Self::StuckIn),
            "InMouth" => Some(Self::InMouth),
            "Pet" => Some(Self::Pet),
            "SewnInto" => Some(Self::SewnInto),
            "Strapped" => Some(Self::Strapped),
            _ => None,
        }
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ArmorLayer {
    LayerUnder = 0,
    LayerOver = 1,
    LayerArmor = 2,
    LayerCover = 3,
}
impl ArmorLayer {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::LayerUnder => "LAYER_UNDER",
            Self::LayerOver => "LAYER_OVER",
            Self::LayerArmor => "LAYER_ARMOR",
            Self::LayerCover => "LAYER_COVER",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "LAYER_UNDER" => Some(Self::LayerUnder),
            "LAYER_OVER" => Some(Self::LayerOver),
            "LAYER_ARMOR" => Some(Self::LayerArmor),
            "LAYER_COVER" => Some(Self::LayerCover),
            _ => None,
        }
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum MatterState {
    Solid = 0,
    Liquid = 1,
    Gas = 2,
    Powder = 3,
    Paste = 4,
    Pressed = 5,
}
impl MatterState {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Solid => "Solid",
            Self::Liquid => "Liquid",
            Self::Gas => "Gas",
            Self::Powder => "Powder",
            Self::Paste => "Paste",
            Self::Pressed => "Pressed",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "Solid" => Some(Self::Solid),
            "Liquid" => Some(Self::Liquid),
            "Gas" => Some(Self::Gas),
            "Powder" => Some(Self::Powder),
            "Paste" => Some(Self::Paste),
            "Pressed" => Some(Self::Pressed),
            _ => None,
        }
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum FrontType {
    FrontNone = 0,
    FrontWarm = 1,
    FrontCold = 2,
    FrontOccluded = 3,
}
impl FrontType {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::FrontNone => "FRONT_NONE",
            Self::FrontWarm => "FRONT_WARM",
            Self::FrontCold => "FRONT_COLD",
            Self::FrontOccluded => "FRONT_OCCLUDED",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "FRONT_NONE" => Some(Self::FrontNone),
            "FRONT_WARM" => Some(Self::FrontWarm),
            "FRONT_COLD" => Some(Self::FrontCold),
            "FRONT_OCCLUDED" => Some(Self::FrontOccluded),
            _ => None,
        }
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum CumulusType {
    CumulusNone = 0,
    CumulusMedium = 1,
    CumulusMulti = 2,
    CumulusNimbus = 3,
}
impl CumulusType {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::CumulusNone => "CUMULUS_NONE",
            Self::CumulusMedium => "CUMULUS_MEDIUM",
            Self::CumulusMulti => "CUMULUS_MULTI",
            Self::CumulusNimbus => "CUMULUS_NIMBUS",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "CUMULUS_NONE" => Some(Self::CumulusNone),
            "CUMULUS_MEDIUM" => Some(Self::CumulusMedium),
            "CUMULUS_MULTI" => Some(Self::CumulusMulti),
            "CUMULUS_NIMBUS" => Some(Self::CumulusNimbus),
            _ => None,
        }
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum StratusType {
    StratusNone = 0,
    StratusAlto = 1,
    StratusProper = 2,
    StratusNimbus = 3,
}
impl StratusType {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::StratusNone => "STRATUS_NONE",
            Self::StratusAlto => "STRATUS_ALTO",
            Self::StratusProper => "STRATUS_PROPER",
            Self::StratusNimbus => "STRATUS_NIMBUS",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "STRATUS_NONE" => Some(Self::StratusNone),
            "STRATUS_ALTO" => Some(Self::StratusAlto),
            "STRATUS_PROPER" => Some(Self::StratusProper),
            "STRATUS_NIMBUS" => Some(Self::StratusNimbus),
            _ => None,
        }
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum FogType {
    FogNone = 0,
    FogMist = 1,
    FogNormal = 2,
    F0gThick = 3,
}
impl FogType {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::FogNone => "FOG_NONE",
            Self::FogMist => "FOG_MIST",
            Self::FogNormal => "FOG_NORMAL",
            Self::F0gThick => "F0G_THICK",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "FOG_NONE" => Some(Self::FogNone),
            "FOG_MIST" => Some(Self::FogMist),
            "FOG_NORMAL" => Some(Self::FogNormal),
            "F0G_THICK" => Some(Self::F0gThick),
            _ => None,
        }
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum PatternType {
    Monotone = 0,
    Stripes = 1,
    IrisEye = 2,
    Spots = 3,
    PupilEye = 4,
    Mottled = 5,
}
impl PatternType {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Monotone => "MONOTONE",
            Self::Stripes => "STRIPES",
            Self::IrisEye => "IRIS_EYE",
            Self::Spots => "SPOTS",
            Self::PupilEye => "PUPIL_EYE",
            Self::Mottled => "MOTTLED",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "MONOTONE" => Some(Self::Monotone),
            "STRIPES" => Some(Self::Stripes),
            "IRIS_EYE" => Some(Self::IrisEye),
            "SPOTS" => Some(Self::Spots),
            "PUPIL_EYE" => Some(Self::PupilEye),
            "MOTTLED" => Some(Self::Mottled),
            _ => None,
        }
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ArtImageElementType {
    ImageCreature = 0,
    ImagePlant = 1,
    ImageTree = 2,
    ImageShape = 3,
    ImageItem = 4,
}
impl ArtImageElementType {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::ImageCreature => "IMAGE_CREATURE",
            Self::ImagePlant => "IMAGE_PLANT",
            Self::ImageTree => "IMAGE_TREE",
            Self::ImageShape => "IMAGE_SHAPE",
            Self::ImageItem => "IMAGE_ITEM",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "IMAGE_CREATURE" => Some(Self::ImageCreature),
            "IMAGE_PLANT" => Some(Self::ImagePlant),
            "IMAGE_TREE" => Some(Self::ImageTree),
            "IMAGE_SHAPE" => Some(Self::ImageShape),
            "IMAGE_ITEM" => Some(Self::ImageItem),
            _ => None,
        }
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ArtImagePropertyType {
    TransitiveVerb = 0,
    IntransitiveVerb = 1,
}
impl ArtImagePropertyType {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::TransitiveVerb => "TRANSITIVE_VERB",
            Self::IntransitiveVerb => "INTRANSITIVE_VERB",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "TRANSITIVE_VERB" => Some(Self::TransitiveVerb),
            "INTRANSITIVE_VERB" => Some(Self::IntransitiveVerb),
            _ => None,
        }
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ArtImageVerb {
    VerbWithering = 0,
    VerbSurroundedby = 1,
    VerbMassacring = 2,
    VerbFighting = 3,
    VerbLaboring = 4,
    VerbGreeting = 5,
    VerbRefusing = 6,
    VerbSpeaking = 7,
    VerbEmbracing = 8,
    VerbStrikingdown = 9,
    VerbMenacingpose = 10,
    VerbTraveling = 11,
    VerbRaising = 12,
    VerbHiding = 13,
    VerbLookingconfused = 14,
    VerbLookingterrified = 15,
    VerbDevouring = 16,
    VerbAdmiring = 17,
    VerbBurning = 18,
    VerbWeeping = 19,
    VerbLookingdejected = 20,
    VerbCringing = 21,
    VerbScreaming = 22,
    VerbSubmissivegesture = 23,
    VerbFetalposition = 24,
    VerbSmearedintospiral = 25,
    VerbFalling = 26,
    VerbDead = 27,
    VerbLaughing = 28,
    VerbLookingoffended = 29,
    VerbBeingshot = 30,
    VerbPlaintivegesture = 31,
    VerbMelting = 32,
    VerbShooting = 33,
    VerbTorturing = 34,
    VerbCommittingdepravedact = 35,
    VerbPraying = 36,
    VerbContemplating = 37,
    VerbCooking = 38,
    VerbEngraving = 39,
    VerbProstrating = 40,
    VerbSuffering = 41,
    VerbBeingimpaled = 42,
    VerbBeingcontorted = 43,
    VerbBeingflayed = 44,
    VerbHangingfrom = 45,
    VerbBeingmutilated = 46,
    VerbTriumphantpose = 47,
}
impl ArtImageVerb {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::VerbWithering => "VERB_WITHERING",
            Self::VerbSurroundedby => "VERB_SURROUNDEDBY",
            Self::VerbMassacring => "VERB_MASSACRING",
            Self::VerbFighting => "VERB_FIGHTING",
            Self::VerbLaboring => "VERB_LABORING",
            Self::VerbGreeting => "VERB_GREETING",
            Self::VerbRefusing => "VERB_REFUSING",
            Self::VerbSpeaking => "VERB_SPEAKING",
            Self::VerbEmbracing => "VERB_EMBRACING",
            Self::VerbStrikingdown => "VERB_STRIKINGDOWN",
            Self::VerbMenacingpose => "VERB_MENACINGPOSE",
            Self::VerbTraveling => "VERB_TRAVELING",
            Self::VerbRaising => "VERB_RAISING",
            Self::VerbHiding => "VERB_HIDING",
            Self::VerbLookingconfused => "VERB_LOOKINGCONFUSED",
            Self::VerbLookingterrified => "VERB_LOOKINGTERRIFIED",
            Self::VerbDevouring => "VERB_DEVOURING",
            Self::VerbAdmiring => "VERB_ADMIRING",
            Self::VerbBurning => "VERB_BURNING",
            Self::VerbWeeping => "VERB_WEEPING",
            Self::VerbLookingdejected => "VERB_LOOKINGDEJECTED",
            Self::VerbCringing => "VERB_CRINGING",
            Self::VerbScreaming => "VERB_SCREAMING",
            Self::VerbSubmissivegesture => "VERB_SUBMISSIVEGESTURE",
            Self::VerbFetalposition => "VERB_FETALPOSITION",
            Self::VerbSmearedintospiral => "VERB_SMEAREDINTOSPIRAL",
            Self::VerbFalling => "VERB_FALLING",
            Self::VerbDead => "VERB_DEAD",
            Self::VerbLaughing => "VERB_LAUGHING",
            Self::VerbLookingoffended => "VERB_LOOKINGOFFENDED",
            Self::VerbBeingshot => "VERB_BEINGSHOT",
            Self::VerbPlaintivegesture => "VERB_PLAINTIVEGESTURE",
            Self::VerbMelting => "VERB_MELTING",
            Self::VerbShooting => "VERB_SHOOTING",
            Self::VerbTorturing => "VERB_TORTURING",
            Self::VerbCommittingdepravedact => "VERB_COMMITTINGDEPRAVEDACT",
            Self::VerbPraying => "VERB_PRAYING",
            Self::VerbContemplating => "VERB_CONTEMPLATING",
            Self::VerbCooking => "VERB_COOKING",
            Self::VerbEngraving => "VERB_ENGRAVING",
            Self::VerbProstrating => "VERB_PROSTRATING",
            Self::VerbSuffering => "VERB_SUFFERING",
            Self::VerbBeingimpaled => "VERB_BEINGIMPALED",
            Self::VerbBeingcontorted => "VERB_BEINGCONTORTED",
            Self::VerbBeingflayed => "VERB_BEINGFLAYED",
            Self::VerbHangingfrom => "VERB_HANGINGFROM",
            Self::VerbBeingmutilated => "VERB_BEINGMUTILATED",
            Self::VerbTriumphantpose => "VERB_TRIUMPHANTPOSE",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "VERB_WITHERING" => Some(Self::VerbWithering),
            "VERB_SURROUNDEDBY" => Some(Self::VerbSurroundedby),
            "VERB_MASSACRING" => Some(Self::VerbMassacring),
            "VERB_FIGHTING" => Some(Self::VerbFighting),
            "VERB_LABORING" => Some(Self::VerbLaboring),
            "VERB_GREETING" => Some(Self::VerbGreeting),
            "VERB_REFUSING" => Some(Self::VerbRefusing),
            "VERB_SPEAKING" => Some(Self::VerbSpeaking),
            "VERB_EMBRACING" => Some(Self::VerbEmbracing),
            "VERB_STRIKINGDOWN" => Some(Self::VerbStrikingdown),
            "VERB_MENACINGPOSE" => Some(Self::VerbMenacingpose),
            "VERB_TRAVELING" => Some(Self::VerbTraveling),
            "VERB_RAISING" => Some(Self::VerbRaising),
            "VERB_HIDING" => Some(Self::VerbHiding),
            "VERB_LOOKINGCONFUSED" => Some(Self::VerbLookingconfused),
            "VERB_LOOKINGTERRIFIED" => Some(Self::VerbLookingterrified),
            "VERB_DEVOURING" => Some(Self::VerbDevouring),
            "VERB_ADMIRING" => Some(Self::VerbAdmiring),
            "VERB_BURNING" => Some(Self::VerbBurning),
            "VERB_WEEPING" => Some(Self::VerbWeeping),
            "VERB_LOOKINGDEJECTED" => Some(Self::VerbLookingdejected),
            "VERB_CRINGING" => Some(Self::VerbCringing),
            "VERB_SCREAMING" => Some(Self::VerbScreaming),
            "VERB_SUBMISSIVEGESTURE" => Some(Self::VerbSubmissivegesture),
            "VERB_FETALPOSITION" => Some(Self::VerbFetalposition),
            "VERB_SMEAREDINTOSPIRAL" => Some(Self::VerbSmearedintospiral),
            "VERB_FALLING" => Some(Self::VerbFalling),
            "VERB_DEAD" => Some(Self::VerbDead),
            "VERB_LAUGHING" => Some(Self::VerbLaughing),
            "VERB_LOOKINGOFFENDED" => Some(Self::VerbLookingoffended),
            "VERB_BEINGSHOT" => Some(Self::VerbBeingshot),
            "VERB_PLAINTIVEGESTURE" => Some(Self::VerbPlaintivegesture),
            "VERB_MELTING" => Some(Self::VerbMelting),
            "VERB_SHOOTING" => Some(Self::VerbShooting),
            "VERB_TORTURING" => Some(Self::VerbTorturing),
            "VERB_COMMITTINGDEPRAVEDACT" => Some(Self::VerbCommittingdepravedact),
            "VERB_PRAYING" => Some(Self::VerbPraying),
            "VERB_CONTEMPLATING" => Some(Self::VerbContemplating),
            "VERB_COOKING" => Some(Self::VerbCooking),
            "VERB_ENGRAVING" => Some(Self::VerbEngraving),
            "VERB_PROSTRATING" => Some(Self::VerbProstrating),
            "VERB_SUFFERING" => Some(Self::VerbSuffering),
            "VERB_BEINGIMPALED" => Some(Self::VerbBeingimpaled),
            "VERB_BEINGCONTORTED" => Some(Self::VerbBeingcontorted),
            "VERB_BEINGFLAYED" => Some(Self::VerbBeingflayed),
            "VERB_HANGINGFROM" => Some(Self::VerbHangingfrom),
            "VERB_BEINGMUTILATED" => Some(Self::VerbBeingmutilated),
            "VERB_TRIUMPHANTPOSE" => Some(Self::VerbTriumphantpose),
            _ => None,
        }
    }
}
#[derive(serde::Serialize)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum FlowType {
    Miasma = 0,
    Steam = 1,
    Mist = 2,
    MaterialDust = 3,
    MagmaMist = 4,
    Smoke = 5,
    Dragonfire = 6,
    Fire = 7,
    Web = 8,
    MaterialGas = 9,
    MaterialVapor = 10,
    OceanWave = 11,
    SeaFoam = 12,
    ItemCloud = 13,
    CampFire = -1,
}
impl FlowType {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Miasma => "Miasma",
            Self::Steam => "Steam",
            Self::Mist => "Mist",
            Self::MaterialDust => "MaterialDust",
            Self::MagmaMist => "MagmaMist",
            Self::Smoke => "Smoke",
            Self::Dragonfire => "Dragonfire",
            Self::Fire => "Fire",
            Self::Web => "Web",
            Self::MaterialGas => "MaterialGas",
            Self::MaterialVapor => "MaterialVapor",
            Self::OceanWave => "OceanWave",
            Self::SeaFoam => "SeaFoam",
            Self::ItemCloud => "ItemCloud",
            Self::CampFire => "CampFire",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "Miasma" => Some(Self::Miasma),
            "Steam" => Some(Self::Steam),
            "Mist" => Some(Self::Mist),
            "MaterialDust" => Some(Self::MaterialDust),
            "MagmaMist" => Some(Self::MagmaMist),
            "Smoke" => Some(Self::Smoke),
            "Dragonfire" => Some(Self::Dragonfire),
            "Fire" => Some(Self::Fire),
            "Web" => Some(Self::Web),
            "MaterialGas" => Some(Self::MaterialGas),
            "MaterialVapor" => Some(Self::MaterialVapor),
            "OceanWave" => Some(Self::OceanWave),
            "SeaFoam" => Some(Self::SeaFoam),
            "ItemCloud" => Some(Self::ItemCloud),
            "CampFire" => Some(Self::CampFire),
            _ => None,
        }
    }
}