1#[cfg(feature = "app-mapinspector-types")]
4mod __types {
5 #[allow(unused_imports)] use ::unity::prelude::*;
6
7 use super::*;
8 use crate::{
9 app::scriptutil::{IScriptUtil, ScriptUtil},
10 system::{
11 object::{IObject, Object},
12 r#enum::{Enum, IEnum},
13 valuetype::{IValueType, ValueType},
14 },
15 };
16
17 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/mapinspector/MapInspector.md"))]
18 #[::unity::class(namespace = "App", name = "MapInspector")]
19 #[parent(crate::app::scriptutil::ScriptUtil)]
20 pub struct MapInspector {
21 #[offset(16)]
22 #[rename(name = "m_Kind")]
23 pub m_kind: crate::app::mapinspector::MapInspector_Kind,
24 #[offset(24)]
25 #[rename(name = "m_Condition")]
26 pub m_condition: crate::moon_sharp::interpreter::dynvalue::DynValue,
27 #[offset(32)]
28 #[rename(name = "m_Function")]
29 pub m_function: crate::moon_sharp::interpreter::dynvalue::DynValue,
30 #[offset(40)]
31 #[rename(name = "m_Args")]
32 pub m_args: ::unity::Array<crate::moon_sharp::interpreter::dynvalue::DynValue>,
33 }
34
35 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/mapinspector/MapInspector_Kind.md"))]
36 #[repr(C)]
37 #[derive(::core::clone::Clone, ::core::marker::Copy, ::core::fmt::Debug, ::core::cmp::PartialEq, ::core::cmp::Eq)]
38 pub struct MapInspector_Kind {
39 pub value: i32,
40 }
41 impl ::unity::ClassIdentity for MapInspector_Kind {
42 const NAME: &'static str = "MapInspector.Kind";
43 const NAMESPACE: &'static str = "App";
44
45 fn class() -> ::unity::Class {
46 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
47 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
48 }
49 }
50 impl ::unity::IlType for MapInspector_Kind {
51 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
52 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
53 }
54 }
55 impl MapInspector_Kind {
56 pub fn none() -> Self {
57 Self { value: 0 }
58 }
59
60 pub fn turn() -> Self {
61 Self { value: 1 }
62 }
63
64 pub fn turn_after() -> Self {
65 Self { value: 2 }
66 }
67
68 pub fn turn_end() -> Self {
69 Self { value: 3 }
70 }
71
72 pub fn area() -> Self {
73 Self { value: 4 }
74 }
75
76 pub fn tbox() -> Self {
77 Self { value: 5 }
78 }
79
80 pub fn door() -> Self {
81 Self { value: 6 }
82 }
83
84 pub fn torch() -> Self {
85 Self { value: 7 }
86 }
87
88 pub fn visit() -> Self {
89 Self { value: 8 }
90 }
91
92 pub fn escape() -> Self {
93 Self { value: 9 }
94 }
95
96 pub fn destroy() -> Self {
97 Self { value: 10 }
98 }
99
100 pub fn breakdown() -> Self {
101 Self { value: 11 }
102 }
103
104 pub fn breakdown_enemy() -> Self {
105 Self { value: 12 }
106 }
107
108 pub fn waypoint() -> Self {
109 Self { value: 13 }
110 }
111
112 pub fn command() -> Self {
113 Self { value: 14 }
114 }
115
116 pub fn die() -> Self {
117 Self { value: 15 }
118 }
119
120 pub fn revive_before() -> Self {
121 Self { value: 16 }
122 }
123
124 pub fn revive_after() -> Self {
125 Self { value: 17 }
126 }
127
128 pub fn fixed() -> Self {
129 Self { value: 18 }
130 }
131
132 pub fn talk() -> Self {
133 Self { value: 19 }
134 }
135
136 pub fn battle_before() -> Self {
137 Self { value: 20 }
138 }
139
140 pub fn battle_talk() -> Self {
141 Self { value: 21 }
142 }
143
144 pub fn battle_after() -> Self {
145 Self { value: 22 }
146 }
147
148 pub fn pickup() -> Self {
149 Self { value: 23 }
150 }
151
152 pub fn target_select() -> Self {
153 Self { value: 24 }
154 }
155
156 pub fn unit_command_prepare() -> Self {
157 Self { value: 25 }
158 }
159
160 pub fn unit_command_interrupt() -> Self {
161 Self { value: 26 }
162 }
163
164 pub fn engage_before() -> Self {
165 Self { value: 27 }
166 }
167
168 pub fn engage_after() -> Self {
169 Self { value: 28 }
170 }
171
172 pub fn cannon() -> Self {
173 Self { value: 29 }
174 }
175
176 pub fn help_spot() -> Self {
177 Self { value: 30 }
178 }
179
180 pub fn num() -> Self {
181 Self { value: 31 }
182 }
183 }
184}
185
186#[cfg(feature = "app-mapinspector-types")]
187pub use __types::*;
188
189#[cfg(feature = "app-mapinspector")]
190impl MapInspector {
191 #[doc = "`op_Implicit(crate::app::mapinspector::MapInspector)` overload"]
192 pub fn op_implicit(exists: impl ::core::convert::Into<crate::app::mapinspector::MapInspector>) -> bool {
193 unsafe {
194 ::unity::il2cpp_call!((::unity::module_base()+0x1de5b90usize)as*mut u8,bool;
195(crate::app::mapinspector::MapInspector)::core::convert::Into::into(exists))
196 }
197 }
198
199 #[doc = "`CanEnter(i32, i32)` overload"]
200 pub fn can_enter(x: impl ::core::convert::Into<i32>, z: impl ::core::convert::Into<i32>) -> bool {
201 unsafe {
202 ::unity::il2cpp_call!((::unity::module_base()+0x1de63a0usize)as*mut u8,bool;
203(i32)::core::convert::Into::into(x),(i32)::core::convert::Into::into(z))
204 }
205 }
206}
207
208#[cfg(feature = "app-mapinspector")]
209pub trait IMapInspectorMethods: IMapInspector {
210 #[doc = "`.ctor(crate::app::mapinspector::MapInspector_Kind)` overload"]
211 fn ctor(self, kind: impl ::core::convert::Into<crate::app::mapinspector::MapInspector_Kind>) -> () {
212 unsafe {
213 let __receiver = <MapInspector as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
214 ::unity::il2cpp_call!((::unity::module_base()+0x1de51c0usize)as*mut u8,();
215(MapInspector)__receiver,(crate::app::mapinspector::MapInspector_Kind)::core::convert::Into::into(kind))
216 }
217 }
218 #[doc = "`GetKind()` overload"]
219 fn get_kind(self) -> crate::app::mapinspector::MapInspector_Kind {
220 unsafe {
221 let __receiver = <MapInspector as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
222 ::unity::il2cpp_call!((::unity::module_base()+0x1de5240usize)as*mut u8,crate::app::mapinspector::MapInspector_Kind;
223(MapInspector)__receiver)
224 }
225 }
226 #[doc = "`GetFunction()` overload"]
227 fn get_function(self) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
228 unsafe {
229 let __receiver = <MapInspector as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
230 ::unity::il2cpp_call!((::unity::module_base()+0x1de5250usize)as*mut u8,crate::moon_sharp::interpreter::dynvalue::DynValue;
231(MapInspector)__receiver)
232 }
233 }
234 #[doc = "`GetArgs()` overload"]
235 fn get_args(self) -> ::unity::Array<crate::moon_sharp::interpreter::dynvalue::DynValue> {
236 unsafe {
237 let __receiver = <MapInspector as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
238 ::unity::il2cpp_call!((::unity::module_base()+0x1de5260usize)as*mut u8, ::unity::Array<crate::moon_sharp::interpreter::dynvalue::DynValue> ;
239(MapInspector)__receiver)
240 }
241 }
242 #[doc = "`GetCondition()` overload"]
243 fn get_condition(self) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
244 unsafe {
245 let __receiver = <MapInspector as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
246 ::unity::il2cpp_call!((::unity::module_base()+0x1de5270usize)as*mut u8,crate::moon_sharp::interpreter::dynvalue::DynValue;
247(MapInspector)__receiver)
248 }
249 }
250 #[doc = "`IsCondition()` overload"]
251 fn is_condition(self) -> bool {
252 unsafe {
253 let __receiver = <MapInspector as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
254 ::unity::il2cpp_call!((::unity::module_base()+0x1de5280usize)as*mut u8,bool;
255(MapInspector)__receiver)
256 }
257 }
258 #[doc = "`IsInside(i32, i32)` overload"]
259 fn is_inside(self, x: impl ::core::convert::Into<i32>, z: impl ::core::convert::Into<i32>) -> bool {
260 unsafe {
261 let __receiver = <MapInspector as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
262 ::unity::il2cpp_call!((::unity::module_base()+0x1de53e0usize)as*mut u8,bool;
263(MapInspector)__receiver,(i32)::core::convert::Into::into(x),(i32)::core::convert::Into::into(z))
264 }
265 }
266 #[doc = "`Completed()` overload"]
267 fn completed(self) -> () {
268 unsafe {
269 let __receiver = <MapInspector as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
270 {
271 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
272 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
273 panic!(
274 "unity: virtual slot {}
275 out of range (vtable len {}
276) on the runtime class behind {}
277 (method `{}
278`)",
279 4usize,
280 __vt.len(),
281 <MapInspector as ::unity::ClassIdentity>::NAME,
282 "Completed",
283 )
284 });
285 let __inner: extern "C" fn(MapInspector, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
286 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
287 __inner(__receiver, __mi)
288 }
289 }
290 }
291 #[doc = "`IsValue(i32, i32)` overload"]
292 fn is_value(self, self_: impl ::core::convert::Into<i32>, other: impl ::core::convert::Into<i32>) -> bool {
293 unsafe {
294 let __receiver = <MapInspector as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
295 ::unity::il2cpp_call!((::unity::module_base()+0x1de5690usize)as*mut u8,bool;
296(MapInspector)__receiver,(i32)::core::convert::Into::into(self_),(i32)::core::convert::Into::into(other))
297 }
298 }
299 #[doc = "`IsEanble()` overload"]
300 fn is_eanble(self) -> bool {
301 unsafe {
302 let __receiver = <MapInspector as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
303 {
304 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
305 let __vi = *__vt.get(5usize).unwrap_or_else(|| {
306 panic!(
307 "unity: virtual slot {}
308 out of range (vtable len {}
309) on the runtime class behind {}
310 (method `{}
311`)",
312 5usize,
313 __vt.len(),
314 <MapInspector as ::unity::ClassIdentity>::NAME,
315 "IsEanble",
316 )
317 });
318 let __inner: extern "C" fn(MapInspector, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
319 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
320 __inner(__receiver, __mi)
321 }
322 }
323 }
324 #[doc = "`IsEanble(i32)` overload"]
325 fn is_eanble_2(self, arg: impl ::core::convert::Into<i32>) -> bool {
326 unsafe {
327 let __receiver = <MapInspector as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
328 {
329 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
330 let __vi = *__vt.get(6usize).unwrap_or_else(|| {
331 panic!(
332 "unity: virtual slot {}
333 out of range (vtable len {}
334) on the runtime class behind {}
335 (method `{}
336`)",
337 6usize,
338 __vt.len(),
339 <MapInspector as ::unity::ClassIdentity>::NAME,
340 "IsEanble",
341 )
342 });
343 let __inner: extern "C" fn(MapInspector, i32, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
344 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
345 __inner(__receiver, ::core::convert::Into::into(arg), __mi)
346 }
347 }
348 }
349 #[doc = "`IsEanble(i32, i32)` overload"]
350 fn is_eanble_3(self, arg1: impl ::core::convert::Into<i32>, arg2: impl ::core::convert::Into<i32>) -> bool {
351 unsafe {
352 let __receiver = <MapInspector as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
353 {
354 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
355 let __vi = *__vt.get(7usize).unwrap_or_else(|| {
356 panic!(
357 "unity: virtual slot {}
358 out of range (vtable len {}
359) on the runtime class behind {}
360 (method `{}
361`)",
362 7usize,
363 __vt.len(),
364 <MapInspector as ::unity::ClassIdentity>::NAME,
365 "IsEanble",
366 )
367 });
368 let __inner: extern "C" fn(MapInspector, i32, i32, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
369 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
370 __inner(__receiver, ::core::convert::Into::into(arg1), ::core::convert::Into::into(arg2), __mi)
371 }
372 }
373 }
374 #[doc = "`IsEanble(i32, i32, i32)` overload"]
375 fn is_eanble_4(
376 self,
377 arg1: impl ::core::convert::Into<i32>,
378 arg2: impl ::core::convert::Into<i32>,
379 arg3: impl ::core::convert::Into<i32>,
380 ) -> bool {
381 unsafe {
382 let __receiver = <MapInspector as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
383 {
384 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
385 let __vi = *__vt.get(8usize).unwrap_or_else(|| {
386 panic!(
387 "unity: virtual slot {}
388 out of range (vtable len {}
389) on the runtime class behind {}
390 (method `{}
391`)",
392 8usize,
393 __vt.len(),
394 <MapInspector as ::unity::ClassIdentity>::NAME,
395 "IsEanble",
396 )
397 });
398 let __inner: extern "C" fn(MapInspector, i32, i32, i32, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
399 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
400 __inner(
401 __receiver,
402 ::core::convert::Into::into(arg1),
403 ::core::convert::Into::into(arg2),
404 ::core::convert::Into::into(arg3),
405 __mi,
406 )
407 }
408 }
409 }
410 #[doc = "`IsEanble(i32, i32, i32, i32)` overload"]
411 fn is_eanble_5(
412 self,
413 arg1: impl ::core::convert::Into<i32>,
414 arg2: impl ::core::convert::Into<i32>,
415 arg3: impl ::core::convert::Into<i32>,
416 arg4: impl ::core::convert::Into<i32>,
417 ) -> bool {
418 unsafe {
419 let __receiver = <MapInspector as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
420 {
421 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
422 let __vi = *__vt.get(9usize).unwrap_or_else(|| {
423 panic!(
424 "unity: virtual slot {}
425 out of range (vtable len {}
426) on the runtime class behind {}
427 (method `{}
428`)",
429 9usize,
430 __vt.len(),
431 <MapInspector as ::unity::ClassIdentity>::NAME,
432 "IsEanble",
433 )
434 });
435 let __inner: extern "C" fn(MapInspector, i32, i32, i32, i32, ::unity::OptionalMethod) -> bool =
436 ::core::mem::transmute(__vi.method_ptr);
437 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
438 __inner(
439 __receiver,
440 ::core::convert::Into::into(arg1),
441 ::core::convert::Into::into(arg2),
442 ::core::convert::Into::into(arg3),
443 ::core::convert::Into::into(arg4),
444 __mi,
445 )
446 }
447 }
448 }
449 #[doc = "`IsTerminated(i32, i32, i32, i32)` overload"]
450 fn is_terminated(
451 self,
452 arg1: impl ::core::convert::Into<i32>,
453 arg2: impl ::core::convert::Into<i32>,
454 arg3: impl ::core::convert::Into<i32>,
455 arg4: impl ::core::convert::Into<i32>,
456 ) -> bool {
457 unsafe {
458 let __receiver = <MapInspector as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
459 {
460 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
461 let __vi = *__vt.get(10usize).unwrap_or_else(|| {
462 panic!(
463 "unity: virtual slot {}
464 out of range (vtable len {}
465) on the runtime class behind {}
466 (method `{}
467`)",
468 10usize,
469 __vt.len(),
470 <MapInspector as ::unity::ClassIdentity>::NAME,
471 "IsTerminated",
472 )
473 });
474 let __inner: extern "C" fn(MapInspector, i32, i32, i32, i32, ::unity::OptionalMethod) -> bool =
475 ::core::mem::transmute(__vi.method_ptr);
476 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
477 __inner(
478 __receiver,
479 ::core::convert::Into::into(arg1),
480 ::core::convert::Into::into(arg2),
481 ::core::convert::Into::into(arg3),
482 ::core::convert::Into::into(arg4),
483 __mi,
484 )
485 }
486 }
487 }
488 #[doc = "`get_Color()` overload"]
489 fn get_color(self) -> crate::unity_engine::color::Color {
490 unsafe {
491 let __receiver = <MapInspector as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
492 {
493 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
494 let __vi = *__vt.get(11usize).unwrap_or_else(|| {
495 panic!(
496 "unity: virtual slot {}
497 out of range (vtable len {}
498) on the runtime class behind {}
499 (method `{}
500`)",
501 11usize,
502 __vt.len(),
503 <MapInspector as ::unity::ClassIdentity>::NAME,
504 "get_Color",
505 )
506 });
507 let __inner: extern "C" fn(MapInspector, ::unity::OptionalMethod) -> crate::unity_engine::color::Color =
508 ::core::mem::transmute(__vi.method_ptr);
509 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
510 __inner(__receiver, __mi)
511 }
512 }
513 }
514 #[doc = "`get_X()` overload"]
515 fn get_x(self) -> i32 {
516 unsafe {
517 let __receiver = <MapInspector as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
518 {
519 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
520 let __vi = *__vt.get(12usize).unwrap_or_else(|| {
521 panic!(
522 "unity: virtual slot {}
523 out of range (vtable len {}
524) on the runtime class behind {}
525 (method `{}
526`)",
527 12usize,
528 __vt.len(),
529 <MapInspector as ::unity::ClassIdentity>::NAME,
530 "get_X",
531 )
532 });
533 let __inner: extern "C" fn(MapInspector, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__vi.method_ptr);
534 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
535 __inner(__receiver, __mi)
536 }
537 }
538 }
539 #[doc = "`get_Z()` overload"]
540 fn get_z(self) -> i32 {
541 unsafe {
542 let __receiver = <MapInspector as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
543 {
544 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
545 let __vi = *__vt.get(13usize).unwrap_or_else(|| {
546 panic!(
547 "unity: virtual slot {}
548 out of range (vtable len {}
549) on the runtime class behind {}
550 (method `{}
551`)",
552 13usize,
553 __vt.len(),
554 <MapInspector as ::unity::ClassIdentity>::NAME,
555 "get_Z",
556 )
557 });
558 let __inner: extern "C" fn(MapInspector, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__vi.method_ptr);
559 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
560 __inner(__receiver, __mi)
561 }
562 }
563 }
564 #[doc = "`get_X1()` overload"]
565 fn get_x1(self) -> i32 {
566 unsafe {
567 let __receiver = <MapInspector as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
568 {
569 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
570 let __vi = *__vt.get(14usize).unwrap_or_else(|| {
571 panic!(
572 "unity: virtual slot {}
573 out of range (vtable len {}
574) on the runtime class behind {}
575 (method `{}
576`)",
577 14usize,
578 __vt.len(),
579 <MapInspector as ::unity::ClassIdentity>::NAME,
580 "get_X1",
581 )
582 });
583 let __inner: extern "C" fn(MapInspector, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__vi.method_ptr);
584 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
585 __inner(__receiver, __mi)
586 }
587 }
588 }
589 #[doc = "`get_Z1()` overload"]
590 fn get_z1(self) -> i32 {
591 unsafe {
592 let __receiver = <MapInspector as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
593 {
594 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
595 let __vi = *__vt.get(15usize).unwrap_or_else(|| {
596 panic!(
597 "unity: virtual slot {}
598 out of range (vtable len {}
599) on the runtime class behind {}
600 (method `{}
601`)",
602 15usize,
603 __vt.len(),
604 <MapInspector as ::unity::ClassIdentity>::NAME,
605 "get_Z1",
606 )
607 });
608 let __inner: extern "C" fn(MapInspector, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__vi.method_ptr);
609 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
610 __inner(__receiver, __mi)
611 }
612 }
613 }
614 #[doc = "`get_X2()` overload"]
615 fn get_x2(self) -> i32 {
616 unsafe {
617 let __receiver = <MapInspector as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
618 {
619 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
620 let __vi = *__vt.get(16usize).unwrap_or_else(|| {
621 panic!(
622 "unity: virtual slot {}
623 out of range (vtable len {}
624) on the runtime class behind {}
625 (method `{}
626`)",
627 16usize,
628 __vt.len(),
629 <MapInspector as ::unity::ClassIdentity>::NAME,
630 "get_X2",
631 )
632 });
633 let __inner: extern "C" fn(MapInspector, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__vi.method_ptr);
634 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
635 __inner(__receiver, __mi)
636 }
637 }
638 }
639 #[doc = "`get_Z2()` overload"]
640 fn get_z2(self) -> i32 {
641 unsafe {
642 let __receiver = <MapInspector as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
643 {
644 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
645 let __vi = *__vt.get(17usize).unwrap_or_else(|| {
646 panic!(
647 "unity: virtual slot {}
648 out of range (vtable len {}
649) on the runtime class behind {}
650 (method `{}
651`)",
652 17usize,
653 __vt.len(),
654 <MapInspector as ::unity::ClassIdentity>::NAME,
655 "get_Z2",
656 )
657 });
658 let __inner: extern "C" fn(MapInspector, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__vi.method_ptr);
659 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
660 __inner(__receiver, __mi)
661 }
662 }
663 }
664 #[doc = "`get_W()` overload"]
665 fn get_w(self) -> i32 {
666 unsafe {
667 let __receiver = <MapInspector as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
668 {
669 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
670 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
671 panic!(
672 "unity: virtual slot {}
673 out of range (vtable len {}
674) on the runtime class behind {}
675 (method `{}
676`)",
677 18usize,
678 __vt.len(),
679 <MapInspector as ::unity::ClassIdentity>::NAME,
680 "get_W",
681 )
682 });
683 let __inner: extern "C" fn(MapInspector, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__vi.method_ptr);
684 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
685 __inner(__receiver, __mi)
686 }
687 }
688 }
689 #[doc = "`get_H()` overload"]
690 fn get_h(self) -> i32 {
691 unsafe {
692 let __receiver = <MapInspector as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
693 {
694 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
695 let __vi = *__vt.get(19usize).unwrap_or_else(|| {
696 panic!(
697 "unity: virtual slot {}
698 out of range (vtable len {}
699) on the runtime class behind {}
700 (method `{}
701`)",
702 19usize,
703 __vt.len(),
704 <MapInspector as ::unity::ClassIdentity>::NAME,
705 "get_H",
706 )
707 });
708 let __inner: extern "C" fn(MapInspector, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__vi.method_ptr);
709 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
710 __inner(__receiver, __mi)
711 }
712 }
713 }
714 #[doc = "`get_Hp()` overload"]
715 fn get_hp(self) -> i32 {
716 unsafe {
717 let __receiver = <MapInspector as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
718 {
719 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
720 let __vi = *__vt.get(20usize).unwrap_or_else(|| {
721 panic!(
722 "unity: virtual slot {}
723 out of range (vtable len {}
724) on the runtime class behind {}
725 (method `{}
726`)",
727 20usize,
728 __vt.len(),
729 <MapInspector as ::unity::ClassIdentity>::NAME,
730 "get_Hp",
731 )
732 });
733 let __inner: extern "C" fn(MapInspector, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__vi.method_ptr);
734 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
735 __inner(__receiver, __mi)
736 }
737 }
738 }
739 #[doc = "`set_Hp(i32)` overload"]
740 fn set_hp(self, value: impl ::core::convert::Into<i32>) -> () {
741 unsafe {
742 let __receiver = <MapInspector as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
743 {
744 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
745 let __vi = *__vt.get(21usize).unwrap_or_else(|| {
746 panic!(
747 "unity: virtual slot {}
748 out of range (vtable len {}
749) on the runtime class behind {}
750 (method `{}
751`)",
752 21usize,
753 __vt.len(),
754 <MapInspector as ::unity::ClassIdentity>::NAME,
755 "set_Hp",
756 )
757 });
758 let __inner: extern "C" fn(MapInspector, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
759 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
760 __inner(__receiver, ::core::convert::Into::into(value), __mi)
761 }
762 }
763 }
764 #[doc = "`get_MaxHp()` overload"]
765 fn get_max_hp(self) -> i32 {
766 unsafe {
767 let __receiver = <MapInspector as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
768 {
769 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
770 let __vi = *__vt.get(22usize).unwrap_or_else(|| {
771 panic!(
772 "unity: virtual slot {}
773 out of range (vtable len {}
774) on the runtime class behind {}
775 (method `{}
776`)",
777 22usize,
778 __vt.len(),
779 <MapInspector as ::unity::ClassIdentity>::NAME,
780 "get_MaxHp",
781 )
782 });
783 let __inner: extern "C" fn(MapInspector, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__vi.method_ptr);
784 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
785 __inner(__receiver, __mi)
786 }
787 }
788 }
789 #[doc = "`set_MaxHp(i32)` overload"]
790 fn set_max_hp(self, value: impl ::core::convert::Into<i32>) -> () {
791 unsafe {
792 let __receiver = <MapInspector as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
793 {
794 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
795 let __vi = *__vt.get(23usize).unwrap_or_else(|| {
796 panic!(
797 "unity: virtual slot {}
798 out of range (vtable len {}
799) on the runtime class behind {}
800 (method `{}
801`)",
802 23usize,
803 __vt.len(),
804 <MapInspector as ::unity::ClassIdentity>::NAME,
805 "set_MaxHp",
806 )
807 });
808 let __inner: extern "C" fn(MapInspector, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
809 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
810 __inner(__receiver, ::core::convert::Into::into(value), __mi)
811 }
812 }
813 }
814 #[doc = "`GetCompleted()` overload"]
815 fn get_completed(self) -> i32 {
816 unsafe {
817 let __receiver = <MapInspector as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
818 {
819 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
820 let __vi = *__vt.get(24usize).unwrap_or_else(|| {
821 panic!(
822 "unity: virtual slot {}
823 out of range (vtable len {}
824) on the runtime class behind {}
825 (method `{}
826`)",
827 24usize,
828 __vt.len(),
829 <MapInspector as ::unity::ClassIdentity>::NAME,
830 "GetCompleted",
831 )
832 });
833 let __inner: extern "C" fn(MapInspector, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__vi.method_ptr);
834 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
835 __inner(__receiver, __mi)
836 }
837 }
838 }
839 #[doc = "`CanBreakable()` overload"]
840 fn can_breakable(self) -> bool {
841 unsafe {
842 let __receiver = <MapInspector as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
843 {
844 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
845 let __vi = *__vt.get(25usize).unwrap_or_else(|| {
846 panic!(
847 "unity: virtual slot {}
848 out of range (vtable len {}
849) on the runtime class behind {}
850 (method `{}
851`)",
852 25usize,
853 __vt.len(),
854 <MapInspector as ::unity::ClassIdentity>::NAME,
855 "CanBreakable",
856 )
857 });
858 let __inner: extern "C" fn(MapInspector, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
859 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
860 __inner(__receiver, __mi)
861 }
862 }
863 }
864 #[doc = "`CanBreakable(crate::app::unit::Unit)` overload"]
865 fn can_breakable_2(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> bool {
866 unsafe {
867 let __receiver = <MapInspector as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
868 {
869 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
870 let __vi = *__vt.get(26usize).unwrap_or_else(|| {
871 panic!(
872 "unity: virtual slot {}
873 out of range (vtable len {}
874) on the runtime class behind {}
875 (method `{}
876`)",
877 26usize,
878 __vt.len(),
879 <MapInspector as ::unity::ClassIdentity>::NAME,
880 "CanBreakable",
881 )
882 });
883 let __inner: extern "C" fn(MapInspector, crate::app::unit::Unit, ::unity::OptionalMethod) -> bool =
884 ::core::mem::transmute(__vi.method_ptr);
885 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
886 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
887 }
888 }
889 }
890 #[doc = "`CanBreakable(crate::app::force::Force_Type)` overload"]
891 fn can_breakable_3(self, force: impl ::core::convert::Into<crate::app::force::Force_Type>) -> bool {
892 unsafe {
893 let __receiver = <MapInspector as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
894 {
895 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
896 let __vi = *__vt.get(27usize).unwrap_or_else(|| {
897 panic!(
898 "unity: virtual slot {}
899 out of range (vtable len {}
900) on the runtime class behind {}
901 (method `{}
902`)",
903 27usize,
904 __vt.len(),
905 <MapInspector as ::unity::ClassIdentity>::NAME,
906 "CanBreakable",
907 )
908 });
909 let __inner: extern "C" fn(MapInspector, crate::app::force::Force_Type, ::unity::OptionalMethod) -> bool =
910 ::core::mem::transmute(__vi.method_ptr);
911 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
912 __inner(__receiver, ::core::convert::Into::into(force), __mi)
913 }
914 }
915 }
916 #[doc = "`CanUseCannon()` overload"]
917 fn can_use_cannon(self) -> bool {
918 unsafe {
919 let __receiver = <MapInspector as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
920 {
921 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
922 let __vi = *__vt.get(28usize).unwrap_or_else(|| {
923 panic!(
924 "unity: virtual slot {}
925 out of range (vtable len {}
926) on the runtime class behind {}
927 (method `{}
928`)",
929 28usize,
930 __vt.len(),
931 <MapInspector as ::unity::ClassIdentity>::NAME,
932 "CanUseCannon",
933 )
934 });
935 let __inner: extern "C" fn(MapInspector, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
936 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
937 __inner(__receiver, __mi)
938 }
939 }
940 }
941 #[doc = "`CanShowBreakIcon()` overload"]
942 fn can_show_break_icon(self) -> bool {
943 unsafe {
944 let __receiver = <MapInspector as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
945 {
946 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
947 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
948 panic!(
949 "unity: virtual slot {}
950 out of range (vtable len {}
951) on the runtime class behind {}
952 (method `{}
953`)",
954 29usize,
955 __vt.len(),
956 <MapInspector as ::unity::ClassIdentity>::NAME,
957 "CanShowBreakIcon",
958 )
959 });
960 let __inner: extern "C" fn(MapInspector, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
961 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
962 __inner(__receiver, __mi)
963 }
964 }
965 }
966 #[doc = "`PreCall(crate::app::procinst::ProcInst)` overload"]
967 fn pre_call(self, super_: impl ::core::convert::Into<crate::app::procinst::ProcInst>) -> () {
968 unsafe {
969 let __receiver = <MapInspector as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
970 {
971 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
972 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
973 panic!(
974 "unity: virtual slot {}
975 out of range (vtable len {}
976) on the runtime class behind {}
977 (method `{}
978`)",
979 30usize,
980 __vt.len(),
981 <MapInspector as ::unity::ClassIdentity>::NAME,
982 "PreCall",
983 )
984 });
985 let __inner: extern "C" fn(MapInspector, crate::app::procinst::ProcInst, ::unity::OptionalMethod) -> () =
986 ::core::mem::transmute(__vi.method_ptr);
987 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
988 __inner(__receiver, ::core::convert::Into::into(super_), __mi)
989 }
990 }
991 }
992 #[doc = "`PostCall(crate::app::procinst::ProcInst)` overload"]
993 fn post_call(self, super_: impl ::core::convert::Into<crate::app::procinst::ProcInst>) -> () {
994 unsafe {
995 let __receiver = <MapInspector as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
996 {
997 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
998 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
999 panic!(
1000 "unity: virtual slot {}
1001 out of range (vtable len {}
1002) on the runtime class behind {}
1003 (method `{}
1004`)",
1005 31usize,
1006 __vt.len(),
1007 <MapInspector as ::unity::ClassIdentity>::NAME,
1008 "PostCall",
1009 )
1010 });
1011 let __inner: extern "C" fn(MapInspector, crate::app::procinst::ProcInst, ::unity::OptionalMethod) -> () =
1012 ::core::mem::transmute(__vi.method_ptr);
1013 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1014 __inner(__receiver, ::core::convert::Into::into(super_), __mi)
1015 }
1016 }
1017 }
1018 #[doc = "`Resume(crate::app::procinst::ProcInst)` overload"]
1019 fn resume(self, super_: impl ::core::convert::Into<crate::app::procinst::ProcInst>) -> crate::app::procinst::ProcInst {
1020 unsafe {
1021 let __receiver = <MapInspector as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1022 {
1023 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1024 let __vi = *__vt.get(32usize).unwrap_or_else(|| {
1025 panic!(
1026 "unity: virtual slot {}
1027 out of range (vtable len {}
1028) on the runtime class behind {}
1029 (method `{}
1030`)",
1031 32usize,
1032 __vt.len(),
1033 <MapInspector as ::unity::ClassIdentity>::NAME,
1034 "Resume",
1035 )
1036 });
1037 let __inner: extern "C" fn(MapInspector, crate::app::procinst::ProcInst, ::unity::OptionalMethod) -> crate::app::procinst::ProcInst =
1038 ::core::mem::transmute(__vi.method_ptr);
1039 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1040 __inner(__receiver, ::core::convert::Into::into(super_), __mi)
1041 }
1042 }
1043 }
1044 #[doc = "`SetFunction(crate::moon_sharp::interpreter::dynvalue::DynValue)` overload"]
1045 fn set_function(
1046 self,
1047 value: impl ::core::convert::Into<crate::moon_sharp::interpreter::dynvalue::DynValue>,
1048 ) -> crate::app::mapinspector::MapInspector {
1049 unsafe {
1050 let __receiver = <MapInspector as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1051 ::unity::il2cpp_call!((::unity::module_base()+0x1de5e00usize)as*mut u8,crate::app::mapinspector::MapInspector;
1052(MapInspector)__receiver,(crate::moon_sharp::interpreter::dynvalue::DynValue)::core::convert::Into::into(value))
1053 }
1054 }
1055 #[doc = "`SetArgs(::unity::Array<crate::moon_sharp::interpreter::dynvalue::DynValue>)` overload"]
1056 fn set_args(
1057 self,
1058 args: impl ::core::convert::Into<::unity::Array<crate::moon_sharp::interpreter::dynvalue::DynValue>>,
1059 ) -> crate::app::mapinspector::MapInspector {
1060 unsafe {
1061 let __receiver = <MapInspector as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1062 ::unity::il2cpp_call!((::unity::module_base()+0x1de5e40usize)as*mut u8,crate::app::mapinspector::MapInspector;
1063(MapInspector)__receiver,(::unity::Array<crate::moon_sharp::interpreter::dynvalue::DynValue>)::core::convert::Into::into(args))
1064 }
1065 }
1066 #[doc = "`SetCondition(crate::moon_sharp::interpreter::dynvalue::DynValue)` overload"]
1067 fn set_condition(
1068 self,
1069 condition: impl ::core::convert::Into<crate::moon_sharp::interpreter::dynvalue::DynValue>,
1070 ) -> crate::app::mapinspector::MapInspector {
1071 unsafe {
1072 let __receiver = <MapInspector as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1073 ::unity::il2cpp_call!((::unity::module_base()+0x1de5e70usize)as*mut u8,crate::app::mapinspector::MapInspector;
1074(MapInspector)__receiver,(crate::moon_sharp::interpreter::dynvalue::DynValue)::core::convert::Into::into(condition))
1075 }
1076 }
1077 #[doc = "`ResetCondition()` overload"]
1078 fn reset_condition(self) -> crate::app::mapinspector::MapInspector {
1079 unsafe {
1080 let __receiver = <MapInspector as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1081 ::unity::il2cpp_call!((::unity::module_base()+0x1de5f50usize)as*mut u8,crate::app::mapinspector::MapInspector;
1082(MapInspector)__receiver)
1083 }
1084 }
1085 #[doc = "`GetGlobalKey()` overload"]
1086 fn get_global_key(self) -> ::unity::Il2CppString {
1087 unsafe {
1088 let __receiver = <MapInspector as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1089 {
1090 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1091 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
1092 panic!(
1093 "unity: virtual slot {}
1094 out of range (vtable len {}
1095) on the runtime class behind {}
1096 (method `{}
1097`)",
1098 33usize,
1099 __vt.len(),
1100 <MapInspector as ::unity::ClassIdentity>::NAME,
1101 "GetGlobalKey",
1102 )
1103 });
1104 let __inner: extern "C" fn(MapInspector, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__vi.method_ptr);
1105 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1106 __inner(__receiver, __mi)
1107 }
1108 }
1109 }
1110 #[doc = "`SetGlobalKey()` overload"]
1111 fn set_global_key(self) -> () {
1112 unsafe {
1113 let __receiver = <MapInspector as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1114 ::unity::il2cpp_call!((::unity::module_base()+0x1de6150usize)as*mut u8,();
1115(MapInspector)__receiver)
1116 }
1117 }
1118 #[doc = "`Serialize(crate::app::stream_2::Stream_2)` overload"]
1119 fn serialize(self, stream: impl ::core::convert::Into<crate::app::stream_2::Stream_2>) -> () {
1120 unsafe {
1121 let __receiver = <MapInspector as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1122 {
1123 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1124 let __vi = *__vt.get(34usize).unwrap_or_else(|| {
1125 panic!(
1126 "unity: virtual slot {}
1127 out of range (vtable len {}
1128) on the runtime class behind {}
1129 (method `{}
1130`)",
1131 34usize,
1132 __vt.len(),
1133 <MapInspector as ::unity::ClassIdentity>::NAME,
1134 "Serialize",
1135 )
1136 });
1137 let __inner: extern "C" fn(MapInspector, crate::app::stream_2::Stream_2, ::unity::OptionalMethod) -> () =
1138 ::core::mem::transmute(__vi.method_ptr);
1139 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1140 __inner(__receiver, ::core::convert::Into::into(stream), __mi)
1141 }
1142 }
1143 }
1144 #[doc = "`Deserialize(crate::app::stream_2::Stream_2)` overload"]
1145 fn deserialize(self, stream: impl ::core::convert::Into<crate::app::stream_2::Stream_2>) -> () {
1146 unsafe {
1147 let __receiver = <MapInspector as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1148 {
1149 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1150 let __vi = *__vt.get(35usize).unwrap_or_else(|| {
1151 panic!(
1152 "unity: virtual slot {}
1153 out of range (vtable len {}
1154) on the runtime class behind {}
1155 (method `{}
1156`)",
1157 35usize,
1158 __vt.len(),
1159 <MapInspector as ::unity::ClassIdentity>::NAME,
1160 "Deserialize",
1161 )
1162 });
1163 let __inner: extern "C" fn(MapInspector, crate::app::stream_2::Stream_2, ::unity::OptionalMethod) -> () =
1164 ::core::mem::transmute(__vi.method_ptr);
1165 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1166 __inner(__receiver, ::core::convert::Into::into(stream), __mi)
1167 }
1168 }
1169 }
1170 #[doc = "`CanEnterAround()` overload"]
1171 fn can_enter_around(self) -> bool {
1172 unsafe {
1173 let __receiver = <MapInspector as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1174 ::unity::il2cpp_call!((::unity::module_base()+0x1de6530usize)as*mut u8,bool;
1175(MapInspector)__receiver)
1176 }
1177 }
1178}
1179
1180#[cfg(feature = "app-mapinspector")]
1181impl<__T: IMapInspector> IMapInspectorMethods for __T {}
1182
1183#[cfg(feature = "app-mapinspector")]
1184impl MapInspector {
1185 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1186 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1187 }
1188
1189 pub fn get_kind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1190 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1191 }
1192
1193 pub fn get_function_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1194 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1195 }
1196
1197 pub fn get_args_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1198 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
1199 }
1200
1201 pub fn get_condition_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1202 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
1203 }
1204
1205 pub fn is_condition_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1206 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
1207 }
1208
1209 pub fn is_inside_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1210 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
1211 }
1212
1213 pub fn completed_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1214 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
1215 }
1216
1217 pub fn is_value_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1218 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
1219 }
1220
1221 pub fn is_eanble_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1222 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
1223 }
1224
1225 pub fn is_eanble_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1226 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
1227 }
1228
1229 pub fn is_eanble_3_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1230 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
1231 }
1232
1233 pub fn is_eanble_4_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1234 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
1235 }
1236
1237 pub fn is_eanble_5_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1238 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
1239 }
1240
1241 pub fn is_terminated_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1242 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[14]
1243 }
1244
1245 pub fn get_color_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1246 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[15]
1247 }
1248
1249 pub fn get_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1250 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[16]
1251 }
1252
1253 pub fn get_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1254 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[17]
1255 }
1256
1257 pub fn get_x1_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1258 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[18]
1259 }
1260
1261 pub fn get_z1_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1262 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[19]
1263 }
1264
1265 pub fn get_x2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1266 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[20]
1267 }
1268
1269 pub fn get_z2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1270 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[21]
1271 }
1272
1273 pub fn get_w_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1274 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[22]
1275 }
1276
1277 pub fn get_h_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1278 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[23]
1279 }
1280
1281 pub fn get_hp_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1282 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[24]
1283 }
1284
1285 pub fn set_hp_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1286 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[25]
1287 }
1288
1289 pub fn get_max_hp_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1290 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[26]
1291 }
1292
1293 pub fn set_max_hp_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1294 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[27]
1295 }
1296
1297 pub fn get_completed_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1298 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[28]
1299 }
1300
1301 pub fn can_breakable_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1302 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[29]
1303 }
1304
1305 pub fn can_breakable_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1306 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[30]
1307 }
1308
1309 pub fn can_breakable_3_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1310 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[31]
1311 }
1312
1313 pub fn can_use_cannon_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1314 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[32]
1315 }
1316
1317 pub fn can_show_break_icon_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1318 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[33]
1319 }
1320
1321 pub fn pre_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1322 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[34]
1323 }
1324
1325 pub fn post_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1326 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[35]
1327 }
1328
1329 pub fn resume_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1330 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[36]
1331 }
1332
1333 pub fn set_function_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1334 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[37]
1335 }
1336
1337 pub fn set_args_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1338 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[38]
1339 }
1340
1341 pub fn set_condition_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1342 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[39]
1343 }
1344
1345 pub fn reset_condition_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1346 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[40]
1347 }
1348
1349 pub fn get_global_key_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1350 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[41]
1351 }
1352
1353 pub fn set_global_key_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1354 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[42]
1355 }
1356
1357 pub fn serialize_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1358 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[43]
1359 }
1360
1361 pub fn deserialize_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1362 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[44]
1363 }
1364
1365 pub fn op_implicit_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1366 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[45]
1367 }
1368
1369 pub fn can_enter_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1370 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[46]
1371 }
1372
1373 pub fn can_enter_around_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1374 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[47]
1375 }
1376}
1377
1378#[cfg(feature = "app-mapinspector")]
1379impl MapInspector {
1380 #[doc = "Direct (non-virtual) call to `MapInspector`'s own `Completed`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1381 pub unsafe fn completed(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
1382 let __mi = Self::completed_method_info();
1383 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1384 __inner(this.into(), ::core::option::Option::None)
1385 }
1386
1387 #[doc = "Direct (non-virtual) call to `MapInspector`'s own `IsEanble`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1388 pub unsafe fn is_eanble(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
1389 let __mi = Self::is_eanble_method_info();
1390 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
1391 __inner(this.into(), ::core::option::Option::None)
1392 }
1393
1394 #[doc = "Direct (non-virtual) call to `MapInspector`'s own `IsEanble`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1395 pub unsafe fn is_eanble_2(this: impl ::core::convert::Into<::unity::IlInstance>, arg: i32) -> bool {
1396 let __mi = Self::is_eanble_2_method_info();
1397 let __inner: extern "C" fn(::unity::IlInstance, i32, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
1398 __inner(this.into(), arg, ::core::option::Option::None)
1399 }
1400
1401 #[doc = "Direct (non-virtual) call to `MapInspector`'s own `IsEanble`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1402 pub unsafe fn is_eanble_3(this: impl ::core::convert::Into<::unity::IlInstance>, arg1: i32, arg2: i32) -> bool {
1403 let __mi = Self::is_eanble_3_method_info();
1404 let __inner: extern "C" fn(::unity::IlInstance, i32, i32, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
1405 __inner(this.into(), arg1, arg2, ::core::option::Option::None)
1406 }
1407
1408 #[doc = "Direct (non-virtual) call to `MapInspector`'s own `IsEanble`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1409 pub unsafe fn is_eanble_4(this: impl ::core::convert::Into<::unity::IlInstance>, arg1: i32, arg2: i32, arg3: i32) -> bool {
1410 let __mi = Self::is_eanble_4_method_info();
1411 let __inner: extern "C" fn(::unity::IlInstance, i32, i32, i32, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
1412 __inner(this.into(), arg1, arg2, arg3, ::core::option::Option::None)
1413 }
1414
1415 #[doc = "Direct (non-virtual) call to `MapInspector`'s own `IsEanble`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1416 pub unsafe fn is_eanble_5(this: impl ::core::convert::Into<::unity::IlInstance>, arg1: i32, arg2: i32, arg3: i32, arg4: i32) -> bool {
1417 let __mi = Self::is_eanble_5_method_info();
1418 let __inner: extern "C" fn(::unity::IlInstance, i32, i32, i32, i32, ::unity::OptionalMethod) -> bool =
1419 ::core::mem::transmute(__mi.method_ptr);
1420 __inner(this.into(), arg1, arg2, arg3, arg4, ::core::option::Option::None)
1421 }
1422
1423 #[doc = "Direct (non-virtual) call to `MapInspector`'s own `IsTerminated`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1424 pub unsafe fn is_terminated(this: impl ::core::convert::Into<::unity::IlInstance>, arg1: i32, arg2: i32, arg3: i32, arg4: i32) -> bool {
1425 let __mi = Self::is_terminated_method_info();
1426 let __inner: extern "C" fn(::unity::IlInstance, i32, i32, i32, i32, ::unity::OptionalMethod) -> bool =
1427 ::core::mem::transmute(__mi.method_ptr);
1428 __inner(this.into(), arg1, arg2, arg3, arg4, ::core::option::Option::None)
1429 }
1430
1431 #[doc = "Direct (non-virtual) call to `MapInspector`'s own `get_Color`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1432 pub unsafe fn get_color(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::unity_engine::color::Color {
1433 let __mi = Self::get_color_method_info();
1434 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::unity_engine::color::Color =
1435 ::core::mem::transmute(__mi.method_ptr);
1436 __inner(this.into(), ::core::option::Option::None)
1437 }
1438
1439 #[doc = "Direct (non-virtual) call to `MapInspector`'s own `get_X`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1440 pub unsafe fn get_x(this: impl ::core::convert::Into<::unity::IlInstance>) -> i32 {
1441 let __mi = Self::get_x_method_info();
1442 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__mi.method_ptr);
1443 __inner(this.into(), ::core::option::Option::None)
1444 }
1445
1446 #[doc = "Direct (non-virtual) call to `MapInspector`'s own `get_Z`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1447 pub unsafe fn get_z(this: impl ::core::convert::Into<::unity::IlInstance>) -> i32 {
1448 let __mi = Self::get_z_method_info();
1449 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__mi.method_ptr);
1450 __inner(this.into(), ::core::option::Option::None)
1451 }
1452
1453 #[doc = "Direct (non-virtual) call to `MapInspector`'s own `get_X1`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1454 pub unsafe fn get_x1(this: impl ::core::convert::Into<::unity::IlInstance>) -> i32 {
1455 let __mi = Self::get_x1_method_info();
1456 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__mi.method_ptr);
1457 __inner(this.into(), ::core::option::Option::None)
1458 }
1459
1460 #[doc = "Direct (non-virtual) call to `MapInspector`'s own `get_Z1`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1461 pub unsafe fn get_z1(this: impl ::core::convert::Into<::unity::IlInstance>) -> i32 {
1462 let __mi = Self::get_z1_method_info();
1463 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__mi.method_ptr);
1464 __inner(this.into(), ::core::option::Option::None)
1465 }
1466
1467 #[doc = "Direct (non-virtual) call to `MapInspector`'s own `get_X2`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1468 pub unsafe fn get_x2(this: impl ::core::convert::Into<::unity::IlInstance>) -> i32 {
1469 let __mi = Self::get_x2_method_info();
1470 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__mi.method_ptr);
1471 __inner(this.into(), ::core::option::Option::None)
1472 }
1473
1474 #[doc = "Direct (non-virtual) call to `MapInspector`'s own `get_Z2`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1475 pub unsafe fn get_z2(this: impl ::core::convert::Into<::unity::IlInstance>) -> i32 {
1476 let __mi = Self::get_z2_method_info();
1477 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__mi.method_ptr);
1478 __inner(this.into(), ::core::option::Option::None)
1479 }
1480
1481 #[doc = "Direct (non-virtual) call to `MapInspector`'s own `get_W`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1482 pub unsafe fn get_w(this: impl ::core::convert::Into<::unity::IlInstance>) -> i32 {
1483 let __mi = Self::get_w_method_info();
1484 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__mi.method_ptr);
1485 __inner(this.into(), ::core::option::Option::None)
1486 }
1487
1488 #[doc = "Direct (non-virtual) call to `MapInspector`'s own `get_H`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1489 pub unsafe fn get_h(this: impl ::core::convert::Into<::unity::IlInstance>) -> i32 {
1490 let __mi = Self::get_h_method_info();
1491 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__mi.method_ptr);
1492 __inner(this.into(), ::core::option::Option::None)
1493 }
1494
1495 #[doc = "Direct (non-virtual) call to `MapInspector`'s own `get_Hp`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1496 pub unsafe fn get_hp(this: impl ::core::convert::Into<::unity::IlInstance>) -> i32 {
1497 let __mi = Self::get_hp_method_info();
1498 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__mi.method_ptr);
1499 __inner(this.into(), ::core::option::Option::None)
1500 }
1501
1502 #[doc = "Direct (non-virtual) call to `MapInspector`'s own `set_Hp`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1503 pub unsafe fn set_hp(this: impl ::core::convert::Into<::unity::IlInstance>, value: i32) -> () {
1504 let __mi = Self::set_hp_method_info();
1505 let __inner: extern "C" fn(::unity::IlInstance, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1506 __inner(this.into(), value, ::core::option::Option::None)
1507 }
1508
1509 #[doc = "Direct (non-virtual) call to `MapInspector`'s own `get_MaxHp`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1510 pub unsafe fn get_max_hp(this: impl ::core::convert::Into<::unity::IlInstance>) -> i32 {
1511 let __mi = Self::get_max_hp_method_info();
1512 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__mi.method_ptr);
1513 __inner(this.into(), ::core::option::Option::None)
1514 }
1515
1516 #[doc = "Direct (non-virtual) call to `MapInspector`'s own `set_MaxHp`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1517 pub unsafe fn set_max_hp(this: impl ::core::convert::Into<::unity::IlInstance>, value: i32) -> () {
1518 let __mi = Self::set_max_hp_method_info();
1519 let __inner: extern "C" fn(::unity::IlInstance, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1520 __inner(this.into(), value, ::core::option::Option::None)
1521 }
1522
1523 #[doc = "Direct (non-virtual) call to `MapInspector`'s own `GetCompleted`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1524 pub unsafe fn get_completed(this: impl ::core::convert::Into<::unity::IlInstance>) -> i32 {
1525 let __mi = Self::get_completed_method_info();
1526 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__mi.method_ptr);
1527 __inner(this.into(), ::core::option::Option::None)
1528 }
1529
1530 #[doc = "Direct (non-virtual) call to `MapInspector`'s own `CanBreakable`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1531 pub unsafe fn can_breakable(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
1532 let __mi = Self::can_breakable_method_info();
1533 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
1534 __inner(this.into(), ::core::option::Option::None)
1535 }
1536
1537 #[doc = "Direct (non-virtual) call to `MapInspector`'s own `CanBreakable`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1538 pub unsafe fn can_breakable_2(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> bool {
1539 let __mi = Self::can_breakable_2_method_info();
1540 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> bool =
1541 ::core::mem::transmute(__mi.method_ptr);
1542 __inner(this.into(), unit, ::core::option::Option::None)
1543 }
1544
1545 #[doc = "Direct (non-virtual) call to `MapInspector`'s own `CanBreakable`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1546 pub unsafe fn can_breakable_3(this: impl ::core::convert::Into<::unity::IlInstance>, force: crate::app::force::Force_Type) -> bool {
1547 let __mi = Self::can_breakable_3_method_info();
1548 let __inner: extern "C" fn(::unity::IlInstance, crate::app::force::Force_Type, ::unity::OptionalMethod) -> bool =
1549 ::core::mem::transmute(__mi.method_ptr);
1550 __inner(this.into(), force, ::core::option::Option::None)
1551 }
1552
1553 #[doc = "Direct (non-virtual) call to `MapInspector`'s own `CanUseCannon`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1554 pub unsafe fn can_use_cannon(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
1555 let __mi = Self::can_use_cannon_method_info();
1556 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
1557 __inner(this.into(), ::core::option::Option::None)
1558 }
1559
1560 #[doc = "Direct (non-virtual) call to `MapInspector`'s own `CanShowBreakIcon`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1561 pub unsafe fn can_show_break_icon(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
1562 let __mi = Self::can_show_break_icon_method_info();
1563 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
1564 __inner(this.into(), ::core::option::Option::None)
1565 }
1566
1567 #[doc = "Direct (non-virtual) call to `MapInspector`'s own `PreCall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1568 pub unsafe fn pre_call(this: impl ::core::convert::Into<::unity::IlInstance>, super_: crate::app::procinst::ProcInst) -> () {
1569 let __mi = Self::pre_call_method_info();
1570 let __inner: extern "C" fn(::unity::IlInstance, crate::app::procinst::ProcInst, ::unity::OptionalMethod) -> () =
1571 ::core::mem::transmute(__mi.method_ptr);
1572 __inner(this.into(), super_, ::core::option::Option::None)
1573 }
1574
1575 #[doc = "Direct (non-virtual) call to `MapInspector`'s own `PostCall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1576 pub unsafe fn post_call(this: impl ::core::convert::Into<::unity::IlInstance>, super_: crate::app::procinst::ProcInst) -> () {
1577 let __mi = Self::post_call_method_info();
1578 let __inner: extern "C" fn(::unity::IlInstance, crate::app::procinst::ProcInst, ::unity::OptionalMethod) -> () =
1579 ::core::mem::transmute(__mi.method_ptr);
1580 __inner(this.into(), super_, ::core::option::Option::None)
1581 }
1582
1583 #[doc = "Direct (non-virtual) call to `MapInspector`'s own `Resume`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1584 pub unsafe fn resume(
1585 this: impl ::core::convert::Into<::unity::IlInstance>,
1586 super_: crate::app::procinst::ProcInst,
1587 ) -> crate::app::procinst::ProcInst {
1588 let __mi = Self::resume_method_info();
1589 let __inner: extern "C" fn(::unity::IlInstance, crate::app::procinst::ProcInst, ::unity::OptionalMethod) -> crate::app::procinst::ProcInst =
1590 ::core::mem::transmute(__mi.method_ptr);
1591 __inner(this.into(), super_, ::core::option::Option::None)
1592 }
1593
1594 #[doc = "Direct (non-virtual) call to `MapInspector`'s own `GetGlobalKey`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1595 pub unsafe fn get_global_key(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1596 let __mi = Self::get_global_key_method_info();
1597 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1598 __inner(this.into(), ::core::option::Option::None)
1599 }
1600
1601 #[doc = "Direct (non-virtual) call to `MapInspector`'s own `Serialize`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1602 pub unsafe fn serialize(this: impl ::core::convert::Into<::unity::IlInstance>, stream: crate::app::stream_2::Stream_2) -> () {
1603 let __mi = Self::serialize_method_info();
1604 let __inner: extern "C" fn(::unity::IlInstance, crate::app::stream_2::Stream_2, ::unity::OptionalMethod) -> () =
1605 ::core::mem::transmute(__mi.method_ptr);
1606 __inner(this.into(), stream, ::core::option::Option::None)
1607 }
1608
1609 #[doc = "Direct (non-virtual) call to `MapInspector`'s own `Deserialize`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1610 pub unsafe fn deserialize(this: impl ::core::convert::Into<::unity::IlInstance>, stream: crate::app::stream_2::Stream_2) -> () {
1611 let __mi = Self::deserialize_method_info();
1612 let __inner: extern "C" fn(::unity::IlInstance, crate::app::stream_2::Stream_2, ::unity::OptionalMethod) -> () =
1613 ::core::mem::transmute(__mi.method_ptr);
1614 __inner(this.into(), stream, ::core::option::Option::None)
1615 }
1616}
1617
1618#[cfg(feature = "app-mapinspector")]
1619impl MapInspector {
1620 #[doc = "`.ctor(crate::app::mapinspector::MapInspector_Kind)` — overload selector"]
1621 pub fn new(kind: crate::app::mapinspector::MapInspector_Kind) -> Self {
1622 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1623 panic!(
1624 "{}
1625::{}
1626 failed to instantiate",
1627 ::core::stringify!(MapInspector),
1628 ::core::stringify!(new),
1629 )
1630 });
1631 <Self as IMapInspectorMethods>::ctor(this, kind);
1632 this
1633 }
1634}
1635
1636#[cfg(feature = "app-mapinspector")]
1637#[doc(hidden)]
1638pub mod prelude {
1639 pub use super::{IMapInspector, IMapInspectorMethods, MapInspector, MapInspector_Kind};
1640 #[cfg(feature = "app-scriptutil")]
1641 pub use crate::app::scriptutil::IScriptUtilMethods;
1642 #[cfg(feature = "system-object")]
1643 pub use crate::system::object::IObjectMethods;
1644 #[cfg(feature = "system-enum")]
1645 pub use crate::system::r#enum::IEnumMethods;
1646 #[cfg(feature = "system-valuetype")]
1647 pub use crate::system::valuetype::IValueTypeMethods;
1648 pub use crate::{
1649 app::scriptutil::IScriptUtil,
1650 system::{object::IObject, r#enum::IEnum, valuetype::IValueType},
1651 };
1652}