dfhack_proto/generated/messages/
Basic.rs

1// This file is generated by rust-protobuf 3.7.2. Do not edit
2// .proto file is parsed by pure
3// @generated
4
5// https://github.com/rust-lang/rust-clippy/issues/702
6#![allow(unknown_lints)]
7#![allow(clippy::all)]
8
9#![allow(unused_attributes)]
10#![cfg_attr(rustfmt, rustfmt::skip)]
11
12#![allow(dead_code)]
13#![allow(missing_docs)]
14#![allow(non_camel_case_types)]
15#![allow(non_snake_case)]
16#![allow(non_upper_case_globals)]
17#![allow(trivial_casts)]
18#![allow(unused_results)]
19#![allow(unused_mut)]
20
21//! Generated file from `Basic.proto`
22
23/// Generated files are compatible only with the same version
24/// of protobuf runtime.
25const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_3_7_2;
26
27// @@protoc_insertion_point(message:dfproto.EnumItemName)
28#[derive(PartialEq,Clone,Default,Debug)]
29pub struct EnumItemName {
30    // message fields
31    // @@protoc_insertion_point(field:dfproto.EnumItemName.value)
32    pub value: ::std::option::Option<i32>,
33    // @@protoc_insertion_point(field:dfproto.EnumItemName.name)
34    pub name: ::std::option::Option<::std::string::String>,
35    // @@protoc_insertion_point(field:dfproto.EnumItemName.bit_size)
36    pub bit_size: ::std::option::Option<i32>,
37    // special fields
38    // @@protoc_insertion_point(special_field:dfproto.EnumItemName.special_fields)
39    pub special_fields: ::protobuf::SpecialFields,
40}
41
42impl<'a> ::std::default::Default for &'a EnumItemName {
43    fn default() -> &'a EnumItemName {
44        <EnumItemName as ::protobuf::Message>::default_instance()
45    }
46}
47
48impl EnumItemName {
49    pub fn new() -> EnumItemName {
50        ::std::default::Default::default()
51    }
52
53    // required int32 value = 1;
54
55    pub fn value(&self) -> i32 {
56        self.value.unwrap_or(0)
57    }
58
59    pub fn clear_value(&mut self) {
60        self.value = ::std::option::Option::None;
61    }
62
63    pub fn has_value(&self) -> bool {
64        self.value.is_some()
65    }
66
67    // Param is passed by value, moved
68    pub fn set_value(&mut self, v: i32) {
69        self.value = ::std::option::Option::Some(v);
70    }
71
72    // optional string name = 2;
73
74    pub fn name(&self) -> &str {
75        match self.name.as_ref() {
76            Some(v) => v,
77            None => "",
78        }
79    }
80
81    pub fn clear_name(&mut self) {
82        self.name = ::std::option::Option::None;
83    }
84
85    pub fn has_name(&self) -> bool {
86        self.name.is_some()
87    }
88
89    // Param is passed by value, moved
90    pub fn set_name(&mut self, v: ::std::string::String) {
91        self.name = ::std::option::Option::Some(v);
92    }
93
94    // Mutable pointer to the field.
95    // If field is not initialized, it is initialized with default value first.
96    pub fn mut_name(&mut self) -> &mut ::std::string::String {
97        if self.name.is_none() {
98            self.name = ::std::option::Option::Some(::std::string::String::new());
99        }
100        self.name.as_mut().unwrap()
101    }
102
103    // Take field
104    pub fn take_name(&mut self) -> ::std::string::String {
105        self.name.take().unwrap_or_else(|| ::std::string::String::new())
106    }
107
108    // optional int32 bit_size = 3;
109
110    pub fn bit_size(&self) -> i32 {
111        self.bit_size.unwrap_or(1i32)
112    }
113
114    pub fn clear_bit_size(&mut self) {
115        self.bit_size = ::std::option::Option::None;
116    }
117
118    pub fn has_bit_size(&self) -> bool {
119        self.bit_size.is_some()
120    }
121
122    // Param is passed by value, moved
123    pub fn set_bit_size(&mut self, v: i32) {
124        self.bit_size = ::std::option::Option::Some(v);
125    }
126
127    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
128        let mut fields = ::std::vec::Vec::with_capacity(3);
129        let mut oneofs = ::std::vec::Vec::with_capacity(0);
130        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
131            "value",
132            |m: &EnumItemName| { &m.value },
133            |m: &mut EnumItemName| { &mut m.value },
134        ));
135        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
136            "name",
137            |m: &EnumItemName| { &m.name },
138            |m: &mut EnumItemName| { &mut m.name },
139        ));
140        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
141            "bit_size",
142            |m: &EnumItemName| { &m.bit_size },
143            |m: &mut EnumItemName| { &mut m.bit_size },
144        ));
145        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<EnumItemName>(
146            "EnumItemName",
147            fields,
148            oneofs,
149        )
150    }
151}
152
153impl ::protobuf::Message for EnumItemName {
154    const NAME: &'static str = "EnumItemName";
155
156    fn is_initialized(&self) -> bool {
157        if self.value.is_none() {
158            return false;
159        }
160        true
161    }
162
163    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
164        while let Some(tag) = is.read_raw_tag_or_eof()? {
165            match tag {
166                8 => {
167                    self.value = ::std::option::Option::Some(is.read_int32()?);
168                },
169                18 => {
170                    self.name = ::std::option::Option::Some(is.read_string()?);
171                },
172                24 => {
173                    self.bit_size = ::std::option::Option::Some(is.read_int32()?);
174                },
175                tag => {
176                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
177                },
178            };
179        }
180        ::std::result::Result::Ok(())
181    }
182
183    // Compute sizes of nested messages
184    #[allow(unused_variables)]
185    fn compute_size(&self) -> u64 {
186        let mut my_size = 0;
187        if let Some(v) = self.value {
188            my_size += ::protobuf::rt::int32_size(1, v);
189        }
190        if let Some(v) = self.name.as_ref() {
191            my_size += ::protobuf::rt::string_size(2, &v);
192        }
193        if let Some(v) = self.bit_size {
194            my_size += ::protobuf::rt::int32_size(3, v);
195        }
196        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
197        self.special_fields.cached_size().set(my_size as u32);
198        my_size
199    }
200
201    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
202        if let Some(v) = self.value {
203            os.write_int32(1, v)?;
204        }
205        if let Some(v) = self.name.as_ref() {
206            os.write_string(2, v)?;
207        }
208        if let Some(v) = self.bit_size {
209            os.write_int32(3, v)?;
210        }
211        os.write_unknown_fields(self.special_fields.unknown_fields())?;
212        ::std::result::Result::Ok(())
213    }
214
215    fn special_fields(&self) -> &::protobuf::SpecialFields {
216        &self.special_fields
217    }
218
219    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
220        &mut self.special_fields
221    }
222
223    fn new() -> EnumItemName {
224        EnumItemName::new()
225    }
226
227    fn clear(&mut self) {
228        self.value = ::std::option::Option::None;
229        self.name = ::std::option::Option::None;
230        self.bit_size = ::std::option::Option::None;
231        self.special_fields.clear();
232    }
233
234    fn default_instance() -> &'static EnumItemName {
235        static instance: EnumItemName = EnumItemName {
236            value: ::std::option::Option::None,
237            name: ::std::option::Option::None,
238            bit_size: ::std::option::Option::None,
239            special_fields: ::protobuf::SpecialFields::new(),
240        };
241        &instance
242    }
243}
244
245impl ::protobuf::MessageFull for EnumItemName {
246    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
247        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
248        descriptor.get(|| file_descriptor().message_by_package_relative_name("EnumItemName").unwrap()).clone()
249    }
250}
251
252impl ::std::fmt::Display for EnumItemName {
253    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
254        ::protobuf::text_format::fmt(self, f)
255    }
256}
257
258impl ::protobuf::reflect::ProtobufValue for EnumItemName {
259    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
260}
261
262// @@protoc_insertion_point(message:dfproto.BasicMaterialId)
263#[derive(PartialEq,Clone,Default,Debug)]
264pub struct BasicMaterialId {
265    // message fields
266    // @@protoc_insertion_point(field:dfproto.BasicMaterialId.type)
267    pub type_: ::std::option::Option<i32>,
268    // @@protoc_insertion_point(field:dfproto.BasicMaterialId.index)
269    pub index: ::std::option::Option<i32>,
270    // special fields
271    // @@protoc_insertion_point(special_field:dfproto.BasicMaterialId.special_fields)
272    pub special_fields: ::protobuf::SpecialFields,
273}
274
275impl<'a> ::std::default::Default for &'a BasicMaterialId {
276    fn default() -> &'a BasicMaterialId {
277        <BasicMaterialId as ::protobuf::Message>::default_instance()
278    }
279}
280
281impl BasicMaterialId {
282    pub fn new() -> BasicMaterialId {
283        ::std::default::Default::default()
284    }
285
286    // required int32 type = 1;
287
288    pub fn type_(&self) -> i32 {
289        self.type_.unwrap_or(0)
290    }
291
292    pub fn clear_type_(&mut self) {
293        self.type_ = ::std::option::Option::None;
294    }
295
296    pub fn has_type(&self) -> bool {
297        self.type_.is_some()
298    }
299
300    // Param is passed by value, moved
301    pub fn set_type(&mut self, v: i32) {
302        self.type_ = ::std::option::Option::Some(v);
303    }
304
305    // required sint32 index = 2;
306
307    pub fn index(&self) -> i32 {
308        self.index.unwrap_or(0)
309    }
310
311    pub fn clear_index(&mut self) {
312        self.index = ::std::option::Option::None;
313    }
314
315    pub fn has_index(&self) -> bool {
316        self.index.is_some()
317    }
318
319    // Param is passed by value, moved
320    pub fn set_index(&mut self, v: i32) {
321        self.index = ::std::option::Option::Some(v);
322    }
323
324    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
325        let mut fields = ::std::vec::Vec::with_capacity(2);
326        let mut oneofs = ::std::vec::Vec::with_capacity(0);
327        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
328            "type",
329            |m: &BasicMaterialId| { &m.type_ },
330            |m: &mut BasicMaterialId| { &mut m.type_ },
331        ));
332        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
333            "index",
334            |m: &BasicMaterialId| { &m.index },
335            |m: &mut BasicMaterialId| { &mut m.index },
336        ));
337        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<BasicMaterialId>(
338            "BasicMaterialId",
339            fields,
340            oneofs,
341        )
342    }
343}
344
345impl ::protobuf::Message for BasicMaterialId {
346    const NAME: &'static str = "BasicMaterialId";
347
348    fn is_initialized(&self) -> bool {
349        if self.type_.is_none() {
350            return false;
351        }
352        if self.index.is_none() {
353            return false;
354        }
355        true
356    }
357
358    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
359        while let Some(tag) = is.read_raw_tag_or_eof()? {
360            match tag {
361                8 => {
362                    self.type_ = ::std::option::Option::Some(is.read_int32()?);
363                },
364                16 => {
365                    self.index = ::std::option::Option::Some(is.read_sint32()?);
366                },
367                tag => {
368                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
369                },
370            };
371        }
372        ::std::result::Result::Ok(())
373    }
374
375    // Compute sizes of nested messages
376    #[allow(unused_variables)]
377    fn compute_size(&self) -> u64 {
378        let mut my_size = 0;
379        if let Some(v) = self.type_ {
380            my_size += ::protobuf::rt::int32_size(1, v);
381        }
382        if let Some(v) = self.index {
383            my_size += ::protobuf::rt::sint32_size(2, v);
384        }
385        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
386        self.special_fields.cached_size().set(my_size as u32);
387        my_size
388    }
389
390    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
391        if let Some(v) = self.type_ {
392            os.write_int32(1, v)?;
393        }
394        if let Some(v) = self.index {
395            os.write_sint32(2, v)?;
396        }
397        os.write_unknown_fields(self.special_fields.unknown_fields())?;
398        ::std::result::Result::Ok(())
399    }
400
401    fn special_fields(&self) -> &::protobuf::SpecialFields {
402        &self.special_fields
403    }
404
405    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
406        &mut self.special_fields
407    }
408
409    fn new() -> BasicMaterialId {
410        BasicMaterialId::new()
411    }
412
413    fn clear(&mut self) {
414        self.type_ = ::std::option::Option::None;
415        self.index = ::std::option::Option::None;
416        self.special_fields.clear();
417    }
418
419    fn default_instance() -> &'static BasicMaterialId {
420        static instance: BasicMaterialId = BasicMaterialId {
421            type_: ::std::option::Option::None,
422            index: ::std::option::Option::None,
423            special_fields: ::protobuf::SpecialFields::new(),
424        };
425        &instance
426    }
427}
428
429impl ::protobuf::MessageFull for BasicMaterialId {
430    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
431        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
432        descriptor.get(|| file_descriptor().message_by_package_relative_name("BasicMaterialId").unwrap()).clone()
433    }
434}
435
436impl ::std::fmt::Display for BasicMaterialId {
437    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
438        ::protobuf::text_format::fmt(self, f)
439    }
440}
441
442impl ::protobuf::reflect::ProtobufValue for BasicMaterialId {
443    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
444}
445
446// @@protoc_insertion_point(message:dfproto.BasicMaterialInfo)
447#[derive(PartialEq,Clone,Default,Debug)]
448pub struct BasicMaterialInfo {
449    // message fields
450    // @@protoc_insertion_point(field:dfproto.BasicMaterialInfo.type)
451    pub type_: ::std::option::Option<i32>,
452    // @@protoc_insertion_point(field:dfproto.BasicMaterialInfo.index)
453    pub index: ::std::option::Option<i32>,
454    // @@protoc_insertion_point(field:dfproto.BasicMaterialInfo.token)
455    pub token: ::std::option::Option<::std::string::String>,
456    // @@protoc_insertion_point(field:dfproto.BasicMaterialInfo.flags)
457    pub flags: ::std::vec::Vec<i32>,
458    // @@protoc_insertion_point(field:dfproto.BasicMaterialInfo.subtype)
459    pub subtype: ::std::option::Option<i32>,
460    // @@protoc_insertion_point(field:dfproto.BasicMaterialInfo.creature_id)
461    pub creature_id: ::std::option::Option<i32>,
462    // @@protoc_insertion_point(field:dfproto.BasicMaterialInfo.plant_id)
463    pub plant_id: ::std::option::Option<i32>,
464    // @@protoc_insertion_point(field:dfproto.BasicMaterialInfo.histfig_id)
465    pub histfig_id: ::std::option::Option<i32>,
466    // @@protoc_insertion_point(field:dfproto.BasicMaterialInfo.name_prefix)
467    pub name_prefix: ::std::option::Option<::std::string::String>,
468    // @@protoc_insertion_point(field:dfproto.BasicMaterialInfo.state_color)
469    pub state_color: ::std::vec::Vec<u32>,
470    // @@protoc_insertion_point(field:dfproto.BasicMaterialInfo.state_name)
471    pub state_name: ::std::vec::Vec<::std::string::String>,
472    // @@protoc_insertion_point(field:dfproto.BasicMaterialInfo.state_adj)
473    pub state_adj: ::std::vec::Vec<::std::string::String>,
474    // @@protoc_insertion_point(field:dfproto.BasicMaterialInfo.reaction_class)
475    pub reaction_class: ::std::vec::Vec<::std::string::String>,
476    // @@protoc_insertion_point(field:dfproto.BasicMaterialInfo.reaction_product)
477    pub reaction_product: ::std::vec::Vec<basic_material_info::Product>,
478    // @@protoc_insertion_point(field:dfproto.BasicMaterialInfo.inorganic_flags)
479    pub inorganic_flags: ::std::vec::Vec<i32>,
480    // special fields
481    // @@protoc_insertion_point(special_field:dfproto.BasicMaterialInfo.special_fields)
482    pub special_fields: ::protobuf::SpecialFields,
483}
484
485impl<'a> ::std::default::Default for &'a BasicMaterialInfo {
486    fn default() -> &'a BasicMaterialInfo {
487        <BasicMaterialInfo as ::protobuf::Message>::default_instance()
488    }
489}
490
491impl BasicMaterialInfo {
492    pub fn new() -> BasicMaterialInfo {
493        ::std::default::Default::default()
494    }
495
496    // required int32 type = 1;
497
498    pub fn type_(&self) -> i32 {
499        self.type_.unwrap_or(0)
500    }
501
502    pub fn clear_type_(&mut self) {
503        self.type_ = ::std::option::Option::None;
504    }
505
506    pub fn has_type(&self) -> bool {
507        self.type_.is_some()
508    }
509
510    // Param is passed by value, moved
511    pub fn set_type(&mut self, v: i32) {
512        self.type_ = ::std::option::Option::Some(v);
513    }
514
515    // required sint32 index = 2;
516
517    pub fn index(&self) -> i32 {
518        self.index.unwrap_or(0)
519    }
520
521    pub fn clear_index(&mut self) {
522        self.index = ::std::option::Option::None;
523    }
524
525    pub fn has_index(&self) -> bool {
526        self.index.is_some()
527    }
528
529    // Param is passed by value, moved
530    pub fn set_index(&mut self, v: i32) {
531        self.index = ::std::option::Option::Some(v);
532    }
533
534    // required string token = 3;
535
536    pub fn token(&self) -> &str {
537        match self.token.as_ref() {
538            Some(v) => v,
539            None => "",
540        }
541    }
542
543    pub fn clear_token(&mut self) {
544        self.token = ::std::option::Option::None;
545    }
546
547    pub fn has_token(&self) -> bool {
548        self.token.is_some()
549    }
550
551    // Param is passed by value, moved
552    pub fn set_token(&mut self, v: ::std::string::String) {
553        self.token = ::std::option::Option::Some(v);
554    }
555
556    // Mutable pointer to the field.
557    // If field is not initialized, it is initialized with default value first.
558    pub fn mut_token(&mut self) -> &mut ::std::string::String {
559        if self.token.is_none() {
560            self.token = ::std::option::Option::Some(::std::string::String::new());
561        }
562        self.token.as_mut().unwrap()
563    }
564
565    // Take field
566    pub fn take_token(&mut self) -> ::std::string::String {
567        self.token.take().unwrap_or_else(|| ::std::string::String::new())
568    }
569
570    // optional int32 subtype = 5;
571
572    pub fn subtype(&self) -> i32 {
573        self.subtype.unwrap_or(-1i32)
574    }
575
576    pub fn clear_subtype(&mut self) {
577        self.subtype = ::std::option::Option::None;
578    }
579
580    pub fn has_subtype(&self) -> bool {
581        self.subtype.is_some()
582    }
583
584    // Param is passed by value, moved
585    pub fn set_subtype(&mut self, v: i32) {
586        self.subtype = ::std::option::Option::Some(v);
587    }
588
589    // optional int32 creature_id = 6;
590
591    pub fn creature_id(&self) -> i32 {
592        self.creature_id.unwrap_or(-1i32)
593    }
594
595    pub fn clear_creature_id(&mut self) {
596        self.creature_id = ::std::option::Option::None;
597    }
598
599    pub fn has_creature_id(&self) -> bool {
600        self.creature_id.is_some()
601    }
602
603    // Param is passed by value, moved
604    pub fn set_creature_id(&mut self, v: i32) {
605        self.creature_id = ::std::option::Option::Some(v);
606    }
607
608    // optional int32 plant_id = 7;
609
610    pub fn plant_id(&self) -> i32 {
611        self.plant_id.unwrap_or(-1i32)
612    }
613
614    pub fn clear_plant_id(&mut self) {
615        self.plant_id = ::std::option::Option::None;
616    }
617
618    pub fn has_plant_id(&self) -> bool {
619        self.plant_id.is_some()
620    }
621
622    // Param is passed by value, moved
623    pub fn set_plant_id(&mut self, v: i32) {
624        self.plant_id = ::std::option::Option::Some(v);
625    }
626
627    // optional int32 histfig_id = 8;
628
629    pub fn histfig_id(&self) -> i32 {
630        self.histfig_id.unwrap_or(-1i32)
631    }
632
633    pub fn clear_histfig_id(&mut self) {
634        self.histfig_id = ::std::option::Option::None;
635    }
636
637    pub fn has_histfig_id(&self) -> bool {
638        self.histfig_id.is_some()
639    }
640
641    // Param is passed by value, moved
642    pub fn set_histfig_id(&mut self, v: i32) {
643        self.histfig_id = ::std::option::Option::Some(v);
644    }
645
646    // optional string name_prefix = 9;
647
648    pub fn name_prefix(&self) -> &str {
649        match self.name_prefix.as_ref() {
650            Some(v) => v,
651            None => "",
652        }
653    }
654
655    pub fn clear_name_prefix(&mut self) {
656        self.name_prefix = ::std::option::Option::None;
657    }
658
659    pub fn has_name_prefix(&self) -> bool {
660        self.name_prefix.is_some()
661    }
662
663    // Param is passed by value, moved
664    pub fn set_name_prefix(&mut self, v: ::std::string::String) {
665        self.name_prefix = ::std::option::Option::Some(v);
666    }
667
668    // Mutable pointer to the field.
669    // If field is not initialized, it is initialized with default value first.
670    pub fn mut_name_prefix(&mut self) -> &mut ::std::string::String {
671        if self.name_prefix.is_none() {
672            self.name_prefix = ::std::option::Option::Some(::std::string::String::new());
673        }
674        self.name_prefix.as_mut().unwrap()
675    }
676
677    // Take field
678    pub fn take_name_prefix(&mut self) -> ::std::string::String {
679        self.name_prefix.take().unwrap_or_else(|| ::std::string::String::new())
680    }
681
682    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
683        let mut fields = ::std::vec::Vec::with_capacity(15);
684        let mut oneofs = ::std::vec::Vec::with_capacity(0);
685        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
686            "type",
687            |m: &BasicMaterialInfo| { &m.type_ },
688            |m: &mut BasicMaterialInfo| { &mut m.type_ },
689        ));
690        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
691            "index",
692            |m: &BasicMaterialInfo| { &m.index },
693            |m: &mut BasicMaterialInfo| { &mut m.index },
694        ));
695        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
696            "token",
697            |m: &BasicMaterialInfo| { &m.token },
698            |m: &mut BasicMaterialInfo| { &mut m.token },
699        ));
700        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
701            "flags",
702            |m: &BasicMaterialInfo| { &m.flags },
703            |m: &mut BasicMaterialInfo| { &mut m.flags },
704        ));
705        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
706            "subtype",
707            |m: &BasicMaterialInfo| { &m.subtype },
708            |m: &mut BasicMaterialInfo| { &mut m.subtype },
709        ));
710        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
711            "creature_id",
712            |m: &BasicMaterialInfo| { &m.creature_id },
713            |m: &mut BasicMaterialInfo| { &mut m.creature_id },
714        ));
715        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
716            "plant_id",
717            |m: &BasicMaterialInfo| { &m.plant_id },
718            |m: &mut BasicMaterialInfo| { &mut m.plant_id },
719        ));
720        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
721            "histfig_id",
722            |m: &BasicMaterialInfo| { &m.histfig_id },
723            |m: &mut BasicMaterialInfo| { &mut m.histfig_id },
724        ));
725        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
726            "name_prefix",
727            |m: &BasicMaterialInfo| { &m.name_prefix },
728            |m: &mut BasicMaterialInfo| { &mut m.name_prefix },
729        ));
730        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
731            "state_color",
732            |m: &BasicMaterialInfo| { &m.state_color },
733            |m: &mut BasicMaterialInfo| { &mut m.state_color },
734        ));
735        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
736            "state_name",
737            |m: &BasicMaterialInfo| { &m.state_name },
738            |m: &mut BasicMaterialInfo| { &mut m.state_name },
739        ));
740        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
741            "state_adj",
742            |m: &BasicMaterialInfo| { &m.state_adj },
743            |m: &mut BasicMaterialInfo| { &mut m.state_adj },
744        ));
745        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
746            "reaction_class",
747            |m: &BasicMaterialInfo| { &m.reaction_class },
748            |m: &mut BasicMaterialInfo| { &mut m.reaction_class },
749        ));
750        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
751            "reaction_product",
752            |m: &BasicMaterialInfo| { &m.reaction_product },
753            |m: &mut BasicMaterialInfo| { &mut m.reaction_product },
754        ));
755        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
756            "inorganic_flags",
757            |m: &BasicMaterialInfo| { &m.inorganic_flags },
758            |m: &mut BasicMaterialInfo| { &mut m.inorganic_flags },
759        ));
760        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<BasicMaterialInfo>(
761            "BasicMaterialInfo",
762            fields,
763            oneofs,
764        )
765    }
766}
767
768impl ::protobuf::Message for BasicMaterialInfo {
769    const NAME: &'static str = "BasicMaterialInfo";
770
771    fn is_initialized(&self) -> bool {
772        if self.type_.is_none() {
773            return false;
774        }
775        if self.index.is_none() {
776            return false;
777        }
778        if self.token.is_none() {
779            return false;
780        }
781        for v in &self.reaction_product {
782            if !v.is_initialized() {
783                return false;
784            }
785        };
786        true
787    }
788
789    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
790        while let Some(tag) = is.read_raw_tag_or_eof()? {
791            match tag {
792                8 => {
793                    self.type_ = ::std::option::Option::Some(is.read_int32()?);
794                },
795                16 => {
796                    self.index = ::std::option::Option::Some(is.read_sint32()?);
797                },
798                26 => {
799                    self.token = ::std::option::Option::Some(is.read_string()?);
800                },
801                34 => {
802                    is.read_repeated_packed_int32_into(&mut self.flags)?;
803                },
804                32 => {
805                    self.flags.push(is.read_int32()?);
806                },
807                40 => {
808                    self.subtype = ::std::option::Option::Some(is.read_int32()?);
809                },
810                48 => {
811                    self.creature_id = ::std::option::Option::Some(is.read_int32()?);
812                },
813                56 => {
814                    self.plant_id = ::std::option::Option::Some(is.read_int32()?);
815                },
816                64 => {
817                    self.histfig_id = ::std::option::Option::Some(is.read_int32()?);
818                },
819                74 => {
820                    self.name_prefix = ::std::option::Option::Some(is.read_string()?);
821                },
822                82 => {
823                    is.read_repeated_packed_fixed32_into(&mut self.state_color)?;
824                },
825                85 => {
826                    self.state_color.push(is.read_fixed32()?);
827                },
828                90 => {
829                    self.state_name.push(is.read_string()?);
830                },
831                98 => {
832                    self.state_adj.push(is.read_string()?);
833                },
834                106 => {
835                    self.reaction_class.push(is.read_string()?);
836                },
837                114 => {
838                    self.reaction_product.push(is.read_message()?);
839                },
840                122 => {
841                    is.read_repeated_packed_int32_into(&mut self.inorganic_flags)?;
842                },
843                120 => {
844                    self.inorganic_flags.push(is.read_int32()?);
845                },
846                tag => {
847                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
848                },
849            };
850        }
851        ::std::result::Result::Ok(())
852    }
853
854    // Compute sizes of nested messages
855    #[allow(unused_variables)]
856    fn compute_size(&self) -> u64 {
857        let mut my_size = 0;
858        if let Some(v) = self.type_ {
859            my_size += ::protobuf::rt::int32_size(1, v);
860        }
861        if let Some(v) = self.index {
862            my_size += ::protobuf::rt::sint32_size(2, v);
863        }
864        if let Some(v) = self.token.as_ref() {
865            my_size += ::protobuf::rt::string_size(3, &v);
866        }
867        for value in &self.flags {
868            my_size += ::protobuf::rt::int32_size(4, *value);
869        };
870        if let Some(v) = self.subtype {
871            my_size += ::protobuf::rt::int32_size(5, v);
872        }
873        if let Some(v) = self.creature_id {
874            my_size += ::protobuf::rt::int32_size(6, v);
875        }
876        if let Some(v) = self.plant_id {
877            my_size += ::protobuf::rt::int32_size(7, v);
878        }
879        if let Some(v) = self.histfig_id {
880            my_size += ::protobuf::rt::int32_size(8, v);
881        }
882        if let Some(v) = self.name_prefix.as_ref() {
883            my_size += ::protobuf::rt::string_size(9, &v);
884        }
885        my_size += 5 * self.state_color.len() as u64;
886        for value in &self.state_name {
887            my_size += ::protobuf::rt::string_size(11, &value);
888        };
889        for value in &self.state_adj {
890            my_size += ::protobuf::rt::string_size(12, &value);
891        };
892        for value in &self.reaction_class {
893            my_size += ::protobuf::rt::string_size(13, &value);
894        };
895        for value in &self.reaction_product {
896            let len = value.compute_size();
897            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
898        };
899        for value in &self.inorganic_flags {
900            my_size += ::protobuf::rt::int32_size(15, *value);
901        };
902        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
903        self.special_fields.cached_size().set(my_size as u32);
904        my_size
905    }
906
907    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
908        if let Some(v) = self.type_ {
909            os.write_int32(1, v)?;
910        }
911        if let Some(v) = self.index {
912            os.write_sint32(2, v)?;
913        }
914        if let Some(v) = self.token.as_ref() {
915            os.write_string(3, v)?;
916        }
917        for v in &self.flags {
918            os.write_int32(4, *v)?;
919        };
920        if let Some(v) = self.subtype {
921            os.write_int32(5, v)?;
922        }
923        if let Some(v) = self.creature_id {
924            os.write_int32(6, v)?;
925        }
926        if let Some(v) = self.plant_id {
927            os.write_int32(7, v)?;
928        }
929        if let Some(v) = self.histfig_id {
930            os.write_int32(8, v)?;
931        }
932        if let Some(v) = self.name_prefix.as_ref() {
933            os.write_string(9, v)?;
934        }
935        for v in &self.state_color {
936            os.write_fixed32(10, *v)?;
937        };
938        for v in &self.state_name {
939            os.write_string(11, &v)?;
940        };
941        for v in &self.state_adj {
942            os.write_string(12, &v)?;
943        };
944        for v in &self.reaction_class {
945            os.write_string(13, &v)?;
946        };
947        for v in &self.reaction_product {
948            ::protobuf::rt::write_message_field_with_cached_size(14, v, os)?;
949        };
950        for v in &self.inorganic_flags {
951            os.write_int32(15, *v)?;
952        };
953        os.write_unknown_fields(self.special_fields.unknown_fields())?;
954        ::std::result::Result::Ok(())
955    }
956
957    fn special_fields(&self) -> &::protobuf::SpecialFields {
958        &self.special_fields
959    }
960
961    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
962        &mut self.special_fields
963    }
964
965    fn new() -> BasicMaterialInfo {
966        BasicMaterialInfo::new()
967    }
968
969    fn clear(&mut self) {
970        self.type_ = ::std::option::Option::None;
971        self.index = ::std::option::Option::None;
972        self.token = ::std::option::Option::None;
973        self.flags.clear();
974        self.subtype = ::std::option::Option::None;
975        self.creature_id = ::std::option::Option::None;
976        self.plant_id = ::std::option::Option::None;
977        self.histfig_id = ::std::option::Option::None;
978        self.name_prefix = ::std::option::Option::None;
979        self.state_color.clear();
980        self.state_name.clear();
981        self.state_adj.clear();
982        self.reaction_class.clear();
983        self.reaction_product.clear();
984        self.inorganic_flags.clear();
985        self.special_fields.clear();
986    }
987
988    fn default_instance() -> &'static BasicMaterialInfo {
989        static instance: BasicMaterialInfo = BasicMaterialInfo {
990            type_: ::std::option::Option::None,
991            index: ::std::option::Option::None,
992            token: ::std::option::Option::None,
993            flags: ::std::vec::Vec::new(),
994            subtype: ::std::option::Option::None,
995            creature_id: ::std::option::Option::None,
996            plant_id: ::std::option::Option::None,
997            histfig_id: ::std::option::Option::None,
998            name_prefix: ::std::option::Option::None,
999            state_color: ::std::vec::Vec::new(),
1000            state_name: ::std::vec::Vec::new(),
1001            state_adj: ::std::vec::Vec::new(),
1002            reaction_class: ::std::vec::Vec::new(),
1003            reaction_product: ::std::vec::Vec::new(),
1004            inorganic_flags: ::std::vec::Vec::new(),
1005            special_fields: ::protobuf::SpecialFields::new(),
1006        };
1007        &instance
1008    }
1009}
1010
1011impl ::protobuf::MessageFull for BasicMaterialInfo {
1012    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
1013        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
1014        descriptor.get(|| file_descriptor().message_by_package_relative_name("BasicMaterialInfo").unwrap()).clone()
1015    }
1016}
1017
1018impl ::std::fmt::Display for BasicMaterialInfo {
1019    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1020        ::protobuf::text_format::fmt(self, f)
1021    }
1022}
1023
1024impl ::protobuf::reflect::ProtobufValue for BasicMaterialInfo {
1025    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
1026}
1027
1028/// Nested message and enums of message `BasicMaterialInfo`
1029pub mod basic_material_info {
1030    // @@protoc_insertion_point(message:dfproto.BasicMaterialInfo.Product)
1031    #[derive(PartialEq,Clone,Default,Debug)]
1032    pub struct Product {
1033        // message fields
1034        // @@protoc_insertion_point(field:dfproto.BasicMaterialInfo.Product.id)
1035        pub id: ::std::option::Option<::std::string::String>,
1036        // @@protoc_insertion_point(field:dfproto.BasicMaterialInfo.Product.type)
1037        pub type_: ::std::option::Option<i32>,
1038        // @@protoc_insertion_point(field:dfproto.BasicMaterialInfo.Product.index)
1039        pub index: ::std::option::Option<i32>,
1040        // special fields
1041        // @@protoc_insertion_point(special_field:dfproto.BasicMaterialInfo.Product.special_fields)
1042        pub special_fields: ::protobuf::SpecialFields,
1043    }
1044
1045    impl<'a> ::std::default::Default for &'a Product {
1046        fn default() -> &'a Product {
1047            <Product as ::protobuf::Message>::default_instance()
1048        }
1049    }
1050
1051    impl Product {
1052        pub fn new() -> Product {
1053            ::std::default::Default::default()
1054        }
1055
1056        // required string id = 1;
1057
1058        pub fn id(&self) -> &str {
1059            match self.id.as_ref() {
1060                Some(v) => v,
1061                None => "",
1062            }
1063        }
1064
1065        pub fn clear_id(&mut self) {
1066            self.id = ::std::option::Option::None;
1067        }
1068
1069        pub fn has_id(&self) -> bool {
1070            self.id.is_some()
1071        }
1072
1073        // Param is passed by value, moved
1074        pub fn set_id(&mut self, v: ::std::string::String) {
1075            self.id = ::std::option::Option::Some(v);
1076        }
1077
1078        // Mutable pointer to the field.
1079        // If field is not initialized, it is initialized with default value first.
1080        pub fn mut_id(&mut self) -> &mut ::std::string::String {
1081            if self.id.is_none() {
1082                self.id = ::std::option::Option::Some(::std::string::String::new());
1083            }
1084            self.id.as_mut().unwrap()
1085        }
1086
1087        // Take field
1088        pub fn take_id(&mut self) -> ::std::string::String {
1089            self.id.take().unwrap_or_else(|| ::std::string::String::new())
1090        }
1091
1092        // required int32 type = 2;
1093
1094        pub fn type_(&self) -> i32 {
1095            self.type_.unwrap_or(0)
1096        }
1097
1098        pub fn clear_type_(&mut self) {
1099            self.type_ = ::std::option::Option::None;
1100        }
1101
1102        pub fn has_type(&self) -> bool {
1103            self.type_.is_some()
1104        }
1105
1106        // Param is passed by value, moved
1107        pub fn set_type(&mut self, v: i32) {
1108            self.type_ = ::std::option::Option::Some(v);
1109        }
1110
1111        // required sint32 index = 3;
1112
1113        pub fn index(&self) -> i32 {
1114            self.index.unwrap_or(0)
1115        }
1116
1117        pub fn clear_index(&mut self) {
1118            self.index = ::std::option::Option::None;
1119        }
1120
1121        pub fn has_index(&self) -> bool {
1122            self.index.is_some()
1123        }
1124
1125        // Param is passed by value, moved
1126        pub fn set_index(&mut self, v: i32) {
1127            self.index = ::std::option::Option::Some(v);
1128        }
1129
1130        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
1131            let mut fields = ::std::vec::Vec::with_capacity(3);
1132            let mut oneofs = ::std::vec::Vec::with_capacity(0);
1133            fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1134                "id",
1135                |m: &Product| { &m.id },
1136                |m: &mut Product| { &mut m.id },
1137            ));
1138            fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1139                "type",
1140                |m: &Product| { &m.type_ },
1141                |m: &mut Product| { &mut m.type_ },
1142            ));
1143            fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1144                "index",
1145                |m: &Product| { &m.index },
1146                |m: &mut Product| { &mut m.index },
1147            ));
1148            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Product>(
1149                "BasicMaterialInfo.Product",
1150                fields,
1151                oneofs,
1152            )
1153        }
1154    }
1155
1156    impl ::protobuf::Message for Product {
1157        const NAME: &'static str = "Product";
1158
1159        fn is_initialized(&self) -> bool {
1160            if self.id.is_none() {
1161                return false;
1162            }
1163            if self.type_.is_none() {
1164                return false;
1165            }
1166            if self.index.is_none() {
1167                return false;
1168            }
1169            true
1170        }
1171
1172        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
1173            while let Some(tag) = is.read_raw_tag_or_eof()? {
1174                match tag {
1175                    10 => {
1176                        self.id = ::std::option::Option::Some(is.read_string()?);
1177                    },
1178                    16 => {
1179                        self.type_ = ::std::option::Option::Some(is.read_int32()?);
1180                    },
1181                    24 => {
1182                        self.index = ::std::option::Option::Some(is.read_sint32()?);
1183                    },
1184                    tag => {
1185                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
1186                    },
1187                };
1188            }
1189            ::std::result::Result::Ok(())
1190        }
1191
1192        // Compute sizes of nested messages
1193        #[allow(unused_variables)]
1194        fn compute_size(&self) -> u64 {
1195            let mut my_size = 0;
1196            if let Some(v) = self.id.as_ref() {
1197                my_size += ::protobuf::rt::string_size(1, &v);
1198            }
1199            if let Some(v) = self.type_ {
1200                my_size += ::protobuf::rt::int32_size(2, v);
1201            }
1202            if let Some(v) = self.index {
1203                my_size += ::protobuf::rt::sint32_size(3, v);
1204            }
1205            my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
1206            self.special_fields.cached_size().set(my_size as u32);
1207            my_size
1208        }
1209
1210        fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
1211            if let Some(v) = self.id.as_ref() {
1212                os.write_string(1, v)?;
1213            }
1214            if let Some(v) = self.type_ {
1215                os.write_int32(2, v)?;
1216            }
1217            if let Some(v) = self.index {
1218                os.write_sint32(3, v)?;
1219            }
1220            os.write_unknown_fields(self.special_fields.unknown_fields())?;
1221            ::std::result::Result::Ok(())
1222        }
1223
1224        fn special_fields(&self) -> &::protobuf::SpecialFields {
1225            &self.special_fields
1226        }
1227
1228        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
1229            &mut self.special_fields
1230        }
1231
1232        fn new() -> Product {
1233            Product::new()
1234        }
1235
1236        fn clear(&mut self) {
1237            self.id = ::std::option::Option::None;
1238            self.type_ = ::std::option::Option::None;
1239            self.index = ::std::option::Option::None;
1240            self.special_fields.clear();
1241        }
1242
1243        fn default_instance() -> &'static Product {
1244            static instance: Product = Product {
1245                id: ::std::option::Option::None,
1246                type_: ::std::option::Option::None,
1247                index: ::std::option::Option::None,
1248                special_fields: ::protobuf::SpecialFields::new(),
1249            };
1250            &instance
1251        }
1252    }
1253
1254    impl ::protobuf::MessageFull for Product {
1255        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
1256            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
1257            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("BasicMaterialInfo.Product").unwrap()).clone()
1258        }
1259    }
1260
1261    impl ::std::fmt::Display for Product {
1262        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1263            ::protobuf::text_format::fmt(self, f)
1264        }
1265    }
1266
1267    impl ::protobuf::reflect::ProtobufValue for Product {
1268        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
1269    }
1270}
1271
1272// @@protoc_insertion_point(message:dfproto.BasicMaterialInfoMask)
1273#[derive(PartialEq,Clone,Default,Debug)]
1274pub struct BasicMaterialInfoMask {
1275    // message fields
1276    // @@protoc_insertion_point(field:dfproto.BasicMaterialInfoMask.states)
1277    pub states: ::std::vec::Vec<::protobuf::EnumOrUnknown<basic_material_info_mask::StateType>>,
1278    // @@protoc_insertion_point(field:dfproto.BasicMaterialInfoMask.temperature)
1279    pub temperature: ::std::option::Option<i32>,
1280    // @@protoc_insertion_point(field:dfproto.BasicMaterialInfoMask.flags)
1281    pub flags: ::std::option::Option<bool>,
1282    // @@protoc_insertion_point(field:dfproto.BasicMaterialInfoMask.reaction)
1283    pub reaction: ::std::option::Option<bool>,
1284    // special fields
1285    // @@protoc_insertion_point(special_field:dfproto.BasicMaterialInfoMask.special_fields)
1286    pub special_fields: ::protobuf::SpecialFields,
1287}
1288
1289impl<'a> ::std::default::Default for &'a BasicMaterialInfoMask {
1290    fn default() -> &'a BasicMaterialInfoMask {
1291        <BasicMaterialInfoMask as ::protobuf::Message>::default_instance()
1292    }
1293}
1294
1295impl BasicMaterialInfoMask {
1296    pub fn new() -> BasicMaterialInfoMask {
1297        ::std::default::Default::default()
1298    }
1299
1300    // optional int32 temperature = 4;
1301
1302    pub fn temperature(&self) -> i32 {
1303        self.temperature.unwrap_or(10015i32)
1304    }
1305
1306    pub fn clear_temperature(&mut self) {
1307        self.temperature = ::std::option::Option::None;
1308    }
1309
1310    pub fn has_temperature(&self) -> bool {
1311        self.temperature.is_some()
1312    }
1313
1314    // Param is passed by value, moved
1315    pub fn set_temperature(&mut self, v: i32) {
1316        self.temperature = ::std::option::Option::Some(v);
1317    }
1318
1319    // optional bool flags = 2;
1320
1321    pub fn flags(&self) -> bool {
1322        self.flags.unwrap_or(false)
1323    }
1324
1325    pub fn clear_flags(&mut self) {
1326        self.flags = ::std::option::Option::None;
1327    }
1328
1329    pub fn has_flags(&self) -> bool {
1330        self.flags.is_some()
1331    }
1332
1333    // Param is passed by value, moved
1334    pub fn set_flags(&mut self, v: bool) {
1335        self.flags = ::std::option::Option::Some(v);
1336    }
1337
1338    // optional bool reaction = 3;
1339
1340    pub fn reaction(&self) -> bool {
1341        self.reaction.unwrap_or(false)
1342    }
1343
1344    pub fn clear_reaction(&mut self) {
1345        self.reaction = ::std::option::Option::None;
1346    }
1347
1348    pub fn has_reaction(&self) -> bool {
1349        self.reaction.is_some()
1350    }
1351
1352    // Param is passed by value, moved
1353    pub fn set_reaction(&mut self, v: bool) {
1354        self.reaction = ::std::option::Option::Some(v);
1355    }
1356
1357    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
1358        let mut fields = ::std::vec::Vec::with_capacity(4);
1359        let mut oneofs = ::std::vec::Vec::with_capacity(0);
1360        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
1361            "states",
1362            |m: &BasicMaterialInfoMask| { &m.states },
1363            |m: &mut BasicMaterialInfoMask| { &mut m.states },
1364        ));
1365        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1366            "temperature",
1367            |m: &BasicMaterialInfoMask| { &m.temperature },
1368            |m: &mut BasicMaterialInfoMask| { &mut m.temperature },
1369        ));
1370        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1371            "flags",
1372            |m: &BasicMaterialInfoMask| { &m.flags },
1373            |m: &mut BasicMaterialInfoMask| { &mut m.flags },
1374        ));
1375        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1376            "reaction",
1377            |m: &BasicMaterialInfoMask| { &m.reaction },
1378            |m: &mut BasicMaterialInfoMask| { &mut m.reaction },
1379        ));
1380        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<BasicMaterialInfoMask>(
1381            "BasicMaterialInfoMask",
1382            fields,
1383            oneofs,
1384        )
1385    }
1386}
1387
1388impl ::protobuf::Message for BasicMaterialInfoMask {
1389    const NAME: &'static str = "BasicMaterialInfoMask";
1390
1391    fn is_initialized(&self) -> bool {
1392        true
1393    }
1394
1395    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
1396        while let Some(tag) = is.read_raw_tag_or_eof()? {
1397            match tag {
1398                8 => {
1399                    self.states.push(is.read_enum_or_unknown()?);
1400                },
1401                10 => {
1402                    ::protobuf::rt::read_repeated_packed_enum_or_unknown_into(is, &mut self.states)?
1403                },
1404                32 => {
1405                    self.temperature = ::std::option::Option::Some(is.read_int32()?);
1406                },
1407                16 => {
1408                    self.flags = ::std::option::Option::Some(is.read_bool()?);
1409                },
1410                24 => {
1411                    self.reaction = ::std::option::Option::Some(is.read_bool()?);
1412                },
1413                tag => {
1414                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
1415                },
1416            };
1417        }
1418        ::std::result::Result::Ok(())
1419    }
1420
1421    // Compute sizes of nested messages
1422    #[allow(unused_variables)]
1423    fn compute_size(&self) -> u64 {
1424        let mut my_size = 0;
1425        for value in &self.states {
1426            my_size += ::protobuf::rt::int32_size(1, value.value());
1427        };
1428        if let Some(v) = self.temperature {
1429            my_size += ::protobuf::rt::int32_size(4, v);
1430        }
1431        if let Some(v) = self.flags {
1432            my_size += 1 + 1;
1433        }
1434        if let Some(v) = self.reaction {
1435            my_size += 1 + 1;
1436        }
1437        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
1438        self.special_fields.cached_size().set(my_size as u32);
1439        my_size
1440    }
1441
1442    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
1443        for v in &self.states {
1444            os.write_enum(1, ::protobuf::EnumOrUnknown::value(v))?;
1445        };
1446        if let Some(v) = self.temperature {
1447            os.write_int32(4, v)?;
1448        }
1449        if let Some(v) = self.flags {
1450            os.write_bool(2, v)?;
1451        }
1452        if let Some(v) = self.reaction {
1453            os.write_bool(3, v)?;
1454        }
1455        os.write_unknown_fields(self.special_fields.unknown_fields())?;
1456        ::std::result::Result::Ok(())
1457    }
1458
1459    fn special_fields(&self) -> &::protobuf::SpecialFields {
1460        &self.special_fields
1461    }
1462
1463    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
1464        &mut self.special_fields
1465    }
1466
1467    fn new() -> BasicMaterialInfoMask {
1468        BasicMaterialInfoMask::new()
1469    }
1470
1471    fn clear(&mut self) {
1472        self.states.clear();
1473        self.temperature = ::std::option::Option::None;
1474        self.flags = ::std::option::Option::None;
1475        self.reaction = ::std::option::Option::None;
1476        self.special_fields.clear();
1477    }
1478
1479    fn default_instance() -> &'static BasicMaterialInfoMask {
1480        static instance: BasicMaterialInfoMask = BasicMaterialInfoMask {
1481            states: ::std::vec::Vec::new(),
1482            temperature: ::std::option::Option::None,
1483            flags: ::std::option::Option::None,
1484            reaction: ::std::option::Option::None,
1485            special_fields: ::protobuf::SpecialFields::new(),
1486        };
1487        &instance
1488    }
1489}
1490
1491impl ::protobuf::MessageFull for BasicMaterialInfoMask {
1492    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
1493        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
1494        descriptor.get(|| file_descriptor().message_by_package_relative_name("BasicMaterialInfoMask").unwrap()).clone()
1495    }
1496}
1497
1498impl ::std::fmt::Display for BasicMaterialInfoMask {
1499    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1500        ::protobuf::text_format::fmt(self, f)
1501    }
1502}
1503
1504impl ::protobuf::reflect::ProtobufValue for BasicMaterialInfoMask {
1505    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
1506}
1507
1508/// Nested message and enums of message `BasicMaterialInfoMask`
1509pub mod basic_material_info_mask {
1510    #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
1511    // @@protoc_insertion_point(enum:dfproto.BasicMaterialInfoMask.StateType)
1512    pub enum StateType {
1513        // @@protoc_insertion_point(enum_value:dfproto.BasicMaterialInfoMask.StateType.Solid)
1514        Solid = 0,
1515        // @@protoc_insertion_point(enum_value:dfproto.BasicMaterialInfoMask.StateType.Liquid)
1516        Liquid = 1,
1517        // @@protoc_insertion_point(enum_value:dfproto.BasicMaterialInfoMask.StateType.Gas)
1518        Gas = 2,
1519        // @@protoc_insertion_point(enum_value:dfproto.BasicMaterialInfoMask.StateType.Powder)
1520        Powder = 3,
1521        // @@protoc_insertion_point(enum_value:dfproto.BasicMaterialInfoMask.StateType.Paste)
1522        Paste = 4,
1523        // @@protoc_insertion_point(enum_value:dfproto.BasicMaterialInfoMask.StateType.Pressed)
1524        Pressed = 5,
1525    }
1526
1527    impl ::protobuf::Enum for StateType {
1528        const NAME: &'static str = "StateType";
1529
1530        fn value(&self) -> i32 {
1531            *self as i32
1532        }
1533
1534        fn from_i32(value: i32) -> ::std::option::Option<StateType> {
1535            match value {
1536                0 => ::std::option::Option::Some(StateType::Solid),
1537                1 => ::std::option::Option::Some(StateType::Liquid),
1538                2 => ::std::option::Option::Some(StateType::Gas),
1539                3 => ::std::option::Option::Some(StateType::Powder),
1540                4 => ::std::option::Option::Some(StateType::Paste),
1541                5 => ::std::option::Option::Some(StateType::Pressed),
1542                _ => ::std::option::Option::None
1543            }
1544        }
1545
1546        fn from_str(str: &str) -> ::std::option::Option<StateType> {
1547            match str {
1548                "Solid" => ::std::option::Option::Some(StateType::Solid),
1549                "Liquid" => ::std::option::Option::Some(StateType::Liquid),
1550                "Gas" => ::std::option::Option::Some(StateType::Gas),
1551                "Powder" => ::std::option::Option::Some(StateType::Powder),
1552                "Paste" => ::std::option::Option::Some(StateType::Paste),
1553                "Pressed" => ::std::option::Option::Some(StateType::Pressed),
1554                _ => ::std::option::Option::None
1555            }
1556        }
1557
1558        const VALUES: &'static [StateType] = &[
1559            StateType::Solid,
1560            StateType::Liquid,
1561            StateType::Gas,
1562            StateType::Powder,
1563            StateType::Paste,
1564            StateType::Pressed,
1565        ];
1566    }
1567
1568    impl ::protobuf::EnumFull for StateType {
1569        fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor {
1570            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new();
1571            descriptor.get(|| super::file_descriptor().enum_by_package_relative_name("BasicMaterialInfoMask.StateType").unwrap()).clone()
1572        }
1573
1574        fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor {
1575            let index = *self as usize;
1576            Self::enum_descriptor().value_by_index(index)
1577        }
1578    }
1579
1580    impl ::std::default::Default for StateType {
1581        fn default() -> Self {
1582            StateType::Solid
1583        }
1584    }
1585
1586    impl StateType {
1587        pub(in super) fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData {
1588            ::protobuf::reflect::GeneratedEnumDescriptorData::new::<StateType>("BasicMaterialInfoMask.StateType")
1589        }
1590    }
1591}
1592
1593// @@protoc_insertion_point(message:dfproto.JobSkillAttr)
1594#[derive(PartialEq,Clone,Default,Debug)]
1595pub struct JobSkillAttr {
1596    // message fields
1597    // @@protoc_insertion_point(field:dfproto.JobSkillAttr.id)
1598    pub id: ::std::option::Option<i32>,
1599    // @@protoc_insertion_point(field:dfproto.JobSkillAttr.key)
1600    pub key: ::std::option::Option<::std::string::String>,
1601    // @@protoc_insertion_point(field:dfproto.JobSkillAttr.caption)
1602    pub caption: ::std::option::Option<::std::string::String>,
1603    // @@protoc_insertion_point(field:dfproto.JobSkillAttr.caption_noun)
1604    pub caption_noun: ::std::option::Option<::std::string::String>,
1605    // @@protoc_insertion_point(field:dfproto.JobSkillAttr.profession)
1606    pub profession: ::std::option::Option<i32>,
1607    // @@protoc_insertion_point(field:dfproto.JobSkillAttr.labor)
1608    pub labor: ::std::option::Option<i32>,
1609    // @@protoc_insertion_point(field:dfproto.JobSkillAttr.type)
1610    pub type_: ::std::option::Option<::std::string::String>,
1611    // special fields
1612    // @@protoc_insertion_point(special_field:dfproto.JobSkillAttr.special_fields)
1613    pub special_fields: ::protobuf::SpecialFields,
1614}
1615
1616impl<'a> ::std::default::Default for &'a JobSkillAttr {
1617    fn default() -> &'a JobSkillAttr {
1618        <JobSkillAttr as ::protobuf::Message>::default_instance()
1619    }
1620}
1621
1622impl JobSkillAttr {
1623    pub fn new() -> JobSkillAttr {
1624        ::std::default::Default::default()
1625    }
1626
1627    // required int32 id = 1;
1628
1629    pub fn id(&self) -> i32 {
1630        self.id.unwrap_or(0)
1631    }
1632
1633    pub fn clear_id(&mut self) {
1634        self.id = ::std::option::Option::None;
1635    }
1636
1637    pub fn has_id(&self) -> bool {
1638        self.id.is_some()
1639    }
1640
1641    // Param is passed by value, moved
1642    pub fn set_id(&mut self, v: i32) {
1643        self.id = ::std::option::Option::Some(v);
1644    }
1645
1646    // required string key = 2;
1647
1648    pub fn key(&self) -> &str {
1649        match self.key.as_ref() {
1650            Some(v) => v,
1651            None => "",
1652        }
1653    }
1654
1655    pub fn clear_key(&mut self) {
1656        self.key = ::std::option::Option::None;
1657    }
1658
1659    pub fn has_key(&self) -> bool {
1660        self.key.is_some()
1661    }
1662
1663    // Param is passed by value, moved
1664    pub fn set_key(&mut self, v: ::std::string::String) {
1665        self.key = ::std::option::Option::Some(v);
1666    }
1667
1668    // Mutable pointer to the field.
1669    // If field is not initialized, it is initialized with default value first.
1670    pub fn mut_key(&mut self) -> &mut ::std::string::String {
1671        if self.key.is_none() {
1672            self.key = ::std::option::Option::Some(::std::string::String::new());
1673        }
1674        self.key.as_mut().unwrap()
1675    }
1676
1677    // Take field
1678    pub fn take_key(&mut self) -> ::std::string::String {
1679        self.key.take().unwrap_or_else(|| ::std::string::String::new())
1680    }
1681
1682    // optional string caption = 3;
1683
1684    pub fn caption(&self) -> &str {
1685        match self.caption.as_ref() {
1686            Some(v) => v,
1687            None => "",
1688        }
1689    }
1690
1691    pub fn clear_caption(&mut self) {
1692        self.caption = ::std::option::Option::None;
1693    }
1694
1695    pub fn has_caption(&self) -> bool {
1696        self.caption.is_some()
1697    }
1698
1699    // Param is passed by value, moved
1700    pub fn set_caption(&mut self, v: ::std::string::String) {
1701        self.caption = ::std::option::Option::Some(v);
1702    }
1703
1704    // Mutable pointer to the field.
1705    // If field is not initialized, it is initialized with default value first.
1706    pub fn mut_caption(&mut self) -> &mut ::std::string::String {
1707        if self.caption.is_none() {
1708            self.caption = ::std::option::Option::Some(::std::string::String::new());
1709        }
1710        self.caption.as_mut().unwrap()
1711    }
1712
1713    // Take field
1714    pub fn take_caption(&mut self) -> ::std::string::String {
1715        self.caption.take().unwrap_or_else(|| ::std::string::String::new())
1716    }
1717
1718    // optional string caption_noun = 4;
1719
1720    pub fn caption_noun(&self) -> &str {
1721        match self.caption_noun.as_ref() {
1722            Some(v) => v,
1723            None => "",
1724        }
1725    }
1726
1727    pub fn clear_caption_noun(&mut self) {
1728        self.caption_noun = ::std::option::Option::None;
1729    }
1730
1731    pub fn has_caption_noun(&self) -> bool {
1732        self.caption_noun.is_some()
1733    }
1734
1735    // Param is passed by value, moved
1736    pub fn set_caption_noun(&mut self, v: ::std::string::String) {
1737        self.caption_noun = ::std::option::Option::Some(v);
1738    }
1739
1740    // Mutable pointer to the field.
1741    // If field is not initialized, it is initialized with default value first.
1742    pub fn mut_caption_noun(&mut self) -> &mut ::std::string::String {
1743        if self.caption_noun.is_none() {
1744            self.caption_noun = ::std::option::Option::Some(::std::string::String::new());
1745        }
1746        self.caption_noun.as_mut().unwrap()
1747    }
1748
1749    // Take field
1750    pub fn take_caption_noun(&mut self) -> ::std::string::String {
1751        self.caption_noun.take().unwrap_or_else(|| ::std::string::String::new())
1752    }
1753
1754    // optional int32 profession = 5;
1755
1756    pub fn profession(&self) -> i32 {
1757        self.profession.unwrap_or(0)
1758    }
1759
1760    pub fn clear_profession(&mut self) {
1761        self.profession = ::std::option::Option::None;
1762    }
1763
1764    pub fn has_profession(&self) -> bool {
1765        self.profession.is_some()
1766    }
1767
1768    // Param is passed by value, moved
1769    pub fn set_profession(&mut self, v: i32) {
1770        self.profession = ::std::option::Option::Some(v);
1771    }
1772
1773    // optional int32 labor = 6;
1774
1775    pub fn labor(&self) -> i32 {
1776        self.labor.unwrap_or(0)
1777    }
1778
1779    pub fn clear_labor(&mut self) {
1780        self.labor = ::std::option::Option::None;
1781    }
1782
1783    pub fn has_labor(&self) -> bool {
1784        self.labor.is_some()
1785    }
1786
1787    // Param is passed by value, moved
1788    pub fn set_labor(&mut self, v: i32) {
1789        self.labor = ::std::option::Option::Some(v);
1790    }
1791
1792    // optional string type = 7;
1793
1794    pub fn type_(&self) -> &str {
1795        match self.type_.as_ref() {
1796            Some(v) => v,
1797            None => "",
1798        }
1799    }
1800
1801    pub fn clear_type_(&mut self) {
1802        self.type_ = ::std::option::Option::None;
1803    }
1804
1805    pub fn has_type(&self) -> bool {
1806        self.type_.is_some()
1807    }
1808
1809    // Param is passed by value, moved
1810    pub fn set_type(&mut self, v: ::std::string::String) {
1811        self.type_ = ::std::option::Option::Some(v);
1812    }
1813
1814    // Mutable pointer to the field.
1815    // If field is not initialized, it is initialized with default value first.
1816    pub fn mut_type(&mut self) -> &mut ::std::string::String {
1817        if self.type_.is_none() {
1818            self.type_ = ::std::option::Option::Some(::std::string::String::new());
1819        }
1820        self.type_.as_mut().unwrap()
1821    }
1822
1823    // Take field
1824    pub fn take_type_(&mut self) -> ::std::string::String {
1825        self.type_.take().unwrap_or_else(|| ::std::string::String::new())
1826    }
1827
1828    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
1829        let mut fields = ::std::vec::Vec::with_capacity(7);
1830        let mut oneofs = ::std::vec::Vec::with_capacity(0);
1831        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1832            "id",
1833            |m: &JobSkillAttr| { &m.id },
1834            |m: &mut JobSkillAttr| { &mut m.id },
1835        ));
1836        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1837            "key",
1838            |m: &JobSkillAttr| { &m.key },
1839            |m: &mut JobSkillAttr| { &mut m.key },
1840        ));
1841        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1842            "caption",
1843            |m: &JobSkillAttr| { &m.caption },
1844            |m: &mut JobSkillAttr| { &mut m.caption },
1845        ));
1846        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1847            "caption_noun",
1848            |m: &JobSkillAttr| { &m.caption_noun },
1849            |m: &mut JobSkillAttr| { &mut m.caption_noun },
1850        ));
1851        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1852            "profession",
1853            |m: &JobSkillAttr| { &m.profession },
1854            |m: &mut JobSkillAttr| { &mut m.profession },
1855        ));
1856        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1857            "labor",
1858            |m: &JobSkillAttr| { &m.labor },
1859            |m: &mut JobSkillAttr| { &mut m.labor },
1860        ));
1861        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1862            "type",
1863            |m: &JobSkillAttr| { &m.type_ },
1864            |m: &mut JobSkillAttr| { &mut m.type_ },
1865        ));
1866        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<JobSkillAttr>(
1867            "JobSkillAttr",
1868            fields,
1869            oneofs,
1870        )
1871    }
1872}
1873
1874impl ::protobuf::Message for JobSkillAttr {
1875    const NAME: &'static str = "JobSkillAttr";
1876
1877    fn is_initialized(&self) -> bool {
1878        if self.id.is_none() {
1879            return false;
1880        }
1881        if self.key.is_none() {
1882            return false;
1883        }
1884        true
1885    }
1886
1887    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
1888        while let Some(tag) = is.read_raw_tag_or_eof()? {
1889            match tag {
1890                8 => {
1891                    self.id = ::std::option::Option::Some(is.read_int32()?);
1892                },
1893                18 => {
1894                    self.key = ::std::option::Option::Some(is.read_string()?);
1895                },
1896                26 => {
1897                    self.caption = ::std::option::Option::Some(is.read_string()?);
1898                },
1899                34 => {
1900                    self.caption_noun = ::std::option::Option::Some(is.read_string()?);
1901                },
1902                40 => {
1903                    self.profession = ::std::option::Option::Some(is.read_int32()?);
1904                },
1905                48 => {
1906                    self.labor = ::std::option::Option::Some(is.read_int32()?);
1907                },
1908                58 => {
1909                    self.type_ = ::std::option::Option::Some(is.read_string()?);
1910                },
1911                tag => {
1912                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
1913                },
1914            };
1915        }
1916        ::std::result::Result::Ok(())
1917    }
1918
1919    // Compute sizes of nested messages
1920    #[allow(unused_variables)]
1921    fn compute_size(&self) -> u64 {
1922        let mut my_size = 0;
1923        if let Some(v) = self.id {
1924            my_size += ::protobuf::rt::int32_size(1, v);
1925        }
1926        if let Some(v) = self.key.as_ref() {
1927            my_size += ::protobuf::rt::string_size(2, &v);
1928        }
1929        if let Some(v) = self.caption.as_ref() {
1930            my_size += ::protobuf::rt::string_size(3, &v);
1931        }
1932        if let Some(v) = self.caption_noun.as_ref() {
1933            my_size += ::protobuf::rt::string_size(4, &v);
1934        }
1935        if let Some(v) = self.profession {
1936            my_size += ::protobuf::rt::int32_size(5, v);
1937        }
1938        if let Some(v) = self.labor {
1939            my_size += ::protobuf::rt::int32_size(6, v);
1940        }
1941        if let Some(v) = self.type_.as_ref() {
1942            my_size += ::protobuf::rt::string_size(7, &v);
1943        }
1944        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
1945        self.special_fields.cached_size().set(my_size as u32);
1946        my_size
1947    }
1948
1949    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
1950        if let Some(v) = self.id {
1951            os.write_int32(1, v)?;
1952        }
1953        if let Some(v) = self.key.as_ref() {
1954            os.write_string(2, v)?;
1955        }
1956        if let Some(v) = self.caption.as_ref() {
1957            os.write_string(3, v)?;
1958        }
1959        if let Some(v) = self.caption_noun.as_ref() {
1960            os.write_string(4, v)?;
1961        }
1962        if let Some(v) = self.profession {
1963            os.write_int32(5, v)?;
1964        }
1965        if let Some(v) = self.labor {
1966            os.write_int32(6, v)?;
1967        }
1968        if let Some(v) = self.type_.as_ref() {
1969            os.write_string(7, v)?;
1970        }
1971        os.write_unknown_fields(self.special_fields.unknown_fields())?;
1972        ::std::result::Result::Ok(())
1973    }
1974
1975    fn special_fields(&self) -> &::protobuf::SpecialFields {
1976        &self.special_fields
1977    }
1978
1979    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
1980        &mut self.special_fields
1981    }
1982
1983    fn new() -> JobSkillAttr {
1984        JobSkillAttr::new()
1985    }
1986
1987    fn clear(&mut self) {
1988        self.id = ::std::option::Option::None;
1989        self.key = ::std::option::Option::None;
1990        self.caption = ::std::option::Option::None;
1991        self.caption_noun = ::std::option::Option::None;
1992        self.profession = ::std::option::Option::None;
1993        self.labor = ::std::option::Option::None;
1994        self.type_ = ::std::option::Option::None;
1995        self.special_fields.clear();
1996    }
1997
1998    fn default_instance() -> &'static JobSkillAttr {
1999        static instance: JobSkillAttr = JobSkillAttr {
2000            id: ::std::option::Option::None,
2001            key: ::std::option::Option::None,
2002            caption: ::std::option::Option::None,
2003            caption_noun: ::std::option::Option::None,
2004            profession: ::std::option::Option::None,
2005            labor: ::std::option::Option::None,
2006            type_: ::std::option::Option::None,
2007            special_fields: ::protobuf::SpecialFields::new(),
2008        };
2009        &instance
2010    }
2011}
2012
2013impl ::protobuf::MessageFull for JobSkillAttr {
2014    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
2015        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
2016        descriptor.get(|| file_descriptor().message_by_package_relative_name("JobSkillAttr").unwrap()).clone()
2017    }
2018}
2019
2020impl ::std::fmt::Display for JobSkillAttr {
2021    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2022        ::protobuf::text_format::fmt(self, f)
2023    }
2024}
2025
2026impl ::protobuf::reflect::ProtobufValue for JobSkillAttr {
2027    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
2028}
2029
2030// @@protoc_insertion_point(message:dfproto.ProfessionAttr)
2031#[derive(PartialEq,Clone,Default,Debug)]
2032pub struct ProfessionAttr {
2033    // message fields
2034    // @@protoc_insertion_point(field:dfproto.ProfessionAttr.id)
2035    pub id: ::std::option::Option<i32>,
2036    // @@protoc_insertion_point(field:dfproto.ProfessionAttr.key)
2037    pub key: ::std::option::Option<::std::string::String>,
2038    // @@protoc_insertion_point(field:dfproto.ProfessionAttr.caption)
2039    pub caption: ::std::option::Option<::std::string::String>,
2040    // @@protoc_insertion_point(field:dfproto.ProfessionAttr.military)
2041    pub military: ::std::option::Option<bool>,
2042    // @@protoc_insertion_point(field:dfproto.ProfessionAttr.can_assign_labor)
2043    pub can_assign_labor: ::std::option::Option<bool>,
2044    // @@protoc_insertion_point(field:dfproto.ProfessionAttr.parent)
2045    pub parent: ::std::option::Option<i32>,
2046    // special fields
2047    // @@protoc_insertion_point(special_field:dfproto.ProfessionAttr.special_fields)
2048    pub special_fields: ::protobuf::SpecialFields,
2049}
2050
2051impl<'a> ::std::default::Default for &'a ProfessionAttr {
2052    fn default() -> &'a ProfessionAttr {
2053        <ProfessionAttr as ::protobuf::Message>::default_instance()
2054    }
2055}
2056
2057impl ProfessionAttr {
2058    pub fn new() -> ProfessionAttr {
2059        ::std::default::Default::default()
2060    }
2061
2062    // required int32 id = 1;
2063
2064    pub fn id(&self) -> i32 {
2065        self.id.unwrap_or(0)
2066    }
2067
2068    pub fn clear_id(&mut self) {
2069        self.id = ::std::option::Option::None;
2070    }
2071
2072    pub fn has_id(&self) -> bool {
2073        self.id.is_some()
2074    }
2075
2076    // Param is passed by value, moved
2077    pub fn set_id(&mut self, v: i32) {
2078        self.id = ::std::option::Option::Some(v);
2079    }
2080
2081    // required string key = 2;
2082
2083    pub fn key(&self) -> &str {
2084        match self.key.as_ref() {
2085            Some(v) => v,
2086            None => "",
2087        }
2088    }
2089
2090    pub fn clear_key(&mut self) {
2091        self.key = ::std::option::Option::None;
2092    }
2093
2094    pub fn has_key(&self) -> bool {
2095        self.key.is_some()
2096    }
2097
2098    // Param is passed by value, moved
2099    pub fn set_key(&mut self, v: ::std::string::String) {
2100        self.key = ::std::option::Option::Some(v);
2101    }
2102
2103    // Mutable pointer to the field.
2104    // If field is not initialized, it is initialized with default value first.
2105    pub fn mut_key(&mut self) -> &mut ::std::string::String {
2106        if self.key.is_none() {
2107            self.key = ::std::option::Option::Some(::std::string::String::new());
2108        }
2109        self.key.as_mut().unwrap()
2110    }
2111
2112    // Take field
2113    pub fn take_key(&mut self) -> ::std::string::String {
2114        self.key.take().unwrap_or_else(|| ::std::string::String::new())
2115    }
2116
2117    // optional string caption = 3;
2118
2119    pub fn caption(&self) -> &str {
2120        match self.caption.as_ref() {
2121            Some(v) => v,
2122            None => "",
2123        }
2124    }
2125
2126    pub fn clear_caption(&mut self) {
2127        self.caption = ::std::option::Option::None;
2128    }
2129
2130    pub fn has_caption(&self) -> bool {
2131        self.caption.is_some()
2132    }
2133
2134    // Param is passed by value, moved
2135    pub fn set_caption(&mut self, v: ::std::string::String) {
2136        self.caption = ::std::option::Option::Some(v);
2137    }
2138
2139    // Mutable pointer to the field.
2140    // If field is not initialized, it is initialized with default value first.
2141    pub fn mut_caption(&mut self) -> &mut ::std::string::String {
2142        if self.caption.is_none() {
2143            self.caption = ::std::option::Option::Some(::std::string::String::new());
2144        }
2145        self.caption.as_mut().unwrap()
2146    }
2147
2148    // Take field
2149    pub fn take_caption(&mut self) -> ::std::string::String {
2150        self.caption.take().unwrap_or_else(|| ::std::string::String::new())
2151    }
2152
2153    // optional bool military = 4;
2154
2155    pub fn military(&self) -> bool {
2156        self.military.unwrap_or(false)
2157    }
2158
2159    pub fn clear_military(&mut self) {
2160        self.military = ::std::option::Option::None;
2161    }
2162
2163    pub fn has_military(&self) -> bool {
2164        self.military.is_some()
2165    }
2166
2167    // Param is passed by value, moved
2168    pub fn set_military(&mut self, v: bool) {
2169        self.military = ::std::option::Option::Some(v);
2170    }
2171
2172    // optional bool can_assign_labor = 5;
2173
2174    pub fn can_assign_labor(&self) -> bool {
2175        self.can_assign_labor.unwrap_or(false)
2176    }
2177
2178    pub fn clear_can_assign_labor(&mut self) {
2179        self.can_assign_labor = ::std::option::Option::None;
2180    }
2181
2182    pub fn has_can_assign_labor(&self) -> bool {
2183        self.can_assign_labor.is_some()
2184    }
2185
2186    // Param is passed by value, moved
2187    pub fn set_can_assign_labor(&mut self, v: bool) {
2188        self.can_assign_labor = ::std::option::Option::Some(v);
2189    }
2190
2191    // optional int32 parent = 6;
2192
2193    pub fn parent(&self) -> i32 {
2194        self.parent.unwrap_or(0)
2195    }
2196
2197    pub fn clear_parent(&mut self) {
2198        self.parent = ::std::option::Option::None;
2199    }
2200
2201    pub fn has_parent(&self) -> bool {
2202        self.parent.is_some()
2203    }
2204
2205    // Param is passed by value, moved
2206    pub fn set_parent(&mut self, v: i32) {
2207        self.parent = ::std::option::Option::Some(v);
2208    }
2209
2210    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
2211        let mut fields = ::std::vec::Vec::with_capacity(6);
2212        let mut oneofs = ::std::vec::Vec::with_capacity(0);
2213        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
2214            "id",
2215            |m: &ProfessionAttr| { &m.id },
2216            |m: &mut ProfessionAttr| { &mut m.id },
2217        ));
2218        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
2219            "key",
2220            |m: &ProfessionAttr| { &m.key },
2221            |m: &mut ProfessionAttr| { &mut m.key },
2222        ));
2223        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
2224            "caption",
2225            |m: &ProfessionAttr| { &m.caption },
2226            |m: &mut ProfessionAttr| { &mut m.caption },
2227        ));
2228        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
2229            "military",
2230            |m: &ProfessionAttr| { &m.military },
2231            |m: &mut ProfessionAttr| { &mut m.military },
2232        ));
2233        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
2234            "can_assign_labor",
2235            |m: &ProfessionAttr| { &m.can_assign_labor },
2236            |m: &mut ProfessionAttr| { &mut m.can_assign_labor },
2237        ));
2238        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
2239            "parent",
2240            |m: &ProfessionAttr| { &m.parent },
2241            |m: &mut ProfessionAttr| { &mut m.parent },
2242        ));
2243        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<ProfessionAttr>(
2244            "ProfessionAttr",
2245            fields,
2246            oneofs,
2247        )
2248    }
2249}
2250
2251impl ::protobuf::Message for ProfessionAttr {
2252    const NAME: &'static str = "ProfessionAttr";
2253
2254    fn is_initialized(&self) -> bool {
2255        if self.id.is_none() {
2256            return false;
2257        }
2258        if self.key.is_none() {
2259            return false;
2260        }
2261        true
2262    }
2263
2264    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
2265        while let Some(tag) = is.read_raw_tag_or_eof()? {
2266            match tag {
2267                8 => {
2268                    self.id = ::std::option::Option::Some(is.read_int32()?);
2269                },
2270                18 => {
2271                    self.key = ::std::option::Option::Some(is.read_string()?);
2272                },
2273                26 => {
2274                    self.caption = ::std::option::Option::Some(is.read_string()?);
2275                },
2276                32 => {
2277                    self.military = ::std::option::Option::Some(is.read_bool()?);
2278                },
2279                40 => {
2280                    self.can_assign_labor = ::std::option::Option::Some(is.read_bool()?);
2281                },
2282                48 => {
2283                    self.parent = ::std::option::Option::Some(is.read_int32()?);
2284                },
2285                tag => {
2286                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
2287                },
2288            };
2289        }
2290        ::std::result::Result::Ok(())
2291    }
2292
2293    // Compute sizes of nested messages
2294    #[allow(unused_variables)]
2295    fn compute_size(&self) -> u64 {
2296        let mut my_size = 0;
2297        if let Some(v) = self.id {
2298            my_size += ::protobuf::rt::int32_size(1, v);
2299        }
2300        if let Some(v) = self.key.as_ref() {
2301            my_size += ::protobuf::rt::string_size(2, &v);
2302        }
2303        if let Some(v) = self.caption.as_ref() {
2304            my_size += ::protobuf::rt::string_size(3, &v);
2305        }
2306        if let Some(v) = self.military {
2307            my_size += 1 + 1;
2308        }
2309        if let Some(v) = self.can_assign_labor {
2310            my_size += 1 + 1;
2311        }
2312        if let Some(v) = self.parent {
2313            my_size += ::protobuf::rt::int32_size(6, v);
2314        }
2315        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
2316        self.special_fields.cached_size().set(my_size as u32);
2317        my_size
2318    }
2319
2320    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
2321        if let Some(v) = self.id {
2322            os.write_int32(1, v)?;
2323        }
2324        if let Some(v) = self.key.as_ref() {
2325            os.write_string(2, v)?;
2326        }
2327        if let Some(v) = self.caption.as_ref() {
2328            os.write_string(3, v)?;
2329        }
2330        if let Some(v) = self.military {
2331            os.write_bool(4, v)?;
2332        }
2333        if let Some(v) = self.can_assign_labor {
2334            os.write_bool(5, v)?;
2335        }
2336        if let Some(v) = self.parent {
2337            os.write_int32(6, v)?;
2338        }
2339        os.write_unknown_fields(self.special_fields.unknown_fields())?;
2340        ::std::result::Result::Ok(())
2341    }
2342
2343    fn special_fields(&self) -> &::protobuf::SpecialFields {
2344        &self.special_fields
2345    }
2346
2347    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
2348        &mut self.special_fields
2349    }
2350
2351    fn new() -> ProfessionAttr {
2352        ProfessionAttr::new()
2353    }
2354
2355    fn clear(&mut self) {
2356        self.id = ::std::option::Option::None;
2357        self.key = ::std::option::Option::None;
2358        self.caption = ::std::option::Option::None;
2359        self.military = ::std::option::Option::None;
2360        self.can_assign_labor = ::std::option::Option::None;
2361        self.parent = ::std::option::Option::None;
2362        self.special_fields.clear();
2363    }
2364
2365    fn default_instance() -> &'static ProfessionAttr {
2366        static instance: ProfessionAttr = ProfessionAttr {
2367            id: ::std::option::Option::None,
2368            key: ::std::option::Option::None,
2369            caption: ::std::option::Option::None,
2370            military: ::std::option::Option::None,
2371            can_assign_labor: ::std::option::Option::None,
2372            parent: ::std::option::Option::None,
2373            special_fields: ::protobuf::SpecialFields::new(),
2374        };
2375        &instance
2376    }
2377}
2378
2379impl ::protobuf::MessageFull for ProfessionAttr {
2380    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
2381        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
2382        descriptor.get(|| file_descriptor().message_by_package_relative_name("ProfessionAttr").unwrap()).clone()
2383    }
2384}
2385
2386impl ::std::fmt::Display for ProfessionAttr {
2387    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2388        ::protobuf::text_format::fmt(self, f)
2389    }
2390}
2391
2392impl ::protobuf::reflect::ProtobufValue for ProfessionAttr {
2393    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
2394}
2395
2396// @@protoc_insertion_point(message:dfproto.UnitLaborAttr)
2397#[derive(PartialEq,Clone,Default,Debug)]
2398pub struct UnitLaborAttr {
2399    // message fields
2400    // @@protoc_insertion_point(field:dfproto.UnitLaborAttr.id)
2401    pub id: ::std::option::Option<i32>,
2402    // @@protoc_insertion_point(field:dfproto.UnitLaborAttr.key)
2403    pub key: ::std::option::Option<::std::string::String>,
2404    // @@protoc_insertion_point(field:dfproto.UnitLaborAttr.caption)
2405    pub caption: ::std::option::Option<::std::string::String>,
2406    // special fields
2407    // @@protoc_insertion_point(special_field:dfproto.UnitLaborAttr.special_fields)
2408    pub special_fields: ::protobuf::SpecialFields,
2409}
2410
2411impl<'a> ::std::default::Default for &'a UnitLaborAttr {
2412    fn default() -> &'a UnitLaborAttr {
2413        <UnitLaborAttr as ::protobuf::Message>::default_instance()
2414    }
2415}
2416
2417impl UnitLaborAttr {
2418    pub fn new() -> UnitLaborAttr {
2419        ::std::default::Default::default()
2420    }
2421
2422    // required int32 id = 1;
2423
2424    pub fn id(&self) -> i32 {
2425        self.id.unwrap_or(0)
2426    }
2427
2428    pub fn clear_id(&mut self) {
2429        self.id = ::std::option::Option::None;
2430    }
2431
2432    pub fn has_id(&self) -> bool {
2433        self.id.is_some()
2434    }
2435
2436    // Param is passed by value, moved
2437    pub fn set_id(&mut self, v: i32) {
2438        self.id = ::std::option::Option::Some(v);
2439    }
2440
2441    // required string key = 2;
2442
2443    pub fn key(&self) -> &str {
2444        match self.key.as_ref() {
2445            Some(v) => v,
2446            None => "",
2447        }
2448    }
2449
2450    pub fn clear_key(&mut self) {
2451        self.key = ::std::option::Option::None;
2452    }
2453
2454    pub fn has_key(&self) -> bool {
2455        self.key.is_some()
2456    }
2457
2458    // Param is passed by value, moved
2459    pub fn set_key(&mut self, v: ::std::string::String) {
2460        self.key = ::std::option::Option::Some(v);
2461    }
2462
2463    // Mutable pointer to the field.
2464    // If field is not initialized, it is initialized with default value first.
2465    pub fn mut_key(&mut self) -> &mut ::std::string::String {
2466        if self.key.is_none() {
2467            self.key = ::std::option::Option::Some(::std::string::String::new());
2468        }
2469        self.key.as_mut().unwrap()
2470    }
2471
2472    // Take field
2473    pub fn take_key(&mut self) -> ::std::string::String {
2474        self.key.take().unwrap_or_else(|| ::std::string::String::new())
2475    }
2476
2477    // optional string caption = 3;
2478
2479    pub fn caption(&self) -> &str {
2480        match self.caption.as_ref() {
2481            Some(v) => v,
2482            None => "",
2483        }
2484    }
2485
2486    pub fn clear_caption(&mut self) {
2487        self.caption = ::std::option::Option::None;
2488    }
2489
2490    pub fn has_caption(&self) -> bool {
2491        self.caption.is_some()
2492    }
2493
2494    // Param is passed by value, moved
2495    pub fn set_caption(&mut self, v: ::std::string::String) {
2496        self.caption = ::std::option::Option::Some(v);
2497    }
2498
2499    // Mutable pointer to the field.
2500    // If field is not initialized, it is initialized with default value first.
2501    pub fn mut_caption(&mut self) -> &mut ::std::string::String {
2502        if self.caption.is_none() {
2503            self.caption = ::std::option::Option::Some(::std::string::String::new());
2504        }
2505        self.caption.as_mut().unwrap()
2506    }
2507
2508    // Take field
2509    pub fn take_caption(&mut self) -> ::std::string::String {
2510        self.caption.take().unwrap_or_else(|| ::std::string::String::new())
2511    }
2512
2513    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
2514        let mut fields = ::std::vec::Vec::with_capacity(3);
2515        let mut oneofs = ::std::vec::Vec::with_capacity(0);
2516        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
2517            "id",
2518            |m: &UnitLaborAttr| { &m.id },
2519            |m: &mut UnitLaborAttr| { &mut m.id },
2520        ));
2521        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
2522            "key",
2523            |m: &UnitLaborAttr| { &m.key },
2524            |m: &mut UnitLaborAttr| { &mut m.key },
2525        ));
2526        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
2527            "caption",
2528            |m: &UnitLaborAttr| { &m.caption },
2529            |m: &mut UnitLaborAttr| { &mut m.caption },
2530        ));
2531        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<UnitLaborAttr>(
2532            "UnitLaborAttr",
2533            fields,
2534            oneofs,
2535        )
2536    }
2537}
2538
2539impl ::protobuf::Message for UnitLaborAttr {
2540    const NAME: &'static str = "UnitLaborAttr";
2541
2542    fn is_initialized(&self) -> bool {
2543        if self.id.is_none() {
2544            return false;
2545        }
2546        if self.key.is_none() {
2547            return false;
2548        }
2549        true
2550    }
2551
2552    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
2553        while let Some(tag) = is.read_raw_tag_or_eof()? {
2554            match tag {
2555                8 => {
2556                    self.id = ::std::option::Option::Some(is.read_int32()?);
2557                },
2558                18 => {
2559                    self.key = ::std::option::Option::Some(is.read_string()?);
2560                },
2561                26 => {
2562                    self.caption = ::std::option::Option::Some(is.read_string()?);
2563                },
2564                tag => {
2565                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
2566                },
2567            };
2568        }
2569        ::std::result::Result::Ok(())
2570    }
2571
2572    // Compute sizes of nested messages
2573    #[allow(unused_variables)]
2574    fn compute_size(&self) -> u64 {
2575        let mut my_size = 0;
2576        if let Some(v) = self.id {
2577            my_size += ::protobuf::rt::int32_size(1, v);
2578        }
2579        if let Some(v) = self.key.as_ref() {
2580            my_size += ::protobuf::rt::string_size(2, &v);
2581        }
2582        if let Some(v) = self.caption.as_ref() {
2583            my_size += ::protobuf::rt::string_size(3, &v);
2584        }
2585        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
2586        self.special_fields.cached_size().set(my_size as u32);
2587        my_size
2588    }
2589
2590    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
2591        if let Some(v) = self.id {
2592            os.write_int32(1, v)?;
2593        }
2594        if let Some(v) = self.key.as_ref() {
2595            os.write_string(2, v)?;
2596        }
2597        if let Some(v) = self.caption.as_ref() {
2598            os.write_string(3, v)?;
2599        }
2600        os.write_unknown_fields(self.special_fields.unknown_fields())?;
2601        ::std::result::Result::Ok(())
2602    }
2603
2604    fn special_fields(&self) -> &::protobuf::SpecialFields {
2605        &self.special_fields
2606    }
2607
2608    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
2609        &mut self.special_fields
2610    }
2611
2612    fn new() -> UnitLaborAttr {
2613        UnitLaborAttr::new()
2614    }
2615
2616    fn clear(&mut self) {
2617        self.id = ::std::option::Option::None;
2618        self.key = ::std::option::Option::None;
2619        self.caption = ::std::option::Option::None;
2620        self.special_fields.clear();
2621    }
2622
2623    fn default_instance() -> &'static UnitLaborAttr {
2624        static instance: UnitLaborAttr = UnitLaborAttr {
2625            id: ::std::option::Option::None,
2626            key: ::std::option::Option::None,
2627            caption: ::std::option::Option::None,
2628            special_fields: ::protobuf::SpecialFields::new(),
2629        };
2630        &instance
2631    }
2632}
2633
2634impl ::protobuf::MessageFull for UnitLaborAttr {
2635    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
2636        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
2637        descriptor.get(|| file_descriptor().message_by_package_relative_name("UnitLaborAttr").unwrap()).clone()
2638    }
2639}
2640
2641impl ::std::fmt::Display for UnitLaborAttr {
2642    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2643        ::protobuf::text_format::fmt(self, f)
2644    }
2645}
2646
2647impl ::protobuf::reflect::ProtobufValue for UnitLaborAttr {
2648    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
2649}
2650
2651// @@protoc_insertion_point(message:dfproto.NameInfo)
2652#[derive(PartialEq,Clone,Default,Debug)]
2653pub struct NameInfo {
2654    // message fields
2655    // @@protoc_insertion_point(field:dfproto.NameInfo.first_name)
2656    pub first_name: ::std::option::Option<::std::string::String>,
2657    // @@protoc_insertion_point(field:dfproto.NameInfo.nickname)
2658    pub nickname: ::std::option::Option<::std::string::String>,
2659    // @@protoc_insertion_point(field:dfproto.NameInfo.language_id)
2660    pub language_id: ::std::option::Option<i32>,
2661    // @@protoc_insertion_point(field:dfproto.NameInfo.last_name)
2662    pub last_name: ::std::option::Option<::std::string::String>,
2663    // @@protoc_insertion_point(field:dfproto.NameInfo.english_name)
2664    pub english_name: ::std::option::Option<::std::string::String>,
2665    // special fields
2666    // @@protoc_insertion_point(special_field:dfproto.NameInfo.special_fields)
2667    pub special_fields: ::protobuf::SpecialFields,
2668}
2669
2670impl<'a> ::std::default::Default for &'a NameInfo {
2671    fn default() -> &'a NameInfo {
2672        <NameInfo as ::protobuf::Message>::default_instance()
2673    }
2674}
2675
2676impl NameInfo {
2677    pub fn new() -> NameInfo {
2678        ::std::default::Default::default()
2679    }
2680
2681    // optional string first_name = 1;
2682
2683    pub fn first_name(&self) -> &str {
2684        match self.first_name.as_ref() {
2685            Some(v) => v,
2686            None => "",
2687        }
2688    }
2689
2690    pub fn clear_first_name(&mut self) {
2691        self.first_name = ::std::option::Option::None;
2692    }
2693
2694    pub fn has_first_name(&self) -> bool {
2695        self.first_name.is_some()
2696    }
2697
2698    // Param is passed by value, moved
2699    pub fn set_first_name(&mut self, v: ::std::string::String) {
2700        self.first_name = ::std::option::Option::Some(v);
2701    }
2702
2703    // Mutable pointer to the field.
2704    // If field is not initialized, it is initialized with default value first.
2705    pub fn mut_first_name(&mut self) -> &mut ::std::string::String {
2706        if self.first_name.is_none() {
2707            self.first_name = ::std::option::Option::Some(::std::string::String::new());
2708        }
2709        self.first_name.as_mut().unwrap()
2710    }
2711
2712    // Take field
2713    pub fn take_first_name(&mut self) -> ::std::string::String {
2714        self.first_name.take().unwrap_or_else(|| ::std::string::String::new())
2715    }
2716
2717    // optional string nickname = 2;
2718
2719    pub fn nickname(&self) -> &str {
2720        match self.nickname.as_ref() {
2721            Some(v) => v,
2722            None => "",
2723        }
2724    }
2725
2726    pub fn clear_nickname(&mut self) {
2727        self.nickname = ::std::option::Option::None;
2728    }
2729
2730    pub fn has_nickname(&self) -> bool {
2731        self.nickname.is_some()
2732    }
2733
2734    // Param is passed by value, moved
2735    pub fn set_nickname(&mut self, v: ::std::string::String) {
2736        self.nickname = ::std::option::Option::Some(v);
2737    }
2738
2739    // Mutable pointer to the field.
2740    // If field is not initialized, it is initialized with default value first.
2741    pub fn mut_nickname(&mut self) -> &mut ::std::string::String {
2742        if self.nickname.is_none() {
2743            self.nickname = ::std::option::Option::Some(::std::string::String::new());
2744        }
2745        self.nickname.as_mut().unwrap()
2746    }
2747
2748    // Take field
2749    pub fn take_nickname(&mut self) -> ::std::string::String {
2750        self.nickname.take().unwrap_or_else(|| ::std::string::String::new())
2751    }
2752
2753    // optional int32 language_id = 3;
2754
2755    pub fn language_id(&self) -> i32 {
2756        self.language_id.unwrap_or(-1i32)
2757    }
2758
2759    pub fn clear_language_id(&mut self) {
2760        self.language_id = ::std::option::Option::None;
2761    }
2762
2763    pub fn has_language_id(&self) -> bool {
2764        self.language_id.is_some()
2765    }
2766
2767    // Param is passed by value, moved
2768    pub fn set_language_id(&mut self, v: i32) {
2769        self.language_id = ::std::option::Option::Some(v);
2770    }
2771
2772    // optional string last_name = 4;
2773
2774    pub fn last_name(&self) -> &str {
2775        match self.last_name.as_ref() {
2776            Some(v) => v,
2777            None => "",
2778        }
2779    }
2780
2781    pub fn clear_last_name(&mut self) {
2782        self.last_name = ::std::option::Option::None;
2783    }
2784
2785    pub fn has_last_name(&self) -> bool {
2786        self.last_name.is_some()
2787    }
2788
2789    // Param is passed by value, moved
2790    pub fn set_last_name(&mut self, v: ::std::string::String) {
2791        self.last_name = ::std::option::Option::Some(v);
2792    }
2793
2794    // Mutable pointer to the field.
2795    // If field is not initialized, it is initialized with default value first.
2796    pub fn mut_last_name(&mut self) -> &mut ::std::string::String {
2797        if self.last_name.is_none() {
2798            self.last_name = ::std::option::Option::Some(::std::string::String::new());
2799        }
2800        self.last_name.as_mut().unwrap()
2801    }
2802
2803    // Take field
2804    pub fn take_last_name(&mut self) -> ::std::string::String {
2805        self.last_name.take().unwrap_or_else(|| ::std::string::String::new())
2806    }
2807
2808    // optional string english_name = 5;
2809
2810    pub fn english_name(&self) -> &str {
2811        match self.english_name.as_ref() {
2812            Some(v) => v,
2813            None => "",
2814        }
2815    }
2816
2817    pub fn clear_english_name(&mut self) {
2818        self.english_name = ::std::option::Option::None;
2819    }
2820
2821    pub fn has_english_name(&self) -> bool {
2822        self.english_name.is_some()
2823    }
2824
2825    // Param is passed by value, moved
2826    pub fn set_english_name(&mut self, v: ::std::string::String) {
2827        self.english_name = ::std::option::Option::Some(v);
2828    }
2829
2830    // Mutable pointer to the field.
2831    // If field is not initialized, it is initialized with default value first.
2832    pub fn mut_english_name(&mut self) -> &mut ::std::string::String {
2833        if self.english_name.is_none() {
2834            self.english_name = ::std::option::Option::Some(::std::string::String::new());
2835        }
2836        self.english_name.as_mut().unwrap()
2837    }
2838
2839    // Take field
2840    pub fn take_english_name(&mut self) -> ::std::string::String {
2841        self.english_name.take().unwrap_or_else(|| ::std::string::String::new())
2842    }
2843
2844    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
2845        let mut fields = ::std::vec::Vec::with_capacity(5);
2846        let mut oneofs = ::std::vec::Vec::with_capacity(0);
2847        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
2848            "first_name",
2849            |m: &NameInfo| { &m.first_name },
2850            |m: &mut NameInfo| { &mut m.first_name },
2851        ));
2852        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
2853            "nickname",
2854            |m: &NameInfo| { &m.nickname },
2855            |m: &mut NameInfo| { &mut m.nickname },
2856        ));
2857        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
2858            "language_id",
2859            |m: &NameInfo| { &m.language_id },
2860            |m: &mut NameInfo| { &mut m.language_id },
2861        ));
2862        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
2863            "last_name",
2864            |m: &NameInfo| { &m.last_name },
2865            |m: &mut NameInfo| { &mut m.last_name },
2866        ));
2867        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
2868            "english_name",
2869            |m: &NameInfo| { &m.english_name },
2870            |m: &mut NameInfo| { &mut m.english_name },
2871        ));
2872        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<NameInfo>(
2873            "NameInfo",
2874            fields,
2875            oneofs,
2876        )
2877    }
2878}
2879
2880impl ::protobuf::Message for NameInfo {
2881    const NAME: &'static str = "NameInfo";
2882
2883    fn is_initialized(&self) -> bool {
2884        true
2885    }
2886
2887    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
2888        while let Some(tag) = is.read_raw_tag_or_eof()? {
2889            match tag {
2890                10 => {
2891                    self.first_name = ::std::option::Option::Some(is.read_string()?);
2892                },
2893                18 => {
2894                    self.nickname = ::std::option::Option::Some(is.read_string()?);
2895                },
2896                24 => {
2897                    self.language_id = ::std::option::Option::Some(is.read_int32()?);
2898                },
2899                34 => {
2900                    self.last_name = ::std::option::Option::Some(is.read_string()?);
2901                },
2902                42 => {
2903                    self.english_name = ::std::option::Option::Some(is.read_string()?);
2904                },
2905                tag => {
2906                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
2907                },
2908            };
2909        }
2910        ::std::result::Result::Ok(())
2911    }
2912
2913    // Compute sizes of nested messages
2914    #[allow(unused_variables)]
2915    fn compute_size(&self) -> u64 {
2916        let mut my_size = 0;
2917        if let Some(v) = self.first_name.as_ref() {
2918            my_size += ::protobuf::rt::string_size(1, &v);
2919        }
2920        if let Some(v) = self.nickname.as_ref() {
2921            my_size += ::protobuf::rt::string_size(2, &v);
2922        }
2923        if let Some(v) = self.language_id {
2924            my_size += ::protobuf::rt::int32_size(3, v);
2925        }
2926        if let Some(v) = self.last_name.as_ref() {
2927            my_size += ::protobuf::rt::string_size(4, &v);
2928        }
2929        if let Some(v) = self.english_name.as_ref() {
2930            my_size += ::protobuf::rt::string_size(5, &v);
2931        }
2932        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
2933        self.special_fields.cached_size().set(my_size as u32);
2934        my_size
2935    }
2936
2937    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
2938        if let Some(v) = self.first_name.as_ref() {
2939            os.write_string(1, v)?;
2940        }
2941        if let Some(v) = self.nickname.as_ref() {
2942            os.write_string(2, v)?;
2943        }
2944        if let Some(v) = self.language_id {
2945            os.write_int32(3, v)?;
2946        }
2947        if let Some(v) = self.last_name.as_ref() {
2948            os.write_string(4, v)?;
2949        }
2950        if let Some(v) = self.english_name.as_ref() {
2951            os.write_string(5, v)?;
2952        }
2953        os.write_unknown_fields(self.special_fields.unknown_fields())?;
2954        ::std::result::Result::Ok(())
2955    }
2956
2957    fn special_fields(&self) -> &::protobuf::SpecialFields {
2958        &self.special_fields
2959    }
2960
2961    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
2962        &mut self.special_fields
2963    }
2964
2965    fn new() -> NameInfo {
2966        NameInfo::new()
2967    }
2968
2969    fn clear(&mut self) {
2970        self.first_name = ::std::option::Option::None;
2971        self.nickname = ::std::option::Option::None;
2972        self.language_id = ::std::option::Option::None;
2973        self.last_name = ::std::option::Option::None;
2974        self.english_name = ::std::option::Option::None;
2975        self.special_fields.clear();
2976    }
2977
2978    fn default_instance() -> &'static NameInfo {
2979        static instance: NameInfo = NameInfo {
2980            first_name: ::std::option::Option::None,
2981            nickname: ::std::option::Option::None,
2982            language_id: ::std::option::Option::None,
2983            last_name: ::std::option::Option::None,
2984            english_name: ::std::option::Option::None,
2985            special_fields: ::protobuf::SpecialFields::new(),
2986        };
2987        &instance
2988    }
2989}
2990
2991impl ::protobuf::MessageFull for NameInfo {
2992    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
2993        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
2994        descriptor.get(|| file_descriptor().message_by_package_relative_name("NameInfo").unwrap()).clone()
2995    }
2996}
2997
2998impl ::std::fmt::Display for NameInfo {
2999    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3000        ::protobuf::text_format::fmt(self, f)
3001    }
3002}
3003
3004impl ::protobuf::reflect::ProtobufValue for NameInfo {
3005    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
3006}
3007
3008// @@protoc_insertion_point(message:dfproto.NameTriple)
3009#[derive(PartialEq,Clone,Default,Debug)]
3010pub struct NameTriple {
3011    // message fields
3012    // @@protoc_insertion_point(field:dfproto.NameTriple.normal)
3013    pub normal: ::std::option::Option<::std::string::String>,
3014    // @@protoc_insertion_point(field:dfproto.NameTriple.plural)
3015    pub plural: ::std::option::Option<::std::string::String>,
3016    // @@protoc_insertion_point(field:dfproto.NameTriple.adjective)
3017    pub adjective: ::std::option::Option<::std::string::String>,
3018    // special fields
3019    // @@protoc_insertion_point(special_field:dfproto.NameTriple.special_fields)
3020    pub special_fields: ::protobuf::SpecialFields,
3021}
3022
3023impl<'a> ::std::default::Default for &'a NameTriple {
3024    fn default() -> &'a NameTriple {
3025        <NameTriple as ::protobuf::Message>::default_instance()
3026    }
3027}
3028
3029impl NameTriple {
3030    pub fn new() -> NameTriple {
3031        ::std::default::Default::default()
3032    }
3033
3034    // required string normal = 1;
3035
3036    pub fn normal(&self) -> &str {
3037        match self.normal.as_ref() {
3038            Some(v) => v,
3039            None => "",
3040        }
3041    }
3042
3043    pub fn clear_normal(&mut self) {
3044        self.normal = ::std::option::Option::None;
3045    }
3046
3047    pub fn has_normal(&self) -> bool {
3048        self.normal.is_some()
3049    }
3050
3051    // Param is passed by value, moved
3052    pub fn set_normal(&mut self, v: ::std::string::String) {
3053        self.normal = ::std::option::Option::Some(v);
3054    }
3055
3056    // Mutable pointer to the field.
3057    // If field is not initialized, it is initialized with default value first.
3058    pub fn mut_normal(&mut self) -> &mut ::std::string::String {
3059        if self.normal.is_none() {
3060            self.normal = ::std::option::Option::Some(::std::string::String::new());
3061        }
3062        self.normal.as_mut().unwrap()
3063    }
3064
3065    // Take field
3066    pub fn take_normal(&mut self) -> ::std::string::String {
3067        self.normal.take().unwrap_or_else(|| ::std::string::String::new())
3068    }
3069
3070    // optional string plural = 2;
3071
3072    pub fn plural(&self) -> &str {
3073        match self.plural.as_ref() {
3074            Some(v) => v,
3075            None => "",
3076        }
3077    }
3078
3079    pub fn clear_plural(&mut self) {
3080        self.plural = ::std::option::Option::None;
3081    }
3082
3083    pub fn has_plural(&self) -> bool {
3084        self.plural.is_some()
3085    }
3086
3087    // Param is passed by value, moved
3088    pub fn set_plural(&mut self, v: ::std::string::String) {
3089        self.plural = ::std::option::Option::Some(v);
3090    }
3091
3092    // Mutable pointer to the field.
3093    // If field is not initialized, it is initialized with default value first.
3094    pub fn mut_plural(&mut self) -> &mut ::std::string::String {
3095        if self.plural.is_none() {
3096            self.plural = ::std::option::Option::Some(::std::string::String::new());
3097        }
3098        self.plural.as_mut().unwrap()
3099    }
3100
3101    // Take field
3102    pub fn take_plural(&mut self) -> ::std::string::String {
3103        self.plural.take().unwrap_or_else(|| ::std::string::String::new())
3104    }
3105
3106    // optional string adjective = 3;
3107
3108    pub fn adjective(&self) -> &str {
3109        match self.adjective.as_ref() {
3110            Some(v) => v,
3111            None => "",
3112        }
3113    }
3114
3115    pub fn clear_adjective(&mut self) {
3116        self.adjective = ::std::option::Option::None;
3117    }
3118
3119    pub fn has_adjective(&self) -> bool {
3120        self.adjective.is_some()
3121    }
3122
3123    // Param is passed by value, moved
3124    pub fn set_adjective(&mut self, v: ::std::string::String) {
3125        self.adjective = ::std::option::Option::Some(v);
3126    }
3127
3128    // Mutable pointer to the field.
3129    // If field is not initialized, it is initialized with default value first.
3130    pub fn mut_adjective(&mut self) -> &mut ::std::string::String {
3131        if self.adjective.is_none() {
3132            self.adjective = ::std::option::Option::Some(::std::string::String::new());
3133        }
3134        self.adjective.as_mut().unwrap()
3135    }
3136
3137    // Take field
3138    pub fn take_adjective(&mut self) -> ::std::string::String {
3139        self.adjective.take().unwrap_or_else(|| ::std::string::String::new())
3140    }
3141
3142    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
3143        let mut fields = ::std::vec::Vec::with_capacity(3);
3144        let mut oneofs = ::std::vec::Vec::with_capacity(0);
3145        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
3146            "normal",
3147            |m: &NameTriple| { &m.normal },
3148            |m: &mut NameTriple| { &mut m.normal },
3149        ));
3150        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
3151            "plural",
3152            |m: &NameTriple| { &m.plural },
3153            |m: &mut NameTriple| { &mut m.plural },
3154        ));
3155        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
3156            "adjective",
3157            |m: &NameTriple| { &m.adjective },
3158            |m: &mut NameTriple| { &mut m.adjective },
3159        ));
3160        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<NameTriple>(
3161            "NameTriple",
3162            fields,
3163            oneofs,
3164        )
3165    }
3166}
3167
3168impl ::protobuf::Message for NameTriple {
3169    const NAME: &'static str = "NameTriple";
3170
3171    fn is_initialized(&self) -> bool {
3172        if self.normal.is_none() {
3173            return false;
3174        }
3175        true
3176    }
3177
3178    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
3179        while let Some(tag) = is.read_raw_tag_or_eof()? {
3180            match tag {
3181                10 => {
3182                    self.normal = ::std::option::Option::Some(is.read_string()?);
3183                },
3184                18 => {
3185                    self.plural = ::std::option::Option::Some(is.read_string()?);
3186                },
3187                26 => {
3188                    self.adjective = ::std::option::Option::Some(is.read_string()?);
3189                },
3190                tag => {
3191                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
3192                },
3193            };
3194        }
3195        ::std::result::Result::Ok(())
3196    }
3197
3198    // Compute sizes of nested messages
3199    #[allow(unused_variables)]
3200    fn compute_size(&self) -> u64 {
3201        let mut my_size = 0;
3202        if let Some(v) = self.normal.as_ref() {
3203            my_size += ::protobuf::rt::string_size(1, &v);
3204        }
3205        if let Some(v) = self.plural.as_ref() {
3206            my_size += ::protobuf::rt::string_size(2, &v);
3207        }
3208        if let Some(v) = self.adjective.as_ref() {
3209            my_size += ::protobuf::rt::string_size(3, &v);
3210        }
3211        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
3212        self.special_fields.cached_size().set(my_size as u32);
3213        my_size
3214    }
3215
3216    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
3217        if let Some(v) = self.normal.as_ref() {
3218            os.write_string(1, v)?;
3219        }
3220        if let Some(v) = self.plural.as_ref() {
3221            os.write_string(2, v)?;
3222        }
3223        if let Some(v) = self.adjective.as_ref() {
3224            os.write_string(3, v)?;
3225        }
3226        os.write_unknown_fields(self.special_fields.unknown_fields())?;
3227        ::std::result::Result::Ok(())
3228    }
3229
3230    fn special_fields(&self) -> &::protobuf::SpecialFields {
3231        &self.special_fields
3232    }
3233
3234    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
3235        &mut self.special_fields
3236    }
3237
3238    fn new() -> NameTriple {
3239        NameTriple::new()
3240    }
3241
3242    fn clear(&mut self) {
3243        self.normal = ::std::option::Option::None;
3244        self.plural = ::std::option::Option::None;
3245        self.adjective = ::std::option::Option::None;
3246        self.special_fields.clear();
3247    }
3248
3249    fn default_instance() -> &'static NameTriple {
3250        static instance: NameTriple = NameTriple {
3251            normal: ::std::option::Option::None,
3252            plural: ::std::option::Option::None,
3253            adjective: ::std::option::Option::None,
3254            special_fields: ::protobuf::SpecialFields::new(),
3255        };
3256        &instance
3257    }
3258}
3259
3260impl ::protobuf::MessageFull for NameTriple {
3261    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
3262        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
3263        descriptor.get(|| file_descriptor().message_by_package_relative_name("NameTriple").unwrap()).clone()
3264    }
3265}
3266
3267impl ::std::fmt::Display for NameTriple {
3268    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3269        ::protobuf::text_format::fmt(self, f)
3270    }
3271}
3272
3273impl ::protobuf::reflect::ProtobufValue for NameTriple {
3274    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
3275}
3276
3277// @@protoc_insertion_point(message:dfproto.UnitCurseInfo)
3278#[derive(PartialEq,Clone,Default,Debug)]
3279pub struct UnitCurseInfo {
3280    // message fields
3281    // @@protoc_insertion_point(field:dfproto.UnitCurseInfo.add_tags1)
3282    pub add_tags1: ::std::option::Option<u32>,
3283    // @@protoc_insertion_point(field:dfproto.UnitCurseInfo.rem_tags1)
3284    pub rem_tags1: ::std::option::Option<u32>,
3285    // @@protoc_insertion_point(field:dfproto.UnitCurseInfo.add_tags2)
3286    pub add_tags2: ::std::option::Option<u32>,
3287    // @@protoc_insertion_point(field:dfproto.UnitCurseInfo.rem_tags2)
3288    pub rem_tags2: ::std::option::Option<u32>,
3289    // @@protoc_insertion_point(field:dfproto.UnitCurseInfo.name)
3290    pub name: ::protobuf::MessageField<NameTriple>,
3291    // special fields
3292    // @@protoc_insertion_point(special_field:dfproto.UnitCurseInfo.special_fields)
3293    pub special_fields: ::protobuf::SpecialFields,
3294}
3295
3296impl<'a> ::std::default::Default for &'a UnitCurseInfo {
3297    fn default() -> &'a UnitCurseInfo {
3298        <UnitCurseInfo as ::protobuf::Message>::default_instance()
3299    }
3300}
3301
3302impl UnitCurseInfo {
3303    pub fn new() -> UnitCurseInfo {
3304        ::std::default::Default::default()
3305    }
3306
3307    // required fixed32 add_tags1 = 1;
3308
3309    pub fn add_tags1(&self) -> u32 {
3310        self.add_tags1.unwrap_or(0)
3311    }
3312
3313    pub fn clear_add_tags1(&mut self) {
3314        self.add_tags1 = ::std::option::Option::None;
3315    }
3316
3317    pub fn has_add_tags1(&self) -> bool {
3318        self.add_tags1.is_some()
3319    }
3320
3321    // Param is passed by value, moved
3322    pub fn set_add_tags1(&mut self, v: u32) {
3323        self.add_tags1 = ::std::option::Option::Some(v);
3324    }
3325
3326    // required fixed32 rem_tags1 = 2;
3327
3328    pub fn rem_tags1(&self) -> u32 {
3329        self.rem_tags1.unwrap_or(0)
3330    }
3331
3332    pub fn clear_rem_tags1(&mut self) {
3333        self.rem_tags1 = ::std::option::Option::None;
3334    }
3335
3336    pub fn has_rem_tags1(&self) -> bool {
3337        self.rem_tags1.is_some()
3338    }
3339
3340    // Param is passed by value, moved
3341    pub fn set_rem_tags1(&mut self, v: u32) {
3342        self.rem_tags1 = ::std::option::Option::Some(v);
3343    }
3344
3345    // required fixed32 add_tags2 = 3;
3346
3347    pub fn add_tags2(&self) -> u32 {
3348        self.add_tags2.unwrap_or(0)
3349    }
3350
3351    pub fn clear_add_tags2(&mut self) {
3352        self.add_tags2 = ::std::option::Option::None;
3353    }
3354
3355    pub fn has_add_tags2(&self) -> bool {
3356        self.add_tags2.is_some()
3357    }
3358
3359    // Param is passed by value, moved
3360    pub fn set_add_tags2(&mut self, v: u32) {
3361        self.add_tags2 = ::std::option::Option::Some(v);
3362    }
3363
3364    // required fixed32 rem_tags2 = 4;
3365
3366    pub fn rem_tags2(&self) -> u32 {
3367        self.rem_tags2.unwrap_or(0)
3368    }
3369
3370    pub fn clear_rem_tags2(&mut self) {
3371        self.rem_tags2 = ::std::option::Option::None;
3372    }
3373
3374    pub fn has_rem_tags2(&self) -> bool {
3375        self.rem_tags2.is_some()
3376    }
3377
3378    // Param is passed by value, moved
3379    pub fn set_rem_tags2(&mut self, v: u32) {
3380        self.rem_tags2 = ::std::option::Option::Some(v);
3381    }
3382
3383    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
3384        let mut fields = ::std::vec::Vec::with_capacity(5);
3385        let mut oneofs = ::std::vec::Vec::with_capacity(0);
3386        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
3387            "add_tags1",
3388            |m: &UnitCurseInfo| { &m.add_tags1 },
3389            |m: &mut UnitCurseInfo| { &mut m.add_tags1 },
3390        ));
3391        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
3392            "rem_tags1",
3393            |m: &UnitCurseInfo| { &m.rem_tags1 },
3394            |m: &mut UnitCurseInfo| { &mut m.rem_tags1 },
3395        ));
3396        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
3397            "add_tags2",
3398            |m: &UnitCurseInfo| { &m.add_tags2 },
3399            |m: &mut UnitCurseInfo| { &mut m.add_tags2 },
3400        ));
3401        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
3402            "rem_tags2",
3403            |m: &UnitCurseInfo| { &m.rem_tags2 },
3404            |m: &mut UnitCurseInfo| { &mut m.rem_tags2 },
3405        ));
3406        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, NameTriple>(
3407            "name",
3408            |m: &UnitCurseInfo| { &m.name },
3409            |m: &mut UnitCurseInfo| { &mut m.name },
3410        ));
3411        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<UnitCurseInfo>(
3412            "UnitCurseInfo",
3413            fields,
3414            oneofs,
3415        )
3416    }
3417}
3418
3419impl ::protobuf::Message for UnitCurseInfo {
3420    const NAME: &'static str = "UnitCurseInfo";
3421
3422    fn is_initialized(&self) -> bool {
3423        if self.add_tags1.is_none() {
3424            return false;
3425        }
3426        if self.rem_tags1.is_none() {
3427            return false;
3428        }
3429        if self.add_tags2.is_none() {
3430            return false;
3431        }
3432        if self.rem_tags2.is_none() {
3433            return false;
3434        }
3435        for v in &self.name {
3436            if !v.is_initialized() {
3437                return false;
3438            }
3439        };
3440        true
3441    }
3442
3443    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
3444        while let Some(tag) = is.read_raw_tag_or_eof()? {
3445            match tag {
3446                13 => {
3447                    self.add_tags1 = ::std::option::Option::Some(is.read_fixed32()?);
3448                },
3449                21 => {
3450                    self.rem_tags1 = ::std::option::Option::Some(is.read_fixed32()?);
3451                },
3452                29 => {
3453                    self.add_tags2 = ::std::option::Option::Some(is.read_fixed32()?);
3454                },
3455                37 => {
3456                    self.rem_tags2 = ::std::option::Option::Some(is.read_fixed32()?);
3457                },
3458                42 => {
3459                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.name)?;
3460                },
3461                tag => {
3462                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
3463                },
3464            };
3465        }
3466        ::std::result::Result::Ok(())
3467    }
3468
3469    // Compute sizes of nested messages
3470    #[allow(unused_variables)]
3471    fn compute_size(&self) -> u64 {
3472        let mut my_size = 0;
3473        if let Some(v) = self.add_tags1 {
3474            my_size += 1 + 4;
3475        }
3476        if let Some(v) = self.rem_tags1 {
3477            my_size += 1 + 4;
3478        }
3479        if let Some(v) = self.add_tags2 {
3480            my_size += 1 + 4;
3481        }
3482        if let Some(v) = self.rem_tags2 {
3483            my_size += 1 + 4;
3484        }
3485        if let Some(v) = self.name.as_ref() {
3486            let len = v.compute_size();
3487            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
3488        }
3489        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
3490        self.special_fields.cached_size().set(my_size as u32);
3491        my_size
3492    }
3493
3494    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
3495        if let Some(v) = self.add_tags1 {
3496            os.write_fixed32(1, v)?;
3497        }
3498        if let Some(v) = self.rem_tags1 {
3499            os.write_fixed32(2, v)?;
3500        }
3501        if let Some(v) = self.add_tags2 {
3502            os.write_fixed32(3, v)?;
3503        }
3504        if let Some(v) = self.rem_tags2 {
3505            os.write_fixed32(4, v)?;
3506        }
3507        if let Some(v) = self.name.as_ref() {
3508            ::protobuf::rt::write_message_field_with_cached_size(5, v, os)?;
3509        }
3510        os.write_unknown_fields(self.special_fields.unknown_fields())?;
3511        ::std::result::Result::Ok(())
3512    }
3513
3514    fn special_fields(&self) -> &::protobuf::SpecialFields {
3515        &self.special_fields
3516    }
3517
3518    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
3519        &mut self.special_fields
3520    }
3521
3522    fn new() -> UnitCurseInfo {
3523        UnitCurseInfo::new()
3524    }
3525
3526    fn clear(&mut self) {
3527        self.add_tags1 = ::std::option::Option::None;
3528        self.rem_tags1 = ::std::option::Option::None;
3529        self.add_tags2 = ::std::option::Option::None;
3530        self.rem_tags2 = ::std::option::Option::None;
3531        self.name.clear();
3532        self.special_fields.clear();
3533    }
3534
3535    fn default_instance() -> &'static UnitCurseInfo {
3536        static instance: UnitCurseInfo = UnitCurseInfo {
3537            add_tags1: ::std::option::Option::None,
3538            rem_tags1: ::std::option::Option::None,
3539            add_tags2: ::std::option::Option::None,
3540            rem_tags2: ::std::option::Option::None,
3541            name: ::protobuf::MessageField::none(),
3542            special_fields: ::protobuf::SpecialFields::new(),
3543        };
3544        &instance
3545    }
3546}
3547
3548impl ::protobuf::MessageFull for UnitCurseInfo {
3549    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
3550        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
3551        descriptor.get(|| file_descriptor().message_by_package_relative_name("UnitCurseInfo").unwrap()).clone()
3552    }
3553}
3554
3555impl ::std::fmt::Display for UnitCurseInfo {
3556    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3557        ::protobuf::text_format::fmt(self, f)
3558    }
3559}
3560
3561impl ::protobuf::reflect::ProtobufValue for UnitCurseInfo {
3562    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
3563}
3564
3565// @@protoc_insertion_point(message:dfproto.SkillInfo)
3566#[derive(PartialEq,Clone,Default,Debug)]
3567pub struct SkillInfo {
3568    // message fields
3569    // @@protoc_insertion_point(field:dfproto.SkillInfo.id)
3570    pub id: ::std::option::Option<i32>,
3571    // @@protoc_insertion_point(field:dfproto.SkillInfo.level)
3572    pub level: ::std::option::Option<i32>,
3573    // @@protoc_insertion_point(field:dfproto.SkillInfo.experience)
3574    pub experience: ::std::option::Option<i32>,
3575    // special fields
3576    // @@protoc_insertion_point(special_field:dfproto.SkillInfo.special_fields)
3577    pub special_fields: ::protobuf::SpecialFields,
3578}
3579
3580impl<'a> ::std::default::Default for &'a SkillInfo {
3581    fn default() -> &'a SkillInfo {
3582        <SkillInfo as ::protobuf::Message>::default_instance()
3583    }
3584}
3585
3586impl SkillInfo {
3587    pub fn new() -> SkillInfo {
3588        ::std::default::Default::default()
3589    }
3590
3591    // required int32 id = 1;
3592
3593    pub fn id(&self) -> i32 {
3594        self.id.unwrap_or(0)
3595    }
3596
3597    pub fn clear_id(&mut self) {
3598        self.id = ::std::option::Option::None;
3599    }
3600
3601    pub fn has_id(&self) -> bool {
3602        self.id.is_some()
3603    }
3604
3605    // Param is passed by value, moved
3606    pub fn set_id(&mut self, v: i32) {
3607        self.id = ::std::option::Option::Some(v);
3608    }
3609
3610    // required int32 level = 2;
3611
3612    pub fn level(&self) -> i32 {
3613        self.level.unwrap_or(0)
3614    }
3615
3616    pub fn clear_level(&mut self) {
3617        self.level = ::std::option::Option::None;
3618    }
3619
3620    pub fn has_level(&self) -> bool {
3621        self.level.is_some()
3622    }
3623
3624    // Param is passed by value, moved
3625    pub fn set_level(&mut self, v: i32) {
3626        self.level = ::std::option::Option::Some(v);
3627    }
3628
3629    // required int32 experience = 3;
3630
3631    pub fn experience(&self) -> i32 {
3632        self.experience.unwrap_or(0)
3633    }
3634
3635    pub fn clear_experience(&mut self) {
3636        self.experience = ::std::option::Option::None;
3637    }
3638
3639    pub fn has_experience(&self) -> bool {
3640        self.experience.is_some()
3641    }
3642
3643    // Param is passed by value, moved
3644    pub fn set_experience(&mut self, v: i32) {
3645        self.experience = ::std::option::Option::Some(v);
3646    }
3647
3648    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
3649        let mut fields = ::std::vec::Vec::with_capacity(3);
3650        let mut oneofs = ::std::vec::Vec::with_capacity(0);
3651        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
3652            "id",
3653            |m: &SkillInfo| { &m.id },
3654            |m: &mut SkillInfo| { &mut m.id },
3655        ));
3656        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
3657            "level",
3658            |m: &SkillInfo| { &m.level },
3659            |m: &mut SkillInfo| { &mut m.level },
3660        ));
3661        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
3662            "experience",
3663            |m: &SkillInfo| { &m.experience },
3664            |m: &mut SkillInfo| { &mut m.experience },
3665        ));
3666        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<SkillInfo>(
3667            "SkillInfo",
3668            fields,
3669            oneofs,
3670        )
3671    }
3672}
3673
3674impl ::protobuf::Message for SkillInfo {
3675    const NAME: &'static str = "SkillInfo";
3676
3677    fn is_initialized(&self) -> bool {
3678        if self.id.is_none() {
3679            return false;
3680        }
3681        if self.level.is_none() {
3682            return false;
3683        }
3684        if self.experience.is_none() {
3685            return false;
3686        }
3687        true
3688    }
3689
3690    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
3691        while let Some(tag) = is.read_raw_tag_or_eof()? {
3692            match tag {
3693                8 => {
3694                    self.id = ::std::option::Option::Some(is.read_int32()?);
3695                },
3696                16 => {
3697                    self.level = ::std::option::Option::Some(is.read_int32()?);
3698                },
3699                24 => {
3700                    self.experience = ::std::option::Option::Some(is.read_int32()?);
3701                },
3702                tag => {
3703                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
3704                },
3705            };
3706        }
3707        ::std::result::Result::Ok(())
3708    }
3709
3710    // Compute sizes of nested messages
3711    #[allow(unused_variables)]
3712    fn compute_size(&self) -> u64 {
3713        let mut my_size = 0;
3714        if let Some(v) = self.id {
3715            my_size += ::protobuf::rt::int32_size(1, v);
3716        }
3717        if let Some(v) = self.level {
3718            my_size += ::protobuf::rt::int32_size(2, v);
3719        }
3720        if let Some(v) = self.experience {
3721            my_size += ::protobuf::rt::int32_size(3, v);
3722        }
3723        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
3724        self.special_fields.cached_size().set(my_size as u32);
3725        my_size
3726    }
3727
3728    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
3729        if let Some(v) = self.id {
3730            os.write_int32(1, v)?;
3731        }
3732        if let Some(v) = self.level {
3733            os.write_int32(2, v)?;
3734        }
3735        if let Some(v) = self.experience {
3736            os.write_int32(3, v)?;
3737        }
3738        os.write_unknown_fields(self.special_fields.unknown_fields())?;
3739        ::std::result::Result::Ok(())
3740    }
3741
3742    fn special_fields(&self) -> &::protobuf::SpecialFields {
3743        &self.special_fields
3744    }
3745
3746    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
3747        &mut self.special_fields
3748    }
3749
3750    fn new() -> SkillInfo {
3751        SkillInfo::new()
3752    }
3753
3754    fn clear(&mut self) {
3755        self.id = ::std::option::Option::None;
3756        self.level = ::std::option::Option::None;
3757        self.experience = ::std::option::Option::None;
3758        self.special_fields.clear();
3759    }
3760
3761    fn default_instance() -> &'static SkillInfo {
3762        static instance: SkillInfo = SkillInfo {
3763            id: ::std::option::Option::None,
3764            level: ::std::option::Option::None,
3765            experience: ::std::option::Option::None,
3766            special_fields: ::protobuf::SpecialFields::new(),
3767        };
3768        &instance
3769    }
3770}
3771
3772impl ::protobuf::MessageFull for SkillInfo {
3773    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
3774        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
3775        descriptor.get(|| file_descriptor().message_by_package_relative_name("SkillInfo").unwrap()).clone()
3776    }
3777}
3778
3779impl ::std::fmt::Display for SkillInfo {
3780    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3781        ::protobuf::text_format::fmt(self, f)
3782    }
3783}
3784
3785impl ::protobuf::reflect::ProtobufValue for SkillInfo {
3786    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
3787}
3788
3789// @@protoc_insertion_point(message:dfproto.UnitMiscTrait)
3790#[derive(PartialEq,Clone,Default,Debug)]
3791pub struct UnitMiscTrait {
3792    // message fields
3793    // @@protoc_insertion_point(field:dfproto.UnitMiscTrait.id)
3794    pub id: ::std::option::Option<i32>,
3795    // @@protoc_insertion_point(field:dfproto.UnitMiscTrait.value)
3796    pub value: ::std::option::Option<i32>,
3797    // special fields
3798    // @@protoc_insertion_point(special_field:dfproto.UnitMiscTrait.special_fields)
3799    pub special_fields: ::protobuf::SpecialFields,
3800}
3801
3802impl<'a> ::std::default::Default for &'a UnitMiscTrait {
3803    fn default() -> &'a UnitMiscTrait {
3804        <UnitMiscTrait as ::protobuf::Message>::default_instance()
3805    }
3806}
3807
3808impl UnitMiscTrait {
3809    pub fn new() -> UnitMiscTrait {
3810        ::std::default::Default::default()
3811    }
3812
3813    // required int32 id = 1;
3814
3815    pub fn id(&self) -> i32 {
3816        self.id.unwrap_or(0)
3817    }
3818
3819    pub fn clear_id(&mut self) {
3820        self.id = ::std::option::Option::None;
3821    }
3822
3823    pub fn has_id(&self) -> bool {
3824        self.id.is_some()
3825    }
3826
3827    // Param is passed by value, moved
3828    pub fn set_id(&mut self, v: i32) {
3829        self.id = ::std::option::Option::Some(v);
3830    }
3831
3832    // required int32 value = 2;
3833
3834    pub fn value(&self) -> i32 {
3835        self.value.unwrap_or(0)
3836    }
3837
3838    pub fn clear_value(&mut self) {
3839        self.value = ::std::option::Option::None;
3840    }
3841
3842    pub fn has_value(&self) -> bool {
3843        self.value.is_some()
3844    }
3845
3846    // Param is passed by value, moved
3847    pub fn set_value(&mut self, v: i32) {
3848        self.value = ::std::option::Option::Some(v);
3849    }
3850
3851    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
3852        let mut fields = ::std::vec::Vec::with_capacity(2);
3853        let mut oneofs = ::std::vec::Vec::with_capacity(0);
3854        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
3855            "id",
3856            |m: &UnitMiscTrait| { &m.id },
3857            |m: &mut UnitMiscTrait| { &mut m.id },
3858        ));
3859        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
3860            "value",
3861            |m: &UnitMiscTrait| { &m.value },
3862            |m: &mut UnitMiscTrait| { &mut m.value },
3863        ));
3864        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<UnitMiscTrait>(
3865            "UnitMiscTrait",
3866            fields,
3867            oneofs,
3868        )
3869    }
3870}
3871
3872impl ::protobuf::Message for UnitMiscTrait {
3873    const NAME: &'static str = "UnitMiscTrait";
3874
3875    fn is_initialized(&self) -> bool {
3876        if self.id.is_none() {
3877            return false;
3878        }
3879        if self.value.is_none() {
3880            return false;
3881        }
3882        true
3883    }
3884
3885    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
3886        while let Some(tag) = is.read_raw_tag_or_eof()? {
3887            match tag {
3888                8 => {
3889                    self.id = ::std::option::Option::Some(is.read_int32()?);
3890                },
3891                16 => {
3892                    self.value = ::std::option::Option::Some(is.read_int32()?);
3893                },
3894                tag => {
3895                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
3896                },
3897            };
3898        }
3899        ::std::result::Result::Ok(())
3900    }
3901
3902    // Compute sizes of nested messages
3903    #[allow(unused_variables)]
3904    fn compute_size(&self) -> u64 {
3905        let mut my_size = 0;
3906        if let Some(v) = self.id {
3907            my_size += ::protobuf::rt::int32_size(1, v);
3908        }
3909        if let Some(v) = self.value {
3910            my_size += ::protobuf::rt::int32_size(2, v);
3911        }
3912        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
3913        self.special_fields.cached_size().set(my_size as u32);
3914        my_size
3915    }
3916
3917    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
3918        if let Some(v) = self.id {
3919            os.write_int32(1, v)?;
3920        }
3921        if let Some(v) = self.value {
3922            os.write_int32(2, v)?;
3923        }
3924        os.write_unknown_fields(self.special_fields.unknown_fields())?;
3925        ::std::result::Result::Ok(())
3926    }
3927
3928    fn special_fields(&self) -> &::protobuf::SpecialFields {
3929        &self.special_fields
3930    }
3931
3932    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
3933        &mut self.special_fields
3934    }
3935
3936    fn new() -> UnitMiscTrait {
3937        UnitMiscTrait::new()
3938    }
3939
3940    fn clear(&mut self) {
3941        self.id = ::std::option::Option::None;
3942        self.value = ::std::option::Option::None;
3943        self.special_fields.clear();
3944    }
3945
3946    fn default_instance() -> &'static UnitMiscTrait {
3947        static instance: UnitMiscTrait = UnitMiscTrait {
3948            id: ::std::option::Option::None,
3949            value: ::std::option::Option::None,
3950            special_fields: ::protobuf::SpecialFields::new(),
3951        };
3952        &instance
3953    }
3954}
3955
3956impl ::protobuf::MessageFull for UnitMiscTrait {
3957    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
3958        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
3959        descriptor.get(|| file_descriptor().message_by_package_relative_name("UnitMiscTrait").unwrap()).clone()
3960    }
3961}
3962
3963impl ::std::fmt::Display for UnitMiscTrait {
3964    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3965        ::protobuf::text_format::fmt(self, f)
3966    }
3967}
3968
3969impl ::protobuf::reflect::ProtobufValue for UnitMiscTrait {
3970    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
3971}
3972
3973// @@protoc_insertion_point(message:dfproto.BasicUnitInfo)
3974#[derive(PartialEq,Clone,Default,Debug)]
3975pub struct BasicUnitInfo {
3976    // message fields
3977    // @@protoc_insertion_point(field:dfproto.BasicUnitInfo.unit_id)
3978    pub unit_id: ::std::option::Option<i32>,
3979    // @@protoc_insertion_point(field:dfproto.BasicUnitInfo.pos_x)
3980    pub pos_x: ::std::option::Option<i32>,
3981    // @@protoc_insertion_point(field:dfproto.BasicUnitInfo.pos_y)
3982    pub pos_y: ::std::option::Option<i32>,
3983    // @@protoc_insertion_point(field:dfproto.BasicUnitInfo.pos_z)
3984    pub pos_z: ::std::option::Option<i32>,
3985    // @@protoc_insertion_point(field:dfproto.BasicUnitInfo.name)
3986    pub name: ::protobuf::MessageField<NameInfo>,
3987    // @@protoc_insertion_point(field:dfproto.BasicUnitInfo.flags1)
3988    pub flags1: ::std::option::Option<u32>,
3989    // @@protoc_insertion_point(field:dfproto.BasicUnitInfo.flags2)
3990    pub flags2: ::std::option::Option<u32>,
3991    // @@protoc_insertion_point(field:dfproto.BasicUnitInfo.flags3)
3992    pub flags3: ::std::option::Option<u32>,
3993    // @@protoc_insertion_point(field:dfproto.BasicUnitInfo.race)
3994    pub race: ::std::option::Option<i32>,
3995    // @@protoc_insertion_point(field:dfproto.BasicUnitInfo.caste)
3996    pub caste: ::std::option::Option<i32>,
3997    // @@protoc_insertion_point(field:dfproto.BasicUnitInfo.gender)
3998    pub gender: ::std::option::Option<i32>,
3999    // @@protoc_insertion_point(field:dfproto.BasicUnitInfo.civ_id)
4000    pub civ_id: ::std::option::Option<i32>,
4001    // @@protoc_insertion_point(field:dfproto.BasicUnitInfo.histfig_id)
4002    pub histfig_id: ::std::option::Option<i32>,
4003    // @@protoc_insertion_point(field:dfproto.BasicUnitInfo.death_id)
4004    pub death_id: ::std::option::Option<i32>,
4005    // @@protoc_insertion_point(field:dfproto.BasicUnitInfo.death_flags)
4006    pub death_flags: ::std::option::Option<u32>,
4007    // @@protoc_insertion_point(field:dfproto.BasicUnitInfo.squad_id)
4008    pub squad_id: ::std::option::Option<i32>,
4009    // @@protoc_insertion_point(field:dfproto.BasicUnitInfo.squad_position)
4010    pub squad_position: ::std::option::Option<i32>,
4011    // @@protoc_insertion_point(field:dfproto.BasicUnitInfo.profession)
4012    pub profession: ::std::option::Option<i32>,
4013    // @@protoc_insertion_point(field:dfproto.BasicUnitInfo.custom_profession)
4014    pub custom_profession: ::std::option::Option<::std::string::String>,
4015    // @@protoc_insertion_point(field:dfproto.BasicUnitInfo.labors)
4016    pub labors: ::std::vec::Vec<i32>,
4017    // @@protoc_insertion_point(field:dfproto.BasicUnitInfo.skills)
4018    pub skills: ::std::vec::Vec<SkillInfo>,
4019    // @@protoc_insertion_point(field:dfproto.BasicUnitInfo.misc_traits)
4020    pub misc_traits: ::std::vec::Vec<UnitMiscTrait>,
4021    // @@protoc_insertion_point(field:dfproto.BasicUnitInfo.curse)
4022    pub curse: ::protobuf::MessageField<UnitCurseInfo>,
4023    // @@protoc_insertion_point(field:dfproto.BasicUnitInfo.burrows)
4024    pub burrows: ::std::vec::Vec<i32>,
4025    // special fields
4026    // @@protoc_insertion_point(special_field:dfproto.BasicUnitInfo.special_fields)
4027    pub special_fields: ::protobuf::SpecialFields,
4028}
4029
4030impl<'a> ::std::default::Default for &'a BasicUnitInfo {
4031    fn default() -> &'a BasicUnitInfo {
4032        <BasicUnitInfo as ::protobuf::Message>::default_instance()
4033    }
4034}
4035
4036impl BasicUnitInfo {
4037    pub fn new() -> BasicUnitInfo {
4038        ::std::default::Default::default()
4039    }
4040
4041    // required int32 unit_id = 1;
4042
4043    pub fn unit_id(&self) -> i32 {
4044        self.unit_id.unwrap_or(0)
4045    }
4046
4047    pub fn clear_unit_id(&mut self) {
4048        self.unit_id = ::std::option::Option::None;
4049    }
4050
4051    pub fn has_unit_id(&self) -> bool {
4052        self.unit_id.is_some()
4053    }
4054
4055    // Param is passed by value, moved
4056    pub fn set_unit_id(&mut self, v: i32) {
4057        self.unit_id = ::std::option::Option::Some(v);
4058    }
4059
4060    // required int32 pos_x = 13;
4061
4062    pub fn pos_x(&self) -> i32 {
4063        self.pos_x.unwrap_or(0)
4064    }
4065
4066    pub fn clear_pos_x(&mut self) {
4067        self.pos_x = ::std::option::Option::None;
4068    }
4069
4070    pub fn has_pos_x(&self) -> bool {
4071        self.pos_x.is_some()
4072    }
4073
4074    // Param is passed by value, moved
4075    pub fn set_pos_x(&mut self, v: i32) {
4076        self.pos_x = ::std::option::Option::Some(v);
4077    }
4078
4079    // required int32 pos_y = 14;
4080
4081    pub fn pos_y(&self) -> i32 {
4082        self.pos_y.unwrap_or(0)
4083    }
4084
4085    pub fn clear_pos_y(&mut self) {
4086        self.pos_y = ::std::option::Option::None;
4087    }
4088
4089    pub fn has_pos_y(&self) -> bool {
4090        self.pos_y.is_some()
4091    }
4092
4093    // Param is passed by value, moved
4094    pub fn set_pos_y(&mut self, v: i32) {
4095        self.pos_y = ::std::option::Option::Some(v);
4096    }
4097
4098    // required int32 pos_z = 15;
4099
4100    pub fn pos_z(&self) -> i32 {
4101        self.pos_z.unwrap_or(0)
4102    }
4103
4104    pub fn clear_pos_z(&mut self) {
4105        self.pos_z = ::std::option::Option::None;
4106    }
4107
4108    pub fn has_pos_z(&self) -> bool {
4109        self.pos_z.is_some()
4110    }
4111
4112    // Param is passed by value, moved
4113    pub fn set_pos_z(&mut self, v: i32) {
4114        self.pos_z = ::std::option::Option::Some(v);
4115    }
4116
4117    // required fixed32 flags1 = 3;
4118
4119    pub fn flags1(&self) -> u32 {
4120        self.flags1.unwrap_or(0)
4121    }
4122
4123    pub fn clear_flags1(&mut self) {
4124        self.flags1 = ::std::option::Option::None;
4125    }
4126
4127    pub fn has_flags1(&self) -> bool {
4128        self.flags1.is_some()
4129    }
4130
4131    // Param is passed by value, moved
4132    pub fn set_flags1(&mut self, v: u32) {
4133        self.flags1 = ::std::option::Option::Some(v);
4134    }
4135
4136    // required fixed32 flags2 = 4;
4137
4138    pub fn flags2(&self) -> u32 {
4139        self.flags2.unwrap_or(0)
4140    }
4141
4142    pub fn clear_flags2(&mut self) {
4143        self.flags2 = ::std::option::Option::None;
4144    }
4145
4146    pub fn has_flags2(&self) -> bool {
4147        self.flags2.is_some()
4148    }
4149
4150    // Param is passed by value, moved
4151    pub fn set_flags2(&mut self, v: u32) {
4152        self.flags2 = ::std::option::Option::Some(v);
4153    }
4154
4155    // required fixed32 flags3 = 5;
4156
4157    pub fn flags3(&self) -> u32 {
4158        self.flags3.unwrap_or(0)
4159    }
4160
4161    pub fn clear_flags3(&mut self) {
4162        self.flags3 = ::std::option::Option::None;
4163    }
4164
4165    pub fn has_flags3(&self) -> bool {
4166        self.flags3.is_some()
4167    }
4168
4169    // Param is passed by value, moved
4170    pub fn set_flags3(&mut self, v: u32) {
4171        self.flags3 = ::std::option::Option::Some(v);
4172    }
4173
4174    // required int32 race = 6;
4175
4176    pub fn race(&self) -> i32 {
4177        self.race.unwrap_or(0)
4178    }
4179
4180    pub fn clear_race(&mut self) {
4181        self.race = ::std::option::Option::None;
4182    }
4183
4184    pub fn has_race(&self) -> bool {
4185        self.race.is_some()
4186    }
4187
4188    // Param is passed by value, moved
4189    pub fn set_race(&mut self, v: i32) {
4190        self.race = ::std::option::Option::Some(v);
4191    }
4192
4193    // required int32 caste = 7;
4194
4195    pub fn caste(&self) -> i32 {
4196        self.caste.unwrap_or(0)
4197    }
4198
4199    pub fn clear_caste(&mut self) {
4200        self.caste = ::std::option::Option::None;
4201    }
4202
4203    pub fn has_caste(&self) -> bool {
4204        self.caste.is_some()
4205    }
4206
4207    // Param is passed by value, moved
4208    pub fn set_caste(&mut self, v: i32) {
4209        self.caste = ::std::option::Option::Some(v);
4210    }
4211
4212    // optional int32 gender = 8;
4213
4214    pub fn gender(&self) -> i32 {
4215        self.gender.unwrap_or(-1i32)
4216    }
4217
4218    pub fn clear_gender(&mut self) {
4219        self.gender = ::std::option::Option::None;
4220    }
4221
4222    pub fn has_gender(&self) -> bool {
4223        self.gender.is_some()
4224    }
4225
4226    // Param is passed by value, moved
4227    pub fn set_gender(&mut self, v: i32) {
4228        self.gender = ::std::option::Option::Some(v);
4229    }
4230
4231    // optional int32 civ_id = 9;
4232
4233    pub fn civ_id(&self) -> i32 {
4234        self.civ_id.unwrap_or(-1i32)
4235    }
4236
4237    pub fn clear_civ_id(&mut self) {
4238        self.civ_id = ::std::option::Option::None;
4239    }
4240
4241    pub fn has_civ_id(&self) -> bool {
4242        self.civ_id.is_some()
4243    }
4244
4245    // Param is passed by value, moved
4246    pub fn set_civ_id(&mut self, v: i32) {
4247        self.civ_id = ::std::option::Option::Some(v);
4248    }
4249
4250    // optional int32 histfig_id = 10;
4251
4252    pub fn histfig_id(&self) -> i32 {
4253        self.histfig_id.unwrap_or(-1i32)
4254    }
4255
4256    pub fn clear_histfig_id(&mut self) {
4257        self.histfig_id = ::std::option::Option::None;
4258    }
4259
4260    pub fn has_histfig_id(&self) -> bool {
4261        self.histfig_id.is_some()
4262    }
4263
4264    // Param is passed by value, moved
4265    pub fn set_histfig_id(&mut self, v: i32) {
4266        self.histfig_id = ::std::option::Option::Some(v);
4267    }
4268
4269    // optional int32 death_id = 17;
4270
4271    pub fn death_id(&self) -> i32 {
4272        self.death_id.unwrap_or(-1i32)
4273    }
4274
4275    pub fn clear_death_id(&mut self) {
4276        self.death_id = ::std::option::Option::None;
4277    }
4278
4279    pub fn has_death_id(&self) -> bool {
4280        self.death_id.is_some()
4281    }
4282
4283    // Param is passed by value, moved
4284    pub fn set_death_id(&mut self, v: i32) {
4285        self.death_id = ::std::option::Option::Some(v);
4286    }
4287
4288    // optional uint32 death_flags = 18;
4289
4290    pub fn death_flags(&self) -> u32 {
4291        self.death_flags.unwrap_or(0)
4292    }
4293
4294    pub fn clear_death_flags(&mut self) {
4295        self.death_flags = ::std::option::Option::None;
4296    }
4297
4298    pub fn has_death_flags(&self) -> bool {
4299        self.death_flags.is_some()
4300    }
4301
4302    // Param is passed by value, moved
4303    pub fn set_death_flags(&mut self, v: u32) {
4304        self.death_flags = ::std::option::Option::Some(v);
4305    }
4306
4307    // optional int32 squad_id = 19;
4308
4309    pub fn squad_id(&self) -> i32 {
4310        self.squad_id.unwrap_or(-1i32)
4311    }
4312
4313    pub fn clear_squad_id(&mut self) {
4314        self.squad_id = ::std::option::Option::None;
4315    }
4316
4317    pub fn has_squad_id(&self) -> bool {
4318        self.squad_id.is_some()
4319    }
4320
4321    // Param is passed by value, moved
4322    pub fn set_squad_id(&mut self, v: i32) {
4323        self.squad_id = ::std::option::Option::Some(v);
4324    }
4325
4326    // optional int32 squad_position = 20;
4327
4328    pub fn squad_position(&self) -> i32 {
4329        self.squad_position.unwrap_or(-1i32)
4330    }
4331
4332    pub fn clear_squad_position(&mut self) {
4333        self.squad_position = ::std::option::Option::None;
4334    }
4335
4336    pub fn has_squad_position(&self) -> bool {
4337        self.squad_position.is_some()
4338    }
4339
4340    // Param is passed by value, moved
4341    pub fn set_squad_position(&mut self, v: i32) {
4342        self.squad_position = ::std::option::Option::Some(v);
4343    }
4344
4345    // optional int32 profession = 22;
4346
4347    pub fn profession(&self) -> i32 {
4348        self.profession.unwrap_or(-1i32)
4349    }
4350
4351    pub fn clear_profession(&mut self) {
4352        self.profession = ::std::option::Option::None;
4353    }
4354
4355    pub fn has_profession(&self) -> bool {
4356        self.profession.is_some()
4357    }
4358
4359    // Param is passed by value, moved
4360    pub fn set_profession(&mut self, v: i32) {
4361        self.profession = ::std::option::Option::Some(v);
4362    }
4363
4364    // optional string custom_profession = 23;
4365
4366    pub fn custom_profession(&self) -> &str {
4367        match self.custom_profession.as_ref() {
4368            Some(v) => v,
4369            None => "",
4370        }
4371    }
4372
4373    pub fn clear_custom_profession(&mut self) {
4374        self.custom_profession = ::std::option::Option::None;
4375    }
4376
4377    pub fn has_custom_profession(&self) -> bool {
4378        self.custom_profession.is_some()
4379    }
4380
4381    // Param is passed by value, moved
4382    pub fn set_custom_profession(&mut self, v: ::std::string::String) {
4383        self.custom_profession = ::std::option::Option::Some(v);
4384    }
4385
4386    // Mutable pointer to the field.
4387    // If field is not initialized, it is initialized with default value first.
4388    pub fn mut_custom_profession(&mut self) -> &mut ::std::string::String {
4389        if self.custom_profession.is_none() {
4390            self.custom_profession = ::std::option::Option::Some(::std::string::String::new());
4391        }
4392        self.custom_profession.as_mut().unwrap()
4393    }
4394
4395    // Take field
4396    pub fn take_custom_profession(&mut self) -> ::std::string::String {
4397        self.custom_profession.take().unwrap_or_else(|| ::std::string::String::new())
4398    }
4399
4400    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
4401        let mut fields = ::std::vec::Vec::with_capacity(24);
4402        let mut oneofs = ::std::vec::Vec::with_capacity(0);
4403        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
4404            "unit_id",
4405            |m: &BasicUnitInfo| { &m.unit_id },
4406            |m: &mut BasicUnitInfo| { &mut m.unit_id },
4407        ));
4408        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
4409            "pos_x",
4410            |m: &BasicUnitInfo| { &m.pos_x },
4411            |m: &mut BasicUnitInfo| { &mut m.pos_x },
4412        ));
4413        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
4414            "pos_y",
4415            |m: &BasicUnitInfo| { &m.pos_y },
4416            |m: &mut BasicUnitInfo| { &mut m.pos_y },
4417        ));
4418        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
4419            "pos_z",
4420            |m: &BasicUnitInfo| { &m.pos_z },
4421            |m: &mut BasicUnitInfo| { &mut m.pos_z },
4422        ));
4423        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, NameInfo>(
4424            "name",
4425            |m: &BasicUnitInfo| { &m.name },
4426            |m: &mut BasicUnitInfo| { &mut m.name },
4427        ));
4428        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
4429            "flags1",
4430            |m: &BasicUnitInfo| { &m.flags1 },
4431            |m: &mut BasicUnitInfo| { &mut m.flags1 },
4432        ));
4433        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
4434            "flags2",
4435            |m: &BasicUnitInfo| { &m.flags2 },
4436            |m: &mut BasicUnitInfo| { &mut m.flags2 },
4437        ));
4438        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
4439            "flags3",
4440            |m: &BasicUnitInfo| { &m.flags3 },
4441            |m: &mut BasicUnitInfo| { &mut m.flags3 },
4442        ));
4443        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
4444            "race",
4445            |m: &BasicUnitInfo| { &m.race },
4446            |m: &mut BasicUnitInfo| { &mut m.race },
4447        ));
4448        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
4449            "caste",
4450            |m: &BasicUnitInfo| { &m.caste },
4451            |m: &mut BasicUnitInfo| { &mut m.caste },
4452        ));
4453        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
4454            "gender",
4455            |m: &BasicUnitInfo| { &m.gender },
4456            |m: &mut BasicUnitInfo| { &mut m.gender },
4457        ));
4458        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
4459            "civ_id",
4460            |m: &BasicUnitInfo| { &m.civ_id },
4461            |m: &mut BasicUnitInfo| { &mut m.civ_id },
4462        ));
4463        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
4464            "histfig_id",
4465            |m: &BasicUnitInfo| { &m.histfig_id },
4466            |m: &mut BasicUnitInfo| { &mut m.histfig_id },
4467        ));
4468        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
4469            "death_id",
4470            |m: &BasicUnitInfo| { &m.death_id },
4471            |m: &mut BasicUnitInfo| { &mut m.death_id },
4472        ));
4473        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
4474            "death_flags",
4475            |m: &BasicUnitInfo| { &m.death_flags },
4476            |m: &mut BasicUnitInfo| { &mut m.death_flags },
4477        ));
4478        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
4479            "squad_id",
4480            |m: &BasicUnitInfo| { &m.squad_id },
4481            |m: &mut BasicUnitInfo| { &mut m.squad_id },
4482        ));
4483        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
4484            "squad_position",
4485            |m: &BasicUnitInfo| { &m.squad_position },
4486            |m: &mut BasicUnitInfo| { &mut m.squad_position },
4487        ));
4488        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
4489            "profession",
4490            |m: &BasicUnitInfo| { &m.profession },
4491            |m: &mut BasicUnitInfo| { &mut m.profession },
4492        ));
4493        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
4494            "custom_profession",
4495            |m: &BasicUnitInfo| { &m.custom_profession },
4496            |m: &mut BasicUnitInfo| { &mut m.custom_profession },
4497        ));
4498        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
4499            "labors",
4500            |m: &BasicUnitInfo| { &m.labors },
4501            |m: &mut BasicUnitInfo| { &mut m.labors },
4502        ));
4503        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
4504            "skills",
4505            |m: &BasicUnitInfo| { &m.skills },
4506            |m: &mut BasicUnitInfo| { &mut m.skills },
4507        ));
4508        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
4509            "misc_traits",
4510            |m: &BasicUnitInfo| { &m.misc_traits },
4511            |m: &mut BasicUnitInfo| { &mut m.misc_traits },
4512        ));
4513        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, UnitCurseInfo>(
4514            "curse",
4515            |m: &BasicUnitInfo| { &m.curse },
4516            |m: &mut BasicUnitInfo| { &mut m.curse },
4517        ));
4518        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
4519            "burrows",
4520            |m: &BasicUnitInfo| { &m.burrows },
4521            |m: &mut BasicUnitInfo| { &mut m.burrows },
4522        ));
4523        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<BasicUnitInfo>(
4524            "BasicUnitInfo",
4525            fields,
4526            oneofs,
4527        )
4528    }
4529}
4530
4531impl ::protobuf::Message for BasicUnitInfo {
4532    const NAME: &'static str = "BasicUnitInfo";
4533
4534    fn is_initialized(&self) -> bool {
4535        if self.unit_id.is_none() {
4536            return false;
4537        }
4538        if self.pos_x.is_none() {
4539            return false;
4540        }
4541        if self.pos_y.is_none() {
4542            return false;
4543        }
4544        if self.pos_z.is_none() {
4545            return false;
4546        }
4547        if self.flags1.is_none() {
4548            return false;
4549        }
4550        if self.flags2.is_none() {
4551            return false;
4552        }
4553        if self.flags3.is_none() {
4554            return false;
4555        }
4556        if self.race.is_none() {
4557            return false;
4558        }
4559        if self.caste.is_none() {
4560            return false;
4561        }
4562        for v in &self.name {
4563            if !v.is_initialized() {
4564                return false;
4565            }
4566        };
4567        for v in &self.skills {
4568            if !v.is_initialized() {
4569                return false;
4570            }
4571        };
4572        for v in &self.misc_traits {
4573            if !v.is_initialized() {
4574                return false;
4575            }
4576        };
4577        for v in &self.curse {
4578            if !v.is_initialized() {
4579                return false;
4580            }
4581        };
4582        true
4583    }
4584
4585    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
4586        while let Some(tag) = is.read_raw_tag_or_eof()? {
4587            match tag {
4588                8 => {
4589                    self.unit_id = ::std::option::Option::Some(is.read_int32()?);
4590                },
4591                104 => {
4592                    self.pos_x = ::std::option::Option::Some(is.read_int32()?);
4593                },
4594                112 => {
4595                    self.pos_y = ::std::option::Option::Some(is.read_int32()?);
4596                },
4597                120 => {
4598                    self.pos_z = ::std::option::Option::Some(is.read_int32()?);
4599                },
4600                18 => {
4601                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.name)?;
4602                },
4603                29 => {
4604                    self.flags1 = ::std::option::Option::Some(is.read_fixed32()?);
4605                },
4606                37 => {
4607                    self.flags2 = ::std::option::Option::Some(is.read_fixed32()?);
4608                },
4609                45 => {
4610                    self.flags3 = ::std::option::Option::Some(is.read_fixed32()?);
4611                },
4612                48 => {
4613                    self.race = ::std::option::Option::Some(is.read_int32()?);
4614                },
4615                56 => {
4616                    self.caste = ::std::option::Option::Some(is.read_int32()?);
4617                },
4618                64 => {
4619                    self.gender = ::std::option::Option::Some(is.read_int32()?);
4620                },
4621                72 => {
4622                    self.civ_id = ::std::option::Option::Some(is.read_int32()?);
4623                },
4624                80 => {
4625                    self.histfig_id = ::std::option::Option::Some(is.read_int32()?);
4626                },
4627                136 => {
4628                    self.death_id = ::std::option::Option::Some(is.read_int32()?);
4629                },
4630                144 => {
4631                    self.death_flags = ::std::option::Option::Some(is.read_uint32()?);
4632                },
4633                152 => {
4634                    self.squad_id = ::std::option::Option::Some(is.read_int32()?);
4635                },
4636                160 => {
4637                    self.squad_position = ::std::option::Option::Some(is.read_int32()?);
4638                },
4639                176 => {
4640                    self.profession = ::std::option::Option::Some(is.read_int32()?);
4641                },
4642                186 => {
4643                    self.custom_profession = ::std::option::Option::Some(is.read_string()?);
4644                },
4645                90 => {
4646                    is.read_repeated_packed_int32_into(&mut self.labors)?;
4647                },
4648                88 => {
4649                    self.labors.push(is.read_int32()?);
4650                },
4651                98 => {
4652                    self.skills.push(is.read_message()?);
4653                },
4654                194 => {
4655                    self.misc_traits.push(is.read_message()?);
4656                },
4657                130 => {
4658                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.curse)?;
4659                },
4660                170 => {
4661                    is.read_repeated_packed_int32_into(&mut self.burrows)?;
4662                },
4663                168 => {
4664                    self.burrows.push(is.read_int32()?);
4665                },
4666                tag => {
4667                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
4668                },
4669            };
4670        }
4671        ::std::result::Result::Ok(())
4672    }
4673
4674    // Compute sizes of nested messages
4675    #[allow(unused_variables)]
4676    fn compute_size(&self) -> u64 {
4677        let mut my_size = 0;
4678        if let Some(v) = self.unit_id {
4679            my_size += ::protobuf::rt::int32_size(1, v);
4680        }
4681        if let Some(v) = self.pos_x {
4682            my_size += ::protobuf::rt::int32_size(13, v);
4683        }
4684        if let Some(v) = self.pos_y {
4685            my_size += ::protobuf::rt::int32_size(14, v);
4686        }
4687        if let Some(v) = self.pos_z {
4688            my_size += ::protobuf::rt::int32_size(15, v);
4689        }
4690        if let Some(v) = self.name.as_ref() {
4691            let len = v.compute_size();
4692            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
4693        }
4694        if let Some(v) = self.flags1 {
4695            my_size += 1 + 4;
4696        }
4697        if let Some(v) = self.flags2 {
4698            my_size += 1 + 4;
4699        }
4700        if let Some(v) = self.flags3 {
4701            my_size += 1 + 4;
4702        }
4703        if let Some(v) = self.race {
4704            my_size += ::protobuf::rt::int32_size(6, v);
4705        }
4706        if let Some(v) = self.caste {
4707            my_size += ::protobuf::rt::int32_size(7, v);
4708        }
4709        if let Some(v) = self.gender {
4710            my_size += ::protobuf::rt::int32_size(8, v);
4711        }
4712        if let Some(v) = self.civ_id {
4713            my_size += ::protobuf::rt::int32_size(9, v);
4714        }
4715        if let Some(v) = self.histfig_id {
4716            my_size += ::protobuf::rt::int32_size(10, v);
4717        }
4718        if let Some(v) = self.death_id {
4719            my_size += ::protobuf::rt::int32_size(17, v);
4720        }
4721        if let Some(v) = self.death_flags {
4722            my_size += ::protobuf::rt::uint32_size(18, v);
4723        }
4724        if let Some(v) = self.squad_id {
4725            my_size += ::protobuf::rt::int32_size(19, v);
4726        }
4727        if let Some(v) = self.squad_position {
4728            my_size += ::protobuf::rt::int32_size(20, v);
4729        }
4730        if let Some(v) = self.profession {
4731            my_size += ::protobuf::rt::int32_size(22, v);
4732        }
4733        if let Some(v) = self.custom_profession.as_ref() {
4734            my_size += ::protobuf::rt::string_size(23, &v);
4735        }
4736        for value in &self.labors {
4737            my_size += ::protobuf::rt::int32_size(11, *value);
4738        };
4739        for value in &self.skills {
4740            let len = value.compute_size();
4741            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
4742        };
4743        for value in &self.misc_traits {
4744            let len = value.compute_size();
4745            my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
4746        };
4747        if let Some(v) = self.curse.as_ref() {
4748            let len = v.compute_size();
4749            my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
4750        }
4751        for value in &self.burrows {
4752            my_size += ::protobuf::rt::int32_size(21, *value);
4753        };
4754        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
4755        self.special_fields.cached_size().set(my_size as u32);
4756        my_size
4757    }
4758
4759    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
4760        if let Some(v) = self.unit_id {
4761            os.write_int32(1, v)?;
4762        }
4763        if let Some(v) = self.pos_x {
4764            os.write_int32(13, v)?;
4765        }
4766        if let Some(v) = self.pos_y {
4767            os.write_int32(14, v)?;
4768        }
4769        if let Some(v) = self.pos_z {
4770            os.write_int32(15, v)?;
4771        }
4772        if let Some(v) = self.name.as_ref() {
4773            ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
4774        }
4775        if let Some(v) = self.flags1 {
4776            os.write_fixed32(3, v)?;
4777        }
4778        if let Some(v) = self.flags2 {
4779            os.write_fixed32(4, v)?;
4780        }
4781        if let Some(v) = self.flags3 {
4782            os.write_fixed32(5, v)?;
4783        }
4784        if let Some(v) = self.race {
4785            os.write_int32(6, v)?;
4786        }
4787        if let Some(v) = self.caste {
4788            os.write_int32(7, v)?;
4789        }
4790        if let Some(v) = self.gender {
4791            os.write_int32(8, v)?;
4792        }
4793        if let Some(v) = self.civ_id {
4794            os.write_int32(9, v)?;
4795        }
4796        if let Some(v) = self.histfig_id {
4797            os.write_int32(10, v)?;
4798        }
4799        if let Some(v) = self.death_id {
4800            os.write_int32(17, v)?;
4801        }
4802        if let Some(v) = self.death_flags {
4803            os.write_uint32(18, v)?;
4804        }
4805        if let Some(v) = self.squad_id {
4806            os.write_int32(19, v)?;
4807        }
4808        if let Some(v) = self.squad_position {
4809            os.write_int32(20, v)?;
4810        }
4811        if let Some(v) = self.profession {
4812            os.write_int32(22, v)?;
4813        }
4814        if let Some(v) = self.custom_profession.as_ref() {
4815            os.write_string(23, v)?;
4816        }
4817        for v in &self.labors {
4818            os.write_int32(11, *v)?;
4819        };
4820        for v in &self.skills {
4821            ::protobuf::rt::write_message_field_with_cached_size(12, v, os)?;
4822        };
4823        for v in &self.misc_traits {
4824            ::protobuf::rt::write_message_field_with_cached_size(24, v, os)?;
4825        };
4826        if let Some(v) = self.curse.as_ref() {
4827            ::protobuf::rt::write_message_field_with_cached_size(16, v, os)?;
4828        }
4829        for v in &self.burrows {
4830            os.write_int32(21, *v)?;
4831        };
4832        os.write_unknown_fields(self.special_fields.unknown_fields())?;
4833        ::std::result::Result::Ok(())
4834    }
4835
4836    fn special_fields(&self) -> &::protobuf::SpecialFields {
4837        &self.special_fields
4838    }
4839
4840    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
4841        &mut self.special_fields
4842    }
4843
4844    fn new() -> BasicUnitInfo {
4845        BasicUnitInfo::new()
4846    }
4847
4848    fn clear(&mut self) {
4849        self.unit_id = ::std::option::Option::None;
4850        self.pos_x = ::std::option::Option::None;
4851        self.pos_y = ::std::option::Option::None;
4852        self.pos_z = ::std::option::Option::None;
4853        self.name.clear();
4854        self.flags1 = ::std::option::Option::None;
4855        self.flags2 = ::std::option::Option::None;
4856        self.flags3 = ::std::option::Option::None;
4857        self.race = ::std::option::Option::None;
4858        self.caste = ::std::option::Option::None;
4859        self.gender = ::std::option::Option::None;
4860        self.civ_id = ::std::option::Option::None;
4861        self.histfig_id = ::std::option::Option::None;
4862        self.death_id = ::std::option::Option::None;
4863        self.death_flags = ::std::option::Option::None;
4864        self.squad_id = ::std::option::Option::None;
4865        self.squad_position = ::std::option::Option::None;
4866        self.profession = ::std::option::Option::None;
4867        self.custom_profession = ::std::option::Option::None;
4868        self.labors.clear();
4869        self.skills.clear();
4870        self.misc_traits.clear();
4871        self.curse.clear();
4872        self.burrows.clear();
4873        self.special_fields.clear();
4874    }
4875
4876    fn default_instance() -> &'static BasicUnitInfo {
4877        static instance: BasicUnitInfo = BasicUnitInfo {
4878            unit_id: ::std::option::Option::None,
4879            pos_x: ::std::option::Option::None,
4880            pos_y: ::std::option::Option::None,
4881            pos_z: ::std::option::Option::None,
4882            name: ::protobuf::MessageField::none(),
4883            flags1: ::std::option::Option::None,
4884            flags2: ::std::option::Option::None,
4885            flags3: ::std::option::Option::None,
4886            race: ::std::option::Option::None,
4887            caste: ::std::option::Option::None,
4888            gender: ::std::option::Option::None,
4889            civ_id: ::std::option::Option::None,
4890            histfig_id: ::std::option::Option::None,
4891            death_id: ::std::option::Option::None,
4892            death_flags: ::std::option::Option::None,
4893            squad_id: ::std::option::Option::None,
4894            squad_position: ::std::option::Option::None,
4895            profession: ::std::option::Option::None,
4896            custom_profession: ::std::option::Option::None,
4897            labors: ::std::vec::Vec::new(),
4898            skills: ::std::vec::Vec::new(),
4899            misc_traits: ::std::vec::Vec::new(),
4900            curse: ::protobuf::MessageField::none(),
4901            burrows: ::std::vec::Vec::new(),
4902            special_fields: ::protobuf::SpecialFields::new(),
4903        };
4904        &instance
4905    }
4906}
4907
4908impl ::protobuf::MessageFull for BasicUnitInfo {
4909    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
4910        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
4911        descriptor.get(|| file_descriptor().message_by_package_relative_name("BasicUnitInfo").unwrap()).clone()
4912    }
4913}
4914
4915impl ::std::fmt::Display for BasicUnitInfo {
4916    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4917        ::protobuf::text_format::fmt(self, f)
4918    }
4919}
4920
4921impl ::protobuf::reflect::ProtobufValue for BasicUnitInfo {
4922    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
4923}
4924
4925// @@protoc_insertion_point(message:dfproto.BasicUnitInfoMask)
4926#[derive(PartialEq,Clone,Default,Debug)]
4927pub struct BasicUnitInfoMask {
4928    // message fields
4929    // @@protoc_insertion_point(field:dfproto.BasicUnitInfoMask.labors)
4930    pub labors: ::std::option::Option<bool>,
4931    // @@protoc_insertion_point(field:dfproto.BasicUnitInfoMask.skills)
4932    pub skills: ::std::option::Option<bool>,
4933    // @@protoc_insertion_point(field:dfproto.BasicUnitInfoMask.profession)
4934    pub profession: ::std::option::Option<bool>,
4935    // @@protoc_insertion_point(field:dfproto.BasicUnitInfoMask.misc_traits)
4936    pub misc_traits: ::std::option::Option<bool>,
4937    // special fields
4938    // @@protoc_insertion_point(special_field:dfproto.BasicUnitInfoMask.special_fields)
4939    pub special_fields: ::protobuf::SpecialFields,
4940}
4941
4942impl<'a> ::std::default::Default for &'a BasicUnitInfoMask {
4943    fn default() -> &'a BasicUnitInfoMask {
4944        <BasicUnitInfoMask as ::protobuf::Message>::default_instance()
4945    }
4946}
4947
4948impl BasicUnitInfoMask {
4949    pub fn new() -> BasicUnitInfoMask {
4950        ::std::default::Default::default()
4951    }
4952
4953    // optional bool labors = 1;
4954
4955    pub fn labors(&self) -> bool {
4956        self.labors.unwrap_or(false)
4957    }
4958
4959    pub fn clear_labors(&mut self) {
4960        self.labors = ::std::option::Option::None;
4961    }
4962
4963    pub fn has_labors(&self) -> bool {
4964        self.labors.is_some()
4965    }
4966
4967    // Param is passed by value, moved
4968    pub fn set_labors(&mut self, v: bool) {
4969        self.labors = ::std::option::Option::Some(v);
4970    }
4971
4972    // optional bool skills = 2;
4973
4974    pub fn skills(&self) -> bool {
4975        self.skills.unwrap_or(false)
4976    }
4977
4978    pub fn clear_skills(&mut self) {
4979        self.skills = ::std::option::Option::None;
4980    }
4981
4982    pub fn has_skills(&self) -> bool {
4983        self.skills.is_some()
4984    }
4985
4986    // Param is passed by value, moved
4987    pub fn set_skills(&mut self, v: bool) {
4988        self.skills = ::std::option::Option::Some(v);
4989    }
4990
4991    // optional bool profession = 3;
4992
4993    pub fn profession(&self) -> bool {
4994        self.profession.unwrap_or(false)
4995    }
4996
4997    pub fn clear_profession(&mut self) {
4998        self.profession = ::std::option::Option::None;
4999    }
5000
5001    pub fn has_profession(&self) -> bool {
5002        self.profession.is_some()
5003    }
5004
5005    // Param is passed by value, moved
5006    pub fn set_profession(&mut self, v: bool) {
5007        self.profession = ::std::option::Option::Some(v);
5008    }
5009
5010    // optional bool misc_traits = 4;
5011
5012    pub fn misc_traits(&self) -> bool {
5013        self.misc_traits.unwrap_or(false)
5014    }
5015
5016    pub fn clear_misc_traits(&mut self) {
5017        self.misc_traits = ::std::option::Option::None;
5018    }
5019
5020    pub fn has_misc_traits(&self) -> bool {
5021        self.misc_traits.is_some()
5022    }
5023
5024    // Param is passed by value, moved
5025    pub fn set_misc_traits(&mut self, v: bool) {
5026        self.misc_traits = ::std::option::Option::Some(v);
5027    }
5028
5029    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
5030        let mut fields = ::std::vec::Vec::with_capacity(4);
5031        let mut oneofs = ::std::vec::Vec::with_capacity(0);
5032        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
5033            "labors",
5034            |m: &BasicUnitInfoMask| { &m.labors },
5035            |m: &mut BasicUnitInfoMask| { &mut m.labors },
5036        ));
5037        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
5038            "skills",
5039            |m: &BasicUnitInfoMask| { &m.skills },
5040            |m: &mut BasicUnitInfoMask| { &mut m.skills },
5041        ));
5042        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
5043            "profession",
5044            |m: &BasicUnitInfoMask| { &m.profession },
5045            |m: &mut BasicUnitInfoMask| { &mut m.profession },
5046        ));
5047        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
5048            "misc_traits",
5049            |m: &BasicUnitInfoMask| { &m.misc_traits },
5050            |m: &mut BasicUnitInfoMask| { &mut m.misc_traits },
5051        ));
5052        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<BasicUnitInfoMask>(
5053            "BasicUnitInfoMask",
5054            fields,
5055            oneofs,
5056        )
5057    }
5058}
5059
5060impl ::protobuf::Message for BasicUnitInfoMask {
5061    const NAME: &'static str = "BasicUnitInfoMask";
5062
5063    fn is_initialized(&self) -> bool {
5064        true
5065    }
5066
5067    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
5068        while let Some(tag) = is.read_raw_tag_or_eof()? {
5069            match tag {
5070                8 => {
5071                    self.labors = ::std::option::Option::Some(is.read_bool()?);
5072                },
5073                16 => {
5074                    self.skills = ::std::option::Option::Some(is.read_bool()?);
5075                },
5076                24 => {
5077                    self.profession = ::std::option::Option::Some(is.read_bool()?);
5078                },
5079                32 => {
5080                    self.misc_traits = ::std::option::Option::Some(is.read_bool()?);
5081                },
5082                tag => {
5083                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
5084                },
5085            };
5086        }
5087        ::std::result::Result::Ok(())
5088    }
5089
5090    // Compute sizes of nested messages
5091    #[allow(unused_variables)]
5092    fn compute_size(&self) -> u64 {
5093        let mut my_size = 0;
5094        if let Some(v) = self.labors {
5095            my_size += 1 + 1;
5096        }
5097        if let Some(v) = self.skills {
5098            my_size += 1 + 1;
5099        }
5100        if let Some(v) = self.profession {
5101            my_size += 1 + 1;
5102        }
5103        if let Some(v) = self.misc_traits {
5104            my_size += 1 + 1;
5105        }
5106        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
5107        self.special_fields.cached_size().set(my_size as u32);
5108        my_size
5109    }
5110
5111    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
5112        if let Some(v) = self.labors {
5113            os.write_bool(1, v)?;
5114        }
5115        if let Some(v) = self.skills {
5116            os.write_bool(2, v)?;
5117        }
5118        if let Some(v) = self.profession {
5119            os.write_bool(3, v)?;
5120        }
5121        if let Some(v) = self.misc_traits {
5122            os.write_bool(4, v)?;
5123        }
5124        os.write_unknown_fields(self.special_fields.unknown_fields())?;
5125        ::std::result::Result::Ok(())
5126    }
5127
5128    fn special_fields(&self) -> &::protobuf::SpecialFields {
5129        &self.special_fields
5130    }
5131
5132    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
5133        &mut self.special_fields
5134    }
5135
5136    fn new() -> BasicUnitInfoMask {
5137        BasicUnitInfoMask::new()
5138    }
5139
5140    fn clear(&mut self) {
5141        self.labors = ::std::option::Option::None;
5142        self.skills = ::std::option::Option::None;
5143        self.profession = ::std::option::Option::None;
5144        self.misc_traits = ::std::option::Option::None;
5145        self.special_fields.clear();
5146    }
5147
5148    fn default_instance() -> &'static BasicUnitInfoMask {
5149        static instance: BasicUnitInfoMask = BasicUnitInfoMask {
5150            labors: ::std::option::Option::None,
5151            skills: ::std::option::Option::None,
5152            profession: ::std::option::Option::None,
5153            misc_traits: ::std::option::Option::None,
5154            special_fields: ::protobuf::SpecialFields::new(),
5155        };
5156        &instance
5157    }
5158}
5159
5160impl ::protobuf::MessageFull for BasicUnitInfoMask {
5161    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
5162        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
5163        descriptor.get(|| file_descriptor().message_by_package_relative_name("BasicUnitInfoMask").unwrap()).clone()
5164    }
5165}
5166
5167impl ::std::fmt::Display for BasicUnitInfoMask {
5168    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5169        ::protobuf::text_format::fmt(self, f)
5170    }
5171}
5172
5173impl ::protobuf::reflect::ProtobufValue for BasicUnitInfoMask {
5174    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
5175}
5176
5177// @@protoc_insertion_point(message:dfproto.BasicSquadInfo)
5178#[derive(PartialEq,Clone,Default,Debug)]
5179pub struct BasicSquadInfo {
5180    // message fields
5181    // @@protoc_insertion_point(field:dfproto.BasicSquadInfo.squad_id)
5182    pub squad_id: ::std::option::Option<i32>,
5183    // @@protoc_insertion_point(field:dfproto.BasicSquadInfo.name)
5184    pub name: ::protobuf::MessageField<NameInfo>,
5185    // @@protoc_insertion_point(field:dfproto.BasicSquadInfo.alias)
5186    pub alias: ::std::option::Option<::std::string::String>,
5187    // @@protoc_insertion_point(field:dfproto.BasicSquadInfo.members)
5188    pub members: ::std::vec::Vec<i32>,
5189    // special fields
5190    // @@protoc_insertion_point(special_field:dfproto.BasicSquadInfo.special_fields)
5191    pub special_fields: ::protobuf::SpecialFields,
5192}
5193
5194impl<'a> ::std::default::Default for &'a BasicSquadInfo {
5195    fn default() -> &'a BasicSquadInfo {
5196        <BasicSquadInfo as ::protobuf::Message>::default_instance()
5197    }
5198}
5199
5200impl BasicSquadInfo {
5201    pub fn new() -> BasicSquadInfo {
5202        ::std::default::Default::default()
5203    }
5204
5205    // required int32 squad_id = 1;
5206
5207    pub fn squad_id(&self) -> i32 {
5208        self.squad_id.unwrap_or(0)
5209    }
5210
5211    pub fn clear_squad_id(&mut self) {
5212        self.squad_id = ::std::option::Option::None;
5213    }
5214
5215    pub fn has_squad_id(&self) -> bool {
5216        self.squad_id.is_some()
5217    }
5218
5219    // Param is passed by value, moved
5220    pub fn set_squad_id(&mut self, v: i32) {
5221        self.squad_id = ::std::option::Option::Some(v);
5222    }
5223
5224    // optional string alias = 3;
5225
5226    pub fn alias(&self) -> &str {
5227        match self.alias.as_ref() {
5228            Some(v) => v,
5229            None => "",
5230        }
5231    }
5232
5233    pub fn clear_alias(&mut self) {
5234        self.alias = ::std::option::Option::None;
5235    }
5236
5237    pub fn has_alias(&self) -> bool {
5238        self.alias.is_some()
5239    }
5240
5241    // Param is passed by value, moved
5242    pub fn set_alias(&mut self, v: ::std::string::String) {
5243        self.alias = ::std::option::Option::Some(v);
5244    }
5245
5246    // Mutable pointer to the field.
5247    // If field is not initialized, it is initialized with default value first.
5248    pub fn mut_alias(&mut self) -> &mut ::std::string::String {
5249        if self.alias.is_none() {
5250            self.alias = ::std::option::Option::Some(::std::string::String::new());
5251        }
5252        self.alias.as_mut().unwrap()
5253    }
5254
5255    // Take field
5256    pub fn take_alias(&mut self) -> ::std::string::String {
5257        self.alias.take().unwrap_or_else(|| ::std::string::String::new())
5258    }
5259
5260    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
5261        let mut fields = ::std::vec::Vec::with_capacity(4);
5262        let mut oneofs = ::std::vec::Vec::with_capacity(0);
5263        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
5264            "squad_id",
5265            |m: &BasicSquadInfo| { &m.squad_id },
5266            |m: &mut BasicSquadInfo| { &mut m.squad_id },
5267        ));
5268        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, NameInfo>(
5269            "name",
5270            |m: &BasicSquadInfo| { &m.name },
5271            |m: &mut BasicSquadInfo| { &mut m.name },
5272        ));
5273        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
5274            "alias",
5275            |m: &BasicSquadInfo| { &m.alias },
5276            |m: &mut BasicSquadInfo| { &mut m.alias },
5277        ));
5278        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
5279            "members",
5280            |m: &BasicSquadInfo| { &m.members },
5281            |m: &mut BasicSquadInfo| { &mut m.members },
5282        ));
5283        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<BasicSquadInfo>(
5284            "BasicSquadInfo",
5285            fields,
5286            oneofs,
5287        )
5288    }
5289}
5290
5291impl ::protobuf::Message for BasicSquadInfo {
5292    const NAME: &'static str = "BasicSquadInfo";
5293
5294    fn is_initialized(&self) -> bool {
5295        if self.squad_id.is_none() {
5296            return false;
5297        }
5298        for v in &self.name {
5299            if !v.is_initialized() {
5300                return false;
5301            }
5302        };
5303        true
5304    }
5305
5306    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
5307        while let Some(tag) = is.read_raw_tag_or_eof()? {
5308            match tag {
5309                8 => {
5310                    self.squad_id = ::std::option::Option::Some(is.read_int32()?);
5311                },
5312                18 => {
5313                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.name)?;
5314                },
5315                26 => {
5316                    self.alias = ::std::option::Option::Some(is.read_string()?);
5317                },
5318                34 => {
5319                    is.read_repeated_packed_sint32_into(&mut self.members)?;
5320                },
5321                32 => {
5322                    self.members.push(is.read_sint32()?);
5323                },
5324                tag => {
5325                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
5326                },
5327            };
5328        }
5329        ::std::result::Result::Ok(())
5330    }
5331
5332    // Compute sizes of nested messages
5333    #[allow(unused_variables)]
5334    fn compute_size(&self) -> u64 {
5335        let mut my_size = 0;
5336        if let Some(v) = self.squad_id {
5337            my_size += ::protobuf::rt::int32_size(1, v);
5338        }
5339        if let Some(v) = self.name.as_ref() {
5340            let len = v.compute_size();
5341            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
5342        }
5343        if let Some(v) = self.alias.as_ref() {
5344            my_size += ::protobuf::rt::string_size(3, &v);
5345        }
5346        for value in &self.members {
5347            my_size += ::protobuf::rt::sint32_size(4, *value);
5348        };
5349        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
5350        self.special_fields.cached_size().set(my_size as u32);
5351        my_size
5352    }
5353
5354    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
5355        if let Some(v) = self.squad_id {
5356            os.write_int32(1, v)?;
5357        }
5358        if let Some(v) = self.name.as_ref() {
5359            ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
5360        }
5361        if let Some(v) = self.alias.as_ref() {
5362            os.write_string(3, v)?;
5363        }
5364        for v in &self.members {
5365            os.write_sint32(4, *v)?;
5366        };
5367        os.write_unknown_fields(self.special_fields.unknown_fields())?;
5368        ::std::result::Result::Ok(())
5369    }
5370
5371    fn special_fields(&self) -> &::protobuf::SpecialFields {
5372        &self.special_fields
5373    }
5374
5375    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
5376        &mut self.special_fields
5377    }
5378
5379    fn new() -> BasicSquadInfo {
5380        BasicSquadInfo::new()
5381    }
5382
5383    fn clear(&mut self) {
5384        self.squad_id = ::std::option::Option::None;
5385        self.name.clear();
5386        self.alias = ::std::option::Option::None;
5387        self.members.clear();
5388        self.special_fields.clear();
5389    }
5390
5391    fn default_instance() -> &'static BasicSquadInfo {
5392        static instance: BasicSquadInfo = BasicSquadInfo {
5393            squad_id: ::std::option::Option::None,
5394            name: ::protobuf::MessageField::none(),
5395            alias: ::std::option::Option::None,
5396            members: ::std::vec::Vec::new(),
5397            special_fields: ::protobuf::SpecialFields::new(),
5398        };
5399        &instance
5400    }
5401}
5402
5403impl ::protobuf::MessageFull for BasicSquadInfo {
5404    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
5405        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
5406        descriptor.get(|| file_descriptor().message_by_package_relative_name("BasicSquadInfo").unwrap()).clone()
5407    }
5408}
5409
5410impl ::std::fmt::Display for BasicSquadInfo {
5411    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5412        ::protobuf::text_format::fmt(self, f)
5413    }
5414}
5415
5416impl ::protobuf::reflect::ProtobufValue for BasicSquadInfo {
5417    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
5418}
5419
5420// @@protoc_insertion_point(message:dfproto.UnitLaborState)
5421#[derive(PartialEq,Clone,Default,Debug)]
5422pub struct UnitLaborState {
5423    // message fields
5424    // @@protoc_insertion_point(field:dfproto.UnitLaborState.unit_id)
5425    pub unit_id: ::std::option::Option<i32>,
5426    // @@protoc_insertion_point(field:dfproto.UnitLaborState.labor)
5427    pub labor: ::std::option::Option<i32>,
5428    // @@protoc_insertion_point(field:dfproto.UnitLaborState.value)
5429    pub value: ::std::option::Option<bool>,
5430    // special fields
5431    // @@protoc_insertion_point(special_field:dfproto.UnitLaborState.special_fields)
5432    pub special_fields: ::protobuf::SpecialFields,
5433}
5434
5435impl<'a> ::std::default::Default for &'a UnitLaborState {
5436    fn default() -> &'a UnitLaborState {
5437        <UnitLaborState as ::protobuf::Message>::default_instance()
5438    }
5439}
5440
5441impl UnitLaborState {
5442    pub fn new() -> UnitLaborState {
5443        ::std::default::Default::default()
5444    }
5445
5446    // required int32 unit_id = 1;
5447
5448    pub fn unit_id(&self) -> i32 {
5449        self.unit_id.unwrap_or(0)
5450    }
5451
5452    pub fn clear_unit_id(&mut self) {
5453        self.unit_id = ::std::option::Option::None;
5454    }
5455
5456    pub fn has_unit_id(&self) -> bool {
5457        self.unit_id.is_some()
5458    }
5459
5460    // Param is passed by value, moved
5461    pub fn set_unit_id(&mut self, v: i32) {
5462        self.unit_id = ::std::option::Option::Some(v);
5463    }
5464
5465    // required int32 labor = 2;
5466
5467    pub fn labor(&self) -> i32 {
5468        self.labor.unwrap_or(0)
5469    }
5470
5471    pub fn clear_labor(&mut self) {
5472        self.labor = ::std::option::Option::None;
5473    }
5474
5475    pub fn has_labor(&self) -> bool {
5476        self.labor.is_some()
5477    }
5478
5479    // Param is passed by value, moved
5480    pub fn set_labor(&mut self, v: i32) {
5481        self.labor = ::std::option::Option::Some(v);
5482    }
5483
5484    // required bool value = 3;
5485
5486    pub fn value(&self) -> bool {
5487        self.value.unwrap_or(false)
5488    }
5489
5490    pub fn clear_value(&mut self) {
5491        self.value = ::std::option::Option::None;
5492    }
5493
5494    pub fn has_value(&self) -> bool {
5495        self.value.is_some()
5496    }
5497
5498    // Param is passed by value, moved
5499    pub fn set_value(&mut self, v: bool) {
5500        self.value = ::std::option::Option::Some(v);
5501    }
5502
5503    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
5504        let mut fields = ::std::vec::Vec::with_capacity(3);
5505        let mut oneofs = ::std::vec::Vec::with_capacity(0);
5506        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
5507            "unit_id",
5508            |m: &UnitLaborState| { &m.unit_id },
5509            |m: &mut UnitLaborState| { &mut m.unit_id },
5510        ));
5511        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
5512            "labor",
5513            |m: &UnitLaborState| { &m.labor },
5514            |m: &mut UnitLaborState| { &mut m.labor },
5515        ));
5516        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
5517            "value",
5518            |m: &UnitLaborState| { &m.value },
5519            |m: &mut UnitLaborState| { &mut m.value },
5520        ));
5521        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<UnitLaborState>(
5522            "UnitLaborState",
5523            fields,
5524            oneofs,
5525        )
5526    }
5527}
5528
5529impl ::protobuf::Message for UnitLaborState {
5530    const NAME: &'static str = "UnitLaborState";
5531
5532    fn is_initialized(&self) -> bool {
5533        if self.unit_id.is_none() {
5534            return false;
5535        }
5536        if self.labor.is_none() {
5537            return false;
5538        }
5539        if self.value.is_none() {
5540            return false;
5541        }
5542        true
5543    }
5544
5545    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
5546        while let Some(tag) = is.read_raw_tag_or_eof()? {
5547            match tag {
5548                8 => {
5549                    self.unit_id = ::std::option::Option::Some(is.read_int32()?);
5550                },
5551                16 => {
5552                    self.labor = ::std::option::Option::Some(is.read_int32()?);
5553                },
5554                24 => {
5555                    self.value = ::std::option::Option::Some(is.read_bool()?);
5556                },
5557                tag => {
5558                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
5559                },
5560            };
5561        }
5562        ::std::result::Result::Ok(())
5563    }
5564
5565    // Compute sizes of nested messages
5566    #[allow(unused_variables)]
5567    fn compute_size(&self) -> u64 {
5568        let mut my_size = 0;
5569        if let Some(v) = self.unit_id {
5570            my_size += ::protobuf::rt::int32_size(1, v);
5571        }
5572        if let Some(v) = self.labor {
5573            my_size += ::protobuf::rt::int32_size(2, v);
5574        }
5575        if let Some(v) = self.value {
5576            my_size += 1 + 1;
5577        }
5578        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
5579        self.special_fields.cached_size().set(my_size as u32);
5580        my_size
5581    }
5582
5583    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
5584        if let Some(v) = self.unit_id {
5585            os.write_int32(1, v)?;
5586        }
5587        if let Some(v) = self.labor {
5588            os.write_int32(2, v)?;
5589        }
5590        if let Some(v) = self.value {
5591            os.write_bool(3, v)?;
5592        }
5593        os.write_unknown_fields(self.special_fields.unknown_fields())?;
5594        ::std::result::Result::Ok(())
5595    }
5596
5597    fn special_fields(&self) -> &::protobuf::SpecialFields {
5598        &self.special_fields
5599    }
5600
5601    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
5602        &mut self.special_fields
5603    }
5604
5605    fn new() -> UnitLaborState {
5606        UnitLaborState::new()
5607    }
5608
5609    fn clear(&mut self) {
5610        self.unit_id = ::std::option::Option::None;
5611        self.labor = ::std::option::Option::None;
5612        self.value = ::std::option::Option::None;
5613        self.special_fields.clear();
5614    }
5615
5616    fn default_instance() -> &'static UnitLaborState {
5617        static instance: UnitLaborState = UnitLaborState {
5618            unit_id: ::std::option::Option::None,
5619            labor: ::std::option::Option::None,
5620            value: ::std::option::Option::None,
5621            special_fields: ::protobuf::SpecialFields::new(),
5622        };
5623        &instance
5624    }
5625}
5626
5627impl ::protobuf::MessageFull for UnitLaborState {
5628    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
5629        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
5630        descriptor.get(|| file_descriptor().message_by_package_relative_name("UnitLaborState").unwrap()).clone()
5631    }
5632}
5633
5634impl ::std::fmt::Display for UnitLaborState {
5635    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5636        ::protobuf::text_format::fmt(self, f)
5637    }
5638}
5639
5640impl ::protobuf::reflect::ProtobufValue for UnitLaborState {
5641    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
5642}
5643
5644static file_descriptor_proto_data: &'static [u8] = b"\
5645    \n\x0bBasic.proto\x12\x07dfproto\"X\n\x0cEnumItemName\x12\x14\n\x05value\
5646    \x18\x01\x20\x02(\x05R\x05value\x12\x12\n\x04name\x18\x02\x20\x01(\tR\
5647    \x04name\x12\x1e\n\x08bit_size\x18\x03\x20\x01(\x05:\x011R\x07bitSizeB\0\
5648    \";\n\x0fBasicMaterialId\x12\x12\n\x04type\x18\x01\x20\x02(\x05R\x04type\
5649    \x12\x14\n\x05index\x18\x02\x20\x02(\x11R\x05index\"\xdc\x04\n\x11BasicM\
5650    aterialInfo\x12\x12\n\x04type\x18\x01\x20\x02(\x05R\x04type\x12\x14\n\
5651    \x05index\x18\x02\x20\x02(\x11R\x05index\x12\x14\n\x05token\x18\x03\x20\
5652    \x02(\tR\x05token\x12\x14\n\x05flags\x18\x04\x20\x03(\x05R\x05flags\x12\
5653    \x1e\n\x07subtype\x18\x05\x20\x01(\x05:\x02-1R\x07subtypeB\0\x12%\n\x0bc\
5654    reature_id\x18\x06\x20\x01(\x05:\x02-1R\ncreatureIdB\0\x12\x1f\n\x08plan\
5655    t_id\x18\x07\x20\x01(\x05:\x02-1R\x07plantIdB\0\x12#\n\nhistfig_id\x18\
5656    \x08\x20\x01(\x05:\x02-1R\thistfigIdB\0\x12#\n\x0bname_prefix\x18\t\x20\
5657    \x01(\t:\0R\nnamePrefixB\0\x12\x1f\n\x0bstate_color\x18\n\x20\x03(\x07R\
5658    \nstateColor\x12\x1d\n\nstate_name\x18\x0b\x20\x03(\tR\tstateName\x12\
5659    \x1b\n\tstate_adj\x18\x0c\x20\x03(\tR\x08stateAdj\x12%\n\x0ereaction_cla\
5660    ss\x18\r\x20\x03(\tR\rreactionClass\x12M\n\x10reaction_product\x18\x0e\
5661    \x20\x03(\x0b2\".dfproto.BasicMaterialInfo.ProductR\x0freactionProduct\
5662    \x12'\n\x0finorganic_flags\x18\x0f\x20\x03(\x05R\x0einorganicFlags\x1aC\
5663    \n\x07Product\x12\x0e\n\x02id\x18\x01\x20\x02(\tR\x02id\x12\x12\n\x04typ\
5664    e\x18\x02\x20\x02(\x05R\x04type\x12\x14\n\x05index\x18\x03\x20\x02(\x11R\
5665    \x05index\"\x99\x02\n\x15BasicMaterialInfoMask\x12@\n\x06states\x18\x01\
5666    \x20\x03(\x0e2(.dfproto.BasicMaterialInfoMask.StateTypeR\x06states\x12)\
5667    \n\x0btemperature\x18\x04\x20\x01(\x05:\x0510015R\x0btemperatureB\0\x12\
5668    \x1d\n\x05flags\x18\x02\x20\x01(\x08:\x05falseR\x05flagsB\0\x12#\n\x08re\
5669    action\x18\x03\x20\x01(\x08:\x05falseR\x08reactionB\0\"O\n\tStateType\
5670    \x12\t\n\x05Solid\x10\0\x12\n\n\x06Liquid\x10\x01\x12\x07\n\x03Gas\x10\
5671    \x02\x12\n\n\x06Powder\x10\x03\x12\t\n\x05Paste\x10\x04\x12\x0b\n\x07Pre\
5672    ssed\x10\x05\"\xb7\x01\n\x0cJobSkillAttr\x12\x0e\n\x02id\x18\x01\x20\x02\
5673    (\x05R\x02id\x12\x10\n\x03key\x18\x02\x20\x02(\tR\x03key\x12\x18\n\x07ca\
5674    ption\x18\x03\x20\x01(\tR\x07caption\x12!\n\x0ccaption_noun\x18\x04\x20\
5675    \x01(\tR\x0bcaptionNoun\x12\x1e\n\nprofession\x18\x05\x20\x01(\x05R\npro\
5676    fession\x12\x14\n\x05labor\x18\x06\x20\x01(\x05R\x05labor\x12\x12\n\x04t\
5677    ype\x18\x07\x20\x01(\tR\x04type\"\xaa\x01\n\x0eProfessionAttr\x12\x0e\n\
5678    \x02id\x18\x01\x20\x02(\x05R\x02id\x12\x10\n\x03key\x18\x02\x20\x02(\tR\
5679    \x03key\x12\x18\n\x07caption\x18\x03\x20\x01(\tR\x07caption\x12\x1a\n\
5680    \x08military\x18\x04\x20\x01(\x08R\x08military\x12(\n\x10can_assign_labo\
5681    r\x18\x05\x20\x01(\x08R\x0ecanAssignLabor\x12\x16\n\x06parent\x18\x06\
5682    \x20\x01(\x05R\x06parent\"K\n\rUnitLaborAttr\x12\x0e\n\x02id\x18\x01\x20\
5683    \x02(\x05R\x02id\x12\x10\n\x03key\x18\x02\x20\x02(\tR\x03key\x12\x18\n\
5684    \x07caption\x18\x03\x20\x01(\tR\x07caption\"\xac\x01\n\x08NameInfo\x12\
5685    \x1d\n\nfirst_name\x18\x01\x20\x01(\tR\tfirstName\x12\x1a\n\x08nickname\
5686    \x18\x02\x20\x01(\tR\x08nickname\x12%\n\x0blanguage_id\x18\x03\x20\x01(\
5687    \x05:\x02-1R\nlanguageIdB\0\x12\x1b\n\tlast_name\x18\x04\x20\x01(\tR\x08\
5688    lastName\x12!\n\x0cenglish_name\x18\x05\x20\x01(\tR\x0benglishName\"Z\n\
5689    \nNameTriple\x12\x16\n\x06normal\x18\x01\x20\x02(\tR\x06normal\x12\x16\n\
5690    \x06plural\x18\x02\x20\x01(\tR\x06plural\x12\x1c\n\tadjective\x18\x03\
5691    \x20\x01(\tR\tadjective\"\xac\x01\n\rUnitCurseInfo\x12\x1b\n\tadd_tags1\
5692    \x18\x01\x20\x02(\x07R\x08addTags1\x12\x1b\n\trem_tags1\x18\x02\x20\x02(\
5693    \x07R\x08remTags1\x12\x1b\n\tadd_tags2\x18\x03\x20\x02(\x07R\x08addTags2\
5694    \x12\x1b\n\trem_tags2\x18\x04\x20\x02(\x07R\x08remTags2\x12'\n\x04name\
5695    \x18\x05\x20\x01(\x0b2\x13.dfproto.NameTripleR\x04name\"Q\n\tSkillInfo\
5696    \x12\x0e\n\x02id\x18\x01\x20\x02(\x05R\x02id\x12\x14\n\x05level\x18\x02\
5697    \x20\x02(\x05R\x05level\x12\x1e\n\nexperience\x18\x03\x20\x02(\x05R\nexp\
5698    erience\"5\n\rUnitMiscTrait\x12\x0e\n\x02id\x18\x01\x20\x02(\x05R\x02id\
5699    \x12\x14\n\x05value\x18\x02\x20\x02(\x05R\x05value\"\x88\x06\n\rBasicUni\
5700    tInfo\x12\x17\n\x07unit_id\x18\x01\x20\x02(\x05R\x06unitId\x12\x13\n\x05\
5701    pos_x\x18\r\x20\x02(\x05R\x04posX\x12\x13\n\x05pos_y\x18\x0e\x20\x02(\
5702    \x05R\x04posY\x12\x13\n\x05pos_z\x18\x0f\x20\x02(\x05R\x04posZ\x12%\n\
5703    \x04name\x18\x02\x20\x01(\x0b2\x11.dfproto.NameInfoR\x04name\x12\x16\n\
5704    \x06flags1\x18\x03\x20\x02(\x07R\x06flags1\x12\x16\n\x06flags2\x18\x04\
5705    \x20\x02(\x07R\x06flags2\x12\x16\n\x06flags3\x18\x05\x20\x02(\x07R\x06fl\
5706    ags3\x12\x12\n\x04race\x18\x06\x20\x02(\x05R\x04race\x12\x14\n\x05caste\
5707    \x18\x07\x20\x02(\x05R\x05caste\x12\x1c\n\x06gender\x18\x08\x20\x01(\x05\
5708    :\x02-1R\x06genderB\0\x12\x1b\n\x06civ_id\x18\t\x20\x01(\x05:\x02-1R\x05\
5709    civIdB\0\x12#\n\nhistfig_id\x18\n\x20\x01(\x05:\x02-1R\thistfigIdB\0\x12\
5710    \x1f\n\x08death_id\x18\x11\x20\x01(\x05:\x02-1R\x07deathIdB\0\x12\x1f\n\
5711    \x0bdeath_flags\x18\x12\x20\x01(\rR\ndeathFlags\x12\x1f\n\x08squad_id\
5712    \x18\x13\x20\x01(\x05:\x02-1R\x07squadIdB\0\x12+\n\x0esquad_position\x18\
5713    \x14\x20\x01(\x05:\x02-1R\rsquadPositionB\0\x12$\n\nprofession\x18\x16\
5714    \x20\x01(\x05:\x02-1R\nprofessionB\0\x12+\n\x11custom_profession\x18\x17\
5715    \x20\x01(\tR\x10customProfession\x12\x16\n\x06labors\x18\x0b\x20\x03(\
5716    \x05R\x06labors\x12*\n\x06skills\x18\x0c\x20\x03(\x0b2\x12.dfproto.Skill\
5717    InfoR\x06skills\x127\n\x0bmisc_traits\x18\x18\x20\x03(\x0b2\x16.dfproto.\
5718    UnitMiscTraitR\nmiscTraits\x12,\n\x05curse\x18\x10\x20\x01(\x0b2\x16.dfp\
5719    roto.UnitCurseInfoR\x05curse\x12\x18\n\x07burrows\x18\x15\x20\x03(\x05R\
5720    \x07burrows\"\xa8\x01\n\x11BasicUnitInfoMask\x12\x1f\n\x06labors\x18\x01\
5721    \x20\x01(\x08:\x05falseR\x06laborsB\0\x12\x1f\n\x06skills\x18\x02\x20\
5722    \x01(\x08:\x05falseR\x06skillsB\0\x12'\n\nprofession\x18\x03\x20\x01(\
5723    \x08:\x05falseR\nprofessionB\0\x12(\n\x0bmisc_traits\x18\x04\x20\x01(\
5724    \x08:\x05falseR\nmiscTraitsB\0\"\x82\x01\n\x0eBasicSquadInfo\x12\x19\n\
5725    \x08squad_id\x18\x01\x20\x02(\x05R\x07squadId\x12%\n\x04name\x18\x02\x20\
5726    \x01(\x0b2\x11.dfproto.NameInfoR\x04name\x12\x14\n\x05alias\x18\x03\x20\
5727    \x01(\tR\x05alias\x12\x18\n\x07members\x18\x04\x20\x03(\x11R\x07members\
5728    \"U\n\x0eUnitLaborState\x12\x17\n\x07unit_id\x18\x01\x20\x02(\x05R\x06un\
5729    itId\x12\x14\n\x05labor\x18\x02\x20\x02(\x05R\x05labor\x12\x14\n\x05valu\
5730    e\x18\x03\x20\x02(\x08R\x05valueB\x02H\x03b\x06proto2\
5731";
5732
5733/// `FileDescriptorProto` object which was a source for this generated file
5734fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
5735    static file_descriptor_proto_lazy: ::protobuf::rt::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::Lazy::new();
5736    file_descriptor_proto_lazy.get(|| {
5737        ::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
5738    })
5739}
5740
5741/// `FileDescriptor` object which allows dynamic access to files
5742pub fn file_descriptor() -> &'static ::protobuf::reflect::FileDescriptor {
5743    static generated_file_descriptor_lazy: ::protobuf::rt::Lazy<::protobuf::reflect::GeneratedFileDescriptor> = ::protobuf::rt::Lazy::new();
5744    static file_descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::FileDescriptor> = ::protobuf::rt::Lazy::new();
5745    file_descriptor.get(|| {
5746        let generated_file_descriptor = generated_file_descriptor_lazy.get(|| {
5747            let mut deps = ::std::vec::Vec::with_capacity(0);
5748            let mut messages = ::std::vec::Vec::with_capacity(17);
5749            messages.push(EnumItemName::generated_message_descriptor_data());
5750            messages.push(BasicMaterialId::generated_message_descriptor_data());
5751            messages.push(BasicMaterialInfo::generated_message_descriptor_data());
5752            messages.push(BasicMaterialInfoMask::generated_message_descriptor_data());
5753            messages.push(JobSkillAttr::generated_message_descriptor_data());
5754            messages.push(ProfessionAttr::generated_message_descriptor_data());
5755            messages.push(UnitLaborAttr::generated_message_descriptor_data());
5756            messages.push(NameInfo::generated_message_descriptor_data());
5757            messages.push(NameTriple::generated_message_descriptor_data());
5758            messages.push(UnitCurseInfo::generated_message_descriptor_data());
5759            messages.push(SkillInfo::generated_message_descriptor_data());
5760            messages.push(UnitMiscTrait::generated_message_descriptor_data());
5761            messages.push(BasicUnitInfo::generated_message_descriptor_data());
5762            messages.push(BasicUnitInfoMask::generated_message_descriptor_data());
5763            messages.push(BasicSquadInfo::generated_message_descriptor_data());
5764            messages.push(UnitLaborState::generated_message_descriptor_data());
5765            messages.push(basic_material_info::Product::generated_message_descriptor_data());
5766            let mut enums = ::std::vec::Vec::with_capacity(1);
5767            enums.push(basic_material_info_mask::StateType::generated_enum_descriptor_data());
5768            ::protobuf::reflect::GeneratedFileDescriptor::new_generated(
5769                file_descriptor_proto(),
5770                deps,
5771                messages,
5772                enums,
5773            )
5774        });
5775        ::protobuf::reflect::FileDescriptor::new_generated_2(generated_file_descriptor)
5776    })
5777}
dfhack_proto/generated/messages/Basic.rs

dfhack_proto/generated/messages/
Basic.rs
