1#[cfg(feature = "app-mapunitcommandmenu-types")]
4mod __types {
5 #[allow(unused_imports)] use ::unity::prelude::*;
6
7 use super::*;
8 use crate::{
9 app::{
10 basicmenu::{BasicMenu, IBasicMenu},
11 basicmenuitem::{BasicMenuItem, IBasicMenuItem},
12 mapbasicmenu::{IMapBasicMenu, MapBasicMenu},
13 mapbasicmenuitem::{IMapBasicMenuItem, MapBasicMenuItem},
14 procinst::{IProcInst, ProcInst},
15 },
16 system::{
17 object::{IObject, Object},
18 r#enum::{Enum, IEnum},
19 valuetype::{IValueType, ValueType},
20 },
21 };
22
23 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/mapunitcommandmenu/MapUnitCommandMenu_TorchOnMenuItem.md"))]
24 #[::unity::class(namespace = "App", name = "MapUnitCommandMenu.TorchOnMenuItem")]
25 #[parent(crate::app::mapunitcommandmenu::MapUnitCommandMenu_BaseMenuItem)]
26 pub struct MapUnitCommandMenu_TorchOnMenuItem {}
27
28 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/mapunitcommandmenu/MapUnitCommandMenu_DestroyMenuItem.md"))]
29 #[::unity::class(namespace = "App", name = "MapUnitCommandMenu.DestroyMenuItem")]
30 #[parent(crate::app::mapunitcommandmenu::MapUnitCommandMenu_JumpToMenuItem)]
31 pub struct MapUnitCommandMenu_DestroyMenuItem {}
32
33 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/mapunitcommandmenu/MapUnitCommandMenu_ItemMenuItem.md"))]
34 #[::unity::class(namespace = "App", name = "MapUnitCommandMenu.ItemMenuItem")]
35 #[parent(crate::app::mapunitcommandmenu::MapUnitCommandMenu_JumpToMenuItem)]
36 pub struct MapUnitCommandMenu_ItemMenuItem {}
37
38 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/mapunitcommandmenu/MapUnitCommandMenu_CannonMenuItem.md"))]
39 #[::unity::class(namespace = "App", name = "MapUnitCommandMenu.CannonMenuItem")]
40 #[parent(crate::app::mapunitcommandmenu::MapUnitCommandMenu_JumpToMenuItem)]
41 pub struct MapUnitCommandMenu_CannonMenuItem {
42 #[offset(100)]
43 #[rename(name = "m_State")]
44 pub m_state: crate::app::mapunitcommandmenu::MapUnitCommandMenu_CannonMenuItem_States,
45 }
46
47 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/mapunitcommandmenu/MapUnitCommandMenu_NoCancelFixedMenuItem.md"))]
48 #[::unity::class(namespace = "App", name = "MapUnitCommandMenu.NoCancelFixedMenuItem")]
49 #[parent(crate::app::mapunitcommandmenu::MapUnitCommandMenu_FixedMenuItem)]
50 pub struct MapUnitCommandMenu_NoCancelFixedMenuItem {}
51
52 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/mapunitcommandmenu/MapUnitCommandMenu_EngageStartMenuItem.md"))]
53 #[::unity::class(namespace = "App", name = "MapUnitCommandMenu.EngageStartMenuItem")]
54 #[parent(crate::app::mapunitcommandmenu::MapUnitCommandMenu_EngageCommandMenuItem)]
55 pub struct MapUnitCommandMenu_EngageStartMenuItem {}
56
57 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/mapunitcommandmenu/MapUnitCommandMenu_VisitMenuItem.md"))]
58 #[::unity::class(namespace = "App", name = "MapUnitCommandMenu.VisitMenuItem")]
59 #[parent(crate::app::mapunitcommandmenu::MapUnitCommandMenu_BaseMenuItem)]
60 pub struct MapUnitCommandMenu_VisitMenuItem {}
61
62 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/mapunitcommandmenu/MapUnitCommandMenu_OverlapSkillMenuItem.md"))]
63 #[::unity::class(namespace = "App", name = "MapUnitCommandMenu.OverlapSkillMenuItem")]
64 #[parent(crate::app::mapbasicmenuitem::MapBasicMenuItem)]
65 pub struct MapUnitCommandMenu_OverlapSkillMenuItem {
66 #[offset(104)]
67 #[rename(name = "m_Skill")]
68 pub m_skill: crate::app::skilldata::SkillData,
69 }
70
71 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/mapunitcommandmenu/MapUnitCommandMenu_AttackMenuItem.md"))]
72 #[::unity::class(namespace = "App", name = "MapUnitCommandMenu.AttackMenuItem")]
73 #[parent(crate::app::mapunitcommandmenu::MapUnitCommandMenu_JumpToMenuItem)]
74 pub struct MapUnitCommandMenu_AttackMenuItem {}
75
76 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/mapunitcommandmenu/MapUnitCommandMenu_EngageLinkMenuItem.md"))]
77 #[::unity::class(namespace = "App", name = "MapUnitCommandMenu.EngageLinkMenuItem")]
78 #[parent(crate::app::mapunitcommandmenu::MapUnitCommandMenu_EngageCommandMenuItem)]
79 pub struct MapUnitCommandMenu_EngageLinkMenuItem {}
80
81 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/mapunitcommandmenu/MapUnitCommandMenu_BreakdownEnemyMenuItem.md"))]
82 #[::unity::class(namespace = "App", name = "MapUnitCommandMenu.BreakdownEnemyMenuItem")]
83 #[parent(crate::app::mapunitcommandmenu::MapUnitCommandMenu_BreakdownBaseMenuItem)]
84 pub struct MapUnitCommandMenu_BreakdownEnemyMenuItem {}
85
86 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/mapunitcommandmenu/MapUnitCommandMenu_EnchantItemMenuItem.md"))]
87 #[::unity::class(namespace = "App", name = "MapUnitCommandMenu.EnchantItemMenuItem")]
88 #[parent(crate::app::mapunitcommandmenu::MapUnitCommandMenu_EnchantMenuItem)]
89 pub struct MapUnitCommandMenu_EnchantItemMenuItem {}
90
91 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/mapunitcommandmenu/MapUnitCommandMenu_EngageActionBaseMenuItem.md"))]
92 #[::unity::class(namespace = "App", name = "MapUnitCommandMenu.EngageActionBaseMenuItem")]
93 #[parent(crate::app::mapunitcommandmenu::MapUnitCommandMenu_SkillAttackMenuItem)]
94 pub struct MapUnitCommandMenu_EngageActionBaseMenuItem {}
95
96 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/mapunitcommandmenu/MapUnitCommandMenu_TransporterMenuItem.md"))]
97 #[::unity::class(namespace = "App", name = "MapUnitCommandMenu.TransporterMenuItem")]
98 #[parent(crate::app::mapunitcommandmenu::MapUnitCommandMenu_BaseMenuItem)]
99 pub struct MapUnitCommandMenu_TransporterMenuItem {}
100
101 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/mapunitcommandmenu/MapUnitCommandMenu_SubMenuItem.md"))]
102 #[::unity::class(namespace = "App", name = "MapUnitCommandMenu.SubMenuItem")]
103 #[parent(crate::app::mapunitcommandmenu::MapUnitCommandMenu_JumpToMenuItem)]
104 pub struct MapUnitCommandMenu_SubMenuItem {
105 #[offset(104)]
106 #[rename(name = "m_CommandSkill")]
107 pub m_command_skill: crate::app::skilldata::SkillData,
108 }
109
110 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/mapunitcommandmenu/MapUnitCommandMenu_EngageRodMenuItem.md"))]
111 #[::unity::class(namespace = "App", name = "MapUnitCommandMenu.EngageRodMenuItem")]
112 #[parent(crate::app::mapunitcommandmenu::MapUnitCommandMenu_EngageActionBaseMenuItem)]
113 pub struct MapUnitCommandMenu_EngageRodMenuItem {}
114
115 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/mapunitcommandmenu/MapUnitCommandMenu_GodChangeMenuItem.md"))]
116 #[::unity::class(namespace = "App", name = "MapUnitCommandMenu.GodChangeMenuItem")]
117 #[parent(crate::app::mapunitcommandmenu::MapUnitCommandMenu_JumpToMenuItem)]
118 pub struct MapUnitCommandMenu_GodChangeMenuItem {}
119
120 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/mapunitcommandmenu/MapUnitCommandMenu_EscapeMenuItem.md"))]
121 #[::unity::class(namespace = "App", name = "MapUnitCommandMenu.EscapeMenuItem")]
122 #[parent(crate::app::mapunitcommandmenu::MapUnitCommandMenu_TargetSelectMenuItem)]
123 pub struct MapUnitCommandMenu_EscapeMenuItem {}
124
125 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/mapunitcommandmenu/MapUnitCommandMenu_DanceMenuItem.md"))]
126 #[::unity::class(namespace = "App", name = "MapUnitCommandMenu.DanceMenuItem")]
127 #[parent(crate::app::mapunitcommandmenu::MapUnitCommandMenu_TargetSelectMenuItem)]
128 pub struct MapUnitCommandMenu_DanceMenuItem {}
129
130 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/mapunitcommandmenu/MapUnitCommandMenu_CannonMenuItem_States.md"))]
131 #[repr(C)]
132 #[derive(::core::clone::Clone, ::core::marker::Copy, ::core::fmt::Debug, ::core::cmp::PartialEq, ::core::cmp::Eq)]
133 pub struct MapUnitCommandMenu_CannonMenuItem_States {
134 pub value: i32,
135 }
136 impl ::unity::ClassIdentity for MapUnitCommandMenu_CannonMenuItem_States {
137 const NAME: &'static str = "MapUnitCommandMenu.CannonMenuItem.States";
138 const NAMESPACE: &'static str = "App";
139
140 fn class() -> ::unity::Class {
141 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
142 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
143 }
144 }
145 impl ::unity::IlType for MapUnitCommandMenu_CannonMenuItem_States {
146 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
147 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
148 }
149 }
150 impl MapUnitCommandMenu_CannonMenuItem_States {
151 pub fn none() -> Self {
152 Self { value: 0 }
153 }
154
155 pub fn not_shell() -> Self {
156 Self { value: 1 }
157 }
158
159 pub fn not_target() -> Self {
160 Self { value: 2 }
161 }
162
163 pub fn not_bow() -> Self {
164 Self { value: 3 }
165 }
166
167 pub fn not_magic() -> Self {
168 Self { value: 4 }
169 }
170
171 pub fn cannon() -> Self {
172 Self { value: 5 }
173 }
174
175 pub fn fire_cannon() -> Self {
176 Self { value: 6 }
177 }
178 }
179
180 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/mapunitcommandmenu/MapUnitCommandMenu_BaseMenuItem.md"))]
181 #[::unity::class(namespace = "App", name = "MapUnitCommandMenu.BaseMenuItem")]
182 #[parent(crate::app::mapbasicmenuitem::MapBasicMenuItem)]
183 pub struct MapUnitCommandMenu_BaseMenuItem {}
184
185 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/mapunitcommandmenu/MapUnitCommandMenu_EnchantMenuItem.md"))]
186 #[::unity::class(namespace = "App", name = "MapUnitCommandMenu.EnchantMenuItem")]
187 #[parent(crate::app::mapunitcommandmenu::MapUnitCommandMenu_JumpToMenuItem)]
188 pub struct MapUnitCommandMenu_EnchantMenuItem {}
189
190 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/mapunitcommandmenu/MapUnitCommandMenu_TreasureBoxMenuItem.md"))]
191 #[::unity::class(namespace = "App", name = "MapUnitCommandMenu.TreasureBoxMenuItem")]
192 #[parent(crate::app::mapunitcommandmenu::MapUnitCommandMenu_BaseMenuItem)]
193 pub struct MapUnitCommandMenu_TreasureBoxMenuItem {}
194
195 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/mapunitcommandmenu/MapUnitCommandMenu.md"))]
196 #[::unity::class(namespace = "App", name = "MapUnitCommandMenu")]
197 #[parent(crate::app::mapbasicmenu::MapBasicMenu)]
198 pub struct MapUnitCommandMenu {
199 #[static_field]
200 #[rename(name = "s_SelectIndex")]
201 pub s_select_index: i32,
202 #[offset(200)]
203 #[rename(name = "m_MapUnitCommandMenuContent")]
204 pub m_map_unit_command_menu_content: crate::app::mapunitcommandmenucontent::MapUnitCommandMenuContent,
205 }
206
207 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/mapunitcommandmenu/MapUnitCommandMenu_RodMenuItem.md"))]
208 #[::unity::class(namespace = "App", name = "MapUnitCommandMenu.RodMenuItem")]
209 #[parent(crate::app::mapunitcommandmenu::MapUnitCommandMenu_JumpToMenuItem)]
210 pub struct MapUnitCommandMenu_RodMenuItem {}
211
212 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/mapunitcommandmenu/MapUnitCommandMenu_VisionCreateMenuItem.md"))]
213 #[::unity::class(namespace = "App", name = "MapUnitCommandMenu.VisionCreateMenuItem")]
214 #[parent(crate::app::mapunitcommandmenu::MapUnitCommandMenu_TargetSelectMenuItem)]
215 pub struct MapUnitCommandMenu_VisionCreateMenuItem {}
216
217 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/mapunitcommandmenu/MapUnitCommandMenu_SkillAttackMenuItem.md"))]
218 #[::unity::class(namespace = "App", name = "MapUnitCommandMenu.SkillAttackMenuItem")]
219 #[parent(crate::app::mapunitcommandmenu::MapUnitCommandMenu_AttackMenuItem)]
220 pub struct MapUnitCommandMenu_SkillAttackMenuItem {
221 #[offset(104)]
222 #[rename(name = "m_CommandSkill")]
223 pub m_command_skill: crate::app::skilldata::SkillData,
224 }
225
226 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/mapunitcommandmenu/MapUnitCommandMenu_EngageWaitMenuItem.md"))]
227 #[::unity::class(namespace = "App", name = "MapUnitCommandMenu.EngageWaitMenuItem")]
228 #[parent(crate::app::mapunitcommandmenu::MapUnitCommandMenu_EngageActionBaseMenuItem)]
229 pub struct MapUnitCommandMenu_EngageWaitMenuItem {}
230
231 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/mapunitcommandmenu/MapUnitCommandMenu_NoCancelMagicMenuItem.md"))]
232 #[::unity::class(namespace = "App", name = "MapUnitCommandMenu.NoCancelMagicMenuItem")]
233 #[parent(crate::app::mapunitcommandmenu::MapUnitCommandMenu_SkillAttackMenuItem)]
234 pub struct MapUnitCommandMenu_NoCancelMagicMenuItem {}
235
236 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/mapunitcommandmenu/MapUnitCommandMenu_TradeMenuItem.md"))]
237 #[::unity::class(namespace = "App", name = "MapUnitCommandMenu.TradeMenuItem")]
238 #[parent(crate::app::mapunitcommandmenu::MapUnitCommandMenu_TargetSelectMenuItem)]
239 pub struct MapUnitCommandMenu_TradeMenuItem {}
240
241 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/mapunitcommandmenu/MapUnitCommandMenu_GuardMenuItem.md"))]
242 #[::unity::class(namespace = "App", name = "MapUnitCommandMenu.GuardMenuItem")]
243 #[parent(crate::app::mapunitcommandmenu::MapUnitCommandMenu_TargetSelectMenuItem)]
244 pub struct MapUnitCommandMenu_GuardMenuItem {
245 #[offset(100)]
246 #[rename(name = "m_GuardType")]
247 pub m_guard_type: crate::app::unit::Unit_GuardType,
248 #[offset(104)]
249 #[rename(name = "m_GuardSkill")]
250 pub m_guard_skill: crate::app::skilldata::SkillData,
251 }
252
253 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/mapunitcommandmenu/MapUnitCommandMenu_EngageCommandMenuItem.md"))]
254 #[::unity::class(namespace = "App", name = "MapUnitCommandMenu.EngageCommandMenuItem")]
255 #[parent(crate::app::mapunitcommandmenu::MapUnitCommandMenu_JumpToMenuItem)]
256 pub struct MapUnitCommandMenu_EngageCommandMenuItem {}
257
258 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/mapunitcommandmenu/MapUnitCommandMenu_BreakdownMenuItem.md"))]
259 #[::unity::class(namespace = "App", name = "MapUnitCommandMenu.BreakdownMenuItem")]
260 #[parent(crate::app::mapunitcommandmenu::MapUnitCommandMenu_BreakdownBaseMenuItem)]
261 pub struct MapUnitCommandMenu_BreakdownMenuItem {}
262
263 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/mapunitcommandmenu/MapUnitCommandMenu_EngageChargeMenuItem.md"))]
264 #[::unity::class(namespace = "App", name = "MapUnitCommandMenu.EngageChargeMenuItem")]
265 #[parent(crate::app::mapunitcommandmenu::MapUnitCommandMenu_EngageActionBaseMenuItem)]
266 pub struct MapUnitCommandMenu_EngageChargeMenuItem {}
267
268 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/mapunitcommandmenu/MapUnitCommandMenu_EngageAttackMenuItem.md"))]
269 #[::unity::class(namespace = "App", name = "MapUnitCommandMenu.EngageAttackMenuItem")]
270 #[parent(crate::app::mapunitcommandmenu::MapUnitCommandMenu_EngageActionBaseMenuItem)]
271 pub struct MapUnitCommandMenu_EngageAttackMenuItem {}
272
273 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/mapunitcommandmenu/MapUnitCommandMenu_TalkMenuItem.md"))]
274 #[::unity::class(namespace = "App", name = "MapUnitCommandMenu.TalkMenuItem")]
275 #[parent(crate::app::mapunitcommandmenu::MapUnitCommandMenu_TargetSelectMenuItem)]
276 pub struct MapUnitCommandMenu_TalkMenuItem {}
277
278 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/mapunitcommandmenu/MapUnitCommandMenu_CommandSkillMenuItem.md"))]
279 #[::unity::class(namespace = "App", name = "MapUnitCommandMenu.CommandSkillMenuItem")]
280 #[parent(crate::app::mapunitcommandmenu::MapUnitCommandMenu_TargetSelectMenuItem)]
281 pub struct MapUnitCommandMenu_CommandSkillMenuItem {
282 #[offset(104)]
283 #[rename(name = "m_CommandSkill")]
284 pub m_command_skill: crate::app::skilldata::SkillData,
285 }
286
287 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/mapunitcommandmenu/MapUnitCommandMenu_EngageRewarpMenuItem.md"))]
288 #[::unity::class(namespace = "App", name = "MapUnitCommandMenu.EngageRewarpMenuItem")]
289 #[parent(crate::app::mapunitcommandmenu::MapUnitCommandMenu_EngageActionBaseMenuItem)]
290 pub struct MapUnitCommandMenu_EngageRewarpMenuItem {}
291
292 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/mapunitcommandmenu/MapUnitCommandMenu_DoorMenuItem.md"))]
293 #[::unity::class(namespace = "App", name = "MapUnitCommandMenu.DoorMenuItem")]
294 #[parent(crate::app::mapunitcommandmenu::MapUnitCommandMenu_BaseMenuItem)]
295 pub struct MapUnitCommandMenu_DoorMenuItem {}
296
297 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/mapunitcommandmenu/MapUnitCommandMenu_BreakthroughMenuItem.md"))]
298 #[::unity::class(namespace = "App", name = "MapUnitCommandMenu.BreakthroughMenuItem")]
299 #[parent(crate::app::mapunitcommandmenu::MapUnitCommandMenu_BaseMenuItem)]
300 pub struct MapUnitCommandMenu_BreakthroughMenuItem {}
301
302 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/mapunitcommandmenu/MapUnitCommandMenu_BreakdownBaseMenuItem.md"))]
303 #[::unity::class(namespace = "App", name = "MapUnitCommandMenu.BreakdownBaseMenuItem")]
304 #[parent(crate::app::mapunitcommandmenu::MapUnitCommandMenu_BaseMenuItem)]
305 pub struct MapUnitCommandMenu_BreakdownBaseMenuItem {}
306
307 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/mapunitcommandmenu/MapUnitCommandMenu_FixedMenuItem.md"))]
308 #[::unity::class(namespace = "App", name = "MapUnitCommandMenu.FixedMenuItem")]
309 #[parent(crate::app::mapunitcommandmenu::MapUnitCommandMenu_BaseMenuItem)]
310 pub struct MapUnitCommandMenu_FixedMenuItem {}
311
312 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/mapunitcommandmenu/MapUnitCommandMenu_TargetSelectMenuItem.md"))]
313 #[::unity::class(namespace = "App", name = "MapUnitCommandMenu.TargetSelectMenuItem")]
314 #[parent(crate::app::mapunitcommandmenu::MapUnitCommandMenu_BaseMenuItem)]
315 pub struct MapUnitCommandMenu_TargetSelectMenuItem {}
316
317 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/mapunitcommandmenu/MapUnitCommandMenu_VisionDeleteMenuItem.md"))]
318 #[::unity::class(namespace = "App", name = "MapUnitCommandMenu.VisionDeleteMenuItem")]
319 #[parent(crate::app::mapunitcommandmenu::MapUnitCommandMenu_TargetSelectMenuItem)]
320 pub struct MapUnitCommandMenu_VisionDeleteMenuItem {}
321
322 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/mapunitcommandmenu/MapUnitCommandMenu_EngageSummonMenuItem.md"))]
323 #[::unity::class(namespace = "App", name = "MapUnitCommandMenu.EngageSummonMenuItem")]
324 #[parent(crate::app::mapunitcommandmenu::MapUnitCommandMenu_EngageActionBaseMenuItem)]
325 pub struct MapUnitCommandMenu_EngageSummonMenuItem {}
326
327 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/mapunitcommandmenu/MapUnitCommandMenu_JumpToMenuItem.md"))]
328 #[::unity::class(namespace = "App", name = "MapUnitCommandMenu.JumpToMenuItem")]
329 #[parent(crate::app::mapunitcommandmenu::MapUnitCommandMenu_BaseMenuItem)]
330 pub struct MapUnitCommandMenu_JumpToMenuItem {}
331
332 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/mapunitcommandmenu/MapUnitCommandMenu_ContractMenuItem.md"))]
333 #[::unity::class(namespace = "App", name = "MapUnitCommandMenu.ContractMenuItem")]
334 #[parent(crate::app::mapunitcommandmenu::MapUnitCommandMenu_TargetSelectMenuItem)]
335 pub struct MapUnitCommandMenu_ContractMenuItem {
336 #[offset(104)]
337 #[rename(name = "m_ContractSkill")]
338 pub m_contract_skill: crate::app::skilldata::SkillData,
339 }
340
341 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/mapunitcommandmenu/MapUnitCommandMenu_EnchantWeaponMenuItem.md"))]
342 #[::unity::class(namespace = "App", name = "MapUnitCommandMenu.EnchantWeaponMenuItem")]
343 #[parent(crate::app::mapunitcommandmenu::MapUnitCommandMenu_EnchantMenuItem)]
344 pub struct MapUnitCommandMenu_EnchantWeaponMenuItem {}
345}
346
347#[cfg(feature = "app-mapunitcommandmenu-types")]
348pub use __types::*;
349
350#[cfg(feature = "app-mapunitcommandmenu")]
351pub trait IMapUnitCommandMenu_TorchOnMenuItemMethods: IMapUnitCommandMenu_TorchOnMenuItem {
352 #[doc = "`get_FlagID()` overload"]
353 fn get_flag_id(self) -> ::unity::Il2CppString {
354 unsafe {
355 let __receiver =
356 <MapUnitCommandMenu_TorchOnMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
357 {
358 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
359 let __vi = *__vt.get(27usize).unwrap_or_else(|| {
360 panic!(
361 "unity: virtual slot {}
362 out of range (vtable len {}
363) on the runtime class behind {}
364 (method `{}
365`)",
366 27usize,
367 __vt.len(),
368 <MapUnitCommandMenu_TorchOnMenuItem as ::unity::ClassIdentity>::NAME,
369 "get_FlagID",
370 )
371 });
372 let __inner: extern "C" fn(MapUnitCommandMenu_TorchOnMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
373 ::core::mem::transmute(__vi.method_ptr);
374 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
375 __inner(__receiver, __mi)
376 }
377 }
378 }
379 #[doc = "`get_ActiveMind()` overload"]
380 fn get_active_mind(self) -> crate::app::mapmind::MapMind_Type {
381 unsafe {
382 let __receiver =
383 <MapUnitCommandMenu_TorchOnMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
384 {
385 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
386 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
387 panic!(
388 "unity: virtual slot {}
389 out of range (vtable len {}
390) on the runtime class behind {}
391 (method `{}
392`)",
393 30usize,
394 __vt.len(),
395 <MapUnitCommandMenu_TorchOnMenuItem as ::unity::ClassIdentity>::NAME,
396 "get_ActiveMind",
397 )
398 });
399 let __inner: extern "C" fn(MapUnitCommandMenu_TorchOnMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
400 ::core::mem::transmute(__vi.method_ptr);
401 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
402 __inner(__receiver, __mi)
403 }
404 }
405 }
406 #[doc = "`get_DeployMode()` overload"]
407 fn get_deploy_mode(self) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
408 unsafe {
409 let __receiver =
410 <MapUnitCommandMenu_TorchOnMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
411 {
412 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
413 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
414 panic!(
415 "unity: virtual slot {}
416 out of range (vtable len {}
417) on the runtime class behind {}
418 (method `{}
419`)",
420 31usize,
421 __vt.len(),
422 <MapUnitCommandMenu_TorchOnMenuItem as ::unity::ClassIdentity>::NAME,
423 "get_DeployMode",
424 )
425 });
426 let __inner: extern "C" fn(
427 MapUnitCommandMenu_TorchOnMenuItem,
428 ::unity::OptionalMethod,
429 ) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode = ::core::mem::transmute(__vi.method_ptr);
430 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
431 __inner(__receiver, __mi)
432 }
433 }
434 }
435 #[doc = "`GetName()` overload"]
436 fn get_name(self) -> ::unity::Il2CppString {
437 unsafe {
438 let __receiver =
439 <MapUnitCommandMenu_TorchOnMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
440 {
441 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
442 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
443 panic!(
444 "unity: virtual slot {}
445 out of range (vtable len {}
446) on the runtime class behind {}
447 (method `{}
448`)",
449 4usize,
450 __vt.len(),
451 <MapUnitCommandMenu_TorchOnMenuItem as ::unity::ClassIdentity>::NAME,
452 "GetName",
453 )
454 });
455 let __inner: extern "C" fn(MapUnitCommandMenu_TorchOnMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
456 ::core::mem::transmute(__vi.method_ptr);
457 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
458 __inner(__receiver, __mi)
459 }
460 }
461 }
462 #[doc = "`GetCommandHelp()` overload"]
463 fn get_command_help(self) -> ::unity::Il2CppString {
464 unsafe {
465 let __receiver =
466 <MapUnitCommandMenu_TorchOnMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
467 {
468 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
469 let __vi = *__vt.get(34usize).unwrap_or_else(|| {
470 panic!(
471 "unity: virtual slot {}
472 out of range (vtable len {}
473) on the runtime class behind {}
474 (method `{}
475`)",
476 34usize,
477 __vt.len(),
478 <MapUnitCommandMenu_TorchOnMenuItem as ::unity::ClassIdentity>::NAME,
479 "GetCommandHelp",
480 )
481 });
482 let __inner: extern "C" fn(MapUnitCommandMenu_TorchOnMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
483 ::core::mem::transmute(__vi.method_ptr);
484 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
485 __inner(__receiver, __mi)
486 }
487 }
488 }
489 #[doc = "`GetTerrainCommand()` overload"]
490 fn get_terrain_command(self) -> crate::app::terraindata_2::TerrainData_Commands {
491 unsafe {
492 let __receiver =
493 <MapUnitCommandMenu_TorchOnMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
494 ::unity::il2cpp_call!((::unity::module_base()+0x1e51340usize)as*mut u8,crate::app::terraindata_2::TerrainData_Commands;
495(MapUnitCommandMenu_TorchOnMenuItem)__receiver)
496 }
497 }
498 #[doc = "`Decide(crate::app::mapmind::MapMind_Type)` overload"]
499 fn decide(self, mind: impl ::core::convert::Into<crate::app::mapmind::MapMind_Type>) -> () {
500 unsafe {
501 let __receiver =
502 <MapUnitCommandMenu_TorchOnMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
503 ::unity::il2cpp_call!((::unity::module_base()+0x1e51590usize)as*mut u8,();
504(MapUnitCommandMenu_TorchOnMenuItem)__receiver,(crate::app::mapmind::MapMind_Type)::core::convert::Into::into(mind))
505 }
506 }
507 #[doc = "`GetMapAttribute()` overload"]
508 fn get_map_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
509 unsafe {
510 let __receiver =
511 <MapUnitCommandMenu_TorchOnMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
512 {
513 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
514 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
515 panic!(
516 "unity: virtual slot {}
517 out of range (vtable len {}
518) on the runtime class behind {}
519 (method `{}
520`)",
521 29usize,
522 __vt.len(),
523 <MapUnitCommandMenu_TorchOnMenuItem as ::unity::ClassIdentity>::NAME,
524 "GetMapAttribute",
525 )
526 });
527 let __inner: extern "C" fn(
528 MapUnitCommandMenu_TorchOnMenuItem,
529 ::unity::OptionalMethod,
530 ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
531 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
532 __inner(__receiver, __mi)
533 }
534 }
535 }
536 #[doc = "`ACall()` overload"]
537 fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
538 unsafe {
539 let __receiver =
540 <MapUnitCommandMenu_TorchOnMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
541 {
542 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
543 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
544 panic!(
545 "unity: virtual slot {}
546 out of range (vtable len {}
547) on the runtime class behind {}
548 (method `{}
549`)",
550 18usize,
551 __vt.len(),
552 <MapUnitCommandMenu_TorchOnMenuItem as ::unity::ClassIdentity>::NAME,
553 "ACall",
554 )
555 });
556 let __inner: extern "C" fn(MapUnitCommandMenu_TorchOnMenuItem, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
557 ::core::mem::transmute(__vi.method_ptr);
558 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
559 __inner(__receiver, __mi)
560 }
561 }
562 }
563 #[doc = "`.ctor()` overload"]
564 fn ctor(self) -> () {
565 unsafe {
566 let __receiver =
567 <MapUnitCommandMenu_TorchOnMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
568 ::unity::il2cpp_call!((::unity::module_base()+0x1e51860usize)as*mut u8,();
569(MapUnitCommandMenu_TorchOnMenuItem)__receiver)
570 }
571 }
572}
573
574#[cfg(feature = "app-mapunitcommandmenu")]
575impl<__T: IMapUnitCommandMenu_TorchOnMenuItem> IMapUnitCommandMenu_TorchOnMenuItemMethods for __T {}
576
577#[cfg(feature = "app-mapunitcommandmenu")]
578impl MapUnitCommandMenu_TorchOnMenuItem {
579 pub fn get_flag_id_method_info() -> &'static ::unity::il2cpp::MethodInfo {
580 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
581 }
582
583 pub fn get_active_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
584 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
585 }
586
587 pub fn get_deploy_mode_method_info() -> &'static ::unity::il2cpp::MethodInfo {
588 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
589 }
590
591 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
592 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
593 }
594
595 pub fn get_command_help_method_info() -> &'static ::unity::il2cpp::MethodInfo {
596 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
597 }
598
599 pub fn get_terrain_command_method_info() -> &'static ::unity::il2cpp::MethodInfo {
600 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
601 }
602
603 pub fn decide_method_info() -> &'static ::unity::il2cpp::MethodInfo {
604 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
605 }
606
607 pub fn get_map_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
608 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
609 }
610
611 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
612 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
613 }
614
615 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
616 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
617 }
618}
619
620#[cfg(feature = "app-mapunitcommandmenu")]
621impl MapUnitCommandMenu_TorchOnMenuItem {
622 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_TorchOnMenuItem`'s own `get_FlagID`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
623 pub unsafe fn get_flag_id(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
624 let __mi = Self::get_flag_id_method_info();
625 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
626 __inner(this.into(), ::core::option::Option::None)
627 }
628
629 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_TorchOnMenuItem`'s own `get_ActiveMind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
630 pub unsafe fn get_active_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
631 let __mi = Self::get_active_mind_method_info();
632 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
633 ::core::mem::transmute(__mi.method_ptr);
634 __inner(this.into(), ::core::option::Option::None)
635 }
636
637 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_TorchOnMenuItem`'s own `get_DeployMode`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
638 pub unsafe fn get_deploy_mode(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
639 let __mi = Self::get_deploy_mode_method_info();
640 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode =
641 ::core::mem::transmute(__mi.method_ptr);
642 __inner(this.into(), ::core::option::Option::None)
643 }
644
645 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_TorchOnMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
646 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
647 let __mi = Self::get_name_method_info();
648 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
649 __inner(this.into(), ::core::option::Option::None)
650 }
651
652 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_TorchOnMenuItem`'s own `GetCommandHelp`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
653 pub unsafe fn get_command_help(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
654 let __mi = Self::get_command_help_method_info();
655 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
656 __inner(this.into(), ::core::option::Option::None)
657 }
658
659 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_TorchOnMenuItem`'s own `GetMapAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
660 pub unsafe fn get_map_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
661 let __mi = Self::get_map_attribute_method_info();
662 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
663 ::core::mem::transmute(__mi.method_ptr);
664 __inner(this.into(), ::core::option::Option::None)
665 }
666
667 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_TorchOnMenuItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
668 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
669 let __mi = Self::a_call_method_info();
670 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
671 ::core::mem::transmute(__mi.method_ptr);
672 __inner(this.into(), ::core::option::Option::None)
673 }
674}
675
676#[cfg(feature = "app-mapunitcommandmenu")]
677impl MapUnitCommandMenu_TorchOnMenuItem {
678 #[doc = "`.ctor()` — no args"]
679 pub fn new() -> Self {
680 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
681 panic!(
682 "{}
683::{}
684 failed to instantiate",
685 ::core::stringify!(MapUnitCommandMenu_TorchOnMenuItem),
686 ::core::stringify!(new),
687 )
688 });
689 <Self as IMapUnitCommandMenu_TorchOnMenuItemMethods>::ctor(this);
690 this
691 }
692}
693
694#[cfg(feature = "app-mapunitcommandmenu")]
695pub trait IMapUnitCommandMenu_DestroyMenuItemMethods: IMapUnitCommandMenu_DestroyMenuItem {
696 #[doc = "`get_FlagID()` overload"]
697 fn get_flag_id(self) -> ::unity::Il2CppString {
698 unsafe {
699 let __receiver =
700 <MapUnitCommandMenu_DestroyMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
701 {
702 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
703 let __vi = *__vt.get(27usize).unwrap_or_else(|| {
704 panic!(
705 "unity: virtual slot {}
706 out of range (vtable len {}
707) on the runtime class behind {}
708 (method `{}
709`)",
710 27usize,
711 __vt.len(),
712 <MapUnitCommandMenu_DestroyMenuItem as ::unity::ClassIdentity>::NAME,
713 "get_FlagID",
714 )
715 });
716 let __inner: extern "C" fn(MapUnitCommandMenu_DestroyMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
717 ::core::mem::transmute(__vi.method_ptr);
718 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
719 __inner(__receiver, __mi)
720 }
721 }
722 }
723 #[doc = "`get_Label()` overload"]
724 fn get_label(self) -> crate::app::mapsequencehuman::MapSequenceHuman_Label {
725 unsafe {
726 let __receiver =
727 <MapUnitCommandMenu_DestroyMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
728 {
729 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
730 let __vi = *__vt.get(36usize).unwrap_or_else(|| {
731 panic!(
732 "unity: virtual slot {}
733 out of range (vtable len {}
734) on the runtime class behind {}
735 (method `{}
736`)",
737 36usize,
738 __vt.len(),
739 <MapUnitCommandMenu_DestroyMenuItem as ::unity::ClassIdentity>::NAME,
740 "get_Label",
741 )
742 });
743 let __inner: extern "C" fn(
744 MapUnitCommandMenu_DestroyMenuItem,
745 ::unity::OptionalMethod,
746 ) -> crate::app::mapsequencehuman::MapSequenceHuman_Label = ::core::mem::transmute(__vi.method_ptr);
747 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
748 __inner(__receiver, __mi)
749 }
750 }
751 }
752 #[doc = "`get_ActiveMind()` overload"]
753 fn get_active_mind(self) -> crate::app::mapmind::MapMind_Type {
754 unsafe {
755 let __receiver =
756 <MapUnitCommandMenu_DestroyMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
757 {
758 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
759 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
760 panic!(
761 "unity: virtual slot {}
762 out of range (vtable len {}
763) on the runtime class behind {}
764 (method `{}
765`)",
766 30usize,
767 __vt.len(),
768 <MapUnitCommandMenu_DestroyMenuItem as ::unity::ClassIdentity>::NAME,
769 "get_ActiveMind",
770 )
771 });
772 let __inner: extern "C" fn(MapUnitCommandMenu_DestroyMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
773 ::core::mem::transmute(__vi.method_ptr);
774 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
775 __inner(__receiver, __mi)
776 }
777 }
778 }
779 #[doc = "`get_DeployMode()` overload"]
780 fn get_deploy_mode(self) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
781 unsafe {
782 let __receiver =
783 <MapUnitCommandMenu_DestroyMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
784 {
785 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
786 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
787 panic!(
788 "unity: virtual slot {}
789 out of range (vtable len {}
790) on the runtime class behind {}
791 (method `{}
792`)",
793 31usize,
794 __vt.len(),
795 <MapUnitCommandMenu_DestroyMenuItem as ::unity::ClassIdentity>::NAME,
796 "get_DeployMode",
797 )
798 });
799 let __inner: extern "C" fn(
800 MapUnitCommandMenu_DestroyMenuItem,
801 ::unity::OptionalMethod,
802 ) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode = ::core::mem::transmute(__vi.method_ptr);
803 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
804 __inner(__receiver, __mi)
805 }
806 }
807 }
808 #[doc = "`GetName()` overload"]
809 fn get_name(self) -> ::unity::Il2CppString {
810 unsafe {
811 let __receiver =
812 <MapUnitCommandMenu_DestroyMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
813 {
814 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
815 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
816 panic!(
817 "unity: virtual slot {}
818 out of range (vtable len {}
819) on the runtime class behind {}
820 (method `{}
821`)",
822 4usize,
823 __vt.len(),
824 <MapUnitCommandMenu_DestroyMenuItem as ::unity::ClassIdentity>::NAME,
825 "GetName",
826 )
827 });
828 let __inner: extern "C" fn(MapUnitCommandMenu_DestroyMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
829 ::core::mem::transmute(__vi.method_ptr);
830 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
831 __inner(__receiver, __mi)
832 }
833 }
834 }
835 #[doc = "`GetCommandHelp()` overload"]
836 fn get_command_help(self) -> ::unity::Il2CppString {
837 unsafe {
838 let __receiver =
839 <MapUnitCommandMenu_DestroyMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
840 {
841 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
842 let __vi = *__vt.get(34usize).unwrap_or_else(|| {
843 panic!(
844 "unity: virtual slot {}
845 out of range (vtable len {}
846) on the runtime class behind {}
847 (method `{}
848`)",
849 34usize,
850 __vt.len(),
851 <MapUnitCommandMenu_DestroyMenuItem as ::unity::ClassIdentity>::NAME,
852 "GetCommandHelp",
853 )
854 });
855 let __inner: extern "C" fn(MapUnitCommandMenu_DestroyMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
856 ::core::mem::transmute(__vi.method_ptr);
857 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
858 __inner(__receiver, __mi)
859 }
860 }
861 }
862 #[doc = "`GetMapAttribute()` overload"]
863 fn get_map_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
864 unsafe {
865 let __receiver =
866 <MapUnitCommandMenu_DestroyMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
867 {
868 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
869 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
870 panic!(
871 "unity: virtual slot {}
872 out of range (vtable len {}
873) on the runtime class behind {}
874 (method `{}
875`)",
876 29usize,
877 __vt.len(),
878 <MapUnitCommandMenu_DestroyMenuItem as ::unity::ClassIdentity>::NAME,
879 "GetMapAttribute",
880 )
881 });
882 let __inner: extern "C" fn(
883 MapUnitCommandMenu_DestroyMenuItem,
884 ::unity::OptionalMethod,
885 ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
886 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
887 __inner(__receiver, __mi)
888 }
889 }
890 }
891 #[doc = "`.ctor()` overload"]
892 fn ctor(self) -> () {
893 unsafe {
894 let __receiver =
895 <MapUnitCommandMenu_DestroyMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
896 ::unity::il2cpp_call!((::unity::module_base()+0x1e4c150usize)as*mut u8,();
897(MapUnitCommandMenu_DestroyMenuItem)__receiver)
898 }
899 }
900}
901
902#[cfg(feature = "app-mapunitcommandmenu")]
903impl<__T: IMapUnitCommandMenu_DestroyMenuItem> IMapUnitCommandMenu_DestroyMenuItemMethods for __T {}
904
905#[cfg(feature = "app-mapunitcommandmenu")]
906impl MapUnitCommandMenu_DestroyMenuItem {
907 pub fn get_flag_id_method_info() -> &'static ::unity::il2cpp::MethodInfo {
908 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
909 }
910
911 pub fn get_label_method_info() -> &'static ::unity::il2cpp::MethodInfo {
912 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
913 }
914
915 pub fn get_active_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
916 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
917 }
918
919 pub fn get_deploy_mode_method_info() -> &'static ::unity::il2cpp::MethodInfo {
920 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
921 }
922
923 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
924 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
925 }
926
927 pub fn get_command_help_method_info() -> &'static ::unity::il2cpp::MethodInfo {
928 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
929 }
930
931 pub fn get_map_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
932 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
933 }
934
935 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
936 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
937 }
938}
939
940#[cfg(feature = "app-mapunitcommandmenu")]
941impl MapUnitCommandMenu_DestroyMenuItem {
942 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_DestroyMenuItem`'s own `get_FlagID`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
943 pub unsafe fn get_flag_id(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
944 let __mi = Self::get_flag_id_method_info();
945 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
946 __inner(this.into(), ::core::option::Option::None)
947 }
948
949 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_DestroyMenuItem`'s own `get_Label`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
950 pub unsafe fn get_label(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapsequencehuman::MapSequenceHuman_Label {
951 let __mi = Self::get_label_method_info();
952 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapsequencehuman::MapSequenceHuman_Label =
953 ::core::mem::transmute(__mi.method_ptr);
954 __inner(this.into(), ::core::option::Option::None)
955 }
956
957 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_DestroyMenuItem`'s own `get_ActiveMind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
958 pub unsafe fn get_active_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
959 let __mi = Self::get_active_mind_method_info();
960 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
961 ::core::mem::transmute(__mi.method_ptr);
962 __inner(this.into(), ::core::option::Option::None)
963 }
964
965 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_DestroyMenuItem`'s own `get_DeployMode`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
966 pub unsafe fn get_deploy_mode(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
967 let __mi = Self::get_deploy_mode_method_info();
968 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode =
969 ::core::mem::transmute(__mi.method_ptr);
970 __inner(this.into(), ::core::option::Option::None)
971 }
972
973 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_DestroyMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
974 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
975 let __mi = Self::get_name_method_info();
976 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
977 __inner(this.into(), ::core::option::Option::None)
978 }
979
980 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_DestroyMenuItem`'s own `GetCommandHelp`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
981 pub unsafe fn get_command_help(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
982 let __mi = Self::get_command_help_method_info();
983 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
984 __inner(this.into(), ::core::option::Option::None)
985 }
986
987 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_DestroyMenuItem`'s own `GetMapAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
988 pub unsafe fn get_map_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
989 let __mi = Self::get_map_attribute_method_info();
990 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
991 ::core::mem::transmute(__mi.method_ptr);
992 __inner(this.into(), ::core::option::Option::None)
993 }
994}
995
996#[cfg(feature = "app-mapunitcommandmenu")]
997impl MapUnitCommandMenu_DestroyMenuItem {
998 #[doc = "`.ctor()` — no args"]
999 pub fn new() -> Self {
1000 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1001 panic!(
1002 "{}
1003::{}
1004 failed to instantiate",
1005 ::core::stringify!(MapUnitCommandMenu_DestroyMenuItem),
1006 ::core::stringify!(new),
1007 )
1008 });
1009 <Self as IMapUnitCommandMenu_DestroyMenuItemMethods>::ctor(this);
1010 this
1011 }
1012}
1013
1014#[cfg(feature = "app-mapunitcommandmenu")]
1015pub trait IMapUnitCommandMenu_ItemMenuItemMethods: IMapUnitCommandMenu_ItemMenuItem {
1016 #[doc = "`get_FlagID()` overload"]
1017 fn get_flag_id(self) -> ::unity::Il2CppString {
1018 unsafe {
1019 let __receiver =
1020 <MapUnitCommandMenu_ItemMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1021 {
1022 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1023 let __vi = *__vt.get(27usize).unwrap_or_else(|| {
1024 panic!(
1025 "unity: virtual slot {}
1026 out of range (vtable len {}
1027) on the runtime class behind {}
1028 (method `{}
1029`)",
1030 27usize,
1031 __vt.len(),
1032 <MapUnitCommandMenu_ItemMenuItem as ::unity::ClassIdentity>::NAME,
1033 "get_FlagID",
1034 )
1035 });
1036 let __inner: extern "C" fn(MapUnitCommandMenu_ItemMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1037 ::core::mem::transmute(__vi.method_ptr);
1038 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1039 __inner(__receiver, __mi)
1040 }
1041 }
1042 }
1043 #[doc = "`get_Label()` overload"]
1044 fn get_label(self) -> crate::app::mapsequencehuman::MapSequenceHuman_Label {
1045 unsafe {
1046 let __receiver =
1047 <MapUnitCommandMenu_ItemMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1048 {
1049 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1050 let __vi = *__vt.get(36usize).unwrap_or_else(|| {
1051 panic!(
1052 "unity: virtual slot {}
1053 out of range (vtable len {}
1054) on the runtime class behind {}
1055 (method `{}
1056`)",
1057 36usize,
1058 __vt.len(),
1059 <MapUnitCommandMenu_ItemMenuItem as ::unity::ClassIdentity>::NAME,
1060 "get_Label",
1061 )
1062 });
1063 let __inner: extern "C" fn(
1064 MapUnitCommandMenu_ItemMenuItem,
1065 ::unity::OptionalMethod,
1066 ) -> crate::app::mapsequencehuman::MapSequenceHuman_Label = ::core::mem::transmute(__vi.method_ptr);
1067 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1068 __inner(__receiver, __mi)
1069 }
1070 }
1071 }
1072 #[doc = "`get_ActiveMind()` overload"]
1073 fn get_active_mind(self) -> crate::app::mapmind::MapMind_Type {
1074 unsafe {
1075 let __receiver =
1076 <MapUnitCommandMenu_ItemMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1077 {
1078 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1079 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
1080 panic!(
1081 "unity: virtual slot {}
1082 out of range (vtable len {}
1083) on the runtime class behind {}
1084 (method `{}
1085`)",
1086 30usize,
1087 __vt.len(),
1088 <MapUnitCommandMenu_ItemMenuItem as ::unity::ClassIdentity>::NAME,
1089 "get_ActiveMind",
1090 )
1091 });
1092 let __inner: extern "C" fn(MapUnitCommandMenu_ItemMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
1093 ::core::mem::transmute(__vi.method_ptr);
1094 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1095 __inner(__receiver, __mi)
1096 }
1097 }
1098 }
1099 #[doc = "`get_DeployMode()` overload"]
1100 fn get_deploy_mode(self) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
1101 unsafe {
1102 let __receiver =
1103 <MapUnitCommandMenu_ItemMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1104 {
1105 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1106 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
1107 panic!(
1108 "unity: virtual slot {}
1109 out of range (vtable len {}
1110) on the runtime class behind {}
1111 (method `{}
1112`)",
1113 31usize,
1114 __vt.len(),
1115 <MapUnitCommandMenu_ItemMenuItem as ::unity::ClassIdentity>::NAME,
1116 "get_DeployMode",
1117 )
1118 });
1119 let __inner: extern "C" fn(
1120 MapUnitCommandMenu_ItemMenuItem,
1121 ::unity::OptionalMethod,
1122 ) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode = ::core::mem::transmute(__vi.method_ptr);
1123 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1124 __inner(__receiver, __mi)
1125 }
1126 }
1127 }
1128 #[doc = "`GetName()` overload"]
1129 fn get_name(self) -> ::unity::Il2CppString {
1130 unsafe {
1131 let __receiver =
1132 <MapUnitCommandMenu_ItemMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1133 {
1134 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1135 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
1136 panic!(
1137 "unity: virtual slot {}
1138 out of range (vtable len {}
1139) on the runtime class behind {}
1140 (method `{}
1141`)",
1142 4usize,
1143 __vt.len(),
1144 <MapUnitCommandMenu_ItemMenuItem as ::unity::ClassIdentity>::NAME,
1145 "GetName",
1146 )
1147 });
1148 let __inner: extern "C" fn(MapUnitCommandMenu_ItemMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1149 ::core::mem::transmute(__vi.method_ptr);
1150 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1151 __inner(__receiver, __mi)
1152 }
1153 }
1154 }
1155 #[doc = "`GetCommandHelp()` overload"]
1156 fn get_command_help(self) -> ::unity::Il2CppString {
1157 unsafe {
1158 let __receiver =
1159 <MapUnitCommandMenu_ItemMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1160 {
1161 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1162 let __vi = *__vt.get(34usize).unwrap_or_else(|| {
1163 panic!(
1164 "unity: virtual slot {}
1165 out of range (vtable len {}
1166) on the runtime class behind {}
1167 (method `{}
1168`)",
1169 34usize,
1170 __vt.len(),
1171 <MapUnitCommandMenu_ItemMenuItem as ::unity::ClassIdentity>::NAME,
1172 "GetCommandHelp",
1173 )
1174 });
1175 let __inner: extern "C" fn(MapUnitCommandMenu_ItemMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1176 ::core::mem::transmute(__vi.method_ptr);
1177 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1178 __inner(__receiver, __mi)
1179 }
1180 }
1181 }
1182 #[doc = "`GetMapAttribute()` overload"]
1183 fn get_map_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
1184 unsafe {
1185 let __receiver =
1186 <MapUnitCommandMenu_ItemMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1187 {
1188 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1189 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
1190 panic!(
1191 "unity: virtual slot {}
1192 out of range (vtable len {}
1193) on the runtime class behind {}
1194 (method `{}
1195`)",
1196 29usize,
1197 __vt.len(),
1198 <MapUnitCommandMenu_ItemMenuItem as ::unity::ClassIdentity>::NAME,
1199 "GetMapAttribute",
1200 )
1201 });
1202 let __inner: extern "C" fn(
1203 MapUnitCommandMenu_ItemMenuItem,
1204 ::unity::OptionalMethod,
1205 ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
1206 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1207 __inner(__receiver, __mi)
1208 }
1209 }
1210 }
1211 #[doc = "`.ctor()` overload"]
1212 fn ctor(self) -> () {
1213 unsafe {
1214 let __receiver =
1215 <MapUnitCommandMenu_ItemMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1216 ::unity::il2cpp_call!((::unity::module_base()+0x1e4f9c0usize)as*mut u8,();
1217(MapUnitCommandMenu_ItemMenuItem)__receiver)
1218 }
1219 }
1220}
1221
1222#[cfg(feature = "app-mapunitcommandmenu")]
1223impl<__T: IMapUnitCommandMenu_ItemMenuItem> IMapUnitCommandMenu_ItemMenuItemMethods for __T {}
1224
1225#[cfg(feature = "app-mapunitcommandmenu")]
1226impl MapUnitCommandMenu_ItemMenuItem {
1227 pub fn get_flag_id_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1228 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1229 }
1230
1231 pub fn get_label_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1232 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1233 }
1234
1235 pub fn get_active_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1236 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1237 }
1238
1239 pub fn get_deploy_mode_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1240 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
1241 }
1242
1243 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1244 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
1245 }
1246
1247 pub fn get_command_help_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1248 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
1249 }
1250
1251 pub fn get_map_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1252 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
1253 }
1254
1255 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1256 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
1257 }
1258}
1259
1260#[cfg(feature = "app-mapunitcommandmenu")]
1261impl MapUnitCommandMenu_ItemMenuItem {
1262 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_ItemMenuItem`'s own `get_FlagID`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1263 pub unsafe fn get_flag_id(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1264 let __mi = Self::get_flag_id_method_info();
1265 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1266 __inner(this.into(), ::core::option::Option::None)
1267 }
1268
1269 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_ItemMenuItem`'s own `get_Label`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1270 pub unsafe fn get_label(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapsequencehuman::MapSequenceHuman_Label {
1271 let __mi = Self::get_label_method_info();
1272 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapsequencehuman::MapSequenceHuman_Label =
1273 ::core::mem::transmute(__mi.method_ptr);
1274 __inner(this.into(), ::core::option::Option::None)
1275 }
1276
1277 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_ItemMenuItem`'s own `get_ActiveMind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1278 pub unsafe fn get_active_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
1279 let __mi = Self::get_active_mind_method_info();
1280 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
1281 ::core::mem::transmute(__mi.method_ptr);
1282 __inner(this.into(), ::core::option::Option::None)
1283 }
1284
1285 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_ItemMenuItem`'s own `get_DeployMode`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1286 pub unsafe fn get_deploy_mode(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
1287 let __mi = Self::get_deploy_mode_method_info();
1288 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode =
1289 ::core::mem::transmute(__mi.method_ptr);
1290 __inner(this.into(), ::core::option::Option::None)
1291 }
1292
1293 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_ItemMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1294 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1295 let __mi = Self::get_name_method_info();
1296 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1297 __inner(this.into(), ::core::option::Option::None)
1298 }
1299
1300 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_ItemMenuItem`'s own `GetCommandHelp`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1301 pub unsafe fn get_command_help(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1302 let __mi = Self::get_command_help_method_info();
1303 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1304 __inner(this.into(), ::core::option::Option::None)
1305 }
1306
1307 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_ItemMenuItem`'s own `GetMapAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1308 pub unsafe fn get_map_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
1309 let __mi = Self::get_map_attribute_method_info();
1310 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
1311 ::core::mem::transmute(__mi.method_ptr);
1312 __inner(this.into(), ::core::option::Option::None)
1313 }
1314}
1315
1316#[cfg(feature = "app-mapunitcommandmenu")]
1317impl MapUnitCommandMenu_ItemMenuItem {
1318 #[doc = "`.ctor()` — no args"]
1319 pub fn new() -> Self {
1320 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1321 panic!(
1322 "{}
1323::{}
1324 failed to instantiate",
1325 ::core::stringify!(MapUnitCommandMenu_ItemMenuItem),
1326 ::core::stringify!(new),
1327 )
1328 });
1329 <Self as IMapUnitCommandMenu_ItemMenuItemMethods>::ctor(this);
1330 this
1331 }
1332}
1333
1334#[cfg(feature = "app-mapunitcommandmenu")]
1335pub trait IMapUnitCommandMenu_CannonMenuItemMethods: IMapUnitCommandMenu_CannonMenuItem {
1336 #[doc = "`get_FlagID()` overload"]
1337 fn get_flag_id(self) -> ::unity::Il2CppString {
1338 unsafe {
1339 let __receiver =
1340 <MapUnitCommandMenu_CannonMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1341 {
1342 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1343 let __vi = *__vt.get(27usize).unwrap_or_else(|| {
1344 panic!(
1345 "unity: virtual slot {}
1346 out of range (vtable len {}
1347) on the runtime class behind {}
1348 (method `{}
1349`)",
1350 27usize,
1351 __vt.len(),
1352 <MapUnitCommandMenu_CannonMenuItem as ::unity::ClassIdentity>::NAME,
1353 "get_FlagID",
1354 )
1355 });
1356 let __inner: extern "C" fn(MapUnitCommandMenu_CannonMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1357 ::core::mem::transmute(__vi.method_ptr);
1358 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1359 __inner(__receiver, __mi)
1360 }
1361 }
1362 }
1363 #[doc = "`get_Label()` overload"]
1364 fn get_label(self) -> crate::app::mapsequencehuman::MapSequenceHuman_Label {
1365 unsafe {
1366 let __receiver =
1367 <MapUnitCommandMenu_CannonMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1368 {
1369 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1370 let __vi = *__vt.get(36usize).unwrap_or_else(|| {
1371 panic!(
1372 "unity: virtual slot {}
1373 out of range (vtable len {}
1374) on the runtime class behind {}
1375 (method `{}
1376`)",
1377 36usize,
1378 __vt.len(),
1379 <MapUnitCommandMenu_CannonMenuItem as ::unity::ClassIdentity>::NAME,
1380 "get_Label",
1381 )
1382 });
1383 let __inner: extern "C" fn(
1384 MapUnitCommandMenu_CannonMenuItem,
1385 ::unity::OptionalMethod,
1386 ) -> crate::app::mapsequencehuman::MapSequenceHuman_Label = ::core::mem::transmute(__vi.method_ptr);
1387 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1388 __inner(__receiver, __mi)
1389 }
1390 }
1391 }
1392 #[doc = "`get_ActiveMind()` overload"]
1393 fn get_active_mind(self) -> crate::app::mapmind::MapMind_Type {
1394 unsafe {
1395 let __receiver =
1396 <MapUnitCommandMenu_CannonMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1397 {
1398 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1399 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
1400 panic!(
1401 "unity: virtual slot {}
1402 out of range (vtable len {}
1403) on the runtime class behind {}
1404 (method `{}
1405`)",
1406 30usize,
1407 __vt.len(),
1408 <MapUnitCommandMenu_CannonMenuItem as ::unity::ClassIdentity>::NAME,
1409 "get_ActiveMind",
1410 )
1411 });
1412 let __inner: extern "C" fn(MapUnitCommandMenu_CannonMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
1413 ::core::mem::transmute(__vi.method_ptr);
1414 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1415 __inner(__receiver, __mi)
1416 }
1417 }
1418 }
1419 #[doc = "`get_DeployMode()` overload"]
1420 fn get_deploy_mode(self) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
1421 unsafe {
1422 let __receiver =
1423 <MapUnitCommandMenu_CannonMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1424 {
1425 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1426 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
1427 panic!(
1428 "unity: virtual slot {}
1429 out of range (vtable len {}
1430) on the runtime class behind {}
1431 (method `{}
1432`)",
1433 31usize,
1434 __vt.len(),
1435 <MapUnitCommandMenu_CannonMenuItem as ::unity::ClassIdentity>::NAME,
1436 "get_DeployMode",
1437 )
1438 });
1439 let __inner: extern "C" fn(
1440 MapUnitCommandMenu_CannonMenuItem,
1441 ::unity::OptionalMethod,
1442 ) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode = ::core::mem::transmute(__vi.method_ptr);
1443 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1444 __inner(__receiver, __mi)
1445 }
1446 }
1447 }
1448 #[doc = "`get_IsForecast()` overload"]
1449 fn get_is_forecast(self) -> bool {
1450 unsafe {
1451 let __receiver =
1452 <MapUnitCommandMenu_CannonMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1453 {
1454 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1455 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
1456 panic!(
1457 "unity: virtual slot {}
1458 out of range (vtable len {}
1459) on the runtime class behind {}
1460 (method `{}
1461`)",
1462 33usize,
1463 __vt.len(),
1464 <MapUnitCommandMenu_CannonMenuItem as ::unity::ClassIdentity>::NAME,
1465 "get_IsForecast",
1466 )
1467 });
1468 let __inner: extern "C" fn(MapUnitCommandMenu_CannonMenuItem, ::unity::OptionalMethod) -> bool =
1469 ::core::mem::transmute(__vi.method_ptr);
1470 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1471 __inner(__receiver, __mi)
1472 }
1473 }
1474 }
1475 #[doc = "`CalcState()` overload"]
1476 fn calc_state(self) -> crate::app::mapunitcommandmenu::MapUnitCommandMenu_CannonMenuItem_States {
1477 unsafe {
1478 let __receiver =
1479 <MapUnitCommandMenu_CannonMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1480 ::unity::il2cpp_call!((::unity::module_base()+0x1e49ec0usize)as*mut u8,crate::app::mapunitcommandmenu::MapUnitCommandMenu_CannonMenuItem_States;
1481(MapUnitCommandMenu_CannonMenuItem)__receiver)
1482 }
1483 }
1484 #[doc = "`.ctor()` overload"]
1485 fn ctor(self) -> () {
1486 unsafe {
1487 let __receiver =
1488 <MapUnitCommandMenu_CannonMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1489 ::unity::il2cpp_call!((::unity::module_base()+0x1e4ace0usize)as*mut u8,();
1490(MapUnitCommandMenu_CannonMenuItem)__receiver)
1491 }
1492 }
1493 #[doc = "`GetName()` overload"]
1494 fn get_name(self) -> ::unity::Il2CppString {
1495 unsafe {
1496 let __receiver =
1497 <MapUnitCommandMenu_CannonMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1498 {
1499 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1500 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
1501 panic!(
1502 "unity: virtual slot {}
1503 out of range (vtable len {}
1504) on the runtime class behind {}
1505 (method `{}
1506`)",
1507 4usize,
1508 __vt.len(),
1509 <MapUnitCommandMenu_CannonMenuItem as ::unity::ClassIdentity>::NAME,
1510 "GetName",
1511 )
1512 });
1513 let __inner: extern "C" fn(MapUnitCommandMenu_CannonMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1514 ::core::mem::transmute(__vi.method_ptr);
1515 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1516 __inner(__receiver, __mi)
1517 }
1518 }
1519 }
1520 #[doc = "`GetCommandHelp()` overload"]
1521 fn get_command_help(self) -> ::unity::Il2CppString {
1522 unsafe {
1523 let __receiver =
1524 <MapUnitCommandMenu_CannonMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1525 {
1526 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1527 let __vi = *__vt.get(34usize).unwrap_or_else(|| {
1528 panic!(
1529 "unity: virtual slot {}
1530 out of range (vtable len {}
1531) on the runtime class behind {}
1532 (method `{}
1533`)",
1534 34usize,
1535 __vt.len(),
1536 <MapUnitCommandMenu_CannonMenuItem as ::unity::ClassIdentity>::NAME,
1537 "GetCommandHelp",
1538 )
1539 });
1540 let __inner: extern "C" fn(MapUnitCommandMenu_CannonMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1541 ::core::mem::transmute(__vi.method_ptr);
1542 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1543 __inner(__receiver, __mi)
1544 }
1545 }
1546 }
1547 #[doc = "`GetMapAttribute()` overload"]
1548 fn get_map_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
1549 unsafe {
1550 let __receiver =
1551 <MapUnitCommandMenu_CannonMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1552 {
1553 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1554 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
1555 panic!(
1556 "unity: virtual slot {}
1557 out of range (vtable len {}
1558) on the runtime class behind {}
1559 (method `{}
1560`)",
1561 29usize,
1562 __vt.len(),
1563 <MapUnitCommandMenu_CannonMenuItem as ::unity::ClassIdentity>::NAME,
1564 "GetMapAttribute",
1565 )
1566 });
1567 let __inner: extern "C" fn(
1568 MapUnitCommandMenu_CannonMenuItem,
1569 ::unity::OptionalMethod,
1570 ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
1571 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1572 __inner(__receiver, __mi)
1573 }
1574 }
1575 }
1576 #[doc = "`ACall()` overload"]
1577 fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
1578 unsafe {
1579 let __receiver =
1580 <MapUnitCommandMenu_CannonMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1581 {
1582 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1583 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
1584 panic!(
1585 "unity: virtual slot {}
1586 out of range (vtable len {}
1587) on the runtime class behind {}
1588 (method `{}
1589`)",
1590 18usize,
1591 __vt.len(),
1592 <MapUnitCommandMenu_CannonMenuItem as ::unity::ClassIdentity>::NAME,
1593 "ACall",
1594 )
1595 });
1596 let __inner: extern "C" fn(MapUnitCommandMenu_CannonMenuItem, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
1597 ::core::mem::transmute(__vi.method_ptr);
1598 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1599 __inner(__receiver, __mi)
1600 }
1601 }
1602 }
1603}
1604
1605#[cfg(feature = "app-mapunitcommandmenu")]
1606impl<__T: IMapUnitCommandMenu_CannonMenuItem> IMapUnitCommandMenu_CannonMenuItemMethods for __T {}
1607
1608#[cfg(feature = "app-mapunitcommandmenu")]
1609impl MapUnitCommandMenu_CannonMenuItem {
1610 pub fn get_flag_id_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1611 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1612 }
1613
1614 pub fn get_label_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1615 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1616 }
1617
1618 pub fn get_active_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1619 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1620 }
1621
1622 pub fn get_deploy_mode_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1623 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
1624 }
1625
1626 pub fn get_is_forecast_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1627 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
1628 }
1629
1630 pub fn calc_state_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1631 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
1632 }
1633
1634 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1635 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
1636 }
1637
1638 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1639 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
1640 }
1641
1642 pub fn get_command_help_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1643 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
1644 }
1645
1646 pub fn get_map_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1647 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
1648 }
1649
1650 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1651 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
1652 }
1653}
1654
1655#[cfg(feature = "app-mapunitcommandmenu")]
1656impl MapUnitCommandMenu_CannonMenuItem {
1657 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_CannonMenuItem`'s own `get_FlagID`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1658 pub unsafe fn get_flag_id(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1659 let __mi = Self::get_flag_id_method_info();
1660 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1661 __inner(this.into(), ::core::option::Option::None)
1662 }
1663
1664 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_CannonMenuItem`'s own `get_Label`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1665 pub unsafe fn get_label(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapsequencehuman::MapSequenceHuman_Label {
1666 let __mi = Self::get_label_method_info();
1667 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapsequencehuman::MapSequenceHuman_Label =
1668 ::core::mem::transmute(__mi.method_ptr);
1669 __inner(this.into(), ::core::option::Option::None)
1670 }
1671
1672 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_CannonMenuItem`'s own `get_ActiveMind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1673 pub unsafe fn get_active_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
1674 let __mi = Self::get_active_mind_method_info();
1675 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
1676 ::core::mem::transmute(__mi.method_ptr);
1677 __inner(this.into(), ::core::option::Option::None)
1678 }
1679
1680 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_CannonMenuItem`'s own `get_DeployMode`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1681 pub unsafe fn get_deploy_mode(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
1682 let __mi = Self::get_deploy_mode_method_info();
1683 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode =
1684 ::core::mem::transmute(__mi.method_ptr);
1685 __inner(this.into(), ::core::option::Option::None)
1686 }
1687
1688 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_CannonMenuItem`'s own `get_IsForecast`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1689 pub unsafe fn get_is_forecast(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
1690 let __mi = Self::get_is_forecast_method_info();
1691 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
1692 __inner(this.into(), ::core::option::Option::None)
1693 }
1694
1695 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_CannonMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1696 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1697 let __mi = Self::get_name_method_info();
1698 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1699 __inner(this.into(), ::core::option::Option::None)
1700 }
1701
1702 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_CannonMenuItem`'s own `GetCommandHelp`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1703 pub unsafe fn get_command_help(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1704 let __mi = Self::get_command_help_method_info();
1705 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1706 __inner(this.into(), ::core::option::Option::None)
1707 }
1708
1709 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_CannonMenuItem`'s own `GetMapAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1710 pub unsafe fn get_map_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
1711 let __mi = Self::get_map_attribute_method_info();
1712 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
1713 ::core::mem::transmute(__mi.method_ptr);
1714 __inner(this.into(), ::core::option::Option::None)
1715 }
1716
1717 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_CannonMenuItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1718 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
1719 let __mi = Self::a_call_method_info();
1720 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
1721 ::core::mem::transmute(__mi.method_ptr);
1722 __inner(this.into(), ::core::option::Option::None)
1723 }
1724}
1725
1726#[cfg(feature = "app-mapunitcommandmenu")]
1727impl MapUnitCommandMenu_CannonMenuItem {
1728 #[doc = "`.ctor()` — no args"]
1729 pub fn new() -> Self {
1730 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1731 panic!(
1732 "{}
1733::{}
1734 failed to instantiate",
1735 ::core::stringify!(MapUnitCommandMenu_CannonMenuItem),
1736 ::core::stringify!(new),
1737 )
1738 });
1739 <Self as IMapUnitCommandMenu_CannonMenuItemMethods>::ctor(this);
1740 this
1741 }
1742}
1743
1744#[cfg(feature = "app-mapunitcommandmenu")]
1745pub trait IMapUnitCommandMenu_NoCancelFixedMenuItemMethods: IMapUnitCommandMenu_NoCancelFixedMenuItem {
1746 #[doc = "`BCall()` overload"]
1747 fn b_call(self) -> crate::app::basicmenu::BasicMenu_Result {
1748 unsafe {
1749 let __receiver = <MapUnitCommandMenu_NoCancelFixedMenuItem as ::unity::FromIlInstance>::from_il_instance(
1750 <Self as ::unity::SystemObject>::as_instance(self),
1751 );
1752 {
1753 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1754 let __vi = *__vt.get(19usize).unwrap_or_else(|| {
1755 panic!(
1756 "unity: virtual slot {}
1757 out of range (vtable len {}
1758) on the runtime class behind {}
1759 (method `{}
1760`)",
1761 19usize,
1762 __vt.len(),
1763 <MapUnitCommandMenu_NoCancelFixedMenuItem as ::unity::ClassIdentity>::NAME,
1764 "BCall",
1765 )
1766 });
1767 let __inner: extern "C" fn(
1768 MapUnitCommandMenu_NoCancelFixedMenuItem,
1769 ::unity::OptionalMethod,
1770 ) -> crate::app::basicmenu::BasicMenu_Result = ::core::mem::transmute(__vi.method_ptr);
1771 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1772 __inner(__receiver, __mi)
1773 }
1774 }
1775 }
1776 #[doc = "`.ctor()` overload"]
1777 fn ctor(self) -> () {
1778 unsafe {
1779 let __receiver = <MapUnitCommandMenu_NoCancelFixedMenuItem as ::unity::FromIlInstance>::from_il_instance(
1780 <Self as ::unity::SystemObject>::as_instance(self),
1781 );
1782 ::unity::il2cpp_call!((::unity::module_base()+0x1e4f9e0usize)as*mut u8,();
1783(MapUnitCommandMenu_NoCancelFixedMenuItem)__receiver)
1784 }
1785 }
1786}
1787
1788#[cfg(feature = "app-mapunitcommandmenu")]
1789impl<__T: IMapUnitCommandMenu_NoCancelFixedMenuItem> IMapUnitCommandMenu_NoCancelFixedMenuItemMethods for __T {}
1790
1791#[cfg(feature = "app-mapunitcommandmenu")]
1792impl MapUnitCommandMenu_NoCancelFixedMenuItem {
1793 pub fn b_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1794 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1795 }
1796
1797 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1798 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1799 }
1800}
1801
1802#[cfg(feature = "app-mapunitcommandmenu")]
1803impl MapUnitCommandMenu_NoCancelFixedMenuItem {
1804 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_NoCancelFixedMenuItem`'s own `BCall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1805 pub unsafe fn b_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
1806 let __mi = Self::b_call_method_info();
1807 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
1808 ::core::mem::transmute(__mi.method_ptr);
1809 __inner(this.into(), ::core::option::Option::None)
1810 }
1811}
1812
1813#[cfg(feature = "app-mapunitcommandmenu")]
1814impl MapUnitCommandMenu_NoCancelFixedMenuItem {
1815 #[doc = "`.ctor()` — no args"]
1816 pub fn new() -> Self {
1817 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1818 panic!(
1819 "{}
1820::{}
1821 failed to instantiate",
1822 ::core::stringify!(MapUnitCommandMenu_NoCancelFixedMenuItem),
1823 ::core::stringify!(new),
1824 )
1825 });
1826 <Self as IMapUnitCommandMenu_NoCancelFixedMenuItemMethods>::ctor(this);
1827 this
1828 }
1829}
1830
1831#[cfg(feature = "app-mapunitcommandmenu")]
1832pub trait IMapUnitCommandMenu_EngageStartMenuItemMethods: IMapUnitCommandMenu_EngageStartMenuItem {
1833 #[doc = "`get_FlagID()` overload"]
1834 fn get_flag_id(self) -> ::unity::Il2CppString {
1835 unsafe {
1836 let __receiver = <MapUnitCommandMenu_EngageStartMenuItem as ::unity::FromIlInstance>::from_il_instance(
1837 <Self as ::unity::SystemObject>::as_instance(self),
1838 );
1839 {
1840 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1841 let __vi = *__vt.get(27usize).unwrap_or_else(|| {
1842 panic!(
1843 "unity: virtual slot {}
1844 out of range (vtable len {}
1845) on the runtime class behind {}
1846 (method `{}
1847`)",
1848 27usize,
1849 __vt.len(),
1850 <MapUnitCommandMenu_EngageStartMenuItem as ::unity::ClassIdentity>::NAME,
1851 "get_FlagID",
1852 )
1853 });
1854 let __inner: extern "C" fn(MapUnitCommandMenu_EngageStartMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1855 ::core::mem::transmute(__vi.method_ptr);
1856 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1857 __inner(__receiver, __mi)
1858 }
1859 }
1860 }
1861 #[doc = "`get_Label()` overload"]
1862 fn get_label(self) -> crate::app::mapsequencehuman::MapSequenceHuman_Label {
1863 unsafe {
1864 let __receiver = <MapUnitCommandMenu_EngageStartMenuItem as ::unity::FromIlInstance>::from_il_instance(
1865 <Self as ::unity::SystemObject>::as_instance(self),
1866 );
1867 {
1868 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1869 let __vi = *__vt.get(36usize).unwrap_or_else(|| {
1870 panic!(
1871 "unity: virtual slot {}
1872 out of range (vtable len {}
1873) on the runtime class behind {}
1874 (method `{}
1875`)",
1876 36usize,
1877 __vt.len(),
1878 <MapUnitCommandMenu_EngageStartMenuItem as ::unity::ClassIdentity>::NAME,
1879 "get_Label",
1880 )
1881 });
1882 let __inner: extern "C" fn(
1883 MapUnitCommandMenu_EngageStartMenuItem,
1884 ::unity::OptionalMethod,
1885 ) -> crate::app::mapsequencehuman::MapSequenceHuman_Label = ::core::mem::transmute(__vi.method_ptr);
1886 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1887 __inner(__receiver, __mi)
1888 }
1889 }
1890 }
1891 #[doc = "`get_Mind()` overload"]
1892 fn get_mind(self) -> crate::app::mapmind::MapMind_Type {
1893 unsafe {
1894 let __receiver = <MapUnitCommandMenu_EngageStartMenuItem as ::unity::FromIlInstance>::from_il_instance(
1895 <Self as ::unity::SystemObject>::as_instance(self),
1896 );
1897 {
1898 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1899 let __vi = *__vt.get(37usize).unwrap_or_else(|| {
1900 panic!(
1901 "unity: virtual slot {}
1902 out of range (vtable len {}
1903) on the runtime class behind {}
1904 (method `{}
1905`)",
1906 37usize,
1907 __vt.len(),
1908 <MapUnitCommandMenu_EngageStartMenuItem as ::unity::ClassIdentity>::NAME,
1909 "get_Mind",
1910 )
1911 });
1912 let __inner: extern "C" fn(MapUnitCommandMenu_EngageStartMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
1913 ::core::mem::transmute(__vi.method_ptr);
1914 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1915 __inner(__receiver, __mi)
1916 }
1917 }
1918 }
1919 #[doc = "`GetName()` overload"]
1920 fn get_name(self) -> ::unity::Il2CppString {
1921 unsafe {
1922 let __receiver = <MapUnitCommandMenu_EngageStartMenuItem as ::unity::FromIlInstance>::from_il_instance(
1923 <Self as ::unity::SystemObject>::as_instance(self),
1924 );
1925 {
1926 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1927 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
1928 panic!(
1929 "unity: virtual slot {}
1930 out of range (vtable len {}
1931) on the runtime class behind {}
1932 (method `{}
1933`)",
1934 4usize,
1935 __vt.len(),
1936 <MapUnitCommandMenu_EngageStartMenuItem as ::unity::ClassIdentity>::NAME,
1937 "GetName",
1938 )
1939 });
1940 let __inner: extern "C" fn(MapUnitCommandMenu_EngageStartMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1941 ::core::mem::transmute(__vi.method_ptr);
1942 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1943 __inner(__receiver, __mi)
1944 }
1945 }
1946 }
1947 #[doc = "`GetCommandHelp()` overload"]
1948 fn get_command_help(self) -> ::unity::Il2CppString {
1949 unsafe {
1950 let __receiver = <MapUnitCommandMenu_EngageStartMenuItem as ::unity::FromIlInstance>::from_il_instance(
1951 <Self as ::unity::SystemObject>::as_instance(self),
1952 );
1953 {
1954 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1955 let __vi = *__vt.get(34usize).unwrap_or_else(|| {
1956 panic!(
1957 "unity: virtual slot {}
1958 out of range (vtable len {}
1959) on the runtime class behind {}
1960 (method `{}
1961`)",
1962 34usize,
1963 __vt.len(),
1964 <MapUnitCommandMenu_EngageStartMenuItem as ::unity::ClassIdentity>::NAME,
1965 "GetCommandHelp",
1966 )
1967 });
1968 let __inner: extern "C" fn(MapUnitCommandMenu_EngageStartMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1969 ::core::mem::transmute(__vi.method_ptr);
1970 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1971 __inner(__receiver, __mi)
1972 }
1973 }
1974 }
1975 #[doc = "`GetMapAttribute()` overload"]
1976 fn get_map_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
1977 unsafe {
1978 let __receiver = <MapUnitCommandMenu_EngageStartMenuItem as ::unity::FromIlInstance>::from_il_instance(
1979 <Self as ::unity::SystemObject>::as_instance(self),
1980 );
1981 {
1982 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1983 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
1984 panic!(
1985 "unity: virtual slot {}
1986 out of range (vtable len {}
1987) on the runtime class behind {}
1988 (method `{}
1989`)",
1990 29usize,
1991 __vt.len(),
1992 <MapUnitCommandMenu_EngageStartMenuItem as ::unity::ClassIdentity>::NAME,
1993 "GetMapAttribute",
1994 )
1995 });
1996 let __inner: extern "C" fn(
1997 MapUnitCommandMenu_EngageStartMenuItem,
1998 ::unity::OptionalMethod,
1999 ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
2000 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2001 __inner(__receiver, __mi)
2002 }
2003 }
2004 }
2005 #[doc = "`.ctor()` overload"]
2006 fn ctor(self) -> () {
2007 unsafe {
2008 let __receiver = <MapUnitCommandMenu_EngageStartMenuItem as ::unity::FromIlInstance>::from_il_instance(
2009 <Self as ::unity::SystemObject>::as_instance(self),
2010 );
2011 ::unity::il2cpp_call!((::unity::module_base()+0x1e4e310usize)as*mut u8,();
2012(MapUnitCommandMenu_EngageStartMenuItem)__receiver)
2013 }
2014 }
2015}
2016
2017#[cfg(feature = "app-mapunitcommandmenu")]
2018impl<__T: IMapUnitCommandMenu_EngageStartMenuItem> IMapUnitCommandMenu_EngageStartMenuItemMethods for __T {}
2019
2020#[cfg(feature = "app-mapunitcommandmenu")]
2021impl MapUnitCommandMenu_EngageStartMenuItem {
2022 pub fn get_flag_id_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2023 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2024 }
2025
2026 pub fn get_label_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2027 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2028 }
2029
2030 pub fn get_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2031 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2032 }
2033
2034 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2035 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
2036 }
2037
2038 pub fn get_command_help_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2039 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
2040 }
2041
2042 pub fn get_map_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2043 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
2044 }
2045
2046 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2047 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
2048 }
2049}
2050
2051#[cfg(feature = "app-mapunitcommandmenu")]
2052impl MapUnitCommandMenu_EngageStartMenuItem {
2053 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageStartMenuItem`'s own `get_FlagID`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2054 pub unsafe fn get_flag_id(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2055 let __mi = Self::get_flag_id_method_info();
2056 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2057 __inner(this.into(), ::core::option::Option::None)
2058 }
2059
2060 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageStartMenuItem`'s own `get_Label`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2061 pub unsafe fn get_label(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapsequencehuman::MapSequenceHuman_Label {
2062 let __mi = Self::get_label_method_info();
2063 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapsequencehuman::MapSequenceHuman_Label =
2064 ::core::mem::transmute(__mi.method_ptr);
2065 __inner(this.into(), ::core::option::Option::None)
2066 }
2067
2068 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageStartMenuItem`'s own `get_Mind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2069 pub unsafe fn get_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
2070 let __mi = Self::get_mind_method_info();
2071 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
2072 ::core::mem::transmute(__mi.method_ptr);
2073 __inner(this.into(), ::core::option::Option::None)
2074 }
2075
2076 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageStartMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2077 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2078 let __mi = Self::get_name_method_info();
2079 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2080 __inner(this.into(), ::core::option::Option::None)
2081 }
2082
2083 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageStartMenuItem`'s own `GetCommandHelp`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2084 pub unsafe fn get_command_help(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2085 let __mi = Self::get_command_help_method_info();
2086 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2087 __inner(this.into(), ::core::option::Option::None)
2088 }
2089
2090 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageStartMenuItem`'s own `GetMapAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2091 pub unsafe fn get_map_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
2092 let __mi = Self::get_map_attribute_method_info();
2093 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
2094 ::core::mem::transmute(__mi.method_ptr);
2095 __inner(this.into(), ::core::option::Option::None)
2096 }
2097}
2098
2099#[cfg(feature = "app-mapunitcommandmenu")]
2100impl MapUnitCommandMenu_EngageStartMenuItem {
2101 #[doc = "`.ctor()` — no args"]
2102 pub fn new() -> Self {
2103 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2104 panic!(
2105 "{}
2106::{}
2107 failed to instantiate",
2108 ::core::stringify!(MapUnitCommandMenu_EngageStartMenuItem),
2109 ::core::stringify!(new),
2110 )
2111 });
2112 <Self as IMapUnitCommandMenu_EngageStartMenuItemMethods>::ctor(this);
2113 this
2114 }
2115}
2116
2117#[cfg(feature = "app-mapunitcommandmenu")]
2118pub trait IMapUnitCommandMenu_VisitMenuItemMethods: IMapUnitCommandMenu_VisitMenuItem {
2119 #[doc = "`OnBuild()` overload"]
2120 fn on_build(self) -> () {
2121 unsafe {
2122 let __receiver =
2123 <MapUnitCommandMenu_VisitMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2124 {
2125 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2126 let __vi = *__vt.get(10usize).unwrap_or_else(|| {
2127 panic!(
2128 "unity: virtual slot {}
2129 out of range (vtable len {}
2130) on the runtime class behind {}
2131 (method `{}
2132`)",
2133 10usize,
2134 __vt.len(),
2135 <MapUnitCommandMenu_VisitMenuItem as ::unity::ClassIdentity>::NAME,
2136 "OnBuild",
2137 )
2138 });
2139 let __inner: extern "C" fn(MapUnitCommandMenu_VisitMenuItem, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
2140 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2141 __inner(__receiver, __mi)
2142 }
2143 }
2144 }
2145 #[doc = "`OnBuildMenuItemContent()` overload"]
2146 fn on_build_menu_item_content(self) -> () {
2147 unsafe {
2148 let __receiver =
2149 <MapUnitCommandMenu_VisitMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2150 {
2151 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2152 let __vi = *__vt.get(11usize).unwrap_or_else(|| {
2153 panic!(
2154 "unity: virtual slot {}
2155 out of range (vtable len {}
2156) on the runtime class behind {}
2157 (method `{}
2158`)",
2159 11usize,
2160 __vt.len(),
2161 <MapUnitCommandMenu_VisitMenuItem as ::unity::ClassIdentity>::NAME,
2162 "OnBuildMenuItemContent",
2163 )
2164 });
2165 let __inner: extern "C" fn(MapUnitCommandMenu_VisitMenuItem, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
2166 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2167 __inner(__receiver, __mi)
2168 }
2169 }
2170 }
2171 #[doc = "`get_FlagID()` overload"]
2172 fn get_flag_id(self) -> ::unity::Il2CppString {
2173 unsafe {
2174 let __receiver =
2175 <MapUnitCommandMenu_VisitMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2176 {
2177 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2178 let __vi = *__vt.get(27usize).unwrap_or_else(|| {
2179 panic!(
2180 "unity: virtual slot {}
2181 out of range (vtable len {}
2182) on the runtime class behind {}
2183 (method `{}
2184`)",
2185 27usize,
2186 __vt.len(),
2187 <MapUnitCommandMenu_VisitMenuItem as ::unity::ClassIdentity>::NAME,
2188 "get_FlagID",
2189 )
2190 });
2191 let __inner: extern "C" fn(MapUnitCommandMenu_VisitMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
2192 ::core::mem::transmute(__vi.method_ptr);
2193 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2194 __inner(__receiver, __mi)
2195 }
2196 }
2197 }
2198 #[doc = "`GetName()` overload"]
2199 fn get_name(self) -> ::unity::Il2CppString {
2200 unsafe {
2201 let __receiver =
2202 <MapUnitCommandMenu_VisitMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2203 {
2204 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2205 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
2206 panic!(
2207 "unity: virtual slot {}
2208 out of range (vtable len {}
2209) on the runtime class behind {}
2210 (method `{}
2211`)",
2212 4usize,
2213 __vt.len(),
2214 <MapUnitCommandMenu_VisitMenuItem as ::unity::ClassIdentity>::NAME,
2215 "GetName",
2216 )
2217 });
2218 let __inner: extern "C" fn(MapUnitCommandMenu_VisitMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
2219 ::core::mem::transmute(__vi.method_ptr);
2220 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2221 __inner(__receiver, __mi)
2222 }
2223 }
2224 }
2225 #[doc = "`GetCommandHelp()` overload"]
2226 fn get_command_help(self) -> ::unity::Il2CppString {
2227 unsafe {
2228 let __receiver =
2229 <MapUnitCommandMenu_VisitMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2230 {
2231 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2232 let __vi = *__vt.get(34usize).unwrap_or_else(|| {
2233 panic!(
2234 "unity: virtual slot {}
2235 out of range (vtable len {}
2236) on the runtime class behind {}
2237 (method `{}
2238`)",
2239 34usize,
2240 __vt.len(),
2241 <MapUnitCommandMenu_VisitMenuItem as ::unity::ClassIdentity>::NAME,
2242 "GetCommandHelp",
2243 )
2244 });
2245 let __inner: extern "C" fn(MapUnitCommandMenu_VisitMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
2246 ::core::mem::transmute(__vi.method_ptr);
2247 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2248 __inner(__receiver, __mi)
2249 }
2250 }
2251 }
2252 #[doc = "`GetMapAttribute()` overload"]
2253 fn get_map_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
2254 unsafe {
2255 let __receiver =
2256 <MapUnitCommandMenu_VisitMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2257 {
2258 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2259 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
2260 panic!(
2261 "unity: virtual slot {}
2262 out of range (vtable len {}
2263) on the runtime class behind {}
2264 (method `{}
2265`)",
2266 29usize,
2267 __vt.len(),
2268 <MapUnitCommandMenu_VisitMenuItem as ::unity::ClassIdentity>::NAME,
2269 "GetMapAttribute",
2270 )
2271 });
2272 let __inner: extern "C" fn(
2273 MapUnitCommandMenu_VisitMenuItem,
2274 ::unity::OptionalMethod,
2275 ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
2276 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2277 __inner(__receiver, __mi)
2278 }
2279 }
2280 }
2281 #[doc = "`ACall()` overload"]
2282 fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
2283 unsafe {
2284 let __receiver =
2285 <MapUnitCommandMenu_VisitMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2286 {
2287 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2288 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
2289 panic!(
2290 "unity: virtual slot {}
2291 out of range (vtable len {}
2292) on the runtime class behind {}
2293 (method `{}
2294`)",
2295 18usize,
2296 __vt.len(),
2297 <MapUnitCommandMenu_VisitMenuItem as ::unity::ClassIdentity>::NAME,
2298 "ACall",
2299 )
2300 });
2301 let __inner: extern "C" fn(MapUnitCommandMenu_VisitMenuItem, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
2302 ::core::mem::transmute(__vi.method_ptr);
2303 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2304 __inner(__receiver, __mi)
2305 }
2306 }
2307 }
2308 #[doc = "`.ctor()` overload"]
2309 fn ctor(self) -> () {
2310 unsafe {
2311 let __receiver =
2312 <MapUnitCommandMenu_VisitMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2313 ::unity::il2cpp_call!((::unity::module_base()+0x1e53280usize)as*mut u8,();
2314(MapUnitCommandMenu_VisitMenuItem)__receiver)
2315 }
2316 }
2317}
2318
2319#[cfg(feature = "app-mapunitcommandmenu")]
2320impl<__T: IMapUnitCommandMenu_VisitMenuItem> IMapUnitCommandMenu_VisitMenuItemMethods for __T {}
2321
2322#[cfg(feature = "app-mapunitcommandmenu")]
2323impl MapUnitCommandMenu_VisitMenuItem {
2324 pub fn on_build_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2325 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2326 }
2327
2328 pub fn on_build_menu_item_content_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2329 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2330 }
2331
2332 pub fn get_flag_id_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2333 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2334 }
2335
2336 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2337 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
2338 }
2339
2340 pub fn get_command_help_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2341 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
2342 }
2343
2344 pub fn get_map_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2345 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
2346 }
2347
2348 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2349 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
2350 }
2351
2352 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2353 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
2354 }
2355}
2356
2357#[cfg(feature = "app-mapunitcommandmenu")]
2358impl MapUnitCommandMenu_VisitMenuItem {
2359 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_VisitMenuItem`'s own `OnBuild`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2360 pub unsafe fn on_build(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
2361 let __mi = Self::on_build_method_info();
2362 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
2363 __inner(this.into(), ::core::option::Option::None)
2364 }
2365
2366 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_VisitMenuItem`'s own `OnBuildMenuItemContent`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2367 pub unsafe fn on_build_menu_item_content(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
2368 let __mi = Self::on_build_menu_item_content_method_info();
2369 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
2370 __inner(this.into(), ::core::option::Option::None)
2371 }
2372
2373 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_VisitMenuItem`'s own `get_FlagID`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2374 pub unsafe fn get_flag_id(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2375 let __mi = Self::get_flag_id_method_info();
2376 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2377 __inner(this.into(), ::core::option::Option::None)
2378 }
2379
2380 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_VisitMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2381 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2382 let __mi = Self::get_name_method_info();
2383 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2384 __inner(this.into(), ::core::option::Option::None)
2385 }
2386
2387 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_VisitMenuItem`'s own `GetCommandHelp`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2388 pub unsafe fn get_command_help(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2389 let __mi = Self::get_command_help_method_info();
2390 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2391 __inner(this.into(), ::core::option::Option::None)
2392 }
2393
2394 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_VisitMenuItem`'s own `GetMapAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2395 pub unsafe fn get_map_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
2396 let __mi = Self::get_map_attribute_method_info();
2397 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
2398 ::core::mem::transmute(__mi.method_ptr);
2399 __inner(this.into(), ::core::option::Option::None)
2400 }
2401
2402 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_VisitMenuItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2403 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
2404 let __mi = Self::a_call_method_info();
2405 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
2406 ::core::mem::transmute(__mi.method_ptr);
2407 __inner(this.into(), ::core::option::Option::None)
2408 }
2409}
2410
2411#[cfg(feature = "app-mapunitcommandmenu")]
2412impl MapUnitCommandMenu_VisitMenuItem {
2413 #[doc = "`.ctor()` — no args"]
2414 pub fn new() -> Self {
2415 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2416 panic!(
2417 "{}
2418::{}
2419 failed to instantiate",
2420 ::core::stringify!(MapUnitCommandMenu_VisitMenuItem),
2421 ::core::stringify!(new),
2422 )
2423 });
2424 <Self as IMapUnitCommandMenu_VisitMenuItemMethods>::ctor(this);
2425 this
2426 }
2427}
2428
2429#[cfg(feature = "app-mapunitcommandmenu")]
2430pub trait IMapUnitCommandMenu_OverlapSkillMenuItemMethods: IMapUnitCommandMenu_OverlapSkillMenuItem {
2431 #[doc = "`get_FlagID()` overload"]
2432 fn get_flag_id(self) -> ::unity::Il2CppString {
2433 unsafe {
2434 let __receiver = <MapUnitCommandMenu_OverlapSkillMenuItem as ::unity::FromIlInstance>::from_il_instance(
2435 <Self as ::unity::SystemObject>::as_instance(self),
2436 );
2437 {
2438 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2439 let __vi = *__vt.get(27usize).unwrap_or_else(|| {
2440 panic!(
2441 "unity: virtual slot {}
2442 out of range (vtable len {}
2443) on the runtime class behind {}
2444 (method `{}
2445`)",
2446 27usize,
2447 __vt.len(),
2448 <MapUnitCommandMenu_OverlapSkillMenuItem as ::unity::ClassIdentity>::NAME,
2449 "get_FlagID",
2450 )
2451 });
2452 let __inner: extern "C" fn(MapUnitCommandMenu_OverlapSkillMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
2453 ::core::mem::transmute(__vi.method_ptr);
2454 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2455 __inner(__receiver, __mi)
2456 }
2457 }
2458 }
2459 #[doc = "`.ctor(crate::app::skilldata::SkillData)` overload"]
2460 fn ctor(self, skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>) -> () {
2461 unsafe {
2462 let __receiver = <MapUnitCommandMenu_OverlapSkillMenuItem as ::unity::FromIlInstance>::from_il_instance(
2463 <Self as ::unity::SystemObject>::as_instance(self),
2464 );
2465 ::unity::il2cpp_call!((::unity::module_base()+0x1e4fc20usize)as*mut u8,();
2466(MapUnitCommandMenu_OverlapSkillMenuItem)__receiver,(crate::app::skilldata::SkillData)::core::convert::Into::into(skill))
2467 }
2468 }
2469 #[doc = "`OnBuild()` overload"]
2470 fn on_build(self) -> () {
2471 unsafe {
2472 let __receiver = <MapUnitCommandMenu_OverlapSkillMenuItem as ::unity::FromIlInstance>::from_il_instance(
2473 <Self as ::unity::SystemObject>::as_instance(self),
2474 );
2475 {
2476 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2477 let __vi = *__vt.get(10usize).unwrap_or_else(|| {
2478 panic!(
2479 "unity: virtual slot {}
2480 out of range (vtable len {}
2481) on the runtime class behind {}
2482 (method `{}
2483`)",
2484 10usize,
2485 __vt.len(),
2486 <MapUnitCommandMenu_OverlapSkillMenuItem as ::unity::ClassIdentity>::NAME,
2487 "OnBuild",
2488 )
2489 });
2490 let __inner: extern "C" fn(MapUnitCommandMenu_OverlapSkillMenuItem, ::unity::OptionalMethod) -> () =
2491 ::core::mem::transmute(__vi.method_ptr);
2492 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2493 __inner(__receiver, __mi)
2494 }
2495 }
2496 }
2497 #[doc = "`OnSelect()` overload"]
2498 fn on_select(self) -> () {
2499 unsafe {
2500 let __receiver = <MapUnitCommandMenu_OverlapSkillMenuItem as ::unity::FromIlInstance>::from_il_instance(
2501 <Self as ::unity::SystemObject>::as_instance(self),
2502 );
2503 {
2504 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2505 let __vi = *__vt.get(12usize).unwrap_or_else(|| {
2506 panic!(
2507 "unity: virtual slot {}
2508 out of range (vtable len {}
2509) on the runtime class behind {}
2510 (method `{}
2511`)",
2512 12usize,
2513 __vt.len(),
2514 <MapUnitCommandMenu_OverlapSkillMenuItem as ::unity::ClassIdentity>::NAME,
2515 "OnSelect",
2516 )
2517 });
2518 let __inner: extern "C" fn(MapUnitCommandMenu_OverlapSkillMenuItem, ::unity::OptionalMethod) -> () =
2519 ::core::mem::transmute(__vi.method_ptr);
2520 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2521 __inner(__receiver, __mi)
2522 }
2523 }
2524 }
2525 #[doc = "`OnDeselect()` overload"]
2526 fn on_deselect(self) -> () {
2527 unsafe {
2528 let __receiver = <MapUnitCommandMenu_OverlapSkillMenuItem as ::unity::FromIlInstance>::from_il_instance(
2529 <Self as ::unity::SystemObject>::as_instance(self),
2530 );
2531 {
2532 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2533 let __vi = *__vt.get(13usize).unwrap_or_else(|| {
2534 panic!(
2535 "unity: virtual slot {}
2536 out of range (vtable len {}
2537) on the runtime class behind {}
2538 (method `{}
2539`)",
2540 13usize,
2541 __vt.len(),
2542 <MapUnitCommandMenu_OverlapSkillMenuItem as ::unity::ClassIdentity>::NAME,
2543 "OnDeselect",
2544 )
2545 });
2546 let __inner: extern "C" fn(MapUnitCommandMenu_OverlapSkillMenuItem, ::unity::OptionalMethod) -> () =
2547 ::core::mem::transmute(__vi.method_ptr);
2548 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2549 __inner(__receiver, __mi)
2550 }
2551 }
2552 }
2553 #[doc = "`OnCursorMoveEnd()` overload"]
2554 fn on_cursor_move_end(self) -> () {
2555 unsafe {
2556 let __receiver = <MapUnitCommandMenu_OverlapSkillMenuItem as ::unity::FromIlInstance>::from_il_instance(
2557 <Self as ::unity::SystemObject>::as_instance(self),
2558 );
2559 {
2560 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2561 let __vi = *__vt.get(14usize).unwrap_or_else(|| {
2562 panic!(
2563 "unity: virtual slot {}
2564 out of range (vtable len {}
2565) on the runtime class behind {}
2566 (method `{}
2567`)",
2568 14usize,
2569 __vt.len(),
2570 <MapUnitCommandMenu_OverlapSkillMenuItem as ::unity::ClassIdentity>::NAME,
2571 "OnCursorMoveEnd",
2572 )
2573 });
2574 let __inner: extern "C" fn(MapUnitCommandMenu_OverlapSkillMenuItem, ::unity::OptionalMethod) -> () =
2575 ::core::mem::transmute(__vi.method_ptr);
2576 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2577 __inner(__receiver, __mi)
2578 }
2579 }
2580 }
2581 #[doc = "`GetName()` overload"]
2582 fn get_name(self) -> ::unity::Il2CppString {
2583 unsafe {
2584 let __receiver = <MapUnitCommandMenu_OverlapSkillMenuItem as ::unity::FromIlInstance>::from_il_instance(
2585 <Self as ::unity::SystemObject>::as_instance(self),
2586 );
2587 {
2588 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2589 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
2590 panic!(
2591 "unity: virtual slot {}
2592 out of range (vtable len {}
2593) on the runtime class behind {}
2594 (method `{}
2595`)",
2596 4usize,
2597 __vt.len(),
2598 <MapUnitCommandMenu_OverlapSkillMenuItem as ::unity::ClassIdentity>::NAME,
2599 "GetName",
2600 )
2601 });
2602 let __inner: extern "C" fn(MapUnitCommandMenu_OverlapSkillMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
2603 ::core::mem::transmute(__vi.method_ptr);
2604 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2605 __inner(__receiver, __mi)
2606 }
2607 }
2608 }
2609 #[doc = "`GetCommandHelp()` overload"]
2610 fn get_command_help(self) -> ::unity::Il2CppString {
2611 unsafe {
2612 let __receiver = <MapUnitCommandMenu_OverlapSkillMenuItem as ::unity::FromIlInstance>::from_il_instance(
2613 <Self as ::unity::SystemObject>::as_instance(self),
2614 );
2615 {
2616 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2617 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
2618 panic!(
2619 "unity: virtual slot {}
2620 out of range (vtable len {}
2621) on the runtime class behind {}
2622 (method `{}
2623`)",
2624 30usize,
2625 __vt.len(),
2626 <MapUnitCommandMenu_OverlapSkillMenuItem as ::unity::ClassIdentity>::NAME,
2627 "GetCommandHelp",
2628 )
2629 });
2630 let __inner: extern "C" fn(MapUnitCommandMenu_OverlapSkillMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
2631 ::core::mem::transmute(__vi.method_ptr);
2632 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2633 __inner(__receiver, __mi)
2634 }
2635 }
2636 }
2637 #[doc = "`SetupHelpText()` overload"]
2638 fn setup_help_text(self) -> () {
2639 unsafe {
2640 let __receiver = <MapUnitCommandMenu_OverlapSkillMenuItem as ::unity::FromIlInstance>::from_il_instance(
2641 <Self as ::unity::SystemObject>::as_instance(self),
2642 );
2643 ::unity::il2cpp_call!((::unity::module_base()+0x1e4fc90usize)as*mut u8,();
2644(MapUnitCommandMenu_OverlapSkillMenuItem)__receiver)
2645 }
2646 }
2647 #[doc = "`Enumerate(crate::app::skilldata::SkillData)` overload"]
2648 fn enumerate(self, skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>) -> i32 {
2649 unsafe {
2650 let __receiver = <MapUnitCommandMenu_OverlapSkillMenuItem as ::unity::FromIlInstance>::from_il_instance(
2651 <Self as ::unity::SystemObject>::as_instance(self),
2652 );
2653 ::unity::il2cpp_call!((::unity::module_base()+0x1e4ff00usize)as*mut u8,i32;
2654(MapUnitCommandMenu_OverlapSkillMenuItem)__receiver,(crate::app::skilldata::SkillData)::core::convert::Into::into(skill))
2655 }
2656 }
2657 #[doc = "`GetMapAttribute()` overload"]
2658 fn get_map_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
2659 unsafe {
2660 let __receiver = <MapUnitCommandMenu_OverlapSkillMenuItem as ::unity::FromIlInstance>::from_il_instance(
2661 <Self as ::unity::SystemObject>::as_instance(self),
2662 );
2663 {
2664 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2665 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
2666 panic!(
2667 "unity: virtual slot {}
2668 out of range (vtable len {}
2669) on the runtime class behind {}
2670 (method `{}
2671`)",
2672 29usize,
2673 __vt.len(),
2674 <MapUnitCommandMenu_OverlapSkillMenuItem as ::unity::ClassIdentity>::NAME,
2675 "GetMapAttribute",
2676 )
2677 });
2678 let __inner: extern "C" fn(
2679 MapUnitCommandMenu_OverlapSkillMenuItem,
2680 ::unity::OptionalMethod,
2681 ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
2682 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2683 __inner(__receiver, __mi)
2684 }
2685 }
2686 }
2687 #[doc = "`ACall()` overload"]
2688 fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
2689 unsafe {
2690 let __receiver = <MapUnitCommandMenu_OverlapSkillMenuItem as ::unity::FromIlInstance>::from_il_instance(
2691 <Self as ::unity::SystemObject>::as_instance(self),
2692 );
2693 {
2694 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2695 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
2696 panic!(
2697 "unity: virtual slot {}
2698 out of range (vtable len {}
2699) on the runtime class behind {}
2700 (method `{}
2701`)",
2702 18usize,
2703 __vt.len(),
2704 <MapUnitCommandMenu_OverlapSkillMenuItem as ::unity::ClassIdentity>::NAME,
2705 "ACall",
2706 )
2707 });
2708 let __inner: extern "C" fn(
2709 MapUnitCommandMenu_OverlapSkillMenuItem,
2710 ::unity::OptionalMethod,
2711 ) -> crate::app::basicmenu::BasicMenu_Result = ::core::mem::transmute(__vi.method_ptr);
2712 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2713 __inner(__receiver, __mi)
2714 }
2715 }
2716 }
2717}
2718
2719#[cfg(feature = "app-mapunitcommandmenu")]
2720impl<__T: IMapUnitCommandMenu_OverlapSkillMenuItem> IMapUnitCommandMenu_OverlapSkillMenuItemMethods for __T {}
2721
2722#[cfg(feature = "app-mapunitcommandmenu")]
2723impl MapUnitCommandMenu_OverlapSkillMenuItem {
2724 pub fn get_flag_id_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2725 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2726 }
2727
2728 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2729 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2730 }
2731
2732 pub fn on_build_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2733 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2734 }
2735
2736 pub fn on_select_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2737 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
2738 }
2739
2740 pub fn on_deselect_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2741 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
2742 }
2743
2744 pub fn on_cursor_move_end_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2745 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
2746 }
2747
2748 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2749 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
2750 }
2751
2752 pub fn get_command_help_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2753 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
2754 }
2755
2756 pub fn setup_help_text_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2757 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
2758 }
2759
2760 pub fn enumerate_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2761 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
2762 }
2763
2764 pub fn get_map_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2765 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
2766 }
2767
2768 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2769 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
2770 }
2771}
2772
2773#[cfg(feature = "app-mapunitcommandmenu")]
2774impl MapUnitCommandMenu_OverlapSkillMenuItem {
2775 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_OverlapSkillMenuItem`'s own `get_FlagID`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2776 pub unsafe fn get_flag_id(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2777 let __mi = Self::get_flag_id_method_info();
2778 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2779 __inner(this.into(), ::core::option::Option::None)
2780 }
2781
2782 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_OverlapSkillMenuItem`'s own `OnBuild`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2783 pub unsafe fn on_build(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
2784 let __mi = Self::on_build_method_info();
2785 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
2786 __inner(this.into(), ::core::option::Option::None)
2787 }
2788
2789 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_OverlapSkillMenuItem`'s own `OnSelect`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2790 pub unsafe fn on_select(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
2791 let __mi = Self::on_select_method_info();
2792 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
2793 __inner(this.into(), ::core::option::Option::None)
2794 }
2795
2796 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_OverlapSkillMenuItem`'s own `OnDeselect`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2797 pub unsafe fn on_deselect(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
2798 let __mi = Self::on_deselect_method_info();
2799 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
2800 __inner(this.into(), ::core::option::Option::None)
2801 }
2802
2803 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_OverlapSkillMenuItem`'s own `OnCursorMoveEnd`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2804 pub unsafe fn on_cursor_move_end(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
2805 let __mi = Self::on_cursor_move_end_method_info();
2806 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
2807 __inner(this.into(), ::core::option::Option::None)
2808 }
2809
2810 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_OverlapSkillMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2811 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2812 let __mi = Self::get_name_method_info();
2813 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2814 __inner(this.into(), ::core::option::Option::None)
2815 }
2816
2817 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_OverlapSkillMenuItem`'s own `GetCommandHelp`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2818 pub unsafe fn get_command_help(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2819 let __mi = Self::get_command_help_method_info();
2820 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2821 __inner(this.into(), ::core::option::Option::None)
2822 }
2823
2824 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_OverlapSkillMenuItem`'s own `GetMapAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2825 pub unsafe fn get_map_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
2826 let __mi = Self::get_map_attribute_method_info();
2827 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
2828 ::core::mem::transmute(__mi.method_ptr);
2829 __inner(this.into(), ::core::option::Option::None)
2830 }
2831
2832 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_OverlapSkillMenuItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2833 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
2834 let __mi = Self::a_call_method_info();
2835 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
2836 ::core::mem::transmute(__mi.method_ptr);
2837 __inner(this.into(), ::core::option::Option::None)
2838 }
2839}
2840
2841#[cfg(feature = "app-mapunitcommandmenu")]
2842impl MapUnitCommandMenu_OverlapSkillMenuItem {
2843 #[doc = "`.ctor(crate::app::skilldata::SkillData)` — overload selector"]
2844 pub fn new(skill: crate::app::skilldata::SkillData) -> Self {
2845 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2846 panic!(
2847 "{}
2848::{}
2849 failed to instantiate",
2850 ::core::stringify!(MapUnitCommandMenu_OverlapSkillMenuItem),
2851 ::core::stringify!(new),
2852 )
2853 });
2854 <Self as IMapUnitCommandMenu_OverlapSkillMenuItemMethods>::ctor(this, skill);
2855 this
2856 }
2857}
2858
2859#[cfg(feature = "app-mapunitcommandmenu")]
2860pub trait IMapUnitCommandMenu_AttackMenuItemMethods: IMapUnitCommandMenu_AttackMenuItem {
2861 #[doc = "`get_FlagID()` overload"]
2862 fn get_flag_id(self) -> ::unity::Il2CppString {
2863 unsafe {
2864 let __receiver =
2865 <MapUnitCommandMenu_AttackMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2866 {
2867 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2868 let __vi = *__vt.get(27usize).unwrap_or_else(|| {
2869 panic!(
2870 "unity: virtual slot {}
2871 out of range (vtable len {}
2872) on the runtime class behind {}
2873 (method `{}
2874`)",
2875 27usize,
2876 __vt.len(),
2877 <MapUnitCommandMenu_AttackMenuItem as ::unity::ClassIdentity>::NAME,
2878 "get_FlagID",
2879 )
2880 });
2881 let __inner: extern "C" fn(MapUnitCommandMenu_AttackMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
2882 ::core::mem::transmute(__vi.method_ptr);
2883 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2884 __inner(__receiver, __mi)
2885 }
2886 }
2887 }
2888 #[doc = "`get_Label()` overload"]
2889 fn get_label(self) -> crate::app::mapsequencehuman::MapSequenceHuman_Label {
2890 unsafe {
2891 let __receiver =
2892 <MapUnitCommandMenu_AttackMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2893 {
2894 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2895 let __vi = *__vt.get(36usize).unwrap_or_else(|| {
2896 panic!(
2897 "unity: virtual slot {}
2898 out of range (vtable len {}
2899) on the runtime class behind {}
2900 (method `{}
2901`)",
2902 36usize,
2903 __vt.len(),
2904 <MapUnitCommandMenu_AttackMenuItem as ::unity::ClassIdentity>::NAME,
2905 "get_Label",
2906 )
2907 });
2908 let __inner: extern "C" fn(
2909 MapUnitCommandMenu_AttackMenuItem,
2910 ::unity::OptionalMethod,
2911 ) -> crate::app::mapsequencehuman::MapSequenceHuman_Label = ::core::mem::transmute(__vi.method_ptr);
2912 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2913 __inner(__receiver, __mi)
2914 }
2915 }
2916 }
2917 #[doc = "`get_ActiveMind()` overload"]
2918 fn get_active_mind(self) -> crate::app::mapmind::MapMind_Type {
2919 unsafe {
2920 let __receiver =
2921 <MapUnitCommandMenu_AttackMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2922 {
2923 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2924 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
2925 panic!(
2926 "unity: virtual slot {}
2927 out of range (vtable len {}
2928) on the runtime class behind {}
2929 (method `{}
2930`)",
2931 30usize,
2932 __vt.len(),
2933 <MapUnitCommandMenu_AttackMenuItem as ::unity::ClassIdentity>::NAME,
2934 "get_ActiveMind",
2935 )
2936 });
2937 let __inner: extern "C" fn(MapUnitCommandMenu_AttackMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
2938 ::core::mem::transmute(__vi.method_ptr);
2939 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2940 __inner(__receiver, __mi)
2941 }
2942 }
2943 }
2944 #[doc = "`get_DeployMode()` overload"]
2945 fn get_deploy_mode(self) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
2946 unsafe {
2947 let __receiver =
2948 <MapUnitCommandMenu_AttackMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2949 {
2950 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2951 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
2952 panic!(
2953 "unity: virtual slot {}
2954 out of range (vtable len {}
2955) on the runtime class behind {}
2956 (method `{}
2957`)",
2958 31usize,
2959 __vt.len(),
2960 <MapUnitCommandMenu_AttackMenuItem as ::unity::ClassIdentity>::NAME,
2961 "get_DeployMode",
2962 )
2963 });
2964 let __inner: extern "C" fn(
2965 MapUnitCommandMenu_AttackMenuItem,
2966 ::unity::OptionalMethod,
2967 ) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode = ::core::mem::transmute(__vi.method_ptr);
2968 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2969 __inner(__receiver, __mi)
2970 }
2971 }
2972 }
2973 #[doc = "`get_IsForecast()` overload"]
2974 fn get_is_forecast(self) -> bool {
2975 unsafe {
2976 let __receiver =
2977 <MapUnitCommandMenu_AttackMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2978 {
2979 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2980 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
2981 panic!(
2982 "unity: virtual slot {}
2983 out of range (vtable len {}
2984) on the runtime class behind {}
2985 (method `{}
2986`)",
2987 33usize,
2988 __vt.len(),
2989 <MapUnitCommandMenu_AttackMenuItem as ::unity::ClassIdentity>::NAME,
2990 "get_IsForecast",
2991 )
2992 });
2993 let __inner: extern "C" fn(MapUnitCommandMenu_AttackMenuItem, ::unity::OptionalMethod) -> bool =
2994 ::core::mem::transmute(__vi.method_ptr);
2995 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2996 __inner(__receiver, __mi)
2997 }
2998 }
2999 }
3000 #[doc = "`get_Mind()` overload"]
3001 fn get_mind(self) -> crate::app::mapmind::MapMind_Type {
3002 unsafe {
3003 let __receiver =
3004 <MapUnitCommandMenu_AttackMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3005 {
3006 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3007 let __vi = *__vt.get(37usize).unwrap_or_else(|| {
3008 panic!(
3009 "unity: virtual slot {}
3010 out of range (vtable len {}
3011) on the runtime class behind {}
3012 (method `{}
3013`)",
3014 37usize,
3015 __vt.len(),
3016 <MapUnitCommandMenu_AttackMenuItem as ::unity::ClassIdentity>::NAME,
3017 "get_Mind",
3018 )
3019 });
3020 let __inner: extern "C" fn(MapUnitCommandMenu_AttackMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
3021 ::core::mem::transmute(__vi.method_ptr);
3022 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3023 __inner(__receiver, __mi)
3024 }
3025 }
3026 }
3027 #[doc = "`get_ActionMask()` overload"]
3028 fn get_action_mask(self) -> crate::app::maptarget::MapTarget_ActionMask {
3029 unsafe {
3030 let __receiver =
3031 <MapUnitCommandMenu_AttackMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3032 {
3033 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3034 let __vi = *__vt.get(38usize).unwrap_or_else(|| {
3035 panic!(
3036 "unity: virtual slot {}
3037 out of range (vtable len {}
3038) on the runtime class behind {}
3039 (method `{}
3040`)",
3041 38usize,
3042 __vt.len(),
3043 <MapUnitCommandMenu_AttackMenuItem as ::unity::ClassIdentity>::NAME,
3044 "get_ActionMask",
3045 )
3046 });
3047 let __inner: extern "C" fn(
3048 MapUnitCommandMenu_AttackMenuItem,
3049 ::unity::OptionalMethod,
3050 ) -> crate::app::maptarget::MapTarget_ActionMask = ::core::mem::transmute(__vi.method_ptr);
3051 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3052 __inner(__receiver, __mi)
3053 }
3054 }
3055 }
3056 #[doc = "`GetName()` overload"]
3057 fn get_name(self) -> ::unity::Il2CppString {
3058 unsafe {
3059 let __receiver =
3060 <MapUnitCommandMenu_AttackMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3061 {
3062 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3063 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
3064 panic!(
3065 "unity: virtual slot {}
3066 out of range (vtable len {}
3067) on the runtime class behind {}
3068 (method `{}
3069`)",
3070 4usize,
3071 __vt.len(),
3072 <MapUnitCommandMenu_AttackMenuItem as ::unity::ClassIdentity>::NAME,
3073 "GetName",
3074 )
3075 });
3076 let __inner: extern "C" fn(MapUnitCommandMenu_AttackMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
3077 ::core::mem::transmute(__vi.method_ptr);
3078 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3079 __inner(__receiver, __mi)
3080 }
3081 }
3082 }
3083 #[doc = "`GetCommandHelp()` overload"]
3084 fn get_command_help(self) -> ::unity::Il2CppString {
3085 unsafe {
3086 let __receiver =
3087 <MapUnitCommandMenu_AttackMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3088 {
3089 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3090 let __vi = *__vt.get(34usize).unwrap_or_else(|| {
3091 panic!(
3092 "unity: virtual slot {}
3093 out of range (vtable len {}
3094) on the runtime class behind {}
3095 (method `{}
3096`)",
3097 34usize,
3098 __vt.len(),
3099 <MapUnitCommandMenu_AttackMenuItem as ::unity::ClassIdentity>::NAME,
3100 "GetCommandHelp",
3101 )
3102 });
3103 let __inner: extern "C" fn(MapUnitCommandMenu_AttackMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
3104 ::core::mem::transmute(__vi.method_ptr);
3105 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3106 __inner(__receiver, __mi)
3107 }
3108 }
3109 }
3110 #[doc = "`CheckBuildableWithUnit(crate::app::unit::Unit)` overload"]
3111 fn check_buildable_with_unit(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> bool {
3112 unsafe {
3113 let __receiver =
3114 <MapUnitCommandMenu_AttackMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3115 {
3116 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3117 let __vi = *__vt.get(35usize).unwrap_or_else(|| {
3118 panic!(
3119 "unity: virtual slot {}
3120 out of range (vtable len {}
3121) on the runtime class behind {}
3122 (method `{}
3123`)",
3124 35usize,
3125 __vt.len(),
3126 <MapUnitCommandMenu_AttackMenuItem as ::unity::ClassIdentity>::NAME,
3127 "CheckBuildableWithUnit",
3128 )
3129 });
3130 let __inner: extern "C" fn(MapUnitCommandMenu_AttackMenuItem, crate::app::unit::Unit, ::unity::OptionalMethod) -> bool =
3131 ::core::mem::transmute(__vi.method_ptr);
3132 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3133 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
3134 }
3135 }
3136 }
3137 #[doc = "`CanEnumerateBuild()` overload"]
3138 fn can_enumerate_build(self) -> bool {
3139 unsafe {
3140 let __receiver =
3141 <MapUnitCommandMenu_AttackMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3142 ::unity::il2cpp_call!((::unity::module_base()+0x1e484c0usize)as*mut u8,bool;
3143(MapUnitCommandMenu_AttackMenuItem)__receiver)
3144 }
3145 }
3146 #[doc = "`GetMapAttribute()` overload"]
3147 fn get_map_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
3148 unsafe {
3149 let __receiver =
3150 <MapUnitCommandMenu_AttackMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3151 {
3152 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3153 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
3154 panic!(
3155 "unity: virtual slot {}
3156 out of range (vtable len {}
3157) on the runtime class behind {}
3158 (method `{}
3159`)",
3160 29usize,
3161 __vt.len(),
3162 <MapUnitCommandMenu_AttackMenuItem as ::unity::ClassIdentity>::NAME,
3163 "GetMapAttribute",
3164 )
3165 });
3166 let __inner: extern "C" fn(
3167 MapUnitCommandMenu_AttackMenuItem,
3168 ::unity::OptionalMethod,
3169 ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
3170 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3171 __inner(__receiver, __mi)
3172 }
3173 }
3174 }
3175 #[doc = "`ACall()` overload"]
3176 fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
3177 unsafe {
3178 let __receiver =
3179 <MapUnitCommandMenu_AttackMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3180 {
3181 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3182 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
3183 panic!(
3184 "unity: virtual slot {}
3185 out of range (vtable len {}
3186) on the runtime class behind {}
3187 (method `{}
3188`)",
3189 18usize,
3190 __vt.len(),
3191 <MapUnitCommandMenu_AttackMenuItem as ::unity::ClassIdentity>::NAME,
3192 "ACall",
3193 )
3194 });
3195 let __inner: extern "C" fn(MapUnitCommandMenu_AttackMenuItem, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
3196 ::core::mem::transmute(__vi.method_ptr);
3197 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3198 __inner(__receiver, __mi)
3199 }
3200 }
3201 }
3202 #[doc = "`.ctor()` overload"]
3203 fn ctor(self) -> () {
3204 unsafe {
3205 let __receiver =
3206 <MapUnitCommandMenu_AttackMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3207 ::unity::il2cpp_call!((::unity::module_base()+0x1e48ae0usize)as*mut u8,();
3208(MapUnitCommandMenu_AttackMenuItem)__receiver)
3209 }
3210 }
3211}
3212
3213#[cfg(feature = "app-mapunitcommandmenu")]
3214impl<__T: IMapUnitCommandMenu_AttackMenuItem> IMapUnitCommandMenu_AttackMenuItemMethods for __T {}
3215
3216#[cfg(feature = "app-mapunitcommandmenu")]
3217impl MapUnitCommandMenu_AttackMenuItem {
3218 pub fn get_flag_id_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3219 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
3220 }
3221
3222 pub fn get_label_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3223 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
3224 }
3225
3226 pub fn get_active_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3227 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
3228 }
3229
3230 pub fn get_deploy_mode_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3231 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
3232 }
3233
3234 pub fn get_is_forecast_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3235 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
3236 }
3237
3238 pub fn get_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3239 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
3240 }
3241
3242 pub fn get_action_mask_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3243 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
3244 }
3245
3246 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3247 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
3248 }
3249
3250 pub fn get_command_help_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3251 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
3252 }
3253
3254 pub fn check_buildable_with_unit_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3255 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
3256 }
3257
3258 pub fn can_enumerate_build_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3259 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
3260 }
3261
3262 pub fn get_map_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3263 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
3264 }
3265
3266 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3267 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
3268 }
3269
3270 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3271 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
3272 }
3273}
3274
3275#[cfg(feature = "app-mapunitcommandmenu")]
3276impl MapUnitCommandMenu_AttackMenuItem {
3277 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_AttackMenuItem`'s own `get_FlagID`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3278 pub unsafe fn get_flag_id(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
3279 let __mi = Self::get_flag_id_method_info();
3280 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
3281 __inner(this.into(), ::core::option::Option::None)
3282 }
3283
3284 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_AttackMenuItem`'s own `get_Label`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3285 pub unsafe fn get_label(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapsequencehuman::MapSequenceHuman_Label {
3286 let __mi = Self::get_label_method_info();
3287 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapsequencehuman::MapSequenceHuman_Label =
3288 ::core::mem::transmute(__mi.method_ptr);
3289 __inner(this.into(), ::core::option::Option::None)
3290 }
3291
3292 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_AttackMenuItem`'s own `get_ActiveMind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3293 pub unsafe fn get_active_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
3294 let __mi = Self::get_active_mind_method_info();
3295 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
3296 ::core::mem::transmute(__mi.method_ptr);
3297 __inner(this.into(), ::core::option::Option::None)
3298 }
3299
3300 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_AttackMenuItem`'s own `get_DeployMode`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3301 pub unsafe fn get_deploy_mode(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
3302 let __mi = Self::get_deploy_mode_method_info();
3303 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode =
3304 ::core::mem::transmute(__mi.method_ptr);
3305 __inner(this.into(), ::core::option::Option::None)
3306 }
3307
3308 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_AttackMenuItem`'s own `get_IsForecast`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3309 pub unsafe fn get_is_forecast(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
3310 let __mi = Self::get_is_forecast_method_info();
3311 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
3312 __inner(this.into(), ::core::option::Option::None)
3313 }
3314
3315 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_AttackMenuItem`'s own `get_Mind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3316 pub unsafe fn get_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
3317 let __mi = Self::get_mind_method_info();
3318 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
3319 ::core::mem::transmute(__mi.method_ptr);
3320 __inner(this.into(), ::core::option::Option::None)
3321 }
3322
3323 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_AttackMenuItem`'s own `get_ActionMask`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3324 pub unsafe fn get_action_mask(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::maptarget::MapTarget_ActionMask {
3325 let __mi = Self::get_action_mask_method_info();
3326 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::maptarget::MapTarget_ActionMask =
3327 ::core::mem::transmute(__mi.method_ptr);
3328 __inner(this.into(), ::core::option::Option::None)
3329 }
3330
3331 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_AttackMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3332 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
3333 let __mi = Self::get_name_method_info();
3334 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
3335 __inner(this.into(), ::core::option::Option::None)
3336 }
3337
3338 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_AttackMenuItem`'s own `GetCommandHelp`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3339 pub unsafe fn get_command_help(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
3340 let __mi = Self::get_command_help_method_info();
3341 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
3342 __inner(this.into(), ::core::option::Option::None)
3343 }
3344
3345 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_AttackMenuItem`'s own `CheckBuildableWithUnit`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3346 pub unsafe fn check_buildable_with_unit(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> bool {
3347 let __mi = Self::check_buildable_with_unit_method_info();
3348 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> bool =
3349 ::core::mem::transmute(__mi.method_ptr);
3350 __inner(this.into(), unit, ::core::option::Option::None)
3351 }
3352
3353 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_AttackMenuItem`'s own `GetMapAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3354 pub unsafe fn get_map_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
3355 let __mi = Self::get_map_attribute_method_info();
3356 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
3357 ::core::mem::transmute(__mi.method_ptr);
3358 __inner(this.into(), ::core::option::Option::None)
3359 }
3360
3361 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_AttackMenuItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3362 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
3363 let __mi = Self::a_call_method_info();
3364 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
3365 ::core::mem::transmute(__mi.method_ptr);
3366 __inner(this.into(), ::core::option::Option::None)
3367 }
3368}
3369
3370#[cfg(feature = "app-mapunitcommandmenu")]
3371impl MapUnitCommandMenu_AttackMenuItem {
3372 #[doc = "`.ctor()` — no args"]
3373 pub fn new() -> Self {
3374 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
3375 panic!(
3376 "{}
3377::{}
3378 failed to instantiate",
3379 ::core::stringify!(MapUnitCommandMenu_AttackMenuItem),
3380 ::core::stringify!(new),
3381 )
3382 });
3383 <Self as IMapUnitCommandMenu_AttackMenuItemMethods>::ctor(this);
3384 this
3385 }
3386}
3387
3388#[cfg(feature = "app-mapunitcommandmenu")]
3389pub trait IMapUnitCommandMenu_EngageLinkMenuItemMethods: IMapUnitCommandMenu_EngageLinkMenuItem {
3390 #[doc = "`get_FlagID()` overload"]
3391 fn get_flag_id(self) -> ::unity::Il2CppString {
3392 unsafe {
3393 let __receiver = <MapUnitCommandMenu_EngageLinkMenuItem as ::unity::FromIlInstance>::from_il_instance(
3394 <Self as ::unity::SystemObject>::as_instance(self),
3395 );
3396 {
3397 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3398 let __vi = *__vt.get(27usize).unwrap_or_else(|| {
3399 panic!(
3400 "unity: virtual slot {}
3401 out of range (vtable len {}
3402) on the runtime class behind {}
3403 (method `{}
3404`)",
3405 27usize,
3406 __vt.len(),
3407 <MapUnitCommandMenu_EngageLinkMenuItem as ::unity::ClassIdentity>::NAME,
3408 "get_FlagID",
3409 )
3410 });
3411 let __inner: extern "C" fn(MapUnitCommandMenu_EngageLinkMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
3412 ::core::mem::transmute(__vi.method_ptr);
3413 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3414 __inner(__receiver, __mi)
3415 }
3416 }
3417 }
3418 #[doc = "`get_Label()` overload"]
3419 fn get_label(self) -> crate::app::mapsequencehuman::MapSequenceHuman_Label {
3420 unsafe {
3421 let __receiver = <MapUnitCommandMenu_EngageLinkMenuItem as ::unity::FromIlInstance>::from_il_instance(
3422 <Self as ::unity::SystemObject>::as_instance(self),
3423 );
3424 {
3425 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3426 let __vi = *__vt.get(36usize).unwrap_or_else(|| {
3427 panic!(
3428 "unity: virtual slot {}
3429 out of range (vtable len {}
3430) on the runtime class behind {}
3431 (method `{}
3432`)",
3433 36usize,
3434 __vt.len(),
3435 <MapUnitCommandMenu_EngageLinkMenuItem as ::unity::ClassIdentity>::NAME,
3436 "get_Label",
3437 )
3438 });
3439 let __inner: extern "C" fn(
3440 MapUnitCommandMenu_EngageLinkMenuItem,
3441 ::unity::OptionalMethod,
3442 ) -> crate::app::mapsequencehuman::MapSequenceHuman_Label = ::core::mem::transmute(__vi.method_ptr);
3443 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3444 __inner(__receiver, __mi)
3445 }
3446 }
3447 }
3448 #[doc = "`get_Mind()` overload"]
3449 fn get_mind(self) -> crate::app::mapmind::MapMind_Type {
3450 unsafe {
3451 let __receiver = <MapUnitCommandMenu_EngageLinkMenuItem as ::unity::FromIlInstance>::from_il_instance(
3452 <Self as ::unity::SystemObject>::as_instance(self),
3453 );
3454 {
3455 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3456 let __vi = *__vt.get(37usize).unwrap_or_else(|| {
3457 panic!(
3458 "unity: virtual slot {}
3459 out of range (vtable len {}
3460) on the runtime class behind {}
3461 (method `{}
3462`)",
3463 37usize,
3464 __vt.len(),
3465 <MapUnitCommandMenu_EngageLinkMenuItem as ::unity::ClassIdentity>::NAME,
3466 "get_Mind",
3467 )
3468 });
3469 let __inner: extern "C" fn(MapUnitCommandMenu_EngageLinkMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
3470 ::core::mem::transmute(__vi.method_ptr);
3471 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3472 __inner(__receiver, __mi)
3473 }
3474 }
3475 }
3476 #[doc = "`get_ActiveMind()` overload"]
3477 fn get_active_mind(self) -> crate::app::mapmind::MapMind_Type {
3478 unsafe {
3479 let __receiver = <MapUnitCommandMenu_EngageLinkMenuItem as ::unity::FromIlInstance>::from_il_instance(
3480 <Self as ::unity::SystemObject>::as_instance(self),
3481 );
3482 {
3483 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3484 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
3485 panic!(
3486 "unity: virtual slot {}
3487 out of range (vtable len {}
3488) on the runtime class behind {}
3489 (method `{}
3490`)",
3491 30usize,
3492 __vt.len(),
3493 <MapUnitCommandMenu_EngageLinkMenuItem as ::unity::ClassIdentity>::NAME,
3494 "get_ActiveMind",
3495 )
3496 });
3497 let __inner: extern "C" fn(MapUnitCommandMenu_EngageLinkMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
3498 ::core::mem::transmute(__vi.method_ptr);
3499 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3500 __inner(__receiver, __mi)
3501 }
3502 }
3503 }
3504 #[doc = "`get_DeployMode()` overload"]
3505 fn get_deploy_mode(self) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
3506 unsafe {
3507 let __receiver = <MapUnitCommandMenu_EngageLinkMenuItem as ::unity::FromIlInstance>::from_il_instance(
3508 <Self as ::unity::SystemObject>::as_instance(self),
3509 );
3510 {
3511 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3512 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
3513 panic!(
3514 "unity: virtual slot {}
3515 out of range (vtable len {}
3516) on the runtime class behind {}
3517 (method `{}
3518`)",
3519 31usize,
3520 __vt.len(),
3521 <MapUnitCommandMenu_EngageLinkMenuItem as ::unity::ClassIdentity>::NAME,
3522 "get_DeployMode",
3523 )
3524 });
3525 let __inner: extern "C" fn(
3526 MapUnitCommandMenu_EngageLinkMenuItem,
3527 ::unity::OptionalMethod,
3528 ) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode = ::core::mem::transmute(__vi.method_ptr);
3529 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3530 __inner(__receiver, __mi)
3531 }
3532 }
3533 }
3534 #[doc = "`GetName()` overload"]
3535 fn get_name(self) -> ::unity::Il2CppString {
3536 unsafe {
3537 let __receiver = <MapUnitCommandMenu_EngageLinkMenuItem as ::unity::FromIlInstance>::from_il_instance(
3538 <Self as ::unity::SystemObject>::as_instance(self),
3539 );
3540 {
3541 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3542 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
3543 panic!(
3544 "unity: virtual slot {}
3545 out of range (vtable len {}
3546) on the runtime class behind {}
3547 (method `{}
3548`)",
3549 4usize,
3550 __vt.len(),
3551 <MapUnitCommandMenu_EngageLinkMenuItem as ::unity::ClassIdentity>::NAME,
3552 "GetName",
3553 )
3554 });
3555 let __inner: extern "C" fn(MapUnitCommandMenu_EngageLinkMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
3556 ::core::mem::transmute(__vi.method_ptr);
3557 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3558 __inner(__receiver, __mi)
3559 }
3560 }
3561 }
3562 #[doc = "`GetCommandHelp()` overload"]
3563 fn get_command_help(self) -> ::unity::Il2CppString {
3564 unsafe {
3565 let __receiver = <MapUnitCommandMenu_EngageLinkMenuItem as ::unity::FromIlInstance>::from_il_instance(
3566 <Self as ::unity::SystemObject>::as_instance(self),
3567 );
3568 {
3569 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3570 let __vi = *__vt.get(34usize).unwrap_or_else(|| {
3571 panic!(
3572 "unity: virtual slot {}
3573 out of range (vtable len {}
3574) on the runtime class behind {}
3575 (method `{}
3576`)",
3577 34usize,
3578 __vt.len(),
3579 <MapUnitCommandMenu_EngageLinkMenuItem as ::unity::ClassIdentity>::NAME,
3580 "GetCommandHelp",
3581 )
3582 });
3583 let __inner: extern "C" fn(MapUnitCommandMenu_EngageLinkMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
3584 ::core::mem::transmute(__vi.method_ptr);
3585 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3586 __inner(__receiver, __mi)
3587 }
3588 }
3589 }
3590 #[doc = "`GetMapAttribute()` overload"]
3591 fn get_map_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
3592 unsafe {
3593 let __receiver = <MapUnitCommandMenu_EngageLinkMenuItem as ::unity::FromIlInstance>::from_il_instance(
3594 <Self as ::unity::SystemObject>::as_instance(self),
3595 );
3596 {
3597 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3598 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
3599 panic!(
3600 "unity: virtual slot {}
3601 out of range (vtable len {}
3602) on the runtime class behind {}
3603 (method `{}
3604`)",
3605 29usize,
3606 __vt.len(),
3607 <MapUnitCommandMenu_EngageLinkMenuItem as ::unity::ClassIdentity>::NAME,
3608 "GetMapAttribute",
3609 )
3610 });
3611 let __inner: extern "C" fn(
3612 MapUnitCommandMenu_EngageLinkMenuItem,
3613 ::unity::OptionalMethod,
3614 ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
3615 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3616 __inner(__receiver, __mi)
3617 }
3618 }
3619 }
3620 #[doc = "`ACall()` overload"]
3621 fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
3622 unsafe {
3623 let __receiver = <MapUnitCommandMenu_EngageLinkMenuItem as ::unity::FromIlInstance>::from_il_instance(
3624 <Self as ::unity::SystemObject>::as_instance(self),
3625 );
3626 {
3627 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3628 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
3629 panic!(
3630 "unity: virtual slot {}
3631 out of range (vtable len {}
3632) on the runtime class behind {}
3633 (method `{}
3634`)",
3635 18usize,
3636 __vt.len(),
3637 <MapUnitCommandMenu_EngageLinkMenuItem as ::unity::ClassIdentity>::NAME,
3638 "ACall",
3639 )
3640 });
3641 let __inner: extern "C" fn(
3642 MapUnitCommandMenu_EngageLinkMenuItem,
3643 ::unity::OptionalMethod,
3644 ) -> crate::app::basicmenu::BasicMenu_Result = ::core::mem::transmute(__vi.method_ptr);
3645 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3646 __inner(__receiver, __mi)
3647 }
3648 }
3649 }
3650 #[doc = "`.ctor()` overload"]
3651 fn ctor(self) -> () {
3652 unsafe {
3653 let __receiver = <MapUnitCommandMenu_EngageLinkMenuItem as ::unity::FromIlInstance>::from_il_instance(
3654 <Self as ::unity::SystemObject>::as_instance(self),
3655 );
3656 ::unity::il2cpp_call!((::unity::module_base()+0x1e4dd90usize)as*mut u8,();
3657(MapUnitCommandMenu_EngageLinkMenuItem)__receiver)
3658 }
3659 }
3660}
3661
3662#[cfg(feature = "app-mapunitcommandmenu")]
3663impl<__T: IMapUnitCommandMenu_EngageLinkMenuItem> IMapUnitCommandMenu_EngageLinkMenuItemMethods for __T {}
3664
3665#[cfg(feature = "app-mapunitcommandmenu")]
3666impl MapUnitCommandMenu_EngageLinkMenuItem {
3667 pub fn get_flag_id_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3668 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
3669 }
3670
3671 pub fn get_label_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3672 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
3673 }
3674
3675 pub fn get_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3676 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
3677 }
3678
3679 pub fn get_active_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3680 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
3681 }
3682
3683 pub fn get_deploy_mode_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3684 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
3685 }
3686
3687 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3688 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
3689 }
3690
3691 pub fn get_command_help_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3692 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
3693 }
3694
3695 pub fn get_map_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3696 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
3697 }
3698
3699 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3700 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
3701 }
3702
3703 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3704 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
3705 }
3706}
3707
3708#[cfg(feature = "app-mapunitcommandmenu")]
3709impl MapUnitCommandMenu_EngageLinkMenuItem {
3710 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageLinkMenuItem`'s own `get_FlagID`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3711 pub unsafe fn get_flag_id(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
3712 let __mi = Self::get_flag_id_method_info();
3713 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
3714 __inner(this.into(), ::core::option::Option::None)
3715 }
3716
3717 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageLinkMenuItem`'s own `get_Label`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3718 pub unsafe fn get_label(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapsequencehuman::MapSequenceHuman_Label {
3719 let __mi = Self::get_label_method_info();
3720 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapsequencehuman::MapSequenceHuman_Label =
3721 ::core::mem::transmute(__mi.method_ptr);
3722 __inner(this.into(), ::core::option::Option::None)
3723 }
3724
3725 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageLinkMenuItem`'s own `get_Mind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3726 pub unsafe fn get_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
3727 let __mi = Self::get_mind_method_info();
3728 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
3729 ::core::mem::transmute(__mi.method_ptr);
3730 __inner(this.into(), ::core::option::Option::None)
3731 }
3732
3733 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageLinkMenuItem`'s own `get_ActiveMind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3734 pub unsafe fn get_active_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
3735 let __mi = Self::get_active_mind_method_info();
3736 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
3737 ::core::mem::transmute(__mi.method_ptr);
3738 __inner(this.into(), ::core::option::Option::None)
3739 }
3740
3741 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageLinkMenuItem`'s own `get_DeployMode`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3742 pub unsafe fn get_deploy_mode(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
3743 let __mi = Self::get_deploy_mode_method_info();
3744 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode =
3745 ::core::mem::transmute(__mi.method_ptr);
3746 __inner(this.into(), ::core::option::Option::None)
3747 }
3748
3749 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageLinkMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3750 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
3751 let __mi = Self::get_name_method_info();
3752 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
3753 __inner(this.into(), ::core::option::Option::None)
3754 }
3755
3756 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageLinkMenuItem`'s own `GetCommandHelp`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3757 pub unsafe fn get_command_help(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
3758 let __mi = Self::get_command_help_method_info();
3759 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
3760 __inner(this.into(), ::core::option::Option::None)
3761 }
3762
3763 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageLinkMenuItem`'s own `GetMapAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3764 pub unsafe fn get_map_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
3765 let __mi = Self::get_map_attribute_method_info();
3766 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
3767 ::core::mem::transmute(__mi.method_ptr);
3768 __inner(this.into(), ::core::option::Option::None)
3769 }
3770
3771 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageLinkMenuItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3772 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
3773 let __mi = Self::a_call_method_info();
3774 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
3775 ::core::mem::transmute(__mi.method_ptr);
3776 __inner(this.into(), ::core::option::Option::None)
3777 }
3778}
3779
3780#[cfg(feature = "app-mapunitcommandmenu")]
3781impl MapUnitCommandMenu_EngageLinkMenuItem {
3782 #[doc = "`.ctor()` — no args"]
3783 pub fn new() -> Self {
3784 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
3785 panic!(
3786 "{}
3787::{}
3788 failed to instantiate",
3789 ::core::stringify!(MapUnitCommandMenu_EngageLinkMenuItem),
3790 ::core::stringify!(new),
3791 )
3792 });
3793 <Self as IMapUnitCommandMenu_EngageLinkMenuItemMethods>::ctor(this);
3794 this
3795 }
3796}
3797
3798#[cfg(feature = "app-mapunitcommandmenu")]
3799pub trait IMapUnitCommandMenu_BreakdownEnemyMenuItemMethods: IMapUnitCommandMenu_BreakdownEnemyMenuItem {
3800 #[doc = "`GetForce()` overload"]
3801 fn get_force(self) -> crate::app::force::Force_Type {
3802 unsafe {
3803 let __receiver = <MapUnitCommandMenu_BreakdownEnemyMenuItem as ::unity::FromIlInstance>::from_il_instance(
3804 <Self as ::unity::SystemObject>::as_instance(self),
3805 );
3806 {
3807 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3808 let __vi = *__vt.get(36usize).unwrap_or_else(|| {
3809 panic!(
3810 "unity: virtual slot {}
3811 out of range (vtable len {}
3812) on the runtime class behind {}
3813 (method `{}
3814`)",
3815 36usize,
3816 __vt.len(),
3817 <MapUnitCommandMenu_BreakdownEnemyMenuItem as ::unity::ClassIdentity>::NAME,
3818 "GetForce",
3819 )
3820 });
3821 let __inner: extern "C" fn(MapUnitCommandMenu_BreakdownEnemyMenuItem, ::unity::OptionalMethod) -> crate::app::force::Force_Type =
3822 ::core::mem::transmute(__vi.method_ptr);
3823 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3824 __inner(__receiver, __mi)
3825 }
3826 }
3827 }
3828 #[doc = "`GetKind()` overload"]
3829 fn get_kind(self) -> crate::app::mapinspector::MapInspector_Kind {
3830 unsafe {
3831 let __receiver = <MapUnitCommandMenu_BreakdownEnemyMenuItem as ::unity::FromIlInstance>::from_il_instance(
3832 <Self as ::unity::SystemObject>::as_instance(self),
3833 );
3834 {
3835 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3836 let __vi = *__vt.get(37usize).unwrap_or_else(|| {
3837 panic!(
3838 "unity: virtual slot {}
3839 out of range (vtable len {}
3840) on the runtime class behind {}
3841 (method `{}
3842`)",
3843 37usize,
3844 __vt.len(),
3845 <MapUnitCommandMenu_BreakdownEnemyMenuItem as ::unity::ClassIdentity>::NAME,
3846 "GetKind",
3847 )
3848 });
3849 let __inner: extern "C" fn(
3850 MapUnitCommandMenu_BreakdownEnemyMenuItem,
3851 ::unity::OptionalMethod,
3852 ) -> crate::app::mapinspector::MapInspector_Kind = ::core::mem::transmute(__vi.method_ptr);
3853 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3854 __inner(__receiver, __mi)
3855 }
3856 }
3857 }
3858 #[doc = "`GetMind()` overload"]
3859 fn get_mind(self) -> crate::app::mapmind::MapMind_Type {
3860 unsafe {
3861 let __receiver = <MapUnitCommandMenu_BreakdownEnemyMenuItem as ::unity::FromIlInstance>::from_il_instance(
3862 <Self as ::unity::SystemObject>::as_instance(self),
3863 );
3864 {
3865 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3866 let __vi = *__vt.get(38usize).unwrap_or_else(|| {
3867 panic!(
3868 "unity: virtual slot {}
3869 out of range (vtable len {}
3870) on the runtime class behind {}
3871 (method `{}
3872`)",
3873 38usize,
3874 __vt.len(),
3875 <MapUnitCommandMenu_BreakdownEnemyMenuItem as ::unity::ClassIdentity>::NAME,
3876 "GetMind",
3877 )
3878 });
3879 let __inner: extern "C" fn(MapUnitCommandMenu_BreakdownEnemyMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
3880 ::core::mem::transmute(__vi.method_ptr);
3881 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3882 __inner(__receiver, __mi)
3883 }
3884 }
3885 }
3886 #[doc = "`.ctor()` overload"]
3887 fn ctor(self) -> () {
3888 unsafe {
3889 let __receiver = <MapUnitCommandMenu_BreakdownEnemyMenuItem as ::unity::FromIlInstance>::from_il_instance(
3890 <Self as ::unity::SystemObject>::as_instance(self),
3891 );
3892 ::unity::il2cpp_call!((::unity::module_base()+0x1e49ad0usize)as*mut u8,();
3893(MapUnitCommandMenu_BreakdownEnemyMenuItem)__receiver)
3894 }
3895 }
3896}
3897
3898#[cfg(feature = "app-mapunitcommandmenu")]
3899impl<__T: IMapUnitCommandMenu_BreakdownEnemyMenuItem> IMapUnitCommandMenu_BreakdownEnemyMenuItemMethods for __T {}
3900
3901#[cfg(feature = "app-mapunitcommandmenu")]
3902impl MapUnitCommandMenu_BreakdownEnemyMenuItem {
3903 pub fn get_force_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3904 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
3905 }
3906
3907 pub fn get_kind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3908 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
3909 }
3910
3911 pub fn get_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3912 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
3913 }
3914
3915 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3916 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
3917 }
3918}
3919
3920#[cfg(feature = "app-mapunitcommandmenu")]
3921impl MapUnitCommandMenu_BreakdownEnemyMenuItem {
3922 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_BreakdownEnemyMenuItem`'s own `GetForce`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3923 pub unsafe fn get_force(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::force::Force_Type {
3924 let __mi = Self::get_force_method_info();
3925 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::force::Force_Type =
3926 ::core::mem::transmute(__mi.method_ptr);
3927 __inner(this.into(), ::core::option::Option::None)
3928 }
3929
3930 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_BreakdownEnemyMenuItem`'s own `GetKind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3931 pub unsafe fn get_kind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapinspector::MapInspector_Kind {
3932 let __mi = Self::get_kind_method_info();
3933 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapinspector::MapInspector_Kind =
3934 ::core::mem::transmute(__mi.method_ptr);
3935 __inner(this.into(), ::core::option::Option::None)
3936 }
3937
3938 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_BreakdownEnemyMenuItem`'s own `GetMind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3939 pub unsafe fn get_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
3940 let __mi = Self::get_mind_method_info();
3941 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
3942 ::core::mem::transmute(__mi.method_ptr);
3943 __inner(this.into(), ::core::option::Option::None)
3944 }
3945}
3946
3947#[cfg(feature = "app-mapunitcommandmenu")]
3948impl MapUnitCommandMenu_BreakdownEnemyMenuItem {
3949 #[doc = "`.ctor()` — no args"]
3950 pub fn new() -> Self {
3951 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
3952 panic!(
3953 "{}
3954::{}
3955 failed to instantiate",
3956 ::core::stringify!(MapUnitCommandMenu_BreakdownEnemyMenuItem),
3957 ::core::stringify!(new),
3958 )
3959 });
3960 <Self as IMapUnitCommandMenu_BreakdownEnemyMenuItemMethods>::ctor(this);
3961 this
3962 }
3963}
3964
3965#[cfg(feature = "app-mapunitcommandmenu")]
3966pub trait IMapUnitCommandMenu_EnchantItemMenuItemMethods: IMapUnitCommandMenu_EnchantItemMenuItem {
3967 #[doc = "`get_Label()` overload"]
3968 fn get_label(self) -> crate::app::mapsequencehuman::MapSequenceHuman_Label {
3969 unsafe {
3970 let __receiver = <MapUnitCommandMenu_EnchantItemMenuItem as ::unity::FromIlInstance>::from_il_instance(
3971 <Self as ::unity::SystemObject>::as_instance(self),
3972 );
3973 {
3974 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3975 let __vi = *__vt.get(36usize).unwrap_or_else(|| {
3976 panic!(
3977 "unity: virtual slot {}
3978 out of range (vtable len {}
3979) on the runtime class behind {}
3980 (method `{}
3981`)",
3982 36usize,
3983 __vt.len(),
3984 <MapUnitCommandMenu_EnchantItemMenuItem as ::unity::ClassIdentity>::NAME,
3985 "get_Label",
3986 )
3987 });
3988 let __inner: extern "C" fn(
3989 MapUnitCommandMenu_EnchantItemMenuItem,
3990 ::unity::OptionalMethod,
3991 ) -> crate::app::mapsequencehuman::MapSequenceHuman_Label = ::core::mem::transmute(__vi.method_ptr);
3992 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3993 __inner(__receiver, __mi)
3994 }
3995 }
3996 }
3997 #[doc = "`get_IsWeapon()` overload"]
3998 fn get_is_weapon(self) -> bool {
3999 unsafe {
4000 let __receiver = <MapUnitCommandMenu_EnchantItemMenuItem as ::unity::FromIlInstance>::from_il_instance(
4001 <Self as ::unity::SystemObject>::as_instance(self),
4002 );
4003 {
4004 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4005 let __vi = *__vt.get(37usize).unwrap_or_else(|| {
4006 panic!(
4007 "unity: virtual slot {}
4008 out of range (vtable len {}
4009) on the runtime class behind {}
4010 (method `{}
4011`)",
4012 37usize,
4013 __vt.len(),
4014 <MapUnitCommandMenu_EnchantItemMenuItem as ::unity::ClassIdentity>::NAME,
4015 "get_IsWeapon",
4016 )
4017 });
4018 let __inner: extern "C" fn(MapUnitCommandMenu_EnchantItemMenuItem, ::unity::OptionalMethod) -> bool =
4019 ::core::mem::transmute(__vi.method_ptr);
4020 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4021 __inner(__receiver, __mi)
4022 }
4023 }
4024 }
4025 #[doc = "`GetName()` overload"]
4026 fn get_name(self) -> ::unity::Il2CppString {
4027 unsafe {
4028 let __receiver = <MapUnitCommandMenu_EnchantItemMenuItem as ::unity::FromIlInstance>::from_il_instance(
4029 <Self as ::unity::SystemObject>::as_instance(self),
4030 );
4031 {
4032 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4033 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
4034 panic!(
4035 "unity: virtual slot {}
4036 out of range (vtable len {}
4037) on the runtime class behind {}
4038 (method `{}
4039`)",
4040 4usize,
4041 __vt.len(),
4042 <MapUnitCommandMenu_EnchantItemMenuItem as ::unity::ClassIdentity>::NAME,
4043 "GetName",
4044 )
4045 });
4046 let __inner: extern "C" fn(MapUnitCommandMenu_EnchantItemMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
4047 ::core::mem::transmute(__vi.method_ptr);
4048 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4049 __inner(__receiver, __mi)
4050 }
4051 }
4052 }
4053 #[doc = "`GetCommandHelp()` overload"]
4054 fn get_command_help(self) -> ::unity::Il2CppString {
4055 unsafe {
4056 let __receiver = <MapUnitCommandMenu_EnchantItemMenuItem as ::unity::FromIlInstance>::from_il_instance(
4057 <Self as ::unity::SystemObject>::as_instance(self),
4058 );
4059 {
4060 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4061 let __vi = *__vt.get(34usize).unwrap_or_else(|| {
4062 panic!(
4063 "unity: virtual slot {}
4064 out of range (vtable len {}
4065) on the runtime class behind {}
4066 (method `{}
4067`)",
4068 34usize,
4069 __vt.len(),
4070 <MapUnitCommandMenu_EnchantItemMenuItem as ::unity::ClassIdentity>::NAME,
4071 "GetCommandHelp",
4072 )
4073 });
4074 let __inner: extern "C" fn(MapUnitCommandMenu_EnchantItemMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
4075 ::core::mem::transmute(__vi.method_ptr);
4076 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4077 __inner(__receiver, __mi)
4078 }
4079 }
4080 }
4081 #[doc = "`.ctor()` overload"]
4082 fn ctor(self) -> () {
4083 unsafe {
4084 let __receiver = <MapUnitCommandMenu_EnchantItemMenuItem as ::unity::FromIlInstance>::from_il_instance(
4085 <Self as ::unity::SystemObject>::as_instance(self),
4086 );
4087 ::unity::il2cpp_call!((::unity::module_base()+0x1e4c810usize)as*mut u8,();
4088(MapUnitCommandMenu_EnchantItemMenuItem)__receiver)
4089 }
4090 }
4091}
4092
4093#[cfg(feature = "app-mapunitcommandmenu")]
4094impl<__T: IMapUnitCommandMenu_EnchantItemMenuItem> IMapUnitCommandMenu_EnchantItemMenuItemMethods for __T {}
4095
4096#[cfg(feature = "app-mapunitcommandmenu")]
4097impl MapUnitCommandMenu_EnchantItemMenuItem {
4098 pub fn get_label_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4099 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
4100 }
4101
4102 pub fn get_is_weapon_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4103 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
4104 }
4105
4106 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4107 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
4108 }
4109
4110 pub fn get_command_help_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4111 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
4112 }
4113
4114 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4115 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
4116 }
4117}
4118
4119#[cfg(feature = "app-mapunitcommandmenu")]
4120impl MapUnitCommandMenu_EnchantItemMenuItem {
4121 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EnchantItemMenuItem`'s own `get_Label`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4122 pub unsafe fn get_label(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapsequencehuman::MapSequenceHuman_Label {
4123 let __mi = Self::get_label_method_info();
4124 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapsequencehuman::MapSequenceHuman_Label =
4125 ::core::mem::transmute(__mi.method_ptr);
4126 __inner(this.into(), ::core::option::Option::None)
4127 }
4128
4129 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EnchantItemMenuItem`'s own `get_IsWeapon`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4130 pub unsafe fn get_is_weapon(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
4131 let __mi = Self::get_is_weapon_method_info();
4132 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
4133 __inner(this.into(), ::core::option::Option::None)
4134 }
4135
4136 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EnchantItemMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4137 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
4138 let __mi = Self::get_name_method_info();
4139 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
4140 __inner(this.into(), ::core::option::Option::None)
4141 }
4142
4143 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EnchantItemMenuItem`'s own `GetCommandHelp`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4144 pub unsafe fn get_command_help(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
4145 let __mi = Self::get_command_help_method_info();
4146 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
4147 __inner(this.into(), ::core::option::Option::None)
4148 }
4149}
4150
4151#[cfg(feature = "app-mapunitcommandmenu")]
4152impl MapUnitCommandMenu_EnchantItemMenuItem {
4153 #[doc = "`.ctor()` — no args"]
4154 pub fn new() -> Self {
4155 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
4156 panic!(
4157 "{}
4158::{}
4159 failed to instantiate",
4160 ::core::stringify!(MapUnitCommandMenu_EnchantItemMenuItem),
4161 ::core::stringify!(new),
4162 )
4163 });
4164 <Self as IMapUnitCommandMenu_EnchantItemMenuItemMethods>::ctor(this);
4165 this
4166 }
4167}
4168
4169#[cfg(feature = "app-mapunitcommandmenu")]
4170pub trait IMapUnitCommandMenu_EngageActionBaseMenuItemMethods: IMapUnitCommandMenu_EngageActionBaseMenuItem {
4171 #[doc = "`get_FlagID()` overload"]
4172 fn get_flag_id(self) -> ::unity::Il2CppString {
4173 unsafe {
4174 let __receiver = <MapUnitCommandMenu_EngageActionBaseMenuItem as ::unity::FromIlInstance>::from_il_instance(
4175 <Self as ::unity::SystemObject>::as_instance(self),
4176 );
4177 {
4178 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4179 let __vi = *__vt.get(27usize).unwrap_or_else(|| {
4180 panic!(
4181 "unity: virtual slot {}
4182 out of range (vtable len {}
4183) on the runtime class behind {}
4184 (method `{}
4185`)",
4186 27usize,
4187 __vt.len(),
4188 <MapUnitCommandMenu_EngageActionBaseMenuItem as ::unity::ClassIdentity>::NAME,
4189 "get_FlagID",
4190 )
4191 });
4192 let __inner: extern "C" fn(MapUnitCommandMenu_EngageActionBaseMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
4193 ::core::mem::transmute(__vi.method_ptr);
4194 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4195 __inner(__receiver, __mi)
4196 }
4197 }
4198 }
4199 #[doc = "`get_Label()` overload"]
4200 fn get_label(self) -> crate::app::mapsequencehuman::MapSequenceHuman_Label {
4201 unsafe {
4202 let __receiver = <MapUnitCommandMenu_EngageActionBaseMenuItem as ::unity::FromIlInstance>::from_il_instance(
4203 <Self as ::unity::SystemObject>::as_instance(self),
4204 );
4205 {
4206 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4207 let __vi = *__vt.get(36usize).unwrap_or_else(|| {
4208 panic!(
4209 "unity: virtual slot {}
4210 out of range (vtable len {}
4211) on the runtime class behind {}
4212 (method `{}
4213`)",
4214 36usize,
4215 __vt.len(),
4216 <MapUnitCommandMenu_EngageActionBaseMenuItem as ::unity::ClassIdentity>::NAME,
4217 "get_Label",
4218 )
4219 });
4220 let __inner: extern "C" fn(
4221 MapUnitCommandMenu_EngageActionBaseMenuItem,
4222 ::unity::OptionalMethod,
4223 ) -> crate::app::mapsequencehuman::MapSequenceHuman_Label = ::core::mem::transmute(__vi.method_ptr);
4224 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4225 __inner(__receiver, __mi)
4226 }
4227 }
4228 }
4229 #[doc = "`get_Mind()` overload"]
4230 fn get_mind(self) -> crate::app::mapmind::MapMind_Type {
4231 unsafe {
4232 let __receiver = <MapUnitCommandMenu_EngageActionBaseMenuItem as ::unity::FromIlInstance>::from_il_instance(
4233 <Self as ::unity::SystemObject>::as_instance(self),
4234 );
4235 {
4236 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4237 let __vi = *__vt.get(37usize).unwrap_or_else(|| {
4238 panic!(
4239 "unity: virtual slot {}
4240 out of range (vtable len {}
4241) on the runtime class behind {}
4242 (method `{}
4243`)",
4244 37usize,
4245 __vt.len(),
4246 <MapUnitCommandMenu_EngageActionBaseMenuItem as ::unity::ClassIdentity>::NAME,
4247 "get_Mind",
4248 )
4249 });
4250 let __inner: extern "C" fn(
4251 MapUnitCommandMenu_EngageActionBaseMenuItem,
4252 ::unity::OptionalMethod,
4253 ) -> crate::app::mapmind::MapMind_Type = ::core::mem::transmute(__vi.method_ptr);
4254 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4255 __inner(__receiver, __mi)
4256 }
4257 }
4258 }
4259 #[doc = "`OnBuild()` overload"]
4260 fn on_build(self) -> () {
4261 unsafe {
4262 let __receiver = <MapUnitCommandMenu_EngageActionBaseMenuItem as ::unity::FromIlInstance>::from_il_instance(
4263 <Self as ::unity::SystemObject>::as_instance(self),
4264 );
4265 {
4266 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4267 let __vi = *__vt.get(10usize).unwrap_or_else(|| {
4268 panic!(
4269 "unity: virtual slot {}
4270 out of range (vtable len {}
4271) on the runtime class behind {}
4272 (method `{}
4273`)",
4274 10usize,
4275 __vt.len(),
4276 <MapUnitCommandMenu_EngageActionBaseMenuItem as ::unity::ClassIdentity>::NAME,
4277 "OnBuild",
4278 )
4279 });
4280 let __inner: extern "C" fn(MapUnitCommandMenu_EngageActionBaseMenuItem, ::unity::OptionalMethod) -> () =
4281 ::core::mem::transmute(__vi.method_ptr);
4282 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4283 __inner(__receiver, __mi)
4284 }
4285 }
4286 }
4287 #[doc = "`OnBuildMenuItemContent()` overload"]
4288 fn on_build_menu_item_content(self) -> () {
4289 unsafe {
4290 let __receiver = <MapUnitCommandMenu_EngageActionBaseMenuItem as ::unity::FromIlInstance>::from_il_instance(
4291 <Self as ::unity::SystemObject>::as_instance(self),
4292 );
4293 {
4294 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4295 let __vi = *__vt.get(11usize).unwrap_or_else(|| {
4296 panic!(
4297 "unity: virtual slot {}
4298 out of range (vtable len {}
4299) on the runtime class behind {}
4300 (method `{}
4301`)",
4302 11usize,
4303 __vt.len(),
4304 <MapUnitCommandMenu_EngageActionBaseMenuItem as ::unity::ClassIdentity>::NAME,
4305 "OnBuildMenuItemContent",
4306 )
4307 });
4308 let __inner: extern "C" fn(MapUnitCommandMenu_EngageActionBaseMenuItem, ::unity::OptionalMethod) -> () =
4309 ::core::mem::transmute(__vi.method_ptr);
4310 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4311 __inner(__receiver, __mi)
4312 }
4313 }
4314 }
4315 #[doc = "`.ctor()` overload"]
4316 fn ctor(self) -> () {
4317 unsafe {
4318 let __receiver = <MapUnitCommandMenu_EngageActionBaseMenuItem as ::unity::FromIlInstance>::from_il_instance(
4319 <Self as ::unity::SystemObject>::as_instance(self),
4320 );
4321 ::unity::il2cpp_call!((::unity::module_base()+0x1e4d2b0usize)as*mut u8,();
4322(MapUnitCommandMenu_EngageActionBaseMenuItem)__receiver)
4323 }
4324 }
4325 #[doc = "`GetEngageMind(crate::app::unit::Unit)` overload"]
4326 fn get_engage_mind(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> crate::app::mapmind::MapMind_Type {
4327 unsafe {
4328 let __receiver = <MapUnitCommandMenu_EngageActionBaseMenuItem as ::unity::FromIlInstance>::from_il_instance(
4329 <Self as ::unity::SystemObject>::as_instance(self),
4330 );
4331 ::unity::il2cpp_call!((::unity::module_base()+0x1e4d3a0usize)as*mut u8,crate::app::mapmind::MapMind_Type;
4332(MapUnitCommandMenu_EngageActionBaseMenuItem)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(unit))
4333 }
4334 }
4335 #[doc = "`CheckBuildableWithUnit(crate::app::unit::Unit)` overload"]
4336 fn check_buildable_with_unit(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> bool {
4337 unsafe {
4338 let __receiver = <MapUnitCommandMenu_EngageActionBaseMenuItem as ::unity::FromIlInstance>::from_il_instance(
4339 <Self as ::unity::SystemObject>::as_instance(self),
4340 );
4341 {
4342 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4343 let __vi = *__vt.get(35usize).unwrap_or_else(|| {
4344 panic!(
4345 "unity: virtual slot {}
4346 out of range (vtable len {}
4347) on the runtime class behind {}
4348 (method `{}
4349`)",
4350 35usize,
4351 __vt.len(),
4352 <MapUnitCommandMenu_EngageActionBaseMenuItem as ::unity::ClassIdentity>::NAME,
4353 "CheckBuildableWithUnit",
4354 )
4355 });
4356 let __inner: extern "C" fn(MapUnitCommandMenu_EngageActionBaseMenuItem, crate::app::unit::Unit, ::unity::OptionalMethod) -> bool =
4357 ::core::mem::transmute(__vi.method_ptr);
4358 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4359 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
4360 }
4361 }
4362 }
4363}
4364
4365#[cfg(feature = "app-mapunitcommandmenu")]
4366impl<__T: IMapUnitCommandMenu_EngageActionBaseMenuItem> IMapUnitCommandMenu_EngageActionBaseMenuItemMethods for __T {}
4367
4368#[cfg(feature = "app-mapunitcommandmenu")]
4369impl MapUnitCommandMenu_EngageActionBaseMenuItem {
4370 pub fn get_flag_id_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4371 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
4372 }
4373
4374 pub fn get_label_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4375 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
4376 }
4377
4378 pub fn get_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4379 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
4380 }
4381
4382 pub fn on_build_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4383 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
4384 }
4385
4386 pub fn on_build_menu_item_content_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4387 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
4388 }
4389
4390 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4391 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
4392 }
4393
4394 pub fn get_engage_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4395 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
4396 }
4397
4398 pub fn check_buildable_with_unit_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4399 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
4400 }
4401}
4402
4403#[cfg(feature = "app-mapunitcommandmenu")]
4404impl MapUnitCommandMenu_EngageActionBaseMenuItem {
4405 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageActionBaseMenuItem`'s own `get_FlagID`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4406 pub unsafe fn get_flag_id(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
4407 let __mi = Self::get_flag_id_method_info();
4408 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
4409 __inner(this.into(), ::core::option::Option::None)
4410 }
4411
4412 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageActionBaseMenuItem`'s own `get_Label`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4413 pub unsafe fn get_label(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapsequencehuman::MapSequenceHuman_Label {
4414 let __mi = Self::get_label_method_info();
4415 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapsequencehuman::MapSequenceHuman_Label =
4416 ::core::mem::transmute(__mi.method_ptr);
4417 __inner(this.into(), ::core::option::Option::None)
4418 }
4419
4420 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageActionBaseMenuItem`'s own `get_Mind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4421 pub unsafe fn get_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
4422 let __mi = Self::get_mind_method_info();
4423 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
4424 ::core::mem::transmute(__mi.method_ptr);
4425 __inner(this.into(), ::core::option::Option::None)
4426 }
4427
4428 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageActionBaseMenuItem`'s own `OnBuild`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4429 pub unsafe fn on_build(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
4430 let __mi = Self::on_build_method_info();
4431 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
4432 __inner(this.into(), ::core::option::Option::None)
4433 }
4434
4435 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageActionBaseMenuItem`'s own `OnBuildMenuItemContent`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4436 pub unsafe fn on_build_menu_item_content(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
4437 let __mi = Self::on_build_menu_item_content_method_info();
4438 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
4439 __inner(this.into(), ::core::option::Option::None)
4440 }
4441
4442 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageActionBaseMenuItem`'s own `CheckBuildableWithUnit`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4443 pub unsafe fn check_buildable_with_unit(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> bool {
4444 let __mi = Self::check_buildable_with_unit_method_info();
4445 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> bool =
4446 ::core::mem::transmute(__mi.method_ptr);
4447 __inner(this.into(), unit, ::core::option::Option::None)
4448 }
4449}
4450
4451#[cfg(feature = "app-mapunitcommandmenu")]
4452impl MapUnitCommandMenu_EngageActionBaseMenuItem {
4453 #[doc = "`.ctor()` — no args"]
4454 pub fn new() -> Self {
4455 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
4456 panic!(
4457 "{}
4458::{}
4459 failed to instantiate",
4460 ::core::stringify!(MapUnitCommandMenu_EngageActionBaseMenuItem),
4461 ::core::stringify!(new),
4462 )
4463 });
4464 <Self as IMapUnitCommandMenu_EngageActionBaseMenuItemMethods>::ctor(this);
4465 this
4466 }
4467}
4468
4469#[cfg(feature = "app-mapunitcommandmenu")]
4470pub trait IMapUnitCommandMenu_TransporterMenuItemMethods: IMapUnitCommandMenu_TransporterMenuItem {
4471 #[doc = "`get_FlagID()` overload"]
4472 fn get_flag_id(self) -> ::unity::Il2CppString {
4473 unsafe {
4474 let __receiver = <MapUnitCommandMenu_TransporterMenuItem as ::unity::FromIlInstance>::from_il_instance(
4475 <Self as ::unity::SystemObject>::as_instance(self),
4476 );
4477 {
4478 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4479 let __vi = *__vt.get(27usize).unwrap_or_else(|| {
4480 panic!(
4481 "unity: virtual slot {}
4482 out of range (vtable len {}
4483) on the runtime class behind {}
4484 (method `{}
4485`)",
4486 27usize,
4487 __vt.len(),
4488 <MapUnitCommandMenu_TransporterMenuItem as ::unity::ClassIdentity>::NAME,
4489 "get_FlagID",
4490 )
4491 });
4492 let __inner: extern "C" fn(MapUnitCommandMenu_TransporterMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
4493 ::core::mem::transmute(__vi.method_ptr);
4494 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4495 __inner(__receiver, __mi)
4496 }
4497 }
4498 }
4499 #[doc = "`get_ActiveMind()` overload"]
4500 fn get_active_mind(self) -> crate::app::mapmind::MapMind_Type {
4501 unsafe {
4502 let __receiver = <MapUnitCommandMenu_TransporterMenuItem as ::unity::FromIlInstance>::from_il_instance(
4503 <Self as ::unity::SystemObject>::as_instance(self),
4504 );
4505 {
4506 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4507 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
4508 panic!(
4509 "unity: virtual slot {}
4510 out of range (vtable len {}
4511) on the runtime class behind {}
4512 (method `{}
4513`)",
4514 30usize,
4515 __vt.len(),
4516 <MapUnitCommandMenu_TransporterMenuItem as ::unity::ClassIdentity>::NAME,
4517 "get_ActiveMind",
4518 )
4519 });
4520 let __inner: extern "C" fn(MapUnitCommandMenu_TransporterMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
4521 ::core::mem::transmute(__vi.method_ptr);
4522 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4523 __inner(__receiver, __mi)
4524 }
4525 }
4526 }
4527 #[doc = "`get_DeployMode()` overload"]
4528 fn get_deploy_mode(self) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
4529 unsafe {
4530 let __receiver = <MapUnitCommandMenu_TransporterMenuItem as ::unity::FromIlInstance>::from_il_instance(
4531 <Self as ::unity::SystemObject>::as_instance(self),
4532 );
4533 {
4534 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4535 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
4536 panic!(
4537 "unity: virtual slot {}
4538 out of range (vtable len {}
4539) on the runtime class behind {}
4540 (method `{}
4541`)",
4542 31usize,
4543 __vt.len(),
4544 <MapUnitCommandMenu_TransporterMenuItem as ::unity::ClassIdentity>::NAME,
4545 "get_DeployMode",
4546 )
4547 });
4548 let __inner: extern "C" fn(
4549 MapUnitCommandMenu_TransporterMenuItem,
4550 ::unity::OptionalMethod,
4551 ) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode = ::core::mem::transmute(__vi.method_ptr);
4552 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4553 __inner(__receiver, __mi)
4554 }
4555 }
4556 }
4557 #[doc = "`GetName()` overload"]
4558 fn get_name(self) -> ::unity::Il2CppString {
4559 unsafe {
4560 let __receiver = <MapUnitCommandMenu_TransporterMenuItem as ::unity::FromIlInstance>::from_il_instance(
4561 <Self as ::unity::SystemObject>::as_instance(self),
4562 );
4563 {
4564 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4565 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
4566 panic!(
4567 "unity: virtual slot {}
4568 out of range (vtable len {}
4569) on the runtime class behind {}
4570 (method `{}
4571`)",
4572 4usize,
4573 __vt.len(),
4574 <MapUnitCommandMenu_TransporterMenuItem as ::unity::ClassIdentity>::NAME,
4575 "GetName",
4576 )
4577 });
4578 let __inner: extern "C" fn(MapUnitCommandMenu_TransporterMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
4579 ::core::mem::transmute(__vi.method_ptr);
4580 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4581 __inner(__receiver, __mi)
4582 }
4583 }
4584 }
4585 #[doc = "`GetCommandHelp()` overload"]
4586 fn get_command_help(self) -> ::unity::Il2CppString {
4587 unsafe {
4588 let __receiver = <MapUnitCommandMenu_TransporterMenuItem as ::unity::FromIlInstance>::from_il_instance(
4589 <Self as ::unity::SystemObject>::as_instance(self),
4590 );
4591 {
4592 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4593 let __vi = *__vt.get(34usize).unwrap_or_else(|| {
4594 panic!(
4595 "unity: virtual slot {}
4596 out of range (vtable len {}
4597) on the runtime class behind {}
4598 (method `{}
4599`)",
4600 34usize,
4601 __vt.len(),
4602 <MapUnitCommandMenu_TransporterMenuItem as ::unity::ClassIdentity>::NAME,
4603 "GetCommandHelp",
4604 )
4605 });
4606 let __inner: extern "C" fn(MapUnitCommandMenu_TransporterMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
4607 ::core::mem::transmute(__vi.method_ptr);
4608 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4609 __inner(__receiver, __mi)
4610 }
4611 }
4612 }
4613 #[doc = "`GetMapAttribute()` overload"]
4614 fn get_map_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
4615 unsafe {
4616 let __receiver = <MapUnitCommandMenu_TransporterMenuItem as ::unity::FromIlInstance>::from_il_instance(
4617 <Self as ::unity::SystemObject>::as_instance(self),
4618 );
4619 {
4620 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4621 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
4622 panic!(
4623 "unity: virtual slot {}
4624 out of range (vtable len {}
4625) on the runtime class behind {}
4626 (method `{}
4627`)",
4628 29usize,
4629 __vt.len(),
4630 <MapUnitCommandMenu_TransporterMenuItem as ::unity::ClassIdentity>::NAME,
4631 "GetMapAttribute",
4632 )
4633 });
4634 let __inner: extern "C" fn(
4635 MapUnitCommandMenu_TransporterMenuItem,
4636 ::unity::OptionalMethod,
4637 ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
4638 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4639 __inner(__receiver, __mi)
4640 }
4641 }
4642 }
4643 #[doc = "`ACall()` overload"]
4644 fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
4645 unsafe {
4646 let __receiver = <MapUnitCommandMenu_TransporterMenuItem as ::unity::FromIlInstance>::from_il_instance(
4647 <Self as ::unity::SystemObject>::as_instance(self),
4648 );
4649 {
4650 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4651 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
4652 panic!(
4653 "unity: virtual slot {}
4654 out of range (vtable len {}
4655) on the runtime class behind {}
4656 (method `{}
4657`)",
4658 18usize,
4659 __vt.len(),
4660 <MapUnitCommandMenu_TransporterMenuItem as ::unity::ClassIdentity>::NAME,
4661 "ACall",
4662 )
4663 });
4664 let __inner: extern "C" fn(
4665 MapUnitCommandMenu_TransporterMenuItem,
4666 ::unity::OptionalMethod,
4667 ) -> crate::app::basicmenu::BasicMenu_Result = ::core::mem::transmute(__vi.method_ptr);
4668 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4669 __inner(__receiver, __mi)
4670 }
4671 }
4672 }
4673 #[doc = "`.ctor()` overload"]
4674 fn ctor(self) -> () {
4675 unsafe {
4676 let __receiver = <MapUnitCommandMenu_TransporterMenuItem as ::unity::FromIlInstance>::from_il_instance(
4677 <Self as ::unity::SystemObject>::as_instance(self),
4678 );
4679 ::unity::il2cpp_call!((::unity::module_base()+0x1e52410usize)as*mut u8,();
4680(MapUnitCommandMenu_TransporterMenuItem)__receiver)
4681 }
4682 }
4683}
4684
4685#[cfg(feature = "app-mapunitcommandmenu")]
4686impl<__T: IMapUnitCommandMenu_TransporterMenuItem> IMapUnitCommandMenu_TransporterMenuItemMethods for __T {}
4687
4688#[cfg(feature = "app-mapunitcommandmenu")]
4689impl MapUnitCommandMenu_TransporterMenuItem {
4690 pub fn get_flag_id_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4691 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
4692 }
4693
4694 pub fn get_active_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4695 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
4696 }
4697
4698 pub fn get_deploy_mode_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4699 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
4700 }
4701
4702 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4703 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
4704 }
4705
4706 pub fn get_command_help_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4707 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
4708 }
4709
4710 pub fn get_map_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4711 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
4712 }
4713
4714 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4715 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
4716 }
4717
4718 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4719 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
4720 }
4721}
4722
4723#[cfg(feature = "app-mapunitcommandmenu")]
4724impl MapUnitCommandMenu_TransporterMenuItem {
4725 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_TransporterMenuItem`'s own `get_FlagID`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4726 pub unsafe fn get_flag_id(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
4727 let __mi = Self::get_flag_id_method_info();
4728 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
4729 __inner(this.into(), ::core::option::Option::None)
4730 }
4731
4732 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_TransporterMenuItem`'s own `get_ActiveMind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4733 pub unsafe fn get_active_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
4734 let __mi = Self::get_active_mind_method_info();
4735 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
4736 ::core::mem::transmute(__mi.method_ptr);
4737 __inner(this.into(), ::core::option::Option::None)
4738 }
4739
4740 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_TransporterMenuItem`'s own `get_DeployMode`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4741 pub unsafe fn get_deploy_mode(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
4742 let __mi = Self::get_deploy_mode_method_info();
4743 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode =
4744 ::core::mem::transmute(__mi.method_ptr);
4745 __inner(this.into(), ::core::option::Option::None)
4746 }
4747
4748 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_TransporterMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4749 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
4750 let __mi = Self::get_name_method_info();
4751 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
4752 __inner(this.into(), ::core::option::Option::None)
4753 }
4754
4755 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_TransporterMenuItem`'s own `GetCommandHelp`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4756 pub unsafe fn get_command_help(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
4757 let __mi = Self::get_command_help_method_info();
4758 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
4759 __inner(this.into(), ::core::option::Option::None)
4760 }
4761
4762 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_TransporterMenuItem`'s own `GetMapAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4763 pub unsafe fn get_map_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
4764 let __mi = Self::get_map_attribute_method_info();
4765 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
4766 ::core::mem::transmute(__mi.method_ptr);
4767 __inner(this.into(), ::core::option::Option::None)
4768 }
4769
4770 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_TransporterMenuItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4771 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
4772 let __mi = Self::a_call_method_info();
4773 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
4774 ::core::mem::transmute(__mi.method_ptr);
4775 __inner(this.into(), ::core::option::Option::None)
4776 }
4777}
4778
4779#[cfg(feature = "app-mapunitcommandmenu")]
4780impl MapUnitCommandMenu_TransporterMenuItem {
4781 #[doc = "`.ctor()` — no args"]
4782 pub fn new() -> Self {
4783 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
4784 panic!(
4785 "{}
4786::{}
4787 failed to instantiate",
4788 ::core::stringify!(MapUnitCommandMenu_TransporterMenuItem),
4789 ::core::stringify!(new),
4790 )
4791 });
4792 <Self as IMapUnitCommandMenu_TransporterMenuItemMethods>::ctor(this);
4793 this
4794 }
4795}
4796
4797#[cfg(feature = "app-mapunitcommandmenu")]
4798pub trait IMapUnitCommandMenu_SubMenuItemMethods: IMapUnitCommandMenu_SubMenuItem {
4799 #[doc = "`get_FlagID()` overload"]
4800 fn get_flag_id(self) -> ::unity::Il2CppString {
4801 unsafe {
4802 let __receiver =
4803 <MapUnitCommandMenu_SubMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4804 {
4805 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4806 let __vi = *__vt.get(27usize).unwrap_or_else(|| {
4807 panic!(
4808 "unity: virtual slot {}
4809 out of range (vtable len {}
4810) on the runtime class behind {}
4811 (method `{}
4812`)",
4813 27usize,
4814 __vt.len(),
4815 <MapUnitCommandMenu_SubMenuItem as ::unity::ClassIdentity>::NAME,
4816 "get_FlagID",
4817 )
4818 });
4819 let __inner: extern "C" fn(MapUnitCommandMenu_SubMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
4820 ::core::mem::transmute(__vi.method_ptr);
4821 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4822 __inner(__receiver, __mi)
4823 }
4824 }
4825 }
4826 #[doc = "`get_Label()` overload"]
4827 fn get_label(self) -> crate::app::mapsequencehuman::MapSequenceHuman_Label {
4828 unsafe {
4829 let __receiver =
4830 <MapUnitCommandMenu_SubMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4831 {
4832 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4833 let __vi = *__vt.get(36usize).unwrap_or_else(|| {
4834 panic!(
4835 "unity: virtual slot {}
4836 out of range (vtable len {}
4837) on the runtime class behind {}
4838 (method `{}
4839`)",
4840 36usize,
4841 __vt.len(),
4842 <MapUnitCommandMenu_SubMenuItem as ::unity::ClassIdentity>::NAME,
4843 "get_Label",
4844 )
4845 });
4846 let __inner: extern "C" fn(
4847 MapUnitCommandMenu_SubMenuItem,
4848 ::unity::OptionalMethod,
4849 ) -> crate::app::mapsequencehuman::MapSequenceHuman_Label = ::core::mem::transmute(__vi.method_ptr);
4850 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4851 __inner(__receiver, __mi)
4852 }
4853 }
4854 }
4855 #[doc = "`get_ActiveMind()` overload"]
4856 fn get_active_mind(self) -> crate::app::mapmind::MapMind_Type {
4857 unsafe {
4858 let __receiver =
4859 <MapUnitCommandMenu_SubMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4860 {
4861 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4862 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
4863 panic!(
4864 "unity: virtual slot {}
4865 out of range (vtable len {}
4866) on the runtime class behind {}
4867 (method `{}
4868`)",
4869 30usize,
4870 __vt.len(),
4871 <MapUnitCommandMenu_SubMenuItem as ::unity::ClassIdentity>::NAME,
4872 "get_ActiveMind",
4873 )
4874 });
4875 let __inner: extern "C" fn(MapUnitCommandMenu_SubMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
4876 ::core::mem::transmute(__vi.method_ptr);
4877 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4878 __inner(__receiver, __mi)
4879 }
4880 }
4881 }
4882 #[doc = "`.ctor(crate::app::skilldata::SkillData)` overload"]
4883 fn ctor(self, skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>) -> () {
4884 unsafe {
4885 let __receiver =
4886 <MapUnitCommandMenu_SubMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4887 ::unity::il2cpp_call!((::unity::module_base()+0x1e50b20usize)as*mut u8,();
4888(MapUnitCommandMenu_SubMenuItem)__receiver,(crate::app::skilldata::SkillData)::core::convert::Into::into(skill))
4889 }
4890 }
4891 #[doc = "`GetName()` overload"]
4892 fn get_name(self) -> ::unity::Il2CppString {
4893 unsafe {
4894 let __receiver =
4895 <MapUnitCommandMenu_SubMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4896 {
4897 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4898 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
4899 panic!(
4900 "unity: virtual slot {}
4901 out of range (vtable len {}
4902) on the runtime class behind {}
4903 (method `{}
4904`)",
4905 4usize,
4906 __vt.len(),
4907 <MapUnitCommandMenu_SubMenuItem as ::unity::ClassIdentity>::NAME,
4908 "GetName",
4909 )
4910 });
4911 let __inner: extern "C" fn(MapUnitCommandMenu_SubMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
4912 ::core::mem::transmute(__vi.method_ptr);
4913 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4914 __inner(__receiver, __mi)
4915 }
4916 }
4917 }
4918 #[doc = "`GetCommandHelp()` overload"]
4919 fn get_command_help(self) -> ::unity::Il2CppString {
4920 unsafe {
4921 let __receiver =
4922 <MapUnitCommandMenu_SubMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4923 {
4924 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4925 let __vi = *__vt.get(34usize).unwrap_or_else(|| {
4926 panic!(
4927 "unity: virtual slot {}
4928 out of range (vtable len {}
4929) on the runtime class behind {}
4930 (method `{}
4931`)",
4932 34usize,
4933 __vt.len(),
4934 <MapUnitCommandMenu_SubMenuItem as ::unity::ClassIdentity>::NAME,
4935 "GetCommandHelp",
4936 )
4937 });
4938 let __inner: extern "C" fn(MapUnitCommandMenu_SubMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
4939 ::core::mem::transmute(__vi.method_ptr);
4940 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4941 __inner(__receiver, __mi)
4942 }
4943 }
4944 }
4945 #[doc = "`GetMapAttribute()` overload"]
4946 fn get_map_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
4947 unsafe {
4948 let __receiver =
4949 <MapUnitCommandMenu_SubMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4950 {
4951 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4952 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
4953 panic!(
4954 "unity: virtual slot {}
4955 out of range (vtable len {}
4956) on the runtime class behind {}
4957 (method `{}
4958`)",
4959 29usize,
4960 __vt.len(),
4961 <MapUnitCommandMenu_SubMenuItem as ::unity::ClassIdentity>::NAME,
4962 "GetMapAttribute",
4963 )
4964 });
4965 let __inner: extern "C" fn(
4966 MapUnitCommandMenu_SubMenuItem,
4967 ::unity::OptionalMethod,
4968 ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
4969 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4970 __inner(__receiver, __mi)
4971 }
4972 }
4973 }
4974 #[doc = "`ACall()` overload"]
4975 fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
4976 unsafe {
4977 let __receiver =
4978 <MapUnitCommandMenu_SubMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4979 {
4980 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4981 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
4982 panic!(
4983 "unity: virtual slot {}
4984 out of range (vtable len {}
4985) on the runtime class behind {}
4986 (method `{}
4987`)",
4988 18usize,
4989 __vt.len(),
4990 <MapUnitCommandMenu_SubMenuItem as ::unity::ClassIdentity>::NAME,
4991 "ACall",
4992 )
4993 });
4994 let __inner: extern "C" fn(MapUnitCommandMenu_SubMenuItem, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
4995 ::core::mem::transmute(__vi.method_ptr);
4996 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4997 __inner(__receiver, __mi)
4998 }
4999 }
5000 }
5001}
5002
5003#[cfg(feature = "app-mapunitcommandmenu")]
5004impl<__T: IMapUnitCommandMenu_SubMenuItem> IMapUnitCommandMenu_SubMenuItemMethods for __T {}
5005
5006#[cfg(feature = "app-mapunitcommandmenu")]
5007impl MapUnitCommandMenu_SubMenuItem {
5008 pub fn get_flag_id_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5009 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
5010 }
5011
5012 pub fn get_label_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5013 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
5014 }
5015
5016 pub fn get_active_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5017 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
5018 }
5019
5020 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5021 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
5022 }
5023
5024 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5025 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
5026 }
5027
5028 pub fn get_command_help_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5029 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
5030 }
5031
5032 pub fn get_map_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5033 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
5034 }
5035
5036 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5037 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
5038 }
5039}
5040
5041#[cfg(feature = "app-mapunitcommandmenu")]
5042impl MapUnitCommandMenu_SubMenuItem {
5043 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_SubMenuItem`'s own `get_FlagID`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5044 pub unsafe fn get_flag_id(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
5045 let __mi = Self::get_flag_id_method_info();
5046 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
5047 __inner(this.into(), ::core::option::Option::None)
5048 }
5049
5050 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_SubMenuItem`'s own `get_Label`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5051 pub unsafe fn get_label(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapsequencehuman::MapSequenceHuman_Label {
5052 let __mi = Self::get_label_method_info();
5053 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapsequencehuman::MapSequenceHuman_Label =
5054 ::core::mem::transmute(__mi.method_ptr);
5055 __inner(this.into(), ::core::option::Option::None)
5056 }
5057
5058 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_SubMenuItem`'s own `get_ActiveMind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5059 pub unsafe fn get_active_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
5060 let __mi = Self::get_active_mind_method_info();
5061 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
5062 ::core::mem::transmute(__mi.method_ptr);
5063 __inner(this.into(), ::core::option::Option::None)
5064 }
5065
5066 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_SubMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5067 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
5068 let __mi = Self::get_name_method_info();
5069 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
5070 __inner(this.into(), ::core::option::Option::None)
5071 }
5072
5073 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_SubMenuItem`'s own `GetCommandHelp`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5074 pub unsafe fn get_command_help(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
5075 let __mi = Self::get_command_help_method_info();
5076 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
5077 __inner(this.into(), ::core::option::Option::None)
5078 }
5079
5080 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_SubMenuItem`'s own `GetMapAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5081 pub unsafe fn get_map_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
5082 let __mi = Self::get_map_attribute_method_info();
5083 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
5084 ::core::mem::transmute(__mi.method_ptr);
5085 __inner(this.into(), ::core::option::Option::None)
5086 }
5087
5088 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_SubMenuItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5089 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
5090 let __mi = Self::a_call_method_info();
5091 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
5092 ::core::mem::transmute(__mi.method_ptr);
5093 __inner(this.into(), ::core::option::Option::None)
5094 }
5095}
5096
5097#[cfg(feature = "app-mapunitcommandmenu")]
5098impl MapUnitCommandMenu_SubMenuItem {
5099 #[doc = "`.ctor(crate::app::skilldata::SkillData)` — overload selector"]
5100 pub fn new(skill: crate::app::skilldata::SkillData) -> Self {
5101 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
5102 panic!(
5103 "{}
5104::{}
5105 failed to instantiate",
5106 ::core::stringify!(MapUnitCommandMenu_SubMenuItem),
5107 ::core::stringify!(new),
5108 )
5109 });
5110 <Self as IMapUnitCommandMenu_SubMenuItemMethods>::ctor(this, skill);
5111 this
5112 }
5113}
5114
5115#[cfg(feature = "app-mapunitcommandmenu")]
5116pub trait IMapUnitCommandMenu_EngageRodMenuItemMethods: IMapUnitCommandMenu_EngageRodMenuItem {
5117 #[doc = "`get_Mind()` overload"]
5118 fn get_mind(self) -> crate::app::mapmind::MapMind_Type {
5119 unsafe {
5120 let __receiver = <MapUnitCommandMenu_EngageRodMenuItem as ::unity::FromIlInstance>::from_il_instance(
5121 <Self as ::unity::SystemObject>::as_instance(self),
5122 );
5123 {
5124 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5125 let __vi = *__vt.get(37usize).unwrap_or_else(|| {
5126 panic!(
5127 "unity: virtual slot {}
5128 out of range (vtable len {}
5129) on the runtime class behind {}
5130 (method `{}
5131`)",
5132 37usize,
5133 __vt.len(),
5134 <MapUnitCommandMenu_EngageRodMenuItem as ::unity::ClassIdentity>::NAME,
5135 "get_Mind",
5136 )
5137 });
5138 let __inner: extern "C" fn(MapUnitCommandMenu_EngageRodMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
5139 ::core::mem::transmute(__vi.method_ptr);
5140 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5141 __inner(__receiver, __mi)
5142 }
5143 }
5144 }
5145 #[doc = "`get_ActionMask()` overload"]
5146 fn get_action_mask(self) -> crate::app::maptarget::MapTarget_ActionMask {
5147 unsafe {
5148 let __receiver = <MapUnitCommandMenu_EngageRodMenuItem as ::unity::FromIlInstance>::from_il_instance(
5149 <Self as ::unity::SystemObject>::as_instance(self),
5150 );
5151 {
5152 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5153 let __vi = *__vt.get(38usize).unwrap_or_else(|| {
5154 panic!(
5155 "unity: virtual slot {}
5156 out of range (vtable len {}
5157) on the runtime class behind {}
5158 (method `{}
5159`)",
5160 38usize,
5161 __vt.len(),
5162 <MapUnitCommandMenu_EngageRodMenuItem as ::unity::ClassIdentity>::NAME,
5163 "get_ActionMask",
5164 )
5165 });
5166 let __inner: extern "C" fn(
5167 MapUnitCommandMenu_EngageRodMenuItem,
5168 ::unity::OptionalMethod,
5169 ) -> crate::app::maptarget::MapTarget_ActionMask = ::core::mem::transmute(__vi.method_ptr);
5170 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5171 __inner(__receiver, __mi)
5172 }
5173 }
5174 }
5175 #[doc = "`get_Label()` overload"]
5176 fn get_label(self) -> crate::app::mapsequencehuman::MapSequenceHuman_Label {
5177 unsafe {
5178 let __receiver = <MapUnitCommandMenu_EngageRodMenuItem as ::unity::FromIlInstance>::from_il_instance(
5179 <Self as ::unity::SystemObject>::as_instance(self),
5180 );
5181 {
5182 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5183 let __vi = *__vt.get(36usize).unwrap_or_else(|| {
5184 panic!(
5185 "unity: virtual slot {}
5186 out of range (vtable len {}
5187) on the runtime class behind {}
5188 (method `{}
5189`)",
5190 36usize,
5191 __vt.len(),
5192 <MapUnitCommandMenu_EngageRodMenuItem as ::unity::ClassIdentity>::NAME,
5193 "get_Label",
5194 )
5195 });
5196 let __inner: extern "C" fn(
5197 MapUnitCommandMenu_EngageRodMenuItem,
5198 ::unity::OptionalMethod,
5199 ) -> crate::app::mapsequencehuman::MapSequenceHuman_Label = ::core::mem::transmute(__vi.method_ptr);
5200 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5201 __inner(__receiver, __mi)
5202 }
5203 }
5204 }
5205 #[doc = "`get_ActiveMind()` overload"]
5206 fn get_active_mind(self) -> crate::app::mapmind::MapMind_Type {
5207 unsafe {
5208 let __receiver = <MapUnitCommandMenu_EngageRodMenuItem as ::unity::FromIlInstance>::from_il_instance(
5209 <Self as ::unity::SystemObject>::as_instance(self),
5210 );
5211 {
5212 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5213 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
5214 panic!(
5215 "unity: virtual slot {}
5216 out of range (vtable len {}
5217) on the runtime class behind {}
5218 (method `{}
5219`)",
5220 30usize,
5221 __vt.len(),
5222 <MapUnitCommandMenu_EngageRodMenuItem as ::unity::ClassIdentity>::NAME,
5223 "get_ActiveMind",
5224 )
5225 });
5226 let __inner: extern "C" fn(MapUnitCommandMenu_EngageRodMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
5227 ::core::mem::transmute(__vi.method_ptr);
5228 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5229 __inner(__receiver, __mi)
5230 }
5231 }
5232 }
5233 #[doc = "`get_DeployMode()` overload"]
5234 fn get_deploy_mode(self) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
5235 unsafe {
5236 let __receiver = <MapUnitCommandMenu_EngageRodMenuItem as ::unity::FromIlInstance>::from_il_instance(
5237 <Self as ::unity::SystemObject>::as_instance(self),
5238 );
5239 {
5240 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5241 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
5242 panic!(
5243 "unity: virtual slot {}
5244 out of range (vtable len {}
5245) on the runtime class behind {}
5246 (method `{}
5247`)",
5248 31usize,
5249 __vt.len(),
5250 <MapUnitCommandMenu_EngageRodMenuItem as ::unity::ClassIdentity>::NAME,
5251 "get_DeployMode",
5252 )
5253 });
5254 let __inner: extern "C" fn(
5255 MapUnitCommandMenu_EngageRodMenuItem,
5256 ::unity::OptionalMethod,
5257 ) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode = ::core::mem::transmute(__vi.method_ptr);
5258 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5259 __inner(__receiver, __mi)
5260 }
5261 }
5262 }
5263 #[doc = "`get_IsForecast()` overload"]
5264 fn get_is_forecast(self) -> bool {
5265 unsafe {
5266 let __receiver = <MapUnitCommandMenu_EngageRodMenuItem as ::unity::FromIlInstance>::from_il_instance(
5267 <Self as ::unity::SystemObject>::as_instance(self),
5268 );
5269 {
5270 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5271 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
5272 panic!(
5273 "unity: virtual slot {}
5274 out of range (vtable len {}
5275) on the runtime class behind {}
5276 (method `{}
5277`)",
5278 33usize,
5279 __vt.len(),
5280 <MapUnitCommandMenu_EngageRodMenuItem as ::unity::ClassIdentity>::NAME,
5281 "get_IsForecast",
5282 )
5283 });
5284 let __inner: extern "C" fn(MapUnitCommandMenu_EngageRodMenuItem, ::unity::OptionalMethod) -> bool =
5285 ::core::mem::transmute(__vi.method_ptr);
5286 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5287 __inner(__receiver, __mi)
5288 }
5289 }
5290 }
5291 #[doc = "`.ctor()` overload"]
5292 fn ctor(self) -> () {
5293 unsafe {
5294 let __receiver = <MapUnitCommandMenu_EngageRodMenuItem as ::unity::FromIlInstance>::from_il_instance(
5295 <Self as ::unity::SystemObject>::as_instance(self),
5296 );
5297 ::unity::il2cpp_call!((::unity::module_base()+0x1e4e020usize)as*mut u8,();
5298(MapUnitCommandMenu_EngageRodMenuItem)__receiver)
5299 }
5300 }
5301}
5302
5303#[cfg(feature = "app-mapunitcommandmenu")]
5304impl<__T: IMapUnitCommandMenu_EngageRodMenuItem> IMapUnitCommandMenu_EngageRodMenuItemMethods for __T {}
5305
5306#[cfg(feature = "app-mapunitcommandmenu")]
5307impl MapUnitCommandMenu_EngageRodMenuItem {
5308 pub fn get_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5309 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
5310 }
5311
5312 pub fn get_action_mask_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5313 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
5314 }
5315
5316 pub fn get_label_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5317 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
5318 }
5319
5320 pub fn get_active_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5321 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
5322 }
5323
5324 pub fn get_deploy_mode_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5325 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
5326 }
5327
5328 pub fn get_is_forecast_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5329 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
5330 }
5331
5332 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5333 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
5334 }
5335}
5336
5337#[cfg(feature = "app-mapunitcommandmenu")]
5338impl MapUnitCommandMenu_EngageRodMenuItem {
5339 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageRodMenuItem`'s own `get_Mind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5340 pub unsafe fn get_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
5341 let __mi = Self::get_mind_method_info();
5342 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
5343 ::core::mem::transmute(__mi.method_ptr);
5344 __inner(this.into(), ::core::option::Option::None)
5345 }
5346
5347 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageRodMenuItem`'s own `get_ActionMask`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5348 pub unsafe fn get_action_mask(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::maptarget::MapTarget_ActionMask {
5349 let __mi = Self::get_action_mask_method_info();
5350 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::maptarget::MapTarget_ActionMask =
5351 ::core::mem::transmute(__mi.method_ptr);
5352 __inner(this.into(), ::core::option::Option::None)
5353 }
5354
5355 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageRodMenuItem`'s own `get_Label`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5356 pub unsafe fn get_label(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapsequencehuman::MapSequenceHuman_Label {
5357 let __mi = Self::get_label_method_info();
5358 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapsequencehuman::MapSequenceHuman_Label =
5359 ::core::mem::transmute(__mi.method_ptr);
5360 __inner(this.into(), ::core::option::Option::None)
5361 }
5362
5363 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageRodMenuItem`'s own `get_ActiveMind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5364 pub unsafe fn get_active_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
5365 let __mi = Self::get_active_mind_method_info();
5366 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
5367 ::core::mem::transmute(__mi.method_ptr);
5368 __inner(this.into(), ::core::option::Option::None)
5369 }
5370
5371 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageRodMenuItem`'s own `get_DeployMode`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5372 pub unsafe fn get_deploy_mode(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
5373 let __mi = Self::get_deploy_mode_method_info();
5374 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode =
5375 ::core::mem::transmute(__mi.method_ptr);
5376 __inner(this.into(), ::core::option::Option::None)
5377 }
5378
5379 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageRodMenuItem`'s own `get_IsForecast`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5380 pub unsafe fn get_is_forecast(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
5381 let __mi = Self::get_is_forecast_method_info();
5382 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
5383 __inner(this.into(), ::core::option::Option::None)
5384 }
5385}
5386
5387#[cfg(feature = "app-mapunitcommandmenu")]
5388impl MapUnitCommandMenu_EngageRodMenuItem {
5389 #[doc = "`.ctor()` — no args"]
5390 pub fn new() -> Self {
5391 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
5392 panic!(
5393 "{}
5394::{}
5395 failed to instantiate",
5396 ::core::stringify!(MapUnitCommandMenu_EngageRodMenuItem),
5397 ::core::stringify!(new),
5398 )
5399 });
5400 <Self as IMapUnitCommandMenu_EngageRodMenuItemMethods>::ctor(this);
5401 this
5402 }
5403}
5404
5405#[cfg(feature = "app-mapunitcommandmenu")]
5406pub trait IMapUnitCommandMenu_GodChangeMenuItemMethods: IMapUnitCommandMenu_GodChangeMenuItem {
5407 #[doc = "`get_FlagID()` overload"]
5408 fn get_flag_id(self) -> ::unity::Il2CppString {
5409 unsafe {
5410 let __receiver = <MapUnitCommandMenu_GodChangeMenuItem as ::unity::FromIlInstance>::from_il_instance(
5411 <Self as ::unity::SystemObject>::as_instance(self),
5412 );
5413 {
5414 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5415 let __vi = *__vt.get(27usize).unwrap_or_else(|| {
5416 panic!(
5417 "unity: virtual slot {}
5418 out of range (vtable len {}
5419) on the runtime class behind {}
5420 (method `{}
5421`)",
5422 27usize,
5423 __vt.len(),
5424 <MapUnitCommandMenu_GodChangeMenuItem as ::unity::ClassIdentity>::NAME,
5425 "get_FlagID",
5426 )
5427 });
5428 let __inner: extern "C" fn(MapUnitCommandMenu_GodChangeMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
5429 ::core::mem::transmute(__vi.method_ptr);
5430 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5431 __inner(__receiver, __mi)
5432 }
5433 }
5434 }
5435 #[doc = "`get_Label()` overload"]
5436 fn get_label(self) -> crate::app::mapsequencehuman::MapSequenceHuman_Label {
5437 unsafe {
5438 let __receiver = <MapUnitCommandMenu_GodChangeMenuItem as ::unity::FromIlInstance>::from_il_instance(
5439 <Self as ::unity::SystemObject>::as_instance(self),
5440 );
5441 {
5442 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5443 let __vi = *__vt.get(36usize).unwrap_or_else(|| {
5444 panic!(
5445 "unity: virtual slot {}
5446 out of range (vtable len {}
5447) on the runtime class behind {}
5448 (method `{}
5449`)",
5450 36usize,
5451 __vt.len(),
5452 <MapUnitCommandMenu_GodChangeMenuItem as ::unity::ClassIdentity>::NAME,
5453 "get_Label",
5454 )
5455 });
5456 let __inner: extern "C" fn(
5457 MapUnitCommandMenu_GodChangeMenuItem,
5458 ::unity::OptionalMethod,
5459 ) -> crate::app::mapsequencehuman::MapSequenceHuman_Label = ::core::mem::transmute(__vi.method_ptr);
5460 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5461 __inner(__receiver, __mi)
5462 }
5463 }
5464 }
5465 #[doc = "`get_ActiveMind()` overload"]
5466 fn get_active_mind(self) -> crate::app::mapmind::MapMind_Type {
5467 unsafe {
5468 let __receiver = <MapUnitCommandMenu_GodChangeMenuItem as ::unity::FromIlInstance>::from_il_instance(
5469 <Self as ::unity::SystemObject>::as_instance(self),
5470 );
5471 {
5472 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5473 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
5474 panic!(
5475 "unity: virtual slot {}
5476 out of range (vtable len {}
5477) on the runtime class behind {}
5478 (method `{}
5479`)",
5480 30usize,
5481 __vt.len(),
5482 <MapUnitCommandMenu_GodChangeMenuItem as ::unity::ClassIdentity>::NAME,
5483 "get_ActiveMind",
5484 )
5485 });
5486 let __inner: extern "C" fn(MapUnitCommandMenu_GodChangeMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
5487 ::core::mem::transmute(__vi.method_ptr);
5488 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5489 __inner(__receiver, __mi)
5490 }
5491 }
5492 }
5493 #[doc = "`get_DeployMode()` overload"]
5494 fn get_deploy_mode(self) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
5495 unsafe {
5496 let __receiver = <MapUnitCommandMenu_GodChangeMenuItem as ::unity::FromIlInstance>::from_il_instance(
5497 <Self as ::unity::SystemObject>::as_instance(self),
5498 );
5499 {
5500 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5501 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
5502 panic!(
5503 "unity: virtual slot {}
5504 out of range (vtable len {}
5505) on the runtime class behind {}
5506 (method `{}
5507`)",
5508 31usize,
5509 __vt.len(),
5510 <MapUnitCommandMenu_GodChangeMenuItem as ::unity::ClassIdentity>::NAME,
5511 "get_DeployMode",
5512 )
5513 });
5514 let __inner: extern "C" fn(
5515 MapUnitCommandMenu_GodChangeMenuItem,
5516 ::unity::OptionalMethod,
5517 ) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode = ::core::mem::transmute(__vi.method_ptr);
5518 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5519 __inner(__receiver, __mi)
5520 }
5521 }
5522 }
5523 #[doc = "`GetName()` overload"]
5524 fn get_name(self) -> ::unity::Il2CppString {
5525 unsafe {
5526 let __receiver = <MapUnitCommandMenu_GodChangeMenuItem as ::unity::FromIlInstance>::from_il_instance(
5527 <Self as ::unity::SystemObject>::as_instance(self),
5528 );
5529 {
5530 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5531 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
5532 panic!(
5533 "unity: virtual slot {}
5534 out of range (vtable len {}
5535) on the runtime class behind {}
5536 (method `{}
5537`)",
5538 4usize,
5539 __vt.len(),
5540 <MapUnitCommandMenu_GodChangeMenuItem as ::unity::ClassIdentity>::NAME,
5541 "GetName",
5542 )
5543 });
5544 let __inner: extern "C" fn(MapUnitCommandMenu_GodChangeMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
5545 ::core::mem::transmute(__vi.method_ptr);
5546 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5547 __inner(__receiver, __mi)
5548 }
5549 }
5550 }
5551 #[doc = "`GetCommandHelp()` overload"]
5552 fn get_command_help(self) -> ::unity::Il2CppString {
5553 unsafe {
5554 let __receiver = <MapUnitCommandMenu_GodChangeMenuItem as ::unity::FromIlInstance>::from_il_instance(
5555 <Self as ::unity::SystemObject>::as_instance(self),
5556 );
5557 {
5558 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5559 let __vi = *__vt.get(34usize).unwrap_or_else(|| {
5560 panic!(
5561 "unity: virtual slot {}
5562 out of range (vtable len {}
5563) on the runtime class behind {}
5564 (method `{}
5565`)",
5566 34usize,
5567 __vt.len(),
5568 <MapUnitCommandMenu_GodChangeMenuItem as ::unity::ClassIdentity>::NAME,
5569 "GetCommandHelp",
5570 )
5571 });
5572 let __inner: extern "C" fn(MapUnitCommandMenu_GodChangeMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
5573 ::core::mem::transmute(__vi.method_ptr);
5574 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5575 __inner(__receiver, __mi)
5576 }
5577 }
5578 }
5579 #[doc = "`GetMapAttribute()` overload"]
5580 fn get_map_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
5581 unsafe {
5582 let __receiver = <MapUnitCommandMenu_GodChangeMenuItem as ::unity::FromIlInstance>::from_il_instance(
5583 <Self as ::unity::SystemObject>::as_instance(self),
5584 );
5585 {
5586 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5587 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
5588 panic!(
5589 "unity: virtual slot {}
5590 out of range (vtable len {}
5591) on the runtime class behind {}
5592 (method `{}
5593`)",
5594 29usize,
5595 __vt.len(),
5596 <MapUnitCommandMenu_GodChangeMenuItem as ::unity::ClassIdentity>::NAME,
5597 "GetMapAttribute",
5598 )
5599 });
5600 let __inner: extern "C" fn(
5601 MapUnitCommandMenu_GodChangeMenuItem,
5602 ::unity::OptionalMethod,
5603 ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
5604 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5605 __inner(__receiver, __mi)
5606 }
5607 }
5608 }
5609 #[doc = "`.ctor()` overload"]
5610 fn ctor(self) -> () {
5611 unsafe {
5612 let __receiver = <MapUnitCommandMenu_GodChangeMenuItem as ::unity::FromIlInstance>::from_il_instance(
5613 <Self as ::unity::SystemObject>::as_instance(self),
5614 );
5615 ::unity::il2cpp_call!((::unity::module_base()+0x1e4ebc0usize)as*mut u8,();
5616(MapUnitCommandMenu_GodChangeMenuItem)__receiver)
5617 }
5618 }
5619}
5620
5621#[cfg(feature = "app-mapunitcommandmenu")]
5622impl<__T: IMapUnitCommandMenu_GodChangeMenuItem> IMapUnitCommandMenu_GodChangeMenuItemMethods for __T {}
5623
5624#[cfg(feature = "app-mapunitcommandmenu")]
5625impl MapUnitCommandMenu_GodChangeMenuItem {
5626 pub fn get_flag_id_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5627 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
5628 }
5629
5630 pub fn get_label_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5631 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
5632 }
5633
5634 pub fn get_active_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5635 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
5636 }
5637
5638 pub fn get_deploy_mode_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5639 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
5640 }
5641
5642 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5643 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
5644 }
5645
5646 pub fn get_command_help_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5647 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
5648 }
5649
5650 pub fn get_map_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5651 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
5652 }
5653
5654 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5655 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
5656 }
5657}
5658
5659#[cfg(feature = "app-mapunitcommandmenu")]
5660impl MapUnitCommandMenu_GodChangeMenuItem {
5661 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_GodChangeMenuItem`'s own `get_FlagID`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5662 pub unsafe fn get_flag_id(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
5663 let __mi = Self::get_flag_id_method_info();
5664 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
5665 __inner(this.into(), ::core::option::Option::None)
5666 }
5667
5668 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_GodChangeMenuItem`'s own `get_Label`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5669 pub unsafe fn get_label(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapsequencehuman::MapSequenceHuman_Label {
5670 let __mi = Self::get_label_method_info();
5671 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapsequencehuman::MapSequenceHuman_Label =
5672 ::core::mem::transmute(__mi.method_ptr);
5673 __inner(this.into(), ::core::option::Option::None)
5674 }
5675
5676 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_GodChangeMenuItem`'s own `get_ActiveMind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5677 pub unsafe fn get_active_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
5678 let __mi = Self::get_active_mind_method_info();
5679 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
5680 ::core::mem::transmute(__mi.method_ptr);
5681 __inner(this.into(), ::core::option::Option::None)
5682 }
5683
5684 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_GodChangeMenuItem`'s own `get_DeployMode`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5685 pub unsafe fn get_deploy_mode(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
5686 let __mi = Self::get_deploy_mode_method_info();
5687 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode =
5688 ::core::mem::transmute(__mi.method_ptr);
5689 __inner(this.into(), ::core::option::Option::None)
5690 }
5691
5692 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_GodChangeMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5693 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
5694 let __mi = Self::get_name_method_info();
5695 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
5696 __inner(this.into(), ::core::option::Option::None)
5697 }
5698
5699 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_GodChangeMenuItem`'s own `GetCommandHelp`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5700 pub unsafe fn get_command_help(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
5701 let __mi = Self::get_command_help_method_info();
5702 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
5703 __inner(this.into(), ::core::option::Option::None)
5704 }
5705
5706 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_GodChangeMenuItem`'s own `GetMapAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5707 pub unsafe fn get_map_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
5708 let __mi = Self::get_map_attribute_method_info();
5709 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
5710 ::core::mem::transmute(__mi.method_ptr);
5711 __inner(this.into(), ::core::option::Option::None)
5712 }
5713}
5714
5715#[cfg(feature = "app-mapunitcommandmenu")]
5716impl MapUnitCommandMenu_GodChangeMenuItem {
5717 #[doc = "`.ctor()` — no args"]
5718 pub fn new() -> Self {
5719 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
5720 panic!(
5721 "{}
5722::{}
5723 failed to instantiate",
5724 ::core::stringify!(MapUnitCommandMenu_GodChangeMenuItem),
5725 ::core::stringify!(new),
5726 )
5727 });
5728 <Self as IMapUnitCommandMenu_GodChangeMenuItemMethods>::ctor(this);
5729 this
5730 }
5731}
5732
5733#[cfg(feature = "app-mapunitcommandmenu")]
5734pub trait IMapUnitCommandMenu_EscapeMenuItemMethods: IMapUnitCommandMenu_EscapeMenuItem {
5735 #[doc = "`get_FlagID()` overload"]
5736 fn get_flag_id(self) -> ::unity::Il2CppString {
5737 unsafe {
5738 let __receiver =
5739 <MapUnitCommandMenu_EscapeMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
5740 {
5741 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5742 let __vi = *__vt.get(27usize).unwrap_or_else(|| {
5743 panic!(
5744 "unity: virtual slot {}
5745 out of range (vtable len {}
5746) on the runtime class behind {}
5747 (method `{}
5748`)",
5749 27usize,
5750 __vt.len(),
5751 <MapUnitCommandMenu_EscapeMenuItem as ::unity::ClassIdentity>::NAME,
5752 "get_FlagID",
5753 )
5754 });
5755 let __inner: extern "C" fn(MapUnitCommandMenu_EscapeMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
5756 ::core::mem::transmute(__vi.method_ptr);
5757 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5758 __inner(__receiver, __mi)
5759 }
5760 }
5761 }
5762 #[doc = "`get_Mind()` overload"]
5763 fn get_mind(self) -> crate::app::mapmind::MapMind_Type {
5764 unsafe {
5765 let __receiver =
5766 <MapUnitCommandMenu_EscapeMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
5767 {
5768 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5769 let __vi = *__vt.get(36usize).unwrap_or_else(|| {
5770 panic!(
5771 "unity: virtual slot {}
5772 out of range (vtable len {}
5773) on the runtime class behind {}
5774 (method `{}
5775`)",
5776 36usize,
5777 __vt.len(),
5778 <MapUnitCommandMenu_EscapeMenuItem as ::unity::ClassIdentity>::NAME,
5779 "get_Mind",
5780 )
5781 });
5782 let __inner: extern "C" fn(MapUnitCommandMenu_EscapeMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
5783 ::core::mem::transmute(__vi.method_ptr);
5784 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5785 __inner(__receiver, __mi)
5786 }
5787 }
5788 }
5789 #[doc = "`get_ActiveMind()` overload"]
5790 fn get_active_mind(self) -> crate::app::mapmind::MapMind_Type {
5791 unsafe {
5792 let __receiver =
5793 <MapUnitCommandMenu_EscapeMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
5794 {
5795 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5796 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
5797 panic!(
5798 "unity: virtual slot {}
5799 out of range (vtable len {}
5800) on the runtime class behind {}
5801 (method `{}
5802`)",
5803 30usize,
5804 __vt.len(),
5805 <MapUnitCommandMenu_EscapeMenuItem as ::unity::ClassIdentity>::NAME,
5806 "get_ActiveMind",
5807 )
5808 });
5809 let __inner: extern "C" fn(MapUnitCommandMenu_EscapeMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
5810 ::core::mem::transmute(__vi.method_ptr);
5811 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5812 __inner(__receiver, __mi)
5813 }
5814 }
5815 }
5816 #[doc = "`OnBuild()` overload"]
5817 fn on_build(self) -> () {
5818 unsafe {
5819 let __receiver =
5820 <MapUnitCommandMenu_EscapeMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
5821 {
5822 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5823 let __vi = *__vt.get(10usize).unwrap_or_else(|| {
5824 panic!(
5825 "unity: virtual slot {}
5826 out of range (vtable len {}
5827) on the runtime class behind {}
5828 (method `{}
5829`)",
5830 10usize,
5831 __vt.len(),
5832 <MapUnitCommandMenu_EscapeMenuItem as ::unity::ClassIdentity>::NAME,
5833 "OnBuild",
5834 )
5835 });
5836 let __inner: extern "C" fn(MapUnitCommandMenu_EscapeMenuItem, ::unity::OptionalMethod) -> () =
5837 ::core::mem::transmute(__vi.method_ptr);
5838 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5839 __inner(__receiver, __mi)
5840 }
5841 }
5842 }
5843 #[doc = "`OnBuildMenuItemContent()` overload"]
5844 fn on_build_menu_item_content(self) -> () {
5845 unsafe {
5846 let __receiver =
5847 <MapUnitCommandMenu_EscapeMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
5848 {
5849 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5850 let __vi = *__vt.get(11usize).unwrap_or_else(|| {
5851 panic!(
5852 "unity: virtual slot {}
5853 out of range (vtable len {}
5854) on the runtime class behind {}
5855 (method `{}
5856`)",
5857 11usize,
5858 __vt.len(),
5859 <MapUnitCommandMenu_EscapeMenuItem as ::unity::ClassIdentity>::NAME,
5860 "OnBuildMenuItemContent",
5861 )
5862 });
5863 let __inner: extern "C" fn(MapUnitCommandMenu_EscapeMenuItem, ::unity::OptionalMethod) -> () =
5864 ::core::mem::transmute(__vi.method_ptr);
5865 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5866 __inner(__receiver, __mi)
5867 }
5868 }
5869 }
5870 #[doc = "`GetName()` overload"]
5871 fn get_name(self) -> ::unity::Il2CppString {
5872 unsafe {
5873 let __receiver =
5874 <MapUnitCommandMenu_EscapeMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
5875 {
5876 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5877 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
5878 panic!(
5879 "unity: virtual slot {}
5880 out of range (vtable len {}
5881) on the runtime class behind {}
5882 (method `{}
5883`)",
5884 4usize,
5885 __vt.len(),
5886 <MapUnitCommandMenu_EscapeMenuItem as ::unity::ClassIdentity>::NAME,
5887 "GetName",
5888 )
5889 });
5890 let __inner: extern "C" fn(MapUnitCommandMenu_EscapeMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
5891 ::core::mem::transmute(__vi.method_ptr);
5892 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5893 __inner(__receiver, __mi)
5894 }
5895 }
5896 }
5897 #[doc = "`GetCommandHelp()` overload"]
5898 fn get_command_help(self) -> ::unity::Il2CppString {
5899 unsafe {
5900 let __receiver =
5901 <MapUnitCommandMenu_EscapeMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
5902 {
5903 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5904 let __vi = *__vt.get(34usize).unwrap_or_else(|| {
5905 panic!(
5906 "unity: virtual slot {}
5907 out of range (vtable len {}
5908) on the runtime class behind {}
5909 (method `{}
5910`)",
5911 34usize,
5912 __vt.len(),
5913 <MapUnitCommandMenu_EscapeMenuItem as ::unity::ClassIdentity>::NAME,
5914 "GetCommandHelp",
5915 )
5916 });
5917 let __inner: extern "C" fn(MapUnitCommandMenu_EscapeMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
5918 ::core::mem::transmute(__vi.method_ptr);
5919 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5920 __inner(__receiver, __mi)
5921 }
5922 }
5923 }
5924 #[doc = "`GetMapAttribute()` overload"]
5925 fn get_map_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
5926 unsafe {
5927 let __receiver =
5928 <MapUnitCommandMenu_EscapeMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
5929 {
5930 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5931 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
5932 panic!(
5933 "unity: virtual slot {}
5934 out of range (vtable len {}
5935) on the runtime class behind {}
5936 (method `{}
5937`)",
5938 29usize,
5939 __vt.len(),
5940 <MapUnitCommandMenu_EscapeMenuItem as ::unity::ClassIdentity>::NAME,
5941 "GetMapAttribute",
5942 )
5943 });
5944 let __inner: extern "C" fn(
5945 MapUnitCommandMenu_EscapeMenuItem,
5946 ::unity::OptionalMethod,
5947 ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
5948 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5949 __inner(__receiver, __mi)
5950 }
5951 }
5952 }
5953 #[doc = "`.ctor()` overload"]
5954 fn ctor(self) -> () {
5955 unsafe {
5956 let __receiver =
5957 <MapUnitCommandMenu_EscapeMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
5958 ::unity::il2cpp_call!((::unity::module_base()+0x1e4e740usize)as*mut u8,();
5959(MapUnitCommandMenu_EscapeMenuItem)__receiver)
5960 }
5961 }
5962}
5963
5964#[cfg(feature = "app-mapunitcommandmenu")]
5965impl<__T: IMapUnitCommandMenu_EscapeMenuItem> IMapUnitCommandMenu_EscapeMenuItemMethods for __T {}
5966
5967#[cfg(feature = "app-mapunitcommandmenu")]
5968impl MapUnitCommandMenu_EscapeMenuItem {
5969 pub fn get_flag_id_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5970 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
5971 }
5972
5973 pub fn get_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5974 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
5975 }
5976
5977 pub fn get_active_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5978 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
5979 }
5980
5981 pub fn on_build_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5982 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
5983 }
5984
5985 pub fn on_build_menu_item_content_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5986 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
5987 }
5988
5989 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5990 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
5991 }
5992
5993 pub fn get_command_help_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5994 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
5995 }
5996
5997 pub fn get_map_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5998 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
5999 }
6000
6001 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6002 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
6003 }
6004}
6005
6006#[cfg(feature = "app-mapunitcommandmenu")]
6007impl MapUnitCommandMenu_EscapeMenuItem {
6008 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EscapeMenuItem`'s own `get_FlagID`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6009 pub unsafe fn get_flag_id(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
6010 let __mi = Self::get_flag_id_method_info();
6011 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
6012 __inner(this.into(), ::core::option::Option::None)
6013 }
6014
6015 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EscapeMenuItem`'s own `get_Mind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6016 pub unsafe fn get_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
6017 let __mi = Self::get_mind_method_info();
6018 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
6019 ::core::mem::transmute(__mi.method_ptr);
6020 __inner(this.into(), ::core::option::Option::None)
6021 }
6022
6023 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EscapeMenuItem`'s own `get_ActiveMind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6024 pub unsafe fn get_active_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
6025 let __mi = Self::get_active_mind_method_info();
6026 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
6027 ::core::mem::transmute(__mi.method_ptr);
6028 __inner(this.into(), ::core::option::Option::None)
6029 }
6030
6031 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EscapeMenuItem`'s own `OnBuild`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6032 pub unsafe fn on_build(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
6033 let __mi = Self::on_build_method_info();
6034 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
6035 __inner(this.into(), ::core::option::Option::None)
6036 }
6037
6038 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EscapeMenuItem`'s own `OnBuildMenuItemContent`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6039 pub unsafe fn on_build_menu_item_content(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
6040 let __mi = Self::on_build_menu_item_content_method_info();
6041 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
6042 __inner(this.into(), ::core::option::Option::None)
6043 }
6044
6045 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EscapeMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6046 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
6047 let __mi = Self::get_name_method_info();
6048 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
6049 __inner(this.into(), ::core::option::Option::None)
6050 }
6051
6052 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EscapeMenuItem`'s own `GetCommandHelp`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6053 pub unsafe fn get_command_help(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
6054 let __mi = Self::get_command_help_method_info();
6055 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
6056 __inner(this.into(), ::core::option::Option::None)
6057 }
6058
6059 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EscapeMenuItem`'s own `GetMapAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6060 pub unsafe fn get_map_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
6061 let __mi = Self::get_map_attribute_method_info();
6062 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
6063 ::core::mem::transmute(__mi.method_ptr);
6064 __inner(this.into(), ::core::option::Option::None)
6065 }
6066}
6067
6068#[cfg(feature = "app-mapunitcommandmenu")]
6069impl MapUnitCommandMenu_EscapeMenuItem {
6070 #[doc = "`.ctor()` — no args"]
6071 pub fn new() -> Self {
6072 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
6073 panic!(
6074 "{}
6075::{}
6076 failed to instantiate",
6077 ::core::stringify!(MapUnitCommandMenu_EscapeMenuItem),
6078 ::core::stringify!(new),
6079 )
6080 });
6081 <Self as IMapUnitCommandMenu_EscapeMenuItemMethods>::ctor(this);
6082 this
6083 }
6084}
6085
6086#[cfg(feature = "app-mapunitcommandmenu")]
6087pub trait IMapUnitCommandMenu_DanceMenuItemMethods: IMapUnitCommandMenu_DanceMenuItem {
6088 #[doc = "`get_FlagID()` overload"]
6089 fn get_flag_id(self) -> ::unity::Il2CppString {
6090 unsafe {
6091 let __receiver =
6092 <MapUnitCommandMenu_DanceMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6093 {
6094 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
6095 let __vi = *__vt.get(27usize).unwrap_or_else(|| {
6096 panic!(
6097 "unity: virtual slot {}
6098 out of range (vtable len {}
6099) on the runtime class behind {}
6100 (method `{}
6101`)",
6102 27usize,
6103 __vt.len(),
6104 <MapUnitCommandMenu_DanceMenuItem as ::unity::ClassIdentity>::NAME,
6105 "get_FlagID",
6106 )
6107 });
6108 let __inner: extern "C" fn(MapUnitCommandMenu_DanceMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
6109 ::core::mem::transmute(__vi.method_ptr);
6110 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
6111 __inner(__receiver, __mi)
6112 }
6113 }
6114 }
6115 #[doc = "`get_Mind()` overload"]
6116 fn get_mind(self) -> crate::app::mapmind::MapMind_Type {
6117 unsafe {
6118 let __receiver =
6119 <MapUnitCommandMenu_DanceMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6120 {
6121 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
6122 let __vi = *__vt.get(36usize).unwrap_or_else(|| {
6123 panic!(
6124 "unity: virtual slot {}
6125 out of range (vtable len {}
6126) on the runtime class behind {}
6127 (method `{}
6128`)",
6129 36usize,
6130 __vt.len(),
6131 <MapUnitCommandMenu_DanceMenuItem as ::unity::ClassIdentity>::NAME,
6132 "get_Mind",
6133 )
6134 });
6135 let __inner: extern "C" fn(MapUnitCommandMenu_DanceMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
6136 ::core::mem::transmute(__vi.method_ptr);
6137 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
6138 __inner(__receiver, __mi)
6139 }
6140 }
6141 }
6142 #[doc = "`get_DeployMode()` overload"]
6143 fn get_deploy_mode(self) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
6144 unsafe {
6145 let __receiver =
6146 <MapUnitCommandMenu_DanceMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6147 {
6148 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
6149 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
6150 panic!(
6151 "unity: virtual slot {}
6152 out of range (vtable len {}
6153) on the runtime class behind {}
6154 (method `{}
6155`)",
6156 31usize,
6157 __vt.len(),
6158 <MapUnitCommandMenu_DanceMenuItem as ::unity::ClassIdentity>::NAME,
6159 "get_DeployMode",
6160 )
6161 });
6162 let __inner: extern "C" fn(
6163 MapUnitCommandMenu_DanceMenuItem,
6164 ::unity::OptionalMethod,
6165 ) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode = ::core::mem::transmute(__vi.method_ptr);
6166 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
6167 __inner(__receiver, __mi)
6168 }
6169 }
6170 }
6171 #[doc = "`get_ActiveMind()` overload"]
6172 fn get_active_mind(self) -> crate::app::mapmind::MapMind_Type {
6173 unsafe {
6174 let __receiver =
6175 <MapUnitCommandMenu_DanceMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6176 {
6177 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
6178 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
6179 panic!(
6180 "unity: virtual slot {}
6181 out of range (vtable len {}
6182) on the runtime class behind {}
6183 (method `{}
6184`)",
6185 30usize,
6186 __vt.len(),
6187 <MapUnitCommandMenu_DanceMenuItem as ::unity::ClassIdentity>::NAME,
6188 "get_ActiveMind",
6189 )
6190 });
6191 let __inner: extern "C" fn(MapUnitCommandMenu_DanceMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
6192 ::core::mem::transmute(__vi.method_ptr);
6193 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
6194 __inner(__receiver, __mi)
6195 }
6196 }
6197 }
6198 #[doc = "`GetName()` overload"]
6199 fn get_name(self) -> ::unity::Il2CppString {
6200 unsafe {
6201 let __receiver =
6202 <MapUnitCommandMenu_DanceMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6203 {
6204 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
6205 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
6206 panic!(
6207 "unity: virtual slot {}
6208 out of range (vtable len {}
6209) on the runtime class behind {}
6210 (method `{}
6211`)",
6212 4usize,
6213 __vt.len(),
6214 <MapUnitCommandMenu_DanceMenuItem as ::unity::ClassIdentity>::NAME,
6215 "GetName",
6216 )
6217 });
6218 let __inner: extern "C" fn(MapUnitCommandMenu_DanceMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
6219 ::core::mem::transmute(__vi.method_ptr);
6220 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
6221 __inner(__receiver, __mi)
6222 }
6223 }
6224 }
6225 #[doc = "`GetCommandHelp()` overload"]
6226 fn get_command_help(self) -> ::unity::Il2CppString {
6227 unsafe {
6228 let __receiver =
6229 <MapUnitCommandMenu_DanceMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6230 {
6231 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
6232 let __vi = *__vt.get(34usize).unwrap_or_else(|| {
6233 panic!(
6234 "unity: virtual slot {}
6235 out of range (vtable len {}
6236) on the runtime class behind {}
6237 (method `{}
6238`)",
6239 34usize,
6240 __vt.len(),
6241 <MapUnitCommandMenu_DanceMenuItem as ::unity::ClassIdentity>::NAME,
6242 "GetCommandHelp",
6243 )
6244 });
6245 let __inner: extern "C" fn(MapUnitCommandMenu_DanceMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
6246 ::core::mem::transmute(__vi.method_ptr);
6247 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
6248 __inner(__receiver, __mi)
6249 }
6250 }
6251 }
6252 #[doc = "`GetMapAttribute()` overload"]
6253 fn get_map_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
6254 unsafe {
6255 let __receiver =
6256 <MapUnitCommandMenu_DanceMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6257 {
6258 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
6259 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
6260 panic!(
6261 "unity: virtual slot {}
6262 out of range (vtable len {}
6263) on the runtime class behind {}
6264 (method `{}
6265`)",
6266 29usize,
6267 __vt.len(),
6268 <MapUnitCommandMenu_DanceMenuItem as ::unity::ClassIdentity>::NAME,
6269 "GetMapAttribute",
6270 )
6271 });
6272 let __inner: extern "C" fn(
6273 MapUnitCommandMenu_DanceMenuItem,
6274 ::unity::OptionalMethod,
6275 ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
6276 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
6277 __inner(__receiver, __mi)
6278 }
6279 }
6280 }
6281 #[doc = "`.ctor()` overload"]
6282 fn ctor(self) -> () {
6283 unsafe {
6284 let __receiver =
6285 <MapUnitCommandMenu_DanceMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6286 ::unity::il2cpp_call!((::unity::module_base()+0x1e4bee0usize)as*mut u8,();
6287(MapUnitCommandMenu_DanceMenuItem)__receiver)
6288 }
6289 }
6290}
6291
6292#[cfg(feature = "app-mapunitcommandmenu")]
6293impl<__T: IMapUnitCommandMenu_DanceMenuItem> IMapUnitCommandMenu_DanceMenuItemMethods for __T {}
6294
6295#[cfg(feature = "app-mapunitcommandmenu")]
6296impl MapUnitCommandMenu_DanceMenuItem {
6297 pub fn get_flag_id_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6298 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
6299 }
6300
6301 pub fn get_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6302 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
6303 }
6304
6305 pub fn get_deploy_mode_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6306 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
6307 }
6308
6309 pub fn get_active_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6310 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
6311 }
6312
6313 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6314 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
6315 }
6316
6317 pub fn get_command_help_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6318 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
6319 }
6320
6321 pub fn get_map_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6322 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
6323 }
6324
6325 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6326 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
6327 }
6328}
6329
6330#[cfg(feature = "app-mapunitcommandmenu")]
6331impl MapUnitCommandMenu_DanceMenuItem {
6332 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_DanceMenuItem`'s own `get_FlagID`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6333 pub unsafe fn get_flag_id(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
6334 let __mi = Self::get_flag_id_method_info();
6335 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
6336 __inner(this.into(), ::core::option::Option::None)
6337 }
6338
6339 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_DanceMenuItem`'s own `get_Mind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6340 pub unsafe fn get_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
6341 let __mi = Self::get_mind_method_info();
6342 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
6343 ::core::mem::transmute(__mi.method_ptr);
6344 __inner(this.into(), ::core::option::Option::None)
6345 }
6346
6347 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_DanceMenuItem`'s own `get_DeployMode`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6348 pub unsafe fn get_deploy_mode(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
6349 let __mi = Self::get_deploy_mode_method_info();
6350 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode =
6351 ::core::mem::transmute(__mi.method_ptr);
6352 __inner(this.into(), ::core::option::Option::None)
6353 }
6354
6355 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_DanceMenuItem`'s own `get_ActiveMind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6356 pub unsafe fn get_active_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
6357 let __mi = Self::get_active_mind_method_info();
6358 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
6359 ::core::mem::transmute(__mi.method_ptr);
6360 __inner(this.into(), ::core::option::Option::None)
6361 }
6362
6363 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_DanceMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6364 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
6365 let __mi = Self::get_name_method_info();
6366 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
6367 __inner(this.into(), ::core::option::Option::None)
6368 }
6369
6370 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_DanceMenuItem`'s own `GetCommandHelp`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6371 pub unsafe fn get_command_help(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
6372 let __mi = Self::get_command_help_method_info();
6373 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
6374 __inner(this.into(), ::core::option::Option::None)
6375 }
6376
6377 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_DanceMenuItem`'s own `GetMapAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6378 pub unsafe fn get_map_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
6379 let __mi = Self::get_map_attribute_method_info();
6380 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
6381 ::core::mem::transmute(__mi.method_ptr);
6382 __inner(this.into(), ::core::option::Option::None)
6383 }
6384}
6385
6386#[cfg(feature = "app-mapunitcommandmenu")]
6387impl MapUnitCommandMenu_DanceMenuItem {
6388 #[doc = "`.ctor()` — no args"]
6389 pub fn new() -> Self {
6390 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
6391 panic!(
6392 "{}
6393::{}
6394 failed to instantiate",
6395 ::core::stringify!(MapUnitCommandMenu_DanceMenuItem),
6396 ::core::stringify!(new),
6397 )
6398 });
6399 <Self as IMapUnitCommandMenu_DanceMenuItemMethods>::ctor(this);
6400 this
6401 }
6402}
6403
6404#[cfg(feature = "app-mapunitcommandmenu")]
6405pub trait IMapUnitCommandMenu_BaseMenuItemMethods: IMapUnitCommandMenu_BaseMenuItem {
6406 #[doc = "`get_ActiveMind()` overload"]
6407 fn get_active_mind(self) -> crate::app::mapmind::MapMind_Type {
6408 unsafe {
6409 let __receiver =
6410 <MapUnitCommandMenu_BaseMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6411 {
6412 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
6413 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
6414 panic!(
6415 "unity: virtual slot {}
6416 out of range (vtable len {}
6417) on the runtime class behind {}
6418 (method `{}
6419`)",
6420 30usize,
6421 __vt.len(),
6422 <MapUnitCommandMenu_BaseMenuItem as ::unity::ClassIdentity>::NAME,
6423 "get_ActiveMind",
6424 )
6425 });
6426 let __inner: extern "C" fn(MapUnitCommandMenu_BaseMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
6427 ::core::mem::transmute(__vi.method_ptr);
6428 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
6429 __inner(__receiver, __mi)
6430 }
6431 }
6432 }
6433 #[doc = "`get_DeployMode()` overload"]
6434 fn get_deploy_mode(self) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
6435 unsafe {
6436 let __receiver =
6437 <MapUnitCommandMenu_BaseMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6438 {
6439 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
6440 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
6441 panic!(
6442 "unity: virtual slot {}
6443 out of range (vtable len {}
6444) on the runtime class behind {}
6445 (method `{}
6446`)",
6447 31usize,
6448 __vt.len(),
6449 <MapUnitCommandMenu_BaseMenuItem as ::unity::ClassIdentity>::NAME,
6450 "get_DeployMode",
6451 )
6452 });
6453 let __inner: extern "C" fn(
6454 MapUnitCommandMenu_BaseMenuItem,
6455 ::unity::OptionalMethod,
6456 ) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode = ::core::mem::transmute(__vi.method_ptr);
6457 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
6458 __inner(__receiver, __mi)
6459 }
6460 }
6461 }
6462 #[doc = "`get_CommandSkill()` overload"]
6463 fn get_command_skill(self) -> crate::app::skilldata::SkillData {
6464 unsafe {
6465 let __receiver =
6466 <MapUnitCommandMenu_BaseMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6467 {
6468 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
6469 let __vi = *__vt.get(32usize).unwrap_or_else(|| {
6470 panic!(
6471 "unity: virtual slot {}
6472 out of range (vtable len {}
6473) on the runtime class behind {}
6474 (method `{}
6475`)",
6476 32usize,
6477 __vt.len(),
6478 <MapUnitCommandMenu_BaseMenuItem as ::unity::ClassIdentity>::NAME,
6479 "get_CommandSkill",
6480 )
6481 });
6482 let __inner: extern "C" fn(MapUnitCommandMenu_BaseMenuItem, ::unity::OptionalMethod) -> crate::app::skilldata::SkillData =
6483 ::core::mem::transmute(__vi.method_ptr);
6484 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
6485 __inner(__receiver, __mi)
6486 }
6487 }
6488 }
6489 #[doc = "`get_IsForecast()` overload"]
6490 fn get_is_forecast(self) -> bool {
6491 unsafe {
6492 let __receiver =
6493 <MapUnitCommandMenu_BaseMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6494 {
6495 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
6496 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
6497 panic!(
6498 "unity: virtual slot {}
6499 out of range (vtable len {}
6500) on the runtime class behind {}
6501 (method `{}
6502`)",
6503 33usize,
6504 __vt.len(),
6505 <MapUnitCommandMenu_BaseMenuItem as ::unity::ClassIdentity>::NAME,
6506 "get_IsForecast",
6507 )
6508 });
6509 let __inner: extern "C" fn(MapUnitCommandMenu_BaseMenuItem, ::unity::OptionalMethod) -> bool =
6510 ::core::mem::transmute(__vi.method_ptr);
6511 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
6512 __inner(__receiver, __mi)
6513 }
6514 }
6515 }
6516 #[doc = "`OnBuildMenuItemContent()` overload"]
6517 fn on_build_menu_item_content(self) -> () {
6518 unsafe {
6519 let __receiver =
6520 <MapUnitCommandMenu_BaseMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6521 {
6522 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
6523 let __vi = *__vt.get(11usize).unwrap_or_else(|| {
6524 panic!(
6525 "unity: virtual slot {}
6526 out of range (vtable len {}
6527) on the runtime class behind {}
6528 (method `{}
6529`)",
6530 11usize,
6531 __vt.len(),
6532 <MapUnitCommandMenu_BaseMenuItem as ::unity::ClassIdentity>::NAME,
6533 "OnBuildMenuItemContent",
6534 )
6535 });
6536 let __inner: extern "C" fn(MapUnitCommandMenu_BaseMenuItem, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
6537 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
6538 __inner(__receiver, __mi)
6539 }
6540 }
6541 }
6542 #[doc = "`CanCancel()` overload"]
6543 fn can_cancel(self) -> bool {
6544 unsafe {
6545 let __receiver =
6546 <MapUnitCommandMenu_BaseMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6547 ::unity::il2cpp_call!((::unity::module_base()+0x1e48d00usize)as*mut u8,bool;
6548(MapUnitCommandMenu_BaseMenuItem)__receiver)
6549 }
6550 }
6551 #[doc = "`BCall()` overload"]
6552 fn b_call(self) -> crate::app::basicmenu::BasicMenu_Result {
6553 unsafe {
6554 let __receiver =
6555 <MapUnitCommandMenu_BaseMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6556 {
6557 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
6558 let __vi = *__vt.get(19usize).unwrap_or_else(|| {
6559 panic!(
6560 "unity: virtual slot {}
6561 out of range (vtable len {}
6562) on the runtime class behind {}
6563 (method `{}
6564`)",
6565 19usize,
6566 __vt.len(),
6567 <MapUnitCommandMenu_BaseMenuItem as ::unity::ClassIdentity>::NAME,
6568 "BCall",
6569 )
6570 });
6571 let __inner: extern "C" fn(MapUnitCommandMenu_BaseMenuItem, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
6572 ::core::mem::transmute(__vi.method_ptr);
6573 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
6574 __inner(__receiver, __mi)
6575 }
6576 }
6577 }
6578 #[doc = "`OnSelect()` overload"]
6579 fn on_select(self) -> () {
6580 unsafe {
6581 let __receiver =
6582 <MapUnitCommandMenu_BaseMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6583 {
6584 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
6585 let __vi = *__vt.get(12usize).unwrap_or_else(|| {
6586 panic!(
6587 "unity: virtual slot {}
6588 out of range (vtable len {}
6589) on the runtime class behind {}
6590 (method `{}
6591`)",
6592 12usize,
6593 __vt.len(),
6594 <MapUnitCommandMenu_BaseMenuItem as ::unity::ClassIdentity>::NAME,
6595 "OnSelect",
6596 )
6597 });
6598 let __inner: extern "C" fn(MapUnitCommandMenu_BaseMenuItem, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
6599 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
6600 __inner(__receiver, __mi)
6601 }
6602 }
6603 }
6604 #[doc = "`OnDeselect()` overload"]
6605 fn on_deselect(self) -> () {
6606 unsafe {
6607 let __receiver =
6608 <MapUnitCommandMenu_BaseMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6609 {
6610 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
6611 let __vi = *__vt.get(13usize).unwrap_or_else(|| {
6612 panic!(
6613 "unity: virtual slot {}
6614 out of range (vtable len {}
6615) on the runtime class behind {}
6616 (method `{}
6617`)",
6618 13usize,
6619 __vt.len(),
6620 <MapUnitCommandMenu_BaseMenuItem as ::unity::ClassIdentity>::NAME,
6621 "OnDeselect",
6622 )
6623 });
6624 let __inner: extern "C" fn(MapUnitCommandMenu_BaseMenuItem, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
6625 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
6626 __inner(__receiver, __mi)
6627 }
6628 }
6629 }
6630 #[doc = "`OnCursorMoveEnd()` overload"]
6631 fn on_cursor_move_end(self) -> () {
6632 unsafe {
6633 let __receiver =
6634 <MapUnitCommandMenu_BaseMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6635 {
6636 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
6637 let __vi = *__vt.get(14usize).unwrap_or_else(|| {
6638 panic!(
6639 "unity: virtual slot {}
6640 out of range (vtable len {}
6641) on the runtime class behind {}
6642 (method `{}
6643`)",
6644 14usize,
6645 __vt.len(),
6646 <MapUnitCommandMenu_BaseMenuItem as ::unity::ClassIdentity>::NAME,
6647 "OnCursorMoveEnd",
6648 )
6649 });
6650 let __inner: extern "C" fn(MapUnitCommandMenu_BaseMenuItem, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
6651 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
6652 __inner(__receiver, __mi)
6653 }
6654 }
6655 }
6656 #[doc = "`GetCommandHelp()` overload"]
6657 fn get_command_help(self) -> ::unity::Il2CppString {
6658 unsafe {
6659 let __receiver =
6660 <MapUnitCommandMenu_BaseMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6661 {
6662 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
6663 let __vi = *__vt.get(34usize).unwrap_or_else(|| {
6664 panic!(
6665 "unity: virtual slot {}
6666 out of range (vtable len {}
6667) on the runtime class behind {}
6668 (method `{}
6669`)",
6670 34usize,
6671 __vt.len(),
6672 <MapUnitCommandMenu_BaseMenuItem as ::unity::ClassIdentity>::NAME,
6673 "GetCommandHelp",
6674 )
6675 });
6676 let __inner: extern "C" fn(MapUnitCommandMenu_BaseMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
6677 ::core::mem::transmute(__vi.method_ptr);
6678 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
6679 __inner(__receiver, __mi)
6680 }
6681 }
6682 }
6683 #[doc = "`SetupHelpText()` overload"]
6684 fn setup_help_text(self) -> () {
6685 unsafe {
6686 let __receiver =
6687 <MapUnitCommandMenu_BaseMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6688 ::unity::il2cpp_call!((::unity::module_base()+0x1e48bf0usize)as*mut u8,();
6689(MapUnitCommandMenu_BaseMenuItem)__receiver)
6690 }
6691 }
6692 #[doc = "`CheckBuildableWithUnit()` overload"]
6693 fn check_buildable_with_unit(self) -> bool {
6694 unsafe {
6695 let __receiver =
6696 <MapUnitCommandMenu_BaseMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6697 ::unity::il2cpp_call!((::unity::module_base()+0x1e485c0usize)as*mut u8,bool;
6698(MapUnitCommandMenu_BaseMenuItem)__receiver)
6699 }
6700 }
6701 #[doc = "`CheckBuildableWithUnit(crate::app::unit::Unit)` overload"]
6702 fn check_buildable_with_unit_2(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> bool {
6703 unsafe {
6704 let __receiver =
6705 <MapUnitCommandMenu_BaseMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6706 {
6707 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
6708 let __vi = *__vt.get(35usize).unwrap_or_else(|| {
6709 panic!(
6710 "unity: virtual slot {}
6711 out of range (vtable len {}
6712) on the runtime class behind {}
6713 (method `{}
6714`)",
6715 35usize,
6716 __vt.len(),
6717 <MapUnitCommandMenu_BaseMenuItem as ::unity::ClassIdentity>::NAME,
6718 "CheckBuildableWithUnit",
6719 )
6720 });
6721 let __inner: extern "C" fn(MapUnitCommandMenu_BaseMenuItem, crate::app::unit::Unit, ::unity::OptionalMethod) -> bool =
6722 ::core::mem::transmute(__vi.method_ptr);
6723 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
6724 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
6725 }
6726 }
6727 }
6728 #[doc = "`JumpMindSequence(crate::app::mapmind::MapMind_Type)` overload"]
6729 fn jump_mind_sequence(self, r#type: impl ::core::convert::Into<crate::app::mapmind::MapMind_Type>) -> () {
6730 unsafe {
6731 let __receiver =
6732 <MapUnitCommandMenu_BaseMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6733 ::unity::il2cpp_call!((::unity::module_base()+0x1e49450usize)as*mut u8,();
6734(MapUnitCommandMenu_BaseMenuItem)__receiver,(crate::app::mapmind::MapMind_Type)::core::convert::Into::into(r#type))
6735 }
6736 }
6737 #[doc = "`JumpSequence(crate::app::mapsequencehuman::MapSequenceHuman_Label)` overload"]
6738 fn jump_sequence(self, label: impl ::core::convert::Into<crate::app::mapsequencehuman::MapSequenceHuman_Label>) -> () {
6739 unsafe {
6740 let __receiver =
6741 <MapUnitCommandMenu_BaseMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6742 ::unity::il2cpp_call!((::unity::module_base()+0x1e49560usize)as*mut u8,();
6743(MapUnitCommandMenu_BaseMenuItem)__receiver,(crate::app::mapsequencehuman::MapSequenceHuman_Label)::core::convert::Into::into(label))
6744 }
6745 }
6746 #[doc = "`GetDisableAttribute()` overload"]
6747 fn get_disable_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
6748 unsafe {
6749 let __receiver =
6750 <MapUnitCommandMenu_BaseMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6751 ::unity::il2cpp_call!((::unity::module_base()+0x1e488b0usize)as*mut u8,crate::app::basicmenuitem::BasicMenuItem_Attribute;
6752(MapUnitCommandMenu_BaseMenuItem)__receiver)
6753 }
6754 }
6755 #[doc = "`.ctor()` overload"]
6756 fn ctor(self) -> () {
6757 unsafe {
6758 let __receiver =
6759 <MapUnitCommandMenu_BaseMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6760 ::unity::il2cpp_call!((::unity::module_base()+0x1e496c0usize)as*mut u8,();
6761(MapUnitCommandMenu_BaseMenuItem)__receiver)
6762 }
6763 }
6764}
6765
6766#[cfg(feature = "app-mapunitcommandmenu")]
6767impl<__T: IMapUnitCommandMenu_BaseMenuItem> IMapUnitCommandMenu_BaseMenuItemMethods for __T {}
6768
6769#[cfg(feature = "app-mapunitcommandmenu")]
6770impl MapUnitCommandMenu_BaseMenuItem {
6771 pub fn get_active_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6772 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
6773 }
6774
6775 pub fn get_deploy_mode_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6776 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
6777 }
6778
6779 pub fn get_command_skill_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6780 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
6781 }
6782
6783 pub fn get_is_forecast_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6784 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
6785 }
6786
6787 pub fn on_build_menu_item_content_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6788 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
6789 }
6790
6791 pub fn can_cancel_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6792 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
6793 }
6794
6795 pub fn b_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6796 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
6797 }
6798
6799 pub fn on_select_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6800 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
6801 }
6802
6803 pub fn on_deselect_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6804 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
6805 }
6806
6807 pub fn on_cursor_move_end_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6808 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
6809 }
6810
6811 pub fn get_command_help_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6812 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
6813 }
6814
6815 pub fn setup_help_text_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6816 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
6817 }
6818
6819 pub fn check_buildable_with_unit_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6820 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
6821 }
6822
6823 pub fn check_buildable_with_unit_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6824 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
6825 }
6826
6827 pub fn jump_mind_sequence_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6828 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[14]
6829 }
6830
6831 pub fn jump_sequence_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6832 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[15]
6833 }
6834
6835 pub fn get_disable_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6836 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[16]
6837 }
6838
6839 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6840 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[17]
6841 }
6842}
6843
6844#[cfg(feature = "app-mapunitcommandmenu")]
6845impl MapUnitCommandMenu_BaseMenuItem {
6846 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_BaseMenuItem`'s own `get_ActiveMind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6847 pub unsafe fn get_active_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
6848 let __mi = Self::get_active_mind_method_info();
6849 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
6850 ::core::mem::transmute(__mi.method_ptr);
6851 __inner(this.into(), ::core::option::Option::None)
6852 }
6853
6854 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_BaseMenuItem`'s own `get_DeployMode`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6855 pub unsafe fn get_deploy_mode(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
6856 let __mi = Self::get_deploy_mode_method_info();
6857 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode =
6858 ::core::mem::transmute(__mi.method_ptr);
6859 __inner(this.into(), ::core::option::Option::None)
6860 }
6861
6862 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_BaseMenuItem`'s own `get_CommandSkill`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6863 pub unsafe fn get_command_skill(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::skilldata::SkillData {
6864 let __mi = Self::get_command_skill_method_info();
6865 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::skilldata::SkillData =
6866 ::core::mem::transmute(__mi.method_ptr);
6867 __inner(this.into(), ::core::option::Option::None)
6868 }
6869
6870 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_BaseMenuItem`'s own `get_IsForecast`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6871 pub unsafe fn get_is_forecast(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
6872 let __mi = Self::get_is_forecast_method_info();
6873 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
6874 __inner(this.into(), ::core::option::Option::None)
6875 }
6876
6877 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_BaseMenuItem`'s own `OnBuildMenuItemContent`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6878 pub unsafe fn on_build_menu_item_content(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
6879 let __mi = Self::on_build_menu_item_content_method_info();
6880 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
6881 __inner(this.into(), ::core::option::Option::None)
6882 }
6883
6884 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_BaseMenuItem`'s own `BCall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6885 pub unsafe fn b_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
6886 let __mi = Self::b_call_method_info();
6887 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
6888 ::core::mem::transmute(__mi.method_ptr);
6889 __inner(this.into(), ::core::option::Option::None)
6890 }
6891
6892 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_BaseMenuItem`'s own `OnSelect`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6893 pub unsafe fn on_select(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
6894 let __mi = Self::on_select_method_info();
6895 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
6896 __inner(this.into(), ::core::option::Option::None)
6897 }
6898
6899 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_BaseMenuItem`'s own `OnDeselect`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6900 pub unsafe fn on_deselect(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
6901 let __mi = Self::on_deselect_method_info();
6902 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
6903 __inner(this.into(), ::core::option::Option::None)
6904 }
6905
6906 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_BaseMenuItem`'s own `OnCursorMoveEnd`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6907 pub unsafe fn on_cursor_move_end(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
6908 let __mi = Self::on_cursor_move_end_method_info();
6909 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
6910 __inner(this.into(), ::core::option::Option::None)
6911 }
6912
6913 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_BaseMenuItem`'s own `GetCommandHelp`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6914 pub unsafe fn get_command_help(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
6915 let __mi = Self::get_command_help_method_info();
6916 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
6917 __inner(this.into(), ::core::option::Option::None)
6918 }
6919
6920 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_BaseMenuItem`'s own `CheckBuildableWithUnit`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6921 pub unsafe fn check_buildable_with_unit_2(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> bool {
6922 let __mi = Self::check_buildable_with_unit_2_method_info();
6923 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> bool =
6924 ::core::mem::transmute(__mi.method_ptr);
6925 __inner(this.into(), unit, ::core::option::Option::None)
6926 }
6927}
6928
6929#[cfg(feature = "app-mapunitcommandmenu")]
6930impl MapUnitCommandMenu_BaseMenuItem {
6931 #[doc = "`.ctor()` — no args"]
6932 pub fn new() -> Self {
6933 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
6934 panic!(
6935 "{}
6936::{}
6937 failed to instantiate",
6938 ::core::stringify!(MapUnitCommandMenu_BaseMenuItem),
6939 ::core::stringify!(new),
6940 )
6941 });
6942 <Self as IMapUnitCommandMenu_BaseMenuItemMethods>::ctor(this);
6943 this
6944 }
6945}
6946
6947#[cfg(feature = "app-mapunitcommandmenu")]
6948pub trait IMapUnitCommandMenu_EnchantMenuItemMethods: IMapUnitCommandMenu_EnchantMenuItem {
6949 #[doc = "`get_FlagID()` overload"]
6950 fn get_flag_id(self) -> ::unity::Il2CppString {
6951 unsafe {
6952 let __receiver =
6953 <MapUnitCommandMenu_EnchantMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6954 {
6955 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
6956 let __vi = *__vt.get(27usize).unwrap_or_else(|| {
6957 panic!(
6958 "unity: virtual slot {}
6959 out of range (vtable len {}
6960) on the runtime class behind {}
6961 (method `{}
6962`)",
6963 27usize,
6964 __vt.len(),
6965 <MapUnitCommandMenu_EnchantMenuItem as ::unity::ClassIdentity>::NAME,
6966 "get_FlagID",
6967 )
6968 });
6969 let __inner: extern "C" fn(MapUnitCommandMenu_EnchantMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
6970 ::core::mem::transmute(__vi.method_ptr);
6971 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
6972 __inner(__receiver, __mi)
6973 }
6974 }
6975 }
6976 #[doc = "`get_Label()` overload"]
6977 fn get_label(self) -> crate::app::mapsequencehuman::MapSequenceHuman_Label {
6978 unsafe {
6979 let __receiver =
6980 <MapUnitCommandMenu_EnchantMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6981 {
6982 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
6983 let __vi = *__vt.get(36usize).unwrap_or_else(|| {
6984 panic!(
6985 "unity: virtual slot {}
6986 out of range (vtable len {}
6987) on the runtime class behind {}
6988 (method `{}
6989`)",
6990 36usize,
6991 __vt.len(),
6992 <MapUnitCommandMenu_EnchantMenuItem as ::unity::ClassIdentity>::NAME,
6993 "get_Label",
6994 )
6995 });
6996 let __inner: extern "C" fn(
6997 MapUnitCommandMenu_EnchantMenuItem,
6998 ::unity::OptionalMethod,
6999 ) -> crate::app::mapsequencehuman::MapSequenceHuman_Label = ::core::mem::transmute(__vi.method_ptr);
7000 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7001 __inner(__receiver, __mi)
7002 }
7003 }
7004 }
7005 #[doc = "`get_ActiveMind()` overload"]
7006 fn get_active_mind(self) -> crate::app::mapmind::MapMind_Type {
7007 unsafe {
7008 let __receiver =
7009 <MapUnitCommandMenu_EnchantMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7010 {
7011 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7012 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
7013 panic!(
7014 "unity: virtual slot {}
7015 out of range (vtable len {}
7016) on the runtime class behind {}
7017 (method `{}
7018`)",
7019 30usize,
7020 __vt.len(),
7021 <MapUnitCommandMenu_EnchantMenuItem as ::unity::ClassIdentity>::NAME,
7022 "get_ActiveMind",
7023 )
7024 });
7025 let __inner: extern "C" fn(MapUnitCommandMenu_EnchantMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
7026 ::core::mem::transmute(__vi.method_ptr);
7027 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7028 __inner(__receiver, __mi)
7029 }
7030 }
7031 }
7032 #[doc = "`get_DeployMode()` overload"]
7033 fn get_deploy_mode(self) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
7034 unsafe {
7035 let __receiver =
7036 <MapUnitCommandMenu_EnchantMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7037 {
7038 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7039 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
7040 panic!(
7041 "unity: virtual slot {}
7042 out of range (vtable len {}
7043) on the runtime class behind {}
7044 (method `{}
7045`)",
7046 31usize,
7047 __vt.len(),
7048 <MapUnitCommandMenu_EnchantMenuItem as ::unity::ClassIdentity>::NAME,
7049 "get_DeployMode",
7050 )
7051 });
7052 let __inner: extern "C" fn(
7053 MapUnitCommandMenu_EnchantMenuItem,
7054 ::unity::OptionalMethod,
7055 ) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode = ::core::mem::transmute(__vi.method_ptr);
7056 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7057 __inner(__receiver, __mi)
7058 }
7059 }
7060 }
7061 #[doc = "`get_IsWeapon()` overload"]
7062 fn get_is_weapon(self) -> bool {
7063 unsafe {
7064 let __receiver =
7065 <MapUnitCommandMenu_EnchantMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7066 {
7067 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7068 let __vi = *__vt.get(37usize).unwrap_or_else(|| {
7069 panic!(
7070 "unity: virtual slot {}
7071 out of range (vtable len {}
7072) on the runtime class behind {}
7073 (method `{}
7074`)",
7075 37usize,
7076 __vt.len(),
7077 <MapUnitCommandMenu_EnchantMenuItem as ::unity::ClassIdentity>::NAME,
7078 "get_IsWeapon",
7079 )
7080 });
7081 let __inner: extern "C" fn(MapUnitCommandMenu_EnchantMenuItem, ::unity::OptionalMethod) -> bool =
7082 ::core::mem::transmute(__vi.method_ptr);
7083 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7084 __inner(__receiver, __mi)
7085 }
7086 }
7087 }
7088 #[doc = "`GetName()` overload"]
7089 fn get_name(self) -> ::unity::Il2CppString {
7090 unsafe {
7091 let __receiver =
7092 <MapUnitCommandMenu_EnchantMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7093 {
7094 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7095 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
7096 panic!(
7097 "unity: virtual slot {}
7098 out of range (vtable len {}
7099) on the runtime class behind {}
7100 (method `{}
7101`)",
7102 4usize,
7103 __vt.len(),
7104 <MapUnitCommandMenu_EnchantMenuItem as ::unity::ClassIdentity>::NAME,
7105 "GetName",
7106 )
7107 });
7108 let __inner: extern "C" fn(MapUnitCommandMenu_EnchantMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
7109 ::core::mem::transmute(__vi.method_ptr);
7110 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7111 __inner(__receiver, __mi)
7112 }
7113 }
7114 }
7115 #[doc = "`GetCommandHelp()` overload"]
7116 fn get_command_help(self) -> ::unity::Il2CppString {
7117 unsafe {
7118 let __receiver =
7119 <MapUnitCommandMenu_EnchantMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7120 {
7121 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7122 let __vi = *__vt.get(34usize).unwrap_or_else(|| {
7123 panic!(
7124 "unity: virtual slot {}
7125 out of range (vtable len {}
7126) on the runtime class behind {}
7127 (method `{}
7128`)",
7129 34usize,
7130 __vt.len(),
7131 <MapUnitCommandMenu_EnchantMenuItem as ::unity::ClassIdentity>::NAME,
7132 "GetCommandHelp",
7133 )
7134 });
7135 let __inner: extern "C" fn(MapUnitCommandMenu_EnchantMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
7136 ::core::mem::transmute(__vi.method_ptr);
7137 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7138 __inner(__receiver, __mi)
7139 }
7140 }
7141 }
7142 #[doc = "`GetMapAttribute()` overload"]
7143 fn get_map_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
7144 unsafe {
7145 let __receiver =
7146 <MapUnitCommandMenu_EnchantMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7147 {
7148 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7149 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
7150 panic!(
7151 "unity: virtual slot {}
7152 out of range (vtable len {}
7153) on the runtime class behind {}
7154 (method `{}
7155`)",
7156 29usize,
7157 __vt.len(),
7158 <MapUnitCommandMenu_EnchantMenuItem as ::unity::ClassIdentity>::NAME,
7159 "GetMapAttribute",
7160 )
7161 });
7162 let __inner: extern "C" fn(
7163 MapUnitCommandMenu_EnchantMenuItem,
7164 ::unity::OptionalMethod,
7165 ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
7166 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7167 __inner(__receiver, __mi)
7168 }
7169 }
7170 }
7171 #[doc = "`HasEnchantItem(crate::app::unit::Unit, bool)` overload"]
7172 fn has_enchant_item(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>, is_weapon: impl ::core::convert::Into<bool>) -> bool {
7173 unsafe {
7174 let __receiver =
7175 <MapUnitCommandMenu_EnchantMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7176 ::unity::il2cpp_call!((::unity::module_base()+0x1e4cce0usize)as*mut u8,bool;
7177(MapUnitCommandMenu_EnchantMenuItem)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(unit),(bool)::core::convert::Into::into(is_weapon))
7178 }
7179 }
7180 #[doc = "`ACall()` overload"]
7181 fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
7182 unsafe {
7183 let __receiver =
7184 <MapUnitCommandMenu_EnchantMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7185 {
7186 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7187 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
7188 panic!(
7189 "unity: virtual slot {}
7190 out of range (vtable len {}
7191) on the runtime class behind {}
7192 (method `{}
7193`)",
7194 18usize,
7195 __vt.len(),
7196 <MapUnitCommandMenu_EnchantMenuItem as ::unity::ClassIdentity>::NAME,
7197 "ACall",
7198 )
7199 });
7200 let __inner: extern "C" fn(MapUnitCommandMenu_EnchantMenuItem, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
7201 ::core::mem::transmute(__vi.method_ptr);
7202 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7203 __inner(__receiver, __mi)
7204 }
7205 }
7206 }
7207 #[doc = "`.ctor()` overload"]
7208 fn ctor(self) -> () {
7209 unsafe {
7210 let __receiver =
7211 <MapUnitCommandMenu_EnchantMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7212 ::unity::il2cpp_call!((::unity::module_base()+0x1e4c820usize)as*mut u8,();
7213(MapUnitCommandMenu_EnchantMenuItem)__receiver)
7214 }
7215 }
7216}
7217
7218#[cfg(feature = "app-mapunitcommandmenu")]
7219impl<__T: IMapUnitCommandMenu_EnchantMenuItem> IMapUnitCommandMenu_EnchantMenuItemMethods for __T {}
7220
7221#[cfg(feature = "app-mapunitcommandmenu")]
7222impl MapUnitCommandMenu_EnchantMenuItem {
7223 pub fn get_flag_id_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7224 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
7225 }
7226
7227 pub fn get_label_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7228 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
7229 }
7230
7231 pub fn get_active_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7232 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
7233 }
7234
7235 pub fn get_deploy_mode_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7236 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
7237 }
7238
7239 pub fn get_is_weapon_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7240 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
7241 }
7242
7243 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7244 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
7245 }
7246
7247 pub fn get_command_help_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7248 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
7249 }
7250
7251 pub fn get_map_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7252 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
7253 }
7254
7255 pub fn has_enchant_item_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7256 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
7257 }
7258
7259 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7260 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
7261 }
7262
7263 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7264 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
7265 }
7266}
7267
7268#[cfg(feature = "app-mapunitcommandmenu")]
7269impl MapUnitCommandMenu_EnchantMenuItem {
7270 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EnchantMenuItem`'s own `get_FlagID`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
7271 pub unsafe fn get_flag_id(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
7272 let __mi = Self::get_flag_id_method_info();
7273 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
7274 __inner(this.into(), ::core::option::Option::None)
7275 }
7276
7277 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EnchantMenuItem`'s own `get_Label`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
7278 pub unsafe fn get_label(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapsequencehuman::MapSequenceHuman_Label {
7279 let __mi = Self::get_label_method_info();
7280 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapsequencehuman::MapSequenceHuman_Label =
7281 ::core::mem::transmute(__mi.method_ptr);
7282 __inner(this.into(), ::core::option::Option::None)
7283 }
7284
7285 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EnchantMenuItem`'s own `get_ActiveMind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
7286 pub unsafe fn get_active_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
7287 let __mi = Self::get_active_mind_method_info();
7288 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
7289 ::core::mem::transmute(__mi.method_ptr);
7290 __inner(this.into(), ::core::option::Option::None)
7291 }
7292
7293 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EnchantMenuItem`'s own `get_DeployMode`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
7294 pub unsafe fn get_deploy_mode(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
7295 let __mi = Self::get_deploy_mode_method_info();
7296 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode =
7297 ::core::mem::transmute(__mi.method_ptr);
7298 __inner(this.into(), ::core::option::Option::None)
7299 }
7300
7301 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EnchantMenuItem`'s own `get_IsWeapon`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
7302 pub unsafe fn get_is_weapon(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
7303 let __mi = Self::get_is_weapon_method_info();
7304 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
7305 __inner(this.into(), ::core::option::Option::None)
7306 }
7307
7308 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EnchantMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
7309 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
7310 let __mi = Self::get_name_method_info();
7311 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
7312 __inner(this.into(), ::core::option::Option::None)
7313 }
7314
7315 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EnchantMenuItem`'s own `GetCommandHelp`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
7316 pub unsafe fn get_command_help(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
7317 let __mi = Self::get_command_help_method_info();
7318 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
7319 __inner(this.into(), ::core::option::Option::None)
7320 }
7321
7322 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EnchantMenuItem`'s own `GetMapAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
7323 pub unsafe fn get_map_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
7324 let __mi = Self::get_map_attribute_method_info();
7325 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
7326 ::core::mem::transmute(__mi.method_ptr);
7327 __inner(this.into(), ::core::option::Option::None)
7328 }
7329
7330 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EnchantMenuItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
7331 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
7332 let __mi = Self::a_call_method_info();
7333 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
7334 ::core::mem::transmute(__mi.method_ptr);
7335 __inner(this.into(), ::core::option::Option::None)
7336 }
7337}
7338
7339#[cfg(feature = "app-mapunitcommandmenu")]
7340impl MapUnitCommandMenu_EnchantMenuItem {
7341 #[doc = "`.ctor()` — no args"]
7342 pub fn new() -> Self {
7343 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
7344 panic!(
7345 "{}
7346::{}
7347 failed to instantiate",
7348 ::core::stringify!(MapUnitCommandMenu_EnchantMenuItem),
7349 ::core::stringify!(new),
7350 )
7351 });
7352 <Self as IMapUnitCommandMenu_EnchantMenuItemMethods>::ctor(this);
7353 this
7354 }
7355}
7356
7357#[cfg(feature = "app-mapunitcommandmenu")]
7358pub trait IMapUnitCommandMenu_TreasureBoxMenuItemMethods: IMapUnitCommandMenu_TreasureBoxMenuItem {
7359 #[doc = "`OnBuild()` overload"]
7360 fn on_build(self) -> () {
7361 unsafe {
7362 let __receiver = <MapUnitCommandMenu_TreasureBoxMenuItem as ::unity::FromIlInstance>::from_il_instance(
7363 <Self as ::unity::SystemObject>::as_instance(self),
7364 );
7365 {
7366 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7367 let __vi = *__vt.get(10usize).unwrap_or_else(|| {
7368 panic!(
7369 "unity: virtual slot {}
7370 out of range (vtable len {}
7371) on the runtime class behind {}
7372 (method `{}
7373`)",
7374 10usize,
7375 __vt.len(),
7376 <MapUnitCommandMenu_TreasureBoxMenuItem as ::unity::ClassIdentity>::NAME,
7377 "OnBuild",
7378 )
7379 });
7380 let __inner: extern "C" fn(MapUnitCommandMenu_TreasureBoxMenuItem, ::unity::OptionalMethod) -> () =
7381 ::core::mem::transmute(__vi.method_ptr);
7382 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7383 __inner(__receiver, __mi)
7384 }
7385 }
7386 }
7387 #[doc = "`OnBuildMenuItemContent()` overload"]
7388 fn on_build_menu_item_content(self) -> () {
7389 unsafe {
7390 let __receiver = <MapUnitCommandMenu_TreasureBoxMenuItem as ::unity::FromIlInstance>::from_il_instance(
7391 <Self as ::unity::SystemObject>::as_instance(self),
7392 );
7393 {
7394 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7395 let __vi = *__vt.get(11usize).unwrap_or_else(|| {
7396 panic!(
7397 "unity: virtual slot {}
7398 out of range (vtable len {}
7399) on the runtime class behind {}
7400 (method `{}
7401`)",
7402 11usize,
7403 __vt.len(),
7404 <MapUnitCommandMenu_TreasureBoxMenuItem as ::unity::ClassIdentity>::NAME,
7405 "OnBuildMenuItemContent",
7406 )
7407 });
7408 let __inner: extern "C" fn(MapUnitCommandMenu_TreasureBoxMenuItem, ::unity::OptionalMethod) -> () =
7409 ::core::mem::transmute(__vi.method_ptr);
7410 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7411 __inner(__receiver, __mi)
7412 }
7413 }
7414 }
7415 #[doc = "`get_FlagID()` overload"]
7416 fn get_flag_id(self) -> ::unity::Il2CppString {
7417 unsafe {
7418 let __receiver = <MapUnitCommandMenu_TreasureBoxMenuItem as ::unity::FromIlInstance>::from_il_instance(
7419 <Self as ::unity::SystemObject>::as_instance(self),
7420 );
7421 {
7422 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7423 let __vi = *__vt.get(27usize).unwrap_or_else(|| {
7424 panic!(
7425 "unity: virtual slot {}
7426 out of range (vtable len {}
7427) on the runtime class behind {}
7428 (method `{}
7429`)",
7430 27usize,
7431 __vt.len(),
7432 <MapUnitCommandMenu_TreasureBoxMenuItem as ::unity::ClassIdentity>::NAME,
7433 "get_FlagID",
7434 )
7435 });
7436 let __inner: extern "C" fn(MapUnitCommandMenu_TreasureBoxMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
7437 ::core::mem::transmute(__vi.method_ptr);
7438 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7439 __inner(__receiver, __mi)
7440 }
7441 }
7442 }
7443 #[doc = "`get_ActiveMind()` overload"]
7444 fn get_active_mind(self) -> crate::app::mapmind::MapMind_Type {
7445 unsafe {
7446 let __receiver = <MapUnitCommandMenu_TreasureBoxMenuItem as ::unity::FromIlInstance>::from_il_instance(
7447 <Self as ::unity::SystemObject>::as_instance(self),
7448 );
7449 {
7450 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7451 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
7452 panic!(
7453 "unity: virtual slot {}
7454 out of range (vtable len {}
7455) on the runtime class behind {}
7456 (method `{}
7457`)",
7458 30usize,
7459 __vt.len(),
7460 <MapUnitCommandMenu_TreasureBoxMenuItem as ::unity::ClassIdentity>::NAME,
7461 "get_ActiveMind",
7462 )
7463 });
7464 let __inner: extern "C" fn(MapUnitCommandMenu_TreasureBoxMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
7465 ::core::mem::transmute(__vi.method_ptr);
7466 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7467 __inner(__receiver, __mi)
7468 }
7469 }
7470 }
7471 #[doc = "`get_DeployMode()` overload"]
7472 fn get_deploy_mode(self) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
7473 unsafe {
7474 let __receiver = <MapUnitCommandMenu_TreasureBoxMenuItem as ::unity::FromIlInstance>::from_il_instance(
7475 <Self as ::unity::SystemObject>::as_instance(self),
7476 );
7477 {
7478 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7479 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
7480 panic!(
7481 "unity: virtual slot {}
7482 out of range (vtable len {}
7483) on the runtime class behind {}
7484 (method `{}
7485`)",
7486 31usize,
7487 __vt.len(),
7488 <MapUnitCommandMenu_TreasureBoxMenuItem as ::unity::ClassIdentity>::NAME,
7489 "get_DeployMode",
7490 )
7491 });
7492 let __inner: extern "C" fn(
7493 MapUnitCommandMenu_TreasureBoxMenuItem,
7494 ::unity::OptionalMethod,
7495 ) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode = ::core::mem::transmute(__vi.method_ptr);
7496 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7497 __inner(__receiver, __mi)
7498 }
7499 }
7500 }
7501 #[doc = "`GetName()` overload"]
7502 fn get_name(self) -> ::unity::Il2CppString {
7503 unsafe {
7504 let __receiver = <MapUnitCommandMenu_TreasureBoxMenuItem as ::unity::FromIlInstance>::from_il_instance(
7505 <Self as ::unity::SystemObject>::as_instance(self),
7506 );
7507 {
7508 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7509 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
7510 panic!(
7511 "unity: virtual slot {}
7512 out of range (vtable len {}
7513) on the runtime class behind {}
7514 (method `{}
7515`)",
7516 4usize,
7517 __vt.len(),
7518 <MapUnitCommandMenu_TreasureBoxMenuItem as ::unity::ClassIdentity>::NAME,
7519 "GetName",
7520 )
7521 });
7522 let __inner: extern "C" fn(MapUnitCommandMenu_TreasureBoxMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
7523 ::core::mem::transmute(__vi.method_ptr);
7524 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7525 __inner(__receiver, __mi)
7526 }
7527 }
7528 }
7529 #[doc = "`GetCommandHelp()` overload"]
7530 fn get_command_help(self) -> ::unity::Il2CppString {
7531 unsafe {
7532 let __receiver = <MapUnitCommandMenu_TreasureBoxMenuItem as ::unity::FromIlInstance>::from_il_instance(
7533 <Self as ::unity::SystemObject>::as_instance(self),
7534 );
7535 {
7536 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7537 let __vi = *__vt.get(34usize).unwrap_or_else(|| {
7538 panic!(
7539 "unity: virtual slot {}
7540 out of range (vtable len {}
7541) on the runtime class behind {}
7542 (method `{}
7543`)",
7544 34usize,
7545 __vt.len(),
7546 <MapUnitCommandMenu_TreasureBoxMenuItem as ::unity::ClassIdentity>::NAME,
7547 "GetCommandHelp",
7548 )
7549 });
7550 let __inner: extern "C" fn(MapUnitCommandMenu_TreasureBoxMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
7551 ::core::mem::transmute(__vi.method_ptr);
7552 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7553 __inner(__receiver, __mi)
7554 }
7555 }
7556 }
7557 #[doc = "`GetMapAttribute()` overload"]
7558 fn get_map_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
7559 unsafe {
7560 let __receiver = <MapUnitCommandMenu_TreasureBoxMenuItem as ::unity::FromIlInstance>::from_il_instance(
7561 <Self as ::unity::SystemObject>::as_instance(self),
7562 );
7563 {
7564 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7565 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
7566 panic!(
7567 "unity: virtual slot {}
7568 out of range (vtable len {}
7569) on the runtime class behind {}
7570 (method `{}
7571`)",
7572 29usize,
7573 __vt.len(),
7574 <MapUnitCommandMenu_TreasureBoxMenuItem as ::unity::ClassIdentity>::NAME,
7575 "GetMapAttribute",
7576 )
7577 });
7578 let __inner: extern "C" fn(
7579 MapUnitCommandMenu_TreasureBoxMenuItem,
7580 ::unity::OptionalMethod,
7581 ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
7582 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7583 __inner(__receiver, __mi)
7584 }
7585 }
7586 }
7587 #[doc = "`ACall()` overload"]
7588 fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
7589 unsafe {
7590 let __receiver = <MapUnitCommandMenu_TreasureBoxMenuItem as ::unity::FromIlInstance>::from_il_instance(
7591 <Self as ::unity::SystemObject>::as_instance(self),
7592 );
7593 {
7594 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7595 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
7596 panic!(
7597 "unity: virtual slot {}
7598 out of range (vtable len {}
7599) on the runtime class behind {}
7600 (method `{}
7601`)",
7602 18usize,
7603 __vt.len(),
7604 <MapUnitCommandMenu_TreasureBoxMenuItem as ::unity::ClassIdentity>::NAME,
7605 "ACall",
7606 )
7607 });
7608 let __inner: extern "C" fn(
7609 MapUnitCommandMenu_TreasureBoxMenuItem,
7610 ::unity::OptionalMethod,
7611 ) -> crate::app::basicmenu::BasicMenu_Result = ::core::mem::transmute(__vi.method_ptr);
7612 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7613 __inner(__receiver, __mi)
7614 }
7615 }
7616 }
7617 #[doc = "`.ctor()` overload"]
7618 fn ctor(self) -> () {
7619 unsafe {
7620 let __receiver = <MapUnitCommandMenu_TreasureBoxMenuItem as ::unity::FromIlInstance>::from_il_instance(
7621 <Self as ::unity::SystemObject>::as_instance(self),
7622 );
7623 ::unity::il2cpp_call!((::unity::module_base()+0x1e529a0usize)as*mut u8,();
7624(MapUnitCommandMenu_TreasureBoxMenuItem)__receiver)
7625 }
7626 }
7627}
7628
7629#[cfg(feature = "app-mapunitcommandmenu")]
7630impl<__T: IMapUnitCommandMenu_TreasureBoxMenuItem> IMapUnitCommandMenu_TreasureBoxMenuItemMethods for __T {}
7631
7632#[cfg(feature = "app-mapunitcommandmenu")]
7633impl MapUnitCommandMenu_TreasureBoxMenuItem {
7634 pub fn on_build_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7635 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
7636 }
7637
7638 pub fn on_build_menu_item_content_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7639 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
7640 }
7641
7642 pub fn get_flag_id_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7643 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
7644 }
7645
7646 pub fn get_active_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7647 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
7648 }
7649
7650 pub fn get_deploy_mode_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7651 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
7652 }
7653
7654 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7655 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
7656 }
7657
7658 pub fn get_command_help_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7659 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
7660 }
7661
7662 pub fn get_map_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7663 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
7664 }
7665
7666 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7667 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
7668 }
7669
7670 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7671 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
7672 }
7673}
7674
7675#[cfg(feature = "app-mapunitcommandmenu")]
7676impl MapUnitCommandMenu_TreasureBoxMenuItem {
7677 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_TreasureBoxMenuItem`'s own `OnBuild`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
7678 pub unsafe fn on_build(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
7679 let __mi = Self::on_build_method_info();
7680 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
7681 __inner(this.into(), ::core::option::Option::None)
7682 }
7683
7684 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_TreasureBoxMenuItem`'s own `OnBuildMenuItemContent`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
7685 pub unsafe fn on_build_menu_item_content(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
7686 let __mi = Self::on_build_menu_item_content_method_info();
7687 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
7688 __inner(this.into(), ::core::option::Option::None)
7689 }
7690
7691 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_TreasureBoxMenuItem`'s own `get_FlagID`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
7692 pub unsafe fn get_flag_id(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
7693 let __mi = Self::get_flag_id_method_info();
7694 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
7695 __inner(this.into(), ::core::option::Option::None)
7696 }
7697
7698 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_TreasureBoxMenuItem`'s own `get_ActiveMind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
7699 pub unsafe fn get_active_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
7700 let __mi = Self::get_active_mind_method_info();
7701 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
7702 ::core::mem::transmute(__mi.method_ptr);
7703 __inner(this.into(), ::core::option::Option::None)
7704 }
7705
7706 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_TreasureBoxMenuItem`'s own `get_DeployMode`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
7707 pub unsafe fn get_deploy_mode(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
7708 let __mi = Self::get_deploy_mode_method_info();
7709 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode =
7710 ::core::mem::transmute(__mi.method_ptr);
7711 __inner(this.into(), ::core::option::Option::None)
7712 }
7713
7714 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_TreasureBoxMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
7715 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
7716 let __mi = Self::get_name_method_info();
7717 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
7718 __inner(this.into(), ::core::option::Option::None)
7719 }
7720
7721 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_TreasureBoxMenuItem`'s own `GetCommandHelp`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
7722 pub unsafe fn get_command_help(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
7723 let __mi = Self::get_command_help_method_info();
7724 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
7725 __inner(this.into(), ::core::option::Option::None)
7726 }
7727
7728 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_TreasureBoxMenuItem`'s own `GetMapAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
7729 pub unsafe fn get_map_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
7730 let __mi = Self::get_map_attribute_method_info();
7731 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
7732 ::core::mem::transmute(__mi.method_ptr);
7733 __inner(this.into(), ::core::option::Option::None)
7734 }
7735
7736 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_TreasureBoxMenuItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
7737 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
7738 let __mi = Self::a_call_method_info();
7739 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
7740 ::core::mem::transmute(__mi.method_ptr);
7741 __inner(this.into(), ::core::option::Option::None)
7742 }
7743}
7744
7745#[cfg(feature = "app-mapunitcommandmenu")]
7746impl MapUnitCommandMenu_TreasureBoxMenuItem {
7747 #[doc = "`.ctor()` — no args"]
7748 pub fn new() -> Self {
7749 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
7750 panic!(
7751 "{}
7752::{}
7753 failed to instantiate",
7754 ::core::stringify!(MapUnitCommandMenu_TreasureBoxMenuItem),
7755 ::core::stringify!(new),
7756 )
7757 });
7758 <Self as IMapUnitCommandMenu_TreasureBoxMenuItemMethods>::ctor(this);
7759 this
7760 }
7761}
7762
7763#[cfg(feature = "app-mapunitcommandmenu")]
7764impl MapUnitCommandMenu {
7765 #[doc = "`CreateBind(crate::app::procinst::ProcInst)` overload"]
7766 pub fn create_bind(super_: impl ::core::convert::Into<crate::app::procinst::ProcInst>) -> () {
7767 unsafe {
7768 ::unity::il2cpp_call!((::unity::module_base()+0x202bd80usize)as*mut u8,();
7769(crate::app::procinst::ProcInst)::core::convert::Into::into(super_))
7770 }
7771 }
7772
7773 #[doc = "`ResetSelectIndex()` overload"]
7774 pub fn reset_select_index() -> () {
7775 unsafe {
7776 ::unity::il2cpp_call!((::unity::module_base()+0x202d2f0usize)as*mut u8,();
7777 )
7778 }
7779 }
7780
7781 #[doc = "`.cctor()` overload"]
7782 pub fn cctor() -> () {
7783 unsafe {
7784 ::unity::il2cpp_call!((::unity::module_base()+0x202d360usize)as*mut u8,();
7785 )
7786 }
7787 }
7788}
7789
7790#[cfg(feature = "app-mapunitcommandmenu")]
7791pub trait IMapUnitCommandMenuMethods: IMapUnitCommandMenu {
7792 #[doc = "`.ctor(crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>, crate::app::mapunitcommandmenucontent::MapUnitCommandMenuContent)` overload"]
7793 fn ctor(
7794 self,
7795 menu_item_list: impl ::core::convert::Into<crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>>,
7796 menu_content: impl ::core::convert::Into<crate::app::mapunitcommandmenucontent::MapUnitCommandMenuContent>,
7797 ) -> () {
7798 unsafe {
7799 let __receiver = <MapUnitCommandMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7800 ::unity::il2cpp_call!((::unity::module_base()+0x202bb00usize)as*mut u8,();
7801(MapUnitCommandMenu)__receiver,(crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>)::core::convert::Into::into(menu_item_list),(crate::app::mapunitcommandmenucontent::MapUnitCommandMenuContent)::core::convert::Into::into(menu_content))
7802 }
7803 }
7804 #[doc = "`get_FlagID()` overload"]
7805 fn get_flag_id(self) -> ::unity::Il2CppString {
7806 unsafe {
7807 let __receiver = <MapUnitCommandMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7808 {
7809 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7810 let __vi = *__vt.get(64usize).unwrap_or_else(|| {
7811 panic!(
7812 "unity: virtual slot {}
7813 out of range (vtable len {}
7814) on the runtime class behind {}
7815 (method `{}
7816`)",
7817 64usize,
7818 __vt.len(),
7819 <MapUnitCommandMenu as ::unity::ClassIdentity>::NAME,
7820 "get_FlagID",
7821 )
7822 });
7823 let __inner: extern "C" fn(MapUnitCommandMenu, ::unity::OptionalMethod) -> ::unity::Il2CppString =
7824 ::core::mem::transmute(__vi.method_ptr);
7825 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7826 __inner(__receiver, __mi)
7827 }
7828 }
7829 }
7830 #[doc = "`GetName()` overload"]
7831 fn get_name(self) -> ::unity::Il2CppString {
7832 unsafe {
7833 let __receiver = <MapUnitCommandMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7834 {
7835 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7836 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
7837 panic!(
7838 "unity: virtual slot {}
7839 out of range (vtable len {}
7840) on the runtime class behind {}
7841 (method `{}
7842`)",
7843 30usize,
7844 __vt.len(),
7845 <MapUnitCommandMenu as ::unity::ClassIdentity>::NAME,
7846 "GetName",
7847 )
7848 });
7849 let __inner: extern "C" fn(MapUnitCommandMenu, ::unity::OptionalMethod) -> ::unity::Il2CppString =
7850 ::core::mem::transmute(__vi.method_ptr);
7851 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7852 __inner(__receiver, __mi)
7853 }
7854 }
7855 }
7856 #[doc = "`AfterBuild()` overload"]
7857 fn after_build(self) -> () {
7858 unsafe {
7859 let __receiver = <MapUnitCommandMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7860 {
7861 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7862 let __vi = *__vt.get(25usize).unwrap_or_else(|| {
7863 panic!(
7864 "unity: virtual slot {}
7865 out of range (vtable len {}
7866) on the runtime class behind {}
7867 (method `{}
7868`)",
7869 25usize,
7870 __vt.len(),
7871 <MapUnitCommandMenu as ::unity::ClassIdentity>::NAME,
7872 "AfterBuild",
7873 )
7874 });
7875 let __inner: extern "C" fn(MapUnitCommandMenu, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
7876 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7877 __inner(__receiver, __mi)
7878 }
7879 }
7880 }
7881 #[doc = "`BCall()` overload"]
7882 fn b_call(self) -> crate::app::basicmenu::BasicMenu_Result {
7883 unsafe {
7884 let __receiver = <MapUnitCommandMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7885 {
7886 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7887 let __vi = *__vt.get(51usize).unwrap_or_else(|| {
7888 panic!(
7889 "unity: virtual slot {}
7890 out of range (vtable len {}
7891) on the runtime class behind {}
7892 (method `{}
7893`)",
7894 51usize,
7895 __vt.len(),
7896 <MapUnitCommandMenu as ::unity::ClassIdentity>::NAME,
7897 "BCall",
7898 )
7899 });
7900 let __inner: extern "C" fn(MapUnitCommandMenu, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
7901 ::core::mem::transmute(__vi.method_ptr);
7902 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7903 __inner(__receiver, __mi)
7904 }
7905 }
7906 }
7907 #[doc = "`OnDispose()` overload"]
7908 fn on_dispose(self) -> () {
7909 unsafe {
7910 let __receiver = <MapUnitCommandMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7911 {
7912 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7913 let __vi = *__vt.get(10usize).unwrap_or_else(|| {
7914 panic!(
7915 "unity: virtual slot {}
7916 out of range (vtable len {}
7917) on the runtime class behind {}
7918 (method `{}
7919`)",
7920 10usize,
7921 __vt.len(),
7922 <MapUnitCommandMenu as ::unity::ClassIdentity>::NAME,
7923 "OnDispose",
7924 )
7925 });
7926 let __inner: extern "C" fn(MapUnitCommandMenu, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
7927 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7928 __inner(__receiver, __mi)
7929 }
7930 }
7931 }
7932 #[doc = "`Tick()` overload"]
7933 fn tick(self) -> () {
7934 unsafe {
7935 let __receiver = <MapUnitCommandMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7936 {
7937 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7938 let __vi = *__vt.get(38usize).unwrap_or_else(|| {
7939 panic!(
7940 "unity: virtual slot {}
7941 out of range (vtable len {}
7942) on the runtime class behind {}
7943 (method `{}
7944`)",
7945 38usize,
7946 __vt.len(),
7947 <MapUnitCommandMenu as ::unity::ClassIdentity>::NAME,
7948 "Tick",
7949 )
7950 });
7951 let __inner: extern "C" fn(MapUnitCommandMenu, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
7952 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7953 __inner(__receiver, __mi)
7954 }
7955 }
7956 }
7957}
7958
7959#[cfg(feature = "app-mapunitcommandmenu")]
7960impl<__T: IMapUnitCommandMenu> IMapUnitCommandMenuMethods for __T {}
7961
7962#[cfg(feature = "app-mapunitcommandmenu")]
7963impl MapUnitCommandMenu {
7964 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7965 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
7966 }
7967
7968 pub fn get_flag_id_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7969 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
7970 }
7971
7972 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7973 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
7974 }
7975
7976 pub fn after_build_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7977 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
7978 }
7979
7980 pub fn b_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7981 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
7982 }
7983
7984 pub fn on_dispose_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7985 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
7986 }
7987
7988 pub fn tick_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7989 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
7990 }
7991
7992 pub fn create_bind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7993 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
7994 }
7995
7996 pub fn reset_select_index_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7997 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
7998 }
7999
8000 pub fn cctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8001 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
8002 }
8003}
8004
8005#[cfg(feature = "app-mapunitcommandmenu")]
8006impl MapUnitCommandMenu {
8007 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu`'s own `get_FlagID`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
8008 pub unsafe fn get_flag_id(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
8009 let __mi = Self::get_flag_id_method_info();
8010 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
8011 __inner(this.into(), ::core::option::Option::None)
8012 }
8013
8014 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
8015 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
8016 let __mi = Self::get_name_method_info();
8017 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
8018 __inner(this.into(), ::core::option::Option::None)
8019 }
8020
8021 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu`'s own `AfterBuild`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
8022 pub unsafe fn after_build(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
8023 let __mi = Self::after_build_method_info();
8024 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
8025 __inner(this.into(), ::core::option::Option::None)
8026 }
8027
8028 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu`'s own `BCall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
8029 pub unsafe fn b_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
8030 let __mi = Self::b_call_method_info();
8031 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
8032 ::core::mem::transmute(__mi.method_ptr);
8033 __inner(this.into(), ::core::option::Option::None)
8034 }
8035
8036 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu`'s own `OnDispose`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
8037 pub unsafe fn on_dispose(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
8038 let __mi = Self::on_dispose_method_info();
8039 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
8040 __inner(this.into(), ::core::option::Option::None)
8041 }
8042
8043 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu`'s own `Tick`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
8044 pub unsafe fn tick(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
8045 let __mi = Self::tick_method_info();
8046 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
8047 __inner(this.into(), ::core::option::Option::None)
8048 }
8049}
8050
8051#[cfg(feature = "app-mapunitcommandmenu")]
8052impl MapUnitCommandMenu {
8053 #[doc = "`.ctor(crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>, crate::app::mapunitcommandmenucontent::MapUnitCommandMenuContent)` — overload selector"]
8054 pub fn new(
8055 menu_item_list: crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>,
8056 menu_content: crate::app::mapunitcommandmenucontent::MapUnitCommandMenuContent,
8057 ) -> Self {
8058 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
8059 panic!(
8060 "{}
8061::{}
8062 failed to instantiate",
8063 ::core::stringify!(MapUnitCommandMenu),
8064 ::core::stringify!(new),
8065 )
8066 });
8067 <Self as IMapUnitCommandMenuMethods>::ctor(this, menu_item_list, menu_content);
8068 this
8069 }
8070}
8071
8072#[cfg(feature = "app-mapunitcommandmenu")]
8073pub trait IMapUnitCommandMenu_RodMenuItemMethods: IMapUnitCommandMenu_RodMenuItem {
8074 #[doc = "`get_FlagID()` overload"]
8075 fn get_flag_id(self) -> ::unity::Il2CppString {
8076 unsafe {
8077 let __receiver =
8078 <MapUnitCommandMenu_RodMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8079 {
8080 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
8081 let __vi = *__vt.get(27usize).unwrap_or_else(|| {
8082 panic!(
8083 "unity: virtual slot {}
8084 out of range (vtable len {}
8085) on the runtime class behind {}
8086 (method `{}
8087`)",
8088 27usize,
8089 __vt.len(),
8090 <MapUnitCommandMenu_RodMenuItem as ::unity::ClassIdentity>::NAME,
8091 "get_FlagID",
8092 )
8093 });
8094 let __inner: extern "C" fn(MapUnitCommandMenu_RodMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
8095 ::core::mem::transmute(__vi.method_ptr);
8096 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
8097 __inner(__receiver, __mi)
8098 }
8099 }
8100 }
8101 #[doc = "`get_Label()` overload"]
8102 fn get_label(self) -> crate::app::mapsequencehuman::MapSequenceHuman_Label {
8103 unsafe {
8104 let __receiver =
8105 <MapUnitCommandMenu_RodMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8106 {
8107 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
8108 let __vi = *__vt.get(36usize).unwrap_or_else(|| {
8109 panic!(
8110 "unity: virtual slot {}
8111 out of range (vtable len {}
8112) on the runtime class behind {}
8113 (method `{}
8114`)",
8115 36usize,
8116 __vt.len(),
8117 <MapUnitCommandMenu_RodMenuItem as ::unity::ClassIdentity>::NAME,
8118 "get_Label",
8119 )
8120 });
8121 let __inner: extern "C" fn(
8122 MapUnitCommandMenu_RodMenuItem,
8123 ::unity::OptionalMethod,
8124 ) -> crate::app::mapsequencehuman::MapSequenceHuman_Label = ::core::mem::transmute(__vi.method_ptr);
8125 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
8126 __inner(__receiver, __mi)
8127 }
8128 }
8129 }
8130 #[doc = "`get_DeployMode()` overload"]
8131 fn get_deploy_mode(self) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
8132 unsafe {
8133 let __receiver =
8134 <MapUnitCommandMenu_RodMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8135 {
8136 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
8137 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
8138 panic!(
8139 "unity: virtual slot {}
8140 out of range (vtable len {}
8141) on the runtime class behind {}
8142 (method `{}
8143`)",
8144 31usize,
8145 __vt.len(),
8146 <MapUnitCommandMenu_RodMenuItem as ::unity::ClassIdentity>::NAME,
8147 "get_DeployMode",
8148 )
8149 });
8150 let __inner: extern "C" fn(
8151 MapUnitCommandMenu_RodMenuItem,
8152 ::unity::OptionalMethod,
8153 ) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode = ::core::mem::transmute(__vi.method_ptr);
8154 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
8155 __inner(__receiver, __mi)
8156 }
8157 }
8158 }
8159 #[doc = "`get_ActiveMind()` overload"]
8160 fn get_active_mind(self) -> crate::app::mapmind::MapMind_Type {
8161 unsafe {
8162 let __receiver =
8163 <MapUnitCommandMenu_RodMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8164 {
8165 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
8166 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
8167 panic!(
8168 "unity: virtual slot {}
8169 out of range (vtable len {}
8170) on the runtime class behind {}
8171 (method `{}
8172`)",
8173 30usize,
8174 __vt.len(),
8175 <MapUnitCommandMenu_RodMenuItem as ::unity::ClassIdentity>::NAME,
8176 "get_ActiveMind",
8177 )
8178 });
8179 let __inner: extern "C" fn(MapUnitCommandMenu_RodMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
8180 ::core::mem::transmute(__vi.method_ptr);
8181 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
8182 __inner(__receiver, __mi)
8183 }
8184 }
8185 }
8186 #[doc = "`GetName()` overload"]
8187 fn get_name(self) -> ::unity::Il2CppString {
8188 unsafe {
8189 let __receiver =
8190 <MapUnitCommandMenu_RodMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8191 {
8192 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
8193 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
8194 panic!(
8195 "unity: virtual slot {}
8196 out of range (vtable len {}
8197) on the runtime class behind {}
8198 (method `{}
8199`)",
8200 4usize,
8201 __vt.len(),
8202 <MapUnitCommandMenu_RodMenuItem as ::unity::ClassIdentity>::NAME,
8203 "GetName",
8204 )
8205 });
8206 let __inner: extern "C" fn(MapUnitCommandMenu_RodMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
8207 ::core::mem::transmute(__vi.method_ptr);
8208 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
8209 __inner(__receiver, __mi)
8210 }
8211 }
8212 }
8213 #[doc = "`GetCommandHelp()` overload"]
8214 fn get_command_help(self) -> ::unity::Il2CppString {
8215 unsafe {
8216 let __receiver =
8217 <MapUnitCommandMenu_RodMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8218 {
8219 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
8220 let __vi = *__vt.get(34usize).unwrap_or_else(|| {
8221 panic!(
8222 "unity: virtual slot {}
8223 out of range (vtable len {}
8224) on the runtime class behind {}
8225 (method `{}
8226`)",
8227 34usize,
8228 __vt.len(),
8229 <MapUnitCommandMenu_RodMenuItem as ::unity::ClassIdentity>::NAME,
8230 "GetCommandHelp",
8231 )
8232 });
8233 let __inner: extern "C" fn(MapUnitCommandMenu_RodMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
8234 ::core::mem::transmute(__vi.method_ptr);
8235 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
8236 __inner(__receiver, __mi)
8237 }
8238 }
8239 }
8240 #[doc = "`GetMapAttribute()` overload"]
8241 fn get_map_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
8242 unsafe {
8243 let __receiver =
8244 <MapUnitCommandMenu_RodMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8245 {
8246 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
8247 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
8248 panic!(
8249 "unity: virtual slot {}
8250 out of range (vtable len {}
8251) on the runtime class behind {}
8252 (method `{}
8253`)",
8254 29usize,
8255 __vt.len(),
8256 <MapUnitCommandMenu_RodMenuItem as ::unity::ClassIdentity>::NAME,
8257 "GetMapAttribute",
8258 )
8259 });
8260 let __inner: extern "C" fn(
8261 MapUnitCommandMenu_RodMenuItem,
8262 ::unity::OptionalMethod,
8263 ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
8264 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
8265 __inner(__receiver, __mi)
8266 }
8267 }
8268 }
8269 #[doc = "`ACall()` overload"]
8270 fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
8271 unsafe {
8272 let __receiver =
8273 <MapUnitCommandMenu_RodMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8274 {
8275 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
8276 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
8277 panic!(
8278 "unity: virtual slot {}
8279 out of range (vtable len {}
8280) on the runtime class behind {}
8281 (method `{}
8282`)",
8283 18usize,
8284 __vt.len(),
8285 <MapUnitCommandMenu_RodMenuItem as ::unity::ClassIdentity>::NAME,
8286 "ACall",
8287 )
8288 });
8289 let __inner: extern "C" fn(MapUnitCommandMenu_RodMenuItem, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
8290 ::core::mem::transmute(__vi.method_ptr);
8291 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
8292 __inner(__receiver, __mi)
8293 }
8294 }
8295 }
8296 #[doc = "`.ctor()` overload"]
8297 fn ctor(self) -> () {
8298 unsafe {
8299 let __receiver =
8300 <MapUnitCommandMenu_RodMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8301 ::unity::il2cpp_call!((::unity::module_base()+0x1e50840usize)as*mut u8,();
8302(MapUnitCommandMenu_RodMenuItem)__receiver)
8303 }
8304 }
8305}
8306
8307#[cfg(feature = "app-mapunitcommandmenu")]
8308impl<__T: IMapUnitCommandMenu_RodMenuItem> IMapUnitCommandMenu_RodMenuItemMethods for __T {}
8309
8310#[cfg(feature = "app-mapunitcommandmenu")]
8311impl MapUnitCommandMenu_RodMenuItem {
8312 pub fn get_flag_id_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8313 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
8314 }
8315
8316 pub fn get_label_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8317 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
8318 }
8319
8320 pub fn get_deploy_mode_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8321 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
8322 }
8323
8324 pub fn get_active_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8325 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
8326 }
8327
8328 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8329 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
8330 }
8331
8332 pub fn get_command_help_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8333 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
8334 }
8335
8336 pub fn get_map_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8337 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
8338 }
8339
8340 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8341 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
8342 }
8343
8344 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8345 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
8346 }
8347}
8348
8349#[cfg(feature = "app-mapunitcommandmenu")]
8350impl MapUnitCommandMenu_RodMenuItem {
8351 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_RodMenuItem`'s own `get_FlagID`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
8352 pub unsafe fn get_flag_id(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
8353 let __mi = Self::get_flag_id_method_info();
8354 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
8355 __inner(this.into(), ::core::option::Option::None)
8356 }
8357
8358 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_RodMenuItem`'s own `get_Label`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
8359 pub unsafe fn get_label(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapsequencehuman::MapSequenceHuman_Label {
8360 let __mi = Self::get_label_method_info();
8361 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapsequencehuman::MapSequenceHuman_Label =
8362 ::core::mem::transmute(__mi.method_ptr);
8363 __inner(this.into(), ::core::option::Option::None)
8364 }
8365
8366 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_RodMenuItem`'s own `get_DeployMode`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
8367 pub unsafe fn get_deploy_mode(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
8368 let __mi = Self::get_deploy_mode_method_info();
8369 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode =
8370 ::core::mem::transmute(__mi.method_ptr);
8371 __inner(this.into(), ::core::option::Option::None)
8372 }
8373
8374 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_RodMenuItem`'s own `get_ActiveMind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
8375 pub unsafe fn get_active_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
8376 let __mi = Self::get_active_mind_method_info();
8377 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
8378 ::core::mem::transmute(__mi.method_ptr);
8379 __inner(this.into(), ::core::option::Option::None)
8380 }
8381
8382 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_RodMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
8383 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
8384 let __mi = Self::get_name_method_info();
8385 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
8386 __inner(this.into(), ::core::option::Option::None)
8387 }
8388
8389 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_RodMenuItem`'s own `GetCommandHelp`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
8390 pub unsafe fn get_command_help(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
8391 let __mi = Self::get_command_help_method_info();
8392 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
8393 __inner(this.into(), ::core::option::Option::None)
8394 }
8395
8396 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_RodMenuItem`'s own `GetMapAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
8397 pub unsafe fn get_map_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
8398 let __mi = Self::get_map_attribute_method_info();
8399 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
8400 ::core::mem::transmute(__mi.method_ptr);
8401 __inner(this.into(), ::core::option::Option::None)
8402 }
8403
8404 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_RodMenuItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
8405 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
8406 let __mi = Self::a_call_method_info();
8407 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
8408 ::core::mem::transmute(__mi.method_ptr);
8409 __inner(this.into(), ::core::option::Option::None)
8410 }
8411}
8412
8413#[cfg(feature = "app-mapunitcommandmenu")]
8414impl MapUnitCommandMenu_RodMenuItem {
8415 #[doc = "`.ctor()` — no args"]
8416 pub fn new() -> Self {
8417 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
8418 panic!(
8419 "{}
8420::{}
8421 failed to instantiate",
8422 ::core::stringify!(MapUnitCommandMenu_RodMenuItem),
8423 ::core::stringify!(new),
8424 )
8425 });
8426 <Self as IMapUnitCommandMenu_RodMenuItemMethods>::ctor(this);
8427 this
8428 }
8429}
8430
8431#[cfg(feature = "app-mapunitcommandmenu")]
8432pub trait IMapUnitCommandMenu_VisionCreateMenuItemMethods: IMapUnitCommandMenu_VisionCreateMenuItem {
8433 #[doc = "`get_FlagID()` overload"]
8434 fn get_flag_id(self) -> ::unity::Il2CppString {
8435 unsafe {
8436 let __receiver = <MapUnitCommandMenu_VisionCreateMenuItem as ::unity::FromIlInstance>::from_il_instance(
8437 <Self as ::unity::SystemObject>::as_instance(self),
8438 );
8439 {
8440 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
8441 let __vi = *__vt.get(27usize).unwrap_or_else(|| {
8442 panic!(
8443 "unity: virtual slot {}
8444 out of range (vtable len {}
8445) on the runtime class behind {}
8446 (method `{}
8447`)",
8448 27usize,
8449 __vt.len(),
8450 <MapUnitCommandMenu_VisionCreateMenuItem as ::unity::ClassIdentity>::NAME,
8451 "get_FlagID",
8452 )
8453 });
8454 let __inner: extern "C" fn(MapUnitCommandMenu_VisionCreateMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
8455 ::core::mem::transmute(__vi.method_ptr);
8456 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
8457 __inner(__receiver, __mi)
8458 }
8459 }
8460 }
8461 #[doc = "`get_Mind()` overload"]
8462 fn get_mind(self) -> crate::app::mapmind::MapMind_Type {
8463 unsafe {
8464 let __receiver = <MapUnitCommandMenu_VisionCreateMenuItem as ::unity::FromIlInstance>::from_il_instance(
8465 <Self as ::unity::SystemObject>::as_instance(self),
8466 );
8467 {
8468 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
8469 let __vi = *__vt.get(36usize).unwrap_or_else(|| {
8470 panic!(
8471 "unity: virtual slot {}
8472 out of range (vtable len {}
8473) on the runtime class behind {}
8474 (method `{}
8475`)",
8476 36usize,
8477 __vt.len(),
8478 <MapUnitCommandMenu_VisionCreateMenuItem as ::unity::ClassIdentity>::NAME,
8479 "get_Mind",
8480 )
8481 });
8482 let __inner: extern "C" fn(MapUnitCommandMenu_VisionCreateMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
8483 ::core::mem::transmute(__vi.method_ptr);
8484 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
8485 __inner(__receiver, __mi)
8486 }
8487 }
8488 }
8489 #[doc = "`get_ActiveMind()` overload"]
8490 fn get_active_mind(self) -> crate::app::mapmind::MapMind_Type {
8491 unsafe {
8492 let __receiver = <MapUnitCommandMenu_VisionCreateMenuItem as ::unity::FromIlInstance>::from_il_instance(
8493 <Self as ::unity::SystemObject>::as_instance(self),
8494 );
8495 {
8496 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
8497 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
8498 panic!(
8499 "unity: virtual slot {}
8500 out of range (vtable len {}
8501) on the runtime class behind {}
8502 (method `{}
8503`)",
8504 30usize,
8505 __vt.len(),
8506 <MapUnitCommandMenu_VisionCreateMenuItem as ::unity::ClassIdentity>::NAME,
8507 "get_ActiveMind",
8508 )
8509 });
8510 let __inner: extern "C" fn(MapUnitCommandMenu_VisionCreateMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
8511 ::core::mem::transmute(__vi.method_ptr);
8512 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
8513 __inner(__receiver, __mi)
8514 }
8515 }
8516 }
8517 #[doc = "`get_DeployMode()` overload"]
8518 fn get_deploy_mode(self) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
8519 unsafe {
8520 let __receiver = <MapUnitCommandMenu_VisionCreateMenuItem as ::unity::FromIlInstance>::from_il_instance(
8521 <Self as ::unity::SystemObject>::as_instance(self),
8522 );
8523 {
8524 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
8525 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
8526 panic!(
8527 "unity: virtual slot {}
8528 out of range (vtable len {}
8529) on the runtime class behind {}
8530 (method `{}
8531`)",
8532 31usize,
8533 __vt.len(),
8534 <MapUnitCommandMenu_VisionCreateMenuItem as ::unity::ClassIdentity>::NAME,
8535 "get_DeployMode",
8536 )
8537 });
8538 let __inner: extern "C" fn(
8539 MapUnitCommandMenu_VisionCreateMenuItem,
8540 ::unity::OptionalMethod,
8541 ) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode = ::core::mem::transmute(__vi.method_ptr);
8542 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
8543 __inner(__receiver, __mi)
8544 }
8545 }
8546 }
8547 #[doc = "`GetName()` overload"]
8548 fn get_name(self) -> ::unity::Il2CppString {
8549 unsafe {
8550 let __receiver = <MapUnitCommandMenu_VisionCreateMenuItem as ::unity::FromIlInstance>::from_il_instance(
8551 <Self as ::unity::SystemObject>::as_instance(self),
8552 );
8553 {
8554 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
8555 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
8556 panic!(
8557 "unity: virtual slot {}
8558 out of range (vtable len {}
8559) on the runtime class behind {}
8560 (method `{}
8561`)",
8562 4usize,
8563 __vt.len(),
8564 <MapUnitCommandMenu_VisionCreateMenuItem as ::unity::ClassIdentity>::NAME,
8565 "GetName",
8566 )
8567 });
8568 let __inner: extern "C" fn(MapUnitCommandMenu_VisionCreateMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
8569 ::core::mem::transmute(__vi.method_ptr);
8570 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
8571 __inner(__receiver, __mi)
8572 }
8573 }
8574 }
8575 #[doc = "`GetCommandHelp()` overload"]
8576 fn get_command_help(self) -> ::unity::Il2CppString {
8577 unsafe {
8578 let __receiver = <MapUnitCommandMenu_VisionCreateMenuItem as ::unity::FromIlInstance>::from_il_instance(
8579 <Self as ::unity::SystemObject>::as_instance(self),
8580 );
8581 {
8582 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
8583 let __vi = *__vt.get(34usize).unwrap_or_else(|| {
8584 panic!(
8585 "unity: virtual slot {}
8586 out of range (vtable len {}
8587) on the runtime class behind {}
8588 (method `{}
8589`)",
8590 34usize,
8591 __vt.len(),
8592 <MapUnitCommandMenu_VisionCreateMenuItem as ::unity::ClassIdentity>::NAME,
8593 "GetCommandHelp",
8594 )
8595 });
8596 let __inner: extern "C" fn(MapUnitCommandMenu_VisionCreateMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
8597 ::core::mem::transmute(__vi.method_ptr);
8598 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
8599 __inner(__receiver, __mi)
8600 }
8601 }
8602 }
8603 #[doc = "`GetMapAttribute()` overload"]
8604 fn get_map_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
8605 unsafe {
8606 let __receiver = <MapUnitCommandMenu_VisionCreateMenuItem as ::unity::FromIlInstance>::from_il_instance(
8607 <Self as ::unity::SystemObject>::as_instance(self),
8608 );
8609 {
8610 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
8611 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
8612 panic!(
8613 "unity: virtual slot {}
8614 out of range (vtable len {}
8615) on the runtime class behind {}
8616 (method `{}
8617`)",
8618 29usize,
8619 __vt.len(),
8620 <MapUnitCommandMenu_VisionCreateMenuItem as ::unity::ClassIdentity>::NAME,
8621 "GetMapAttribute",
8622 )
8623 });
8624 let __inner: extern "C" fn(
8625 MapUnitCommandMenu_VisionCreateMenuItem,
8626 ::unity::OptionalMethod,
8627 ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
8628 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
8629 __inner(__receiver, __mi)
8630 }
8631 }
8632 }
8633 #[doc = "`.ctor()` overload"]
8634 fn ctor(self) -> () {
8635 unsafe {
8636 let __receiver = <MapUnitCommandMenu_VisionCreateMenuItem as ::unity::FromIlInstance>::from_il_instance(
8637 <Self as ::unity::SystemObject>::as_instance(self),
8638 );
8639 ::unity::il2cpp_call!((::unity::module_base()+0x1e52c50usize)as*mut u8,();
8640(MapUnitCommandMenu_VisionCreateMenuItem)__receiver)
8641 }
8642 }
8643}
8644
8645#[cfg(feature = "app-mapunitcommandmenu")]
8646impl<__T: IMapUnitCommandMenu_VisionCreateMenuItem> IMapUnitCommandMenu_VisionCreateMenuItemMethods for __T {}
8647
8648#[cfg(feature = "app-mapunitcommandmenu")]
8649impl MapUnitCommandMenu_VisionCreateMenuItem {
8650 pub fn get_flag_id_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8651 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
8652 }
8653
8654 pub fn get_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8655 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
8656 }
8657
8658 pub fn get_active_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8659 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
8660 }
8661
8662 pub fn get_deploy_mode_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8663 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
8664 }
8665
8666 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8667 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
8668 }
8669
8670 pub fn get_command_help_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8671 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
8672 }
8673
8674 pub fn get_map_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8675 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
8676 }
8677
8678 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8679 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
8680 }
8681}
8682
8683#[cfg(feature = "app-mapunitcommandmenu")]
8684impl MapUnitCommandMenu_VisionCreateMenuItem {
8685 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_VisionCreateMenuItem`'s own `get_FlagID`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
8686 pub unsafe fn get_flag_id(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
8687 let __mi = Self::get_flag_id_method_info();
8688 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
8689 __inner(this.into(), ::core::option::Option::None)
8690 }
8691
8692 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_VisionCreateMenuItem`'s own `get_Mind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
8693 pub unsafe fn get_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
8694 let __mi = Self::get_mind_method_info();
8695 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
8696 ::core::mem::transmute(__mi.method_ptr);
8697 __inner(this.into(), ::core::option::Option::None)
8698 }
8699
8700 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_VisionCreateMenuItem`'s own `get_ActiveMind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
8701 pub unsafe fn get_active_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
8702 let __mi = Self::get_active_mind_method_info();
8703 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
8704 ::core::mem::transmute(__mi.method_ptr);
8705 __inner(this.into(), ::core::option::Option::None)
8706 }
8707
8708 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_VisionCreateMenuItem`'s own `get_DeployMode`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
8709 pub unsafe fn get_deploy_mode(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
8710 let __mi = Self::get_deploy_mode_method_info();
8711 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode =
8712 ::core::mem::transmute(__mi.method_ptr);
8713 __inner(this.into(), ::core::option::Option::None)
8714 }
8715
8716 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_VisionCreateMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
8717 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
8718 let __mi = Self::get_name_method_info();
8719 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
8720 __inner(this.into(), ::core::option::Option::None)
8721 }
8722
8723 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_VisionCreateMenuItem`'s own `GetCommandHelp`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
8724 pub unsafe fn get_command_help(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
8725 let __mi = Self::get_command_help_method_info();
8726 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
8727 __inner(this.into(), ::core::option::Option::None)
8728 }
8729
8730 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_VisionCreateMenuItem`'s own `GetMapAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
8731 pub unsafe fn get_map_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
8732 let __mi = Self::get_map_attribute_method_info();
8733 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
8734 ::core::mem::transmute(__mi.method_ptr);
8735 __inner(this.into(), ::core::option::Option::None)
8736 }
8737}
8738
8739#[cfg(feature = "app-mapunitcommandmenu")]
8740impl MapUnitCommandMenu_VisionCreateMenuItem {
8741 #[doc = "`.ctor()` — no args"]
8742 pub fn new() -> Self {
8743 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
8744 panic!(
8745 "{}
8746::{}
8747 failed to instantiate",
8748 ::core::stringify!(MapUnitCommandMenu_VisionCreateMenuItem),
8749 ::core::stringify!(new),
8750 )
8751 });
8752 <Self as IMapUnitCommandMenu_VisionCreateMenuItemMethods>::ctor(this);
8753 this
8754 }
8755}
8756
8757#[cfg(feature = "app-mapunitcommandmenu")]
8758pub trait IMapUnitCommandMenu_SkillAttackMenuItemMethods: IMapUnitCommandMenu_SkillAttackMenuItem {
8759 #[doc = "`.ctor(crate::app::skilldata::SkillData)` overload"]
8760 fn ctor(self, command_skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>) -> () {
8761 unsafe {
8762 let __receiver = <MapUnitCommandMenu_SkillAttackMenuItem as ::unity::FromIlInstance>::from_il_instance(
8763 <Self as ::unity::SystemObject>::as_instance(self),
8764 );
8765 ::unity::il2cpp_call!((::unity::module_base()+0x1e4d360usize)as*mut u8,();
8766(MapUnitCommandMenu_SkillAttackMenuItem)__receiver,(crate::app::skilldata::SkillData)::core::convert::Into::into(command_skill))
8767 }
8768 }
8769 #[doc = "`get_CommandSkill()` overload"]
8770 fn get_command_skill(self) -> crate::app::skilldata::SkillData {
8771 unsafe {
8772 let __receiver = <MapUnitCommandMenu_SkillAttackMenuItem as ::unity::FromIlInstance>::from_il_instance(
8773 <Self as ::unity::SystemObject>::as_instance(self),
8774 );
8775 {
8776 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
8777 let __vi = *__vt.get(32usize).unwrap_or_else(|| {
8778 panic!(
8779 "unity: virtual slot {}
8780 out of range (vtable len {}
8781) on the runtime class behind {}
8782 (method `{}
8783`)",
8784 32usize,
8785 __vt.len(),
8786 <MapUnitCommandMenu_SkillAttackMenuItem as ::unity::ClassIdentity>::NAME,
8787 "get_CommandSkill",
8788 )
8789 });
8790 let __inner: extern "C" fn(MapUnitCommandMenu_SkillAttackMenuItem, ::unity::OptionalMethod) -> crate::app::skilldata::SkillData =
8791 ::core::mem::transmute(__vi.method_ptr);
8792 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
8793 __inner(__receiver, __mi)
8794 }
8795 }
8796 }
8797 #[doc = "`get_Mind()` overload"]
8798 fn get_mind(self) -> crate::app::mapmind::MapMind_Type {
8799 unsafe {
8800 let __receiver = <MapUnitCommandMenu_SkillAttackMenuItem as ::unity::FromIlInstance>::from_il_instance(
8801 <Self as ::unity::SystemObject>::as_instance(self),
8802 );
8803 {
8804 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
8805 let __vi = *__vt.get(37usize).unwrap_or_else(|| {
8806 panic!(
8807 "unity: virtual slot {}
8808 out of range (vtable len {}
8809) on the runtime class behind {}
8810 (method `{}
8811`)",
8812 37usize,
8813 __vt.len(),
8814 <MapUnitCommandMenu_SkillAttackMenuItem as ::unity::ClassIdentity>::NAME,
8815 "get_Mind",
8816 )
8817 });
8818 let __inner: extern "C" fn(MapUnitCommandMenu_SkillAttackMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
8819 ::core::mem::transmute(__vi.method_ptr);
8820 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
8821 __inner(__receiver, __mi)
8822 }
8823 }
8824 }
8825 #[doc = "`get_ActiveMind()` overload"]
8826 fn get_active_mind(self) -> crate::app::mapmind::MapMind_Type {
8827 unsafe {
8828 let __receiver = <MapUnitCommandMenu_SkillAttackMenuItem as ::unity::FromIlInstance>::from_il_instance(
8829 <Self as ::unity::SystemObject>::as_instance(self),
8830 );
8831 {
8832 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
8833 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
8834 panic!(
8835 "unity: virtual slot {}
8836 out of range (vtable len {}
8837) on the runtime class behind {}
8838 (method `{}
8839`)",
8840 30usize,
8841 __vt.len(),
8842 <MapUnitCommandMenu_SkillAttackMenuItem as ::unity::ClassIdentity>::NAME,
8843 "get_ActiveMind",
8844 )
8845 });
8846 let __inner: extern "C" fn(MapUnitCommandMenu_SkillAttackMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
8847 ::core::mem::transmute(__vi.method_ptr);
8848 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
8849 __inner(__receiver, __mi)
8850 }
8851 }
8852 }
8853 #[doc = "`get_DeployMode()` overload"]
8854 fn get_deploy_mode(self) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
8855 unsafe {
8856 let __receiver = <MapUnitCommandMenu_SkillAttackMenuItem as ::unity::FromIlInstance>::from_il_instance(
8857 <Self as ::unity::SystemObject>::as_instance(self),
8858 );
8859 {
8860 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
8861 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
8862 panic!(
8863 "unity: virtual slot {}
8864 out of range (vtable len {}
8865) on the runtime class behind {}
8866 (method `{}
8867`)",
8868 31usize,
8869 __vt.len(),
8870 <MapUnitCommandMenu_SkillAttackMenuItem as ::unity::ClassIdentity>::NAME,
8871 "get_DeployMode",
8872 )
8873 });
8874 let __inner: extern "C" fn(
8875 MapUnitCommandMenu_SkillAttackMenuItem,
8876 ::unity::OptionalMethod,
8877 ) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode = ::core::mem::transmute(__vi.method_ptr);
8878 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
8879 __inner(__receiver, __mi)
8880 }
8881 }
8882 }
8883 #[doc = "`GetMapAttribute()` overload"]
8884 fn get_map_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
8885 unsafe {
8886 let __receiver = <MapUnitCommandMenu_SkillAttackMenuItem as ::unity::FromIlInstance>::from_il_instance(
8887 <Self as ::unity::SystemObject>::as_instance(self),
8888 );
8889 {
8890 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
8891 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
8892 panic!(
8893 "unity: virtual slot {}
8894 out of range (vtable len {}
8895) on the runtime class behind {}
8896 (method `{}
8897`)",
8898 29usize,
8899 __vt.len(),
8900 <MapUnitCommandMenu_SkillAttackMenuItem as ::unity::ClassIdentity>::NAME,
8901 "GetMapAttribute",
8902 )
8903 });
8904 let __inner: extern "C" fn(
8905 MapUnitCommandMenu_SkillAttackMenuItem,
8906 ::unity::OptionalMethod,
8907 ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
8908 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
8909 __inner(__receiver, __mi)
8910 }
8911 }
8912 }
8913}
8914
8915#[cfg(feature = "app-mapunitcommandmenu")]
8916impl<__T: IMapUnitCommandMenu_SkillAttackMenuItem> IMapUnitCommandMenu_SkillAttackMenuItemMethods for __T {}
8917
8918#[cfg(feature = "app-mapunitcommandmenu")]
8919impl MapUnitCommandMenu_SkillAttackMenuItem {
8920 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8921 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
8922 }
8923
8924 pub fn get_command_skill_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8925 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
8926 }
8927
8928 pub fn get_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8929 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
8930 }
8931
8932 pub fn get_active_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8933 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
8934 }
8935
8936 pub fn get_deploy_mode_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8937 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
8938 }
8939
8940 pub fn get_map_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8941 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
8942 }
8943}
8944
8945#[cfg(feature = "app-mapunitcommandmenu")]
8946impl MapUnitCommandMenu_SkillAttackMenuItem {
8947 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_SkillAttackMenuItem`'s own `get_CommandSkill`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
8948 pub unsafe fn get_command_skill(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::skilldata::SkillData {
8949 let __mi = Self::get_command_skill_method_info();
8950 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::skilldata::SkillData =
8951 ::core::mem::transmute(__mi.method_ptr);
8952 __inner(this.into(), ::core::option::Option::None)
8953 }
8954
8955 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_SkillAttackMenuItem`'s own `get_Mind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
8956 pub unsafe fn get_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
8957 let __mi = Self::get_mind_method_info();
8958 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
8959 ::core::mem::transmute(__mi.method_ptr);
8960 __inner(this.into(), ::core::option::Option::None)
8961 }
8962
8963 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_SkillAttackMenuItem`'s own `get_ActiveMind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
8964 pub unsafe fn get_active_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
8965 let __mi = Self::get_active_mind_method_info();
8966 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
8967 ::core::mem::transmute(__mi.method_ptr);
8968 __inner(this.into(), ::core::option::Option::None)
8969 }
8970
8971 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_SkillAttackMenuItem`'s own `get_DeployMode`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
8972 pub unsafe fn get_deploy_mode(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
8973 let __mi = Self::get_deploy_mode_method_info();
8974 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode =
8975 ::core::mem::transmute(__mi.method_ptr);
8976 __inner(this.into(), ::core::option::Option::None)
8977 }
8978
8979 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_SkillAttackMenuItem`'s own `GetMapAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
8980 pub unsafe fn get_map_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
8981 let __mi = Self::get_map_attribute_method_info();
8982 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
8983 ::core::mem::transmute(__mi.method_ptr);
8984 __inner(this.into(), ::core::option::Option::None)
8985 }
8986}
8987
8988#[cfg(feature = "app-mapunitcommandmenu")]
8989impl MapUnitCommandMenu_SkillAttackMenuItem {
8990 #[doc = "`.ctor(crate::app::skilldata::SkillData)` — overload selector"]
8991 pub fn new(command_skill: crate::app::skilldata::SkillData) -> Self {
8992 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
8993 panic!(
8994 "{}
8995::{}
8996 failed to instantiate",
8997 ::core::stringify!(MapUnitCommandMenu_SkillAttackMenuItem),
8998 ::core::stringify!(new),
8999 )
9000 });
9001 <Self as IMapUnitCommandMenu_SkillAttackMenuItemMethods>::ctor(this, command_skill);
9002 this
9003 }
9004}
9005
9006#[cfg(feature = "app-mapunitcommandmenu")]
9007pub trait IMapUnitCommandMenu_EngageWaitMenuItemMethods: IMapUnitCommandMenu_EngageWaitMenuItem {
9008 #[doc = "`get_Mind()` overload"]
9009 fn get_mind(self) -> crate::app::mapmind::MapMind_Type {
9010 unsafe {
9011 let __receiver = <MapUnitCommandMenu_EngageWaitMenuItem as ::unity::FromIlInstance>::from_il_instance(
9012 <Self as ::unity::SystemObject>::as_instance(self),
9013 );
9014 {
9015 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
9016 let __vi = *__vt.get(37usize).unwrap_or_else(|| {
9017 panic!(
9018 "unity: virtual slot {}
9019 out of range (vtable len {}
9020) on the runtime class behind {}
9021 (method `{}
9022`)",
9023 37usize,
9024 __vt.len(),
9025 <MapUnitCommandMenu_EngageWaitMenuItem as ::unity::ClassIdentity>::NAME,
9026 "get_Mind",
9027 )
9028 });
9029 let __inner: extern "C" fn(MapUnitCommandMenu_EngageWaitMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
9030 ::core::mem::transmute(__vi.method_ptr);
9031 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
9032 __inner(__receiver, __mi)
9033 }
9034 }
9035 }
9036 #[doc = "`get_ActionMask()` overload"]
9037 fn get_action_mask(self) -> crate::app::maptarget::MapTarget_ActionMask {
9038 unsafe {
9039 let __receiver = <MapUnitCommandMenu_EngageWaitMenuItem as ::unity::FromIlInstance>::from_il_instance(
9040 <Self as ::unity::SystemObject>::as_instance(self),
9041 );
9042 {
9043 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
9044 let __vi = *__vt.get(38usize).unwrap_or_else(|| {
9045 panic!(
9046 "unity: virtual slot {}
9047 out of range (vtable len {}
9048) on the runtime class behind {}
9049 (method `{}
9050`)",
9051 38usize,
9052 __vt.len(),
9053 <MapUnitCommandMenu_EngageWaitMenuItem as ::unity::ClassIdentity>::NAME,
9054 "get_ActionMask",
9055 )
9056 });
9057 let __inner: extern "C" fn(
9058 MapUnitCommandMenu_EngageWaitMenuItem,
9059 ::unity::OptionalMethod,
9060 ) -> crate::app::maptarget::MapTarget_ActionMask = ::core::mem::transmute(__vi.method_ptr);
9061 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
9062 __inner(__receiver, __mi)
9063 }
9064 }
9065 }
9066 #[doc = "`get_Label()` overload"]
9067 fn get_label(self) -> crate::app::mapsequencehuman::MapSequenceHuman_Label {
9068 unsafe {
9069 let __receiver = <MapUnitCommandMenu_EngageWaitMenuItem as ::unity::FromIlInstance>::from_il_instance(
9070 <Self as ::unity::SystemObject>::as_instance(self),
9071 );
9072 {
9073 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
9074 let __vi = *__vt.get(36usize).unwrap_or_else(|| {
9075 panic!(
9076 "unity: virtual slot {}
9077 out of range (vtable len {}
9078) on the runtime class behind {}
9079 (method `{}
9080`)",
9081 36usize,
9082 __vt.len(),
9083 <MapUnitCommandMenu_EngageWaitMenuItem as ::unity::ClassIdentity>::NAME,
9084 "get_Label",
9085 )
9086 });
9087 let __inner: extern "C" fn(
9088 MapUnitCommandMenu_EngageWaitMenuItem,
9089 ::unity::OptionalMethod,
9090 ) -> crate::app::mapsequencehuman::MapSequenceHuman_Label = ::core::mem::transmute(__vi.method_ptr);
9091 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
9092 __inner(__receiver, __mi)
9093 }
9094 }
9095 }
9096 #[doc = "`get_ActiveMind()` overload"]
9097 fn get_active_mind(self) -> crate::app::mapmind::MapMind_Type {
9098 unsafe {
9099 let __receiver = <MapUnitCommandMenu_EngageWaitMenuItem as ::unity::FromIlInstance>::from_il_instance(
9100 <Self as ::unity::SystemObject>::as_instance(self),
9101 );
9102 {
9103 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
9104 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
9105 panic!(
9106 "unity: virtual slot {}
9107 out of range (vtable len {}
9108) on the runtime class behind {}
9109 (method `{}
9110`)",
9111 30usize,
9112 __vt.len(),
9113 <MapUnitCommandMenu_EngageWaitMenuItem as ::unity::ClassIdentity>::NAME,
9114 "get_ActiveMind",
9115 )
9116 });
9117 let __inner: extern "C" fn(MapUnitCommandMenu_EngageWaitMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
9118 ::core::mem::transmute(__vi.method_ptr);
9119 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
9120 __inner(__receiver, __mi)
9121 }
9122 }
9123 }
9124 #[doc = "`get_DeployMode()` overload"]
9125 fn get_deploy_mode(self) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
9126 unsafe {
9127 let __receiver = <MapUnitCommandMenu_EngageWaitMenuItem as ::unity::FromIlInstance>::from_il_instance(
9128 <Self as ::unity::SystemObject>::as_instance(self),
9129 );
9130 {
9131 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
9132 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
9133 panic!(
9134 "unity: virtual slot {}
9135 out of range (vtable len {}
9136) on the runtime class behind {}
9137 (method `{}
9138`)",
9139 31usize,
9140 __vt.len(),
9141 <MapUnitCommandMenu_EngageWaitMenuItem as ::unity::ClassIdentity>::NAME,
9142 "get_DeployMode",
9143 )
9144 });
9145 let __inner: extern "C" fn(
9146 MapUnitCommandMenu_EngageWaitMenuItem,
9147 ::unity::OptionalMethod,
9148 ) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode = ::core::mem::transmute(__vi.method_ptr);
9149 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
9150 __inner(__receiver, __mi)
9151 }
9152 }
9153 }
9154 #[doc = "`get_IsForecast()` overload"]
9155 fn get_is_forecast(self) -> bool {
9156 unsafe {
9157 let __receiver = <MapUnitCommandMenu_EngageWaitMenuItem as ::unity::FromIlInstance>::from_il_instance(
9158 <Self as ::unity::SystemObject>::as_instance(self),
9159 );
9160 {
9161 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
9162 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
9163 panic!(
9164 "unity: virtual slot {}
9165 out of range (vtable len {}
9166) on the runtime class behind {}
9167 (method `{}
9168`)",
9169 33usize,
9170 __vt.len(),
9171 <MapUnitCommandMenu_EngageWaitMenuItem as ::unity::ClassIdentity>::NAME,
9172 "get_IsForecast",
9173 )
9174 });
9175 let __inner: extern "C" fn(MapUnitCommandMenu_EngageWaitMenuItem, ::unity::OptionalMethod) -> bool =
9176 ::core::mem::transmute(__vi.method_ptr);
9177 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
9178 __inner(__receiver, __mi)
9179 }
9180 }
9181 }
9182 #[doc = "`.ctor()` overload"]
9183 fn ctor(self) -> () {
9184 unsafe {
9185 let __receiver = <MapUnitCommandMenu_EngageWaitMenuItem as ::unity::FromIlInstance>::from_il_instance(
9186 <Self as ::unity::SystemObject>::as_instance(self),
9187 );
9188 ::unity::il2cpp_call!((::unity::module_base()+0x1e4e3f0usize)as*mut u8,();
9189(MapUnitCommandMenu_EngageWaitMenuItem)__receiver)
9190 }
9191 }
9192}
9193
9194#[cfg(feature = "app-mapunitcommandmenu")]
9195impl<__T: IMapUnitCommandMenu_EngageWaitMenuItem> IMapUnitCommandMenu_EngageWaitMenuItemMethods for __T {}
9196
9197#[cfg(feature = "app-mapunitcommandmenu")]
9198impl MapUnitCommandMenu_EngageWaitMenuItem {
9199 pub fn get_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
9200 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
9201 }
9202
9203 pub fn get_action_mask_method_info() -> &'static ::unity::il2cpp::MethodInfo {
9204 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
9205 }
9206
9207 pub fn get_label_method_info() -> &'static ::unity::il2cpp::MethodInfo {
9208 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
9209 }
9210
9211 pub fn get_active_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
9212 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
9213 }
9214
9215 pub fn get_deploy_mode_method_info() -> &'static ::unity::il2cpp::MethodInfo {
9216 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
9217 }
9218
9219 pub fn get_is_forecast_method_info() -> &'static ::unity::il2cpp::MethodInfo {
9220 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
9221 }
9222
9223 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
9224 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
9225 }
9226}
9227
9228#[cfg(feature = "app-mapunitcommandmenu")]
9229impl MapUnitCommandMenu_EngageWaitMenuItem {
9230 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageWaitMenuItem`'s own `get_Mind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
9231 pub unsafe fn get_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
9232 let __mi = Self::get_mind_method_info();
9233 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
9234 ::core::mem::transmute(__mi.method_ptr);
9235 __inner(this.into(), ::core::option::Option::None)
9236 }
9237
9238 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageWaitMenuItem`'s own `get_ActionMask`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
9239 pub unsafe fn get_action_mask(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::maptarget::MapTarget_ActionMask {
9240 let __mi = Self::get_action_mask_method_info();
9241 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::maptarget::MapTarget_ActionMask =
9242 ::core::mem::transmute(__mi.method_ptr);
9243 __inner(this.into(), ::core::option::Option::None)
9244 }
9245
9246 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageWaitMenuItem`'s own `get_Label`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
9247 pub unsafe fn get_label(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapsequencehuman::MapSequenceHuman_Label {
9248 let __mi = Self::get_label_method_info();
9249 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapsequencehuman::MapSequenceHuman_Label =
9250 ::core::mem::transmute(__mi.method_ptr);
9251 __inner(this.into(), ::core::option::Option::None)
9252 }
9253
9254 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageWaitMenuItem`'s own `get_ActiveMind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
9255 pub unsafe fn get_active_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
9256 let __mi = Self::get_active_mind_method_info();
9257 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
9258 ::core::mem::transmute(__mi.method_ptr);
9259 __inner(this.into(), ::core::option::Option::None)
9260 }
9261
9262 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageWaitMenuItem`'s own `get_DeployMode`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
9263 pub unsafe fn get_deploy_mode(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
9264 let __mi = Self::get_deploy_mode_method_info();
9265 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode =
9266 ::core::mem::transmute(__mi.method_ptr);
9267 __inner(this.into(), ::core::option::Option::None)
9268 }
9269
9270 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageWaitMenuItem`'s own `get_IsForecast`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
9271 pub unsafe fn get_is_forecast(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
9272 let __mi = Self::get_is_forecast_method_info();
9273 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
9274 __inner(this.into(), ::core::option::Option::None)
9275 }
9276}
9277
9278#[cfg(feature = "app-mapunitcommandmenu")]
9279impl MapUnitCommandMenu_EngageWaitMenuItem {
9280 #[doc = "`.ctor()` — no args"]
9281 pub fn new() -> Self {
9282 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
9283 panic!(
9284 "{}
9285::{}
9286 failed to instantiate",
9287 ::core::stringify!(MapUnitCommandMenu_EngageWaitMenuItem),
9288 ::core::stringify!(new),
9289 )
9290 });
9291 <Self as IMapUnitCommandMenu_EngageWaitMenuItemMethods>::ctor(this);
9292 this
9293 }
9294}
9295
9296#[cfg(feature = "app-mapunitcommandmenu")]
9297pub trait IMapUnitCommandMenu_NoCancelMagicMenuItemMethods: IMapUnitCommandMenu_NoCancelMagicMenuItem {
9298 #[doc = "`.ctor()` overload"]
9299 fn ctor(self) -> () {
9300 unsafe {
9301 let __receiver = <MapUnitCommandMenu_NoCancelMagicMenuItem as ::unity::FromIlInstance>::from_il_instance(
9302 <Self as ::unity::SystemObject>::as_instance(self),
9303 );
9304 ::unity::il2cpp_call!((::unity::module_base()+0x1e4f9f0usize)as*mut u8,();
9305(MapUnitCommandMenu_NoCancelMagicMenuItem)__receiver)
9306 }
9307 }
9308 #[doc = "`BCall()` overload"]
9309 fn b_call(self) -> crate::app::basicmenu::BasicMenu_Result {
9310 unsafe {
9311 let __receiver = <MapUnitCommandMenu_NoCancelMagicMenuItem as ::unity::FromIlInstance>::from_il_instance(
9312 <Self as ::unity::SystemObject>::as_instance(self),
9313 );
9314 {
9315 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
9316 let __vi = *__vt.get(19usize).unwrap_or_else(|| {
9317 panic!(
9318 "unity: virtual slot {}
9319 out of range (vtable len {}
9320) on the runtime class behind {}
9321 (method `{}
9322`)",
9323 19usize,
9324 __vt.len(),
9325 <MapUnitCommandMenu_NoCancelMagicMenuItem as ::unity::ClassIdentity>::NAME,
9326 "BCall",
9327 )
9328 });
9329 let __inner: extern "C" fn(
9330 MapUnitCommandMenu_NoCancelMagicMenuItem,
9331 ::unity::OptionalMethod,
9332 ) -> crate::app::basicmenu::BasicMenu_Result = ::core::mem::transmute(__vi.method_ptr);
9333 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
9334 __inner(__receiver, __mi)
9335 }
9336 }
9337 }
9338}
9339
9340#[cfg(feature = "app-mapunitcommandmenu")]
9341impl<__T: IMapUnitCommandMenu_NoCancelMagicMenuItem> IMapUnitCommandMenu_NoCancelMagicMenuItemMethods for __T {}
9342
9343#[cfg(feature = "app-mapunitcommandmenu")]
9344impl MapUnitCommandMenu_NoCancelMagicMenuItem {
9345 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
9346 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
9347 }
9348
9349 pub fn b_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
9350 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
9351 }
9352}
9353
9354#[cfg(feature = "app-mapunitcommandmenu")]
9355impl MapUnitCommandMenu_NoCancelMagicMenuItem {
9356 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_NoCancelMagicMenuItem`'s own `BCall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
9357 pub unsafe fn b_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
9358 let __mi = Self::b_call_method_info();
9359 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
9360 ::core::mem::transmute(__mi.method_ptr);
9361 __inner(this.into(), ::core::option::Option::None)
9362 }
9363}
9364
9365#[cfg(feature = "app-mapunitcommandmenu")]
9366impl MapUnitCommandMenu_NoCancelMagicMenuItem {
9367 #[doc = "`.ctor()` — no args"]
9368 pub fn new() -> Self {
9369 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
9370 panic!(
9371 "{}
9372::{}
9373 failed to instantiate",
9374 ::core::stringify!(MapUnitCommandMenu_NoCancelMagicMenuItem),
9375 ::core::stringify!(new),
9376 )
9377 });
9378 <Self as IMapUnitCommandMenu_NoCancelMagicMenuItemMethods>::ctor(this);
9379 this
9380 }
9381}
9382
9383#[cfg(feature = "app-mapunitcommandmenu")]
9384pub trait IMapUnitCommandMenu_TradeMenuItemMethods: IMapUnitCommandMenu_TradeMenuItem {
9385 #[doc = "`get_FlagID()` overload"]
9386 fn get_flag_id(self) -> ::unity::Il2CppString {
9387 unsafe {
9388 let __receiver =
9389 <MapUnitCommandMenu_TradeMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9390 {
9391 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
9392 let __vi = *__vt.get(27usize).unwrap_or_else(|| {
9393 panic!(
9394 "unity: virtual slot {}
9395 out of range (vtable len {}
9396) on the runtime class behind {}
9397 (method `{}
9398`)",
9399 27usize,
9400 __vt.len(),
9401 <MapUnitCommandMenu_TradeMenuItem as ::unity::ClassIdentity>::NAME,
9402 "get_FlagID",
9403 )
9404 });
9405 let __inner: extern "C" fn(MapUnitCommandMenu_TradeMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
9406 ::core::mem::transmute(__vi.method_ptr);
9407 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
9408 __inner(__receiver, __mi)
9409 }
9410 }
9411 }
9412 #[doc = "`get_Mind()` overload"]
9413 fn get_mind(self) -> crate::app::mapmind::MapMind_Type {
9414 unsafe {
9415 let __receiver =
9416 <MapUnitCommandMenu_TradeMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9417 {
9418 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
9419 let __vi = *__vt.get(36usize).unwrap_or_else(|| {
9420 panic!(
9421 "unity: virtual slot {}
9422 out of range (vtable len {}
9423) on the runtime class behind {}
9424 (method `{}
9425`)",
9426 36usize,
9427 __vt.len(),
9428 <MapUnitCommandMenu_TradeMenuItem as ::unity::ClassIdentity>::NAME,
9429 "get_Mind",
9430 )
9431 });
9432 let __inner: extern "C" fn(MapUnitCommandMenu_TradeMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
9433 ::core::mem::transmute(__vi.method_ptr);
9434 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
9435 __inner(__receiver, __mi)
9436 }
9437 }
9438 }
9439 #[doc = "`get_ActiveMind()` overload"]
9440 fn get_active_mind(self) -> crate::app::mapmind::MapMind_Type {
9441 unsafe {
9442 let __receiver =
9443 <MapUnitCommandMenu_TradeMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9444 {
9445 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
9446 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
9447 panic!(
9448 "unity: virtual slot {}
9449 out of range (vtable len {}
9450) on the runtime class behind {}
9451 (method `{}
9452`)",
9453 30usize,
9454 __vt.len(),
9455 <MapUnitCommandMenu_TradeMenuItem as ::unity::ClassIdentity>::NAME,
9456 "get_ActiveMind",
9457 )
9458 });
9459 let __inner: extern "C" fn(MapUnitCommandMenu_TradeMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
9460 ::core::mem::transmute(__vi.method_ptr);
9461 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
9462 __inner(__receiver, __mi)
9463 }
9464 }
9465 }
9466 #[doc = "`get_DeployMode()` overload"]
9467 fn get_deploy_mode(self) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
9468 unsafe {
9469 let __receiver =
9470 <MapUnitCommandMenu_TradeMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9471 {
9472 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
9473 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
9474 panic!(
9475 "unity: virtual slot {}
9476 out of range (vtable len {}
9477) on the runtime class behind {}
9478 (method `{}
9479`)",
9480 31usize,
9481 __vt.len(),
9482 <MapUnitCommandMenu_TradeMenuItem as ::unity::ClassIdentity>::NAME,
9483 "get_DeployMode",
9484 )
9485 });
9486 let __inner: extern "C" fn(
9487 MapUnitCommandMenu_TradeMenuItem,
9488 ::unity::OptionalMethod,
9489 ) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode = ::core::mem::transmute(__vi.method_ptr);
9490 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
9491 __inner(__receiver, __mi)
9492 }
9493 }
9494 }
9495 #[doc = "`GetName()` overload"]
9496 fn get_name(self) -> ::unity::Il2CppString {
9497 unsafe {
9498 let __receiver =
9499 <MapUnitCommandMenu_TradeMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9500 {
9501 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
9502 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
9503 panic!(
9504 "unity: virtual slot {}
9505 out of range (vtable len {}
9506) on the runtime class behind {}
9507 (method `{}
9508`)",
9509 4usize,
9510 __vt.len(),
9511 <MapUnitCommandMenu_TradeMenuItem as ::unity::ClassIdentity>::NAME,
9512 "GetName",
9513 )
9514 });
9515 let __inner: extern "C" fn(MapUnitCommandMenu_TradeMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
9516 ::core::mem::transmute(__vi.method_ptr);
9517 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
9518 __inner(__receiver, __mi)
9519 }
9520 }
9521 }
9522 #[doc = "`GetCommandHelp()` overload"]
9523 fn get_command_help(self) -> ::unity::Il2CppString {
9524 unsafe {
9525 let __receiver =
9526 <MapUnitCommandMenu_TradeMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9527 {
9528 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
9529 let __vi = *__vt.get(34usize).unwrap_or_else(|| {
9530 panic!(
9531 "unity: virtual slot {}
9532 out of range (vtable len {}
9533) on the runtime class behind {}
9534 (method `{}
9535`)",
9536 34usize,
9537 __vt.len(),
9538 <MapUnitCommandMenu_TradeMenuItem as ::unity::ClassIdentity>::NAME,
9539 "GetCommandHelp",
9540 )
9541 });
9542 let __inner: extern "C" fn(MapUnitCommandMenu_TradeMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
9543 ::core::mem::transmute(__vi.method_ptr);
9544 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
9545 __inner(__receiver, __mi)
9546 }
9547 }
9548 }
9549 #[doc = "`GetMapAttribute()` overload"]
9550 fn get_map_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
9551 unsafe {
9552 let __receiver =
9553 <MapUnitCommandMenu_TradeMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9554 {
9555 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
9556 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
9557 panic!(
9558 "unity: virtual slot {}
9559 out of range (vtable len {}
9560) on the runtime class behind {}
9561 (method `{}
9562`)",
9563 29usize,
9564 __vt.len(),
9565 <MapUnitCommandMenu_TradeMenuItem as ::unity::ClassIdentity>::NAME,
9566 "GetMapAttribute",
9567 )
9568 });
9569 let __inner: extern "C" fn(
9570 MapUnitCommandMenu_TradeMenuItem,
9571 ::unity::OptionalMethod,
9572 ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
9573 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
9574 __inner(__receiver, __mi)
9575 }
9576 }
9577 }
9578 #[doc = "`ACall()` overload"]
9579 fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
9580 unsafe {
9581 let __receiver =
9582 <MapUnitCommandMenu_TradeMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9583 {
9584 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
9585 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
9586 panic!(
9587 "unity: virtual slot {}
9588 out of range (vtable len {}
9589) on the runtime class behind {}
9590 (method `{}
9591`)",
9592 18usize,
9593 __vt.len(),
9594 <MapUnitCommandMenu_TradeMenuItem as ::unity::ClassIdentity>::NAME,
9595 "ACall",
9596 )
9597 });
9598 let __inner: extern "C" fn(MapUnitCommandMenu_TradeMenuItem, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
9599 ::core::mem::transmute(__vi.method_ptr);
9600 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
9601 __inner(__receiver, __mi)
9602 }
9603 }
9604 }
9605 #[doc = "`.ctor()` overload"]
9606 fn ctor(self) -> () {
9607 unsafe {
9608 let __receiver =
9609 <MapUnitCommandMenu_TradeMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9610 ::unity::il2cpp_call!((::unity::module_base()+0x1e51bf0usize)as*mut u8,();
9611(MapUnitCommandMenu_TradeMenuItem)__receiver)
9612 }
9613 }
9614}
9615
9616#[cfg(feature = "app-mapunitcommandmenu")]
9617impl<__T: IMapUnitCommandMenu_TradeMenuItem> IMapUnitCommandMenu_TradeMenuItemMethods for __T {}
9618
9619#[cfg(feature = "app-mapunitcommandmenu")]
9620impl MapUnitCommandMenu_TradeMenuItem {
9621 pub fn get_flag_id_method_info() -> &'static ::unity::il2cpp::MethodInfo {
9622 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
9623 }
9624
9625 pub fn get_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
9626 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
9627 }
9628
9629 pub fn get_active_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
9630 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
9631 }
9632
9633 pub fn get_deploy_mode_method_info() -> &'static ::unity::il2cpp::MethodInfo {
9634 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
9635 }
9636
9637 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
9638 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
9639 }
9640
9641 pub fn get_command_help_method_info() -> &'static ::unity::il2cpp::MethodInfo {
9642 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
9643 }
9644
9645 pub fn get_map_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
9646 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
9647 }
9648
9649 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
9650 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
9651 }
9652
9653 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
9654 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
9655 }
9656}
9657
9658#[cfg(feature = "app-mapunitcommandmenu")]
9659impl MapUnitCommandMenu_TradeMenuItem {
9660 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_TradeMenuItem`'s own `get_FlagID`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
9661 pub unsafe fn get_flag_id(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
9662 let __mi = Self::get_flag_id_method_info();
9663 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
9664 __inner(this.into(), ::core::option::Option::None)
9665 }
9666
9667 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_TradeMenuItem`'s own `get_Mind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
9668 pub unsafe fn get_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
9669 let __mi = Self::get_mind_method_info();
9670 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
9671 ::core::mem::transmute(__mi.method_ptr);
9672 __inner(this.into(), ::core::option::Option::None)
9673 }
9674
9675 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_TradeMenuItem`'s own `get_ActiveMind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
9676 pub unsafe fn get_active_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
9677 let __mi = Self::get_active_mind_method_info();
9678 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
9679 ::core::mem::transmute(__mi.method_ptr);
9680 __inner(this.into(), ::core::option::Option::None)
9681 }
9682
9683 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_TradeMenuItem`'s own `get_DeployMode`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
9684 pub unsafe fn get_deploy_mode(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
9685 let __mi = Self::get_deploy_mode_method_info();
9686 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode =
9687 ::core::mem::transmute(__mi.method_ptr);
9688 __inner(this.into(), ::core::option::Option::None)
9689 }
9690
9691 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_TradeMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
9692 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
9693 let __mi = Self::get_name_method_info();
9694 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
9695 __inner(this.into(), ::core::option::Option::None)
9696 }
9697
9698 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_TradeMenuItem`'s own `GetCommandHelp`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
9699 pub unsafe fn get_command_help(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
9700 let __mi = Self::get_command_help_method_info();
9701 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
9702 __inner(this.into(), ::core::option::Option::None)
9703 }
9704
9705 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_TradeMenuItem`'s own `GetMapAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
9706 pub unsafe fn get_map_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
9707 let __mi = Self::get_map_attribute_method_info();
9708 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
9709 ::core::mem::transmute(__mi.method_ptr);
9710 __inner(this.into(), ::core::option::Option::None)
9711 }
9712
9713 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_TradeMenuItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
9714 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
9715 let __mi = Self::a_call_method_info();
9716 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
9717 ::core::mem::transmute(__mi.method_ptr);
9718 __inner(this.into(), ::core::option::Option::None)
9719 }
9720}
9721
9722#[cfg(feature = "app-mapunitcommandmenu")]
9723impl MapUnitCommandMenu_TradeMenuItem {
9724 #[doc = "`.ctor()` — no args"]
9725 pub fn new() -> Self {
9726 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
9727 panic!(
9728 "{}
9729::{}
9730 failed to instantiate",
9731 ::core::stringify!(MapUnitCommandMenu_TradeMenuItem),
9732 ::core::stringify!(new),
9733 )
9734 });
9735 <Self as IMapUnitCommandMenu_TradeMenuItemMethods>::ctor(this);
9736 this
9737 }
9738}
9739
9740#[cfg(feature = "app-mapunitcommandmenu")]
9741pub trait IMapUnitCommandMenu_GuardMenuItemMethods: IMapUnitCommandMenu_GuardMenuItem {
9742 #[doc = "`get_FlagID()` overload"]
9743 fn get_flag_id(self) -> ::unity::Il2CppString {
9744 unsafe {
9745 let __receiver =
9746 <MapUnitCommandMenu_GuardMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9747 {
9748 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
9749 let __vi = *__vt.get(27usize).unwrap_or_else(|| {
9750 panic!(
9751 "unity: virtual slot {}
9752 out of range (vtable len {}
9753) on the runtime class behind {}
9754 (method `{}
9755`)",
9756 27usize,
9757 __vt.len(),
9758 <MapUnitCommandMenu_GuardMenuItem as ::unity::ClassIdentity>::NAME,
9759 "get_FlagID",
9760 )
9761 });
9762 let __inner: extern "C" fn(MapUnitCommandMenu_GuardMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
9763 ::core::mem::transmute(__vi.method_ptr);
9764 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
9765 __inner(__receiver, __mi)
9766 }
9767 }
9768 }
9769 #[doc = "`get_Mind()` overload"]
9770 fn get_mind(self) -> crate::app::mapmind::MapMind_Type {
9771 unsafe {
9772 let __receiver =
9773 <MapUnitCommandMenu_GuardMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9774 {
9775 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
9776 let __vi = *__vt.get(36usize).unwrap_or_else(|| {
9777 panic!(
9778 "unity: virtual slot {}
9779 out of range (vtable len {}
9780) on the runtime class behind {}
9781 (method `{}
9782`)",
9783 36usize,
9784 __vt.len(),
9785 <MapUnitCommandMenu_GuardMenuItem as ::unity::ClassIdentity>::NAME,
9786 "get_Mind",
9787 )
9788 });
9789 let __inner: extern "C" fn(MapUnitCommandMenu_GuardMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
9790 ::core::mem::transmute(__vi.method_ptr);
9791 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
9792 __inner(__receiver, __mi)
9793 }
9794 }
9795 }
9796 #[doc = "`get_ActiveMind()` overload"]
9797 fn get_active_mind(self) -> crate::app::mapmind::MapMind_Type {
9798 unsafe {
9799 let __receiver =
9800 <MapUnitCommandMenu_GuardMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9801 {
9802 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
9803 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
9804 panic!(
9805 "unity: virtual slot {}
9806 out of range (vtable len {}
9807) on the runtime class behind {}
9808 (method `{}
9809`)",
9810 30usize,
9811 __vt.len(),
9812 <MapUnitCommandMenu_GuardMenuItem as ::unity::ClassIdentity>::NAME,
9813 "get_ActiveMind",
9814 )
9815 });
9816 let __inner: extern "C" fn(MapUnitCommandMenu_GuardMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
9817 ::core::mem::transmute(__vi.method_ptr);
9818 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
9819 __inner(__receiver, __mi)
9820 }
9821 }
9822 }
9823 #[doc = "`get_DeployMode()` overload"]
9824 fn get_deploy_mode(self) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
9825 unsafe {
9826 let __receiver =
9827 <MapUnitCommandMenu_GuardMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9828 {
9829 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
9830 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
9831 panic!(
9832 "unity: virtual slot {}
9833 out of range (vtable len {}
9834) on the runtime class behind {}
9835 (method `{}
9836`)",
9837 31usize,
9838 __vt.len(),
9839 <MapUnitCommandMenu_GuardMenuItem as ::unity::ClassIdentity>::NAME,
9840 "get_DeployMode",
9841 )
9842 });
9843 let __inner: extern "C" fn(
9844 MapUnitCommandMenu_GuardMenuItem,
9845 ::unity::OptionalMethod,
9846 ) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode = ::core::mem::transmute(__vi.method_ptr);
9847 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
9848 __inner(__receiver, __mi)
9849 }
9850 }
9851 }
9852 #[doc = "`.ctor()` overload"]
9853 fn ctor(self) -> () {
9854 unsafe {
9855 let __receiver =
9856 <MapUnitCommandMenu_GuardMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9857 ::unity::il2cpp_call!((::unity::module_base()+0x1e4ec50usize)as*mut u8,();
9858(MapUnitCommandMenu_GuardMenuItem)__receiver)
9859 }
9860 }
9861 #[doc = "`GetName()` overload"]
9862 fn get_name(self) -> ::unity::Il2CppString {
9863 unsafe {
9864 let __receiver =
9865 <MapUnitCommandMenu_GuardMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9866 {
9867 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
9868 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
9869 panic!(
9870 "unity: virtual slot {}
9871 out of range (vtable len {}
9872) on the runtime class behind {}
9873 (method `{}
9874`)",
9875 4usize,
9876 __vt.len(),
9877 <MapUnitCommandMenu_GuardMenuItem as ::unity::ClassIdentity>::NAME,
9878 "GetName",
9879 )
9880 });
9881 let __inner: extern "C" fn(MapUnitCommandMenu_GuardMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
9882 ::core::mem::transmute(__vi.method_ptr);
9883 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
9884 __inner(__receiver, __mi)
9885 }
9886 }
9887 }
9888 #[doc = "`GetCommandHelp()` overload"]
9889 fn get_command_help(self) -> ::unity::Il2CppString {
9890 unsafe {
9891 let __receiver =
9892 <MapUnitCommandMenu_GuardMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9893 {
9894 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
9895 let __vi = *__vt.get(34usize).unwrap_or_else(|| {
9896 panic!(
9897 "unity: virtual slot {}
9898 out of range (vtable len {}
9899) on the runtime class behind {}
9900 (method `{}
9901`)",
9902 34usize,
9903 __vt.len(),
9904 <MapUnitCommandMenu_GuardMenuItem as ::unity::ClassIdentity>::NAME,
9905 "GetCommandHelp",
9906 )
9907 });
9908 let __inner: extern "C" fn(MapUnitCommandMenu_GuardMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
9909 ::core::mem::transmute(__vi.method_ptr);
9910 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
9911 __inner(__receiver, __mi)
9912 }
9913 }
9914 }
9915 #[doc = "`GetMapAttribute()` overload"]
9916 fn get_map_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
9917 unsafe {
9918 let __receiver =
9919 <MapUnitCommandMenu_GuardMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9920 {
9921 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
9922 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
9923 panic!(
9924 "unity: virtual slot {}
9925 out of range (vtable len {}
9926) on the runtime class behind {}
9927 (method `{}
9928`)",
9929 29usize,
9930 __vt.len(),
9931 <MapUnitCommandMenu_GuardMenuItem as ::unity::ClassIdentity>::NAME,
9932 "GetMapAttribute",
9933 )
9934 });
9935 let __inner: extern "C" fn(
9936 MapUnitCommandMenu_GuardMenuItem,
9937 ::unity::OptionalMethod,
9938 ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
9939 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
9940 __inner(__receiver, __mi)
9941 }
9942 }
9943 }
9944 #[doc = "`ACall()` overload"]
9945 fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
9946 unsafe {
9947 let __receiver =
9948 <MapUnitCommandMenu_GuardMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9949 {
9950 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
9951 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
9952 panic!(
9953 "unity: virtual slot {}
9954 out of range (vtable len {}
9955) on the runtime class behind {}
9956 (method `{}
9957`)",
9958 18usize,
9959 __vt.len(),
9960 <MapUnitCommandMenu_GuardMenuItem as ::unity::ClassIdentity>::NAME,
9961 "ACall",
9962 )
9963 });
9964 let __inner: extern "C" fn(MapUnitCommandMenu_GuardMenuItem, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
9965 ::core::mem::transmute(__vi.method_ptr);
9966 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
9967 __inner(__receiver, __mi)
9968 }
9969 }
9970 }
9971}
9972
9973#[cfg(feature = "app-mapunitcommandmenu")]
9974impl<__T: IMapUnitCommandMenu_GuardMenuItem> IMapUnitCommandMenu_GuardMenuItemMethods for __T {}
9975
9976#[cfg(feature = "app-mapunitcommandmenu")]
9977impl MapUnitCommandMenu_GuardMenuItem {
9978 pub fn get_flag_id_method_info() -> &'static ::unity::il2cpp::MethodInfo {
9979 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
9980 }
9981
9982 pub fn get_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
9983 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
9984 }
9985
9986 pub fn get_active_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
9987 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
9988 }
9989
9990 pub fn get_deploy_mode_method_info() -> &'static ::unity::il2cpp::MethodInfo {
9991 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
9992 }
9993
9994 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
9995 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
9996 }
9997
9998 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
9999 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
10000 }
10001
10002 pub fn get_command_help_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10003 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
10004 }
10005
10006 pub fn get_map_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10007 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
10008 }
10009
10010 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10011 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
10012 }
10013}
10014
10015#[cfg(feature = "app-mapunitcommandmenu")]
10016impl MapUnitCommandMenu_GuardMenuItem {
10017 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_GuardMenuItem`'s own `get_FlagID`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
10018 pub unsafe fn get_flag_id(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
10019 let __mi = Self::get_flag_id_method_info();
10020 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
10021 __inner(this.into(), ::core::option::Option::None)
10022 }
10023
10024 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_GuardMenuItem`'s own `get_Mind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
10025 pub unsafe fn get_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
10026 let __mi = Self::get_mind_method_info();
10027 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
10028 ::core::mem::transmute(__mi.method_ptr);
10029 __inner(this.into(), ::core::option::Option::None)
10030 }
10031
10032 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_GuardMenuItem`'s own `get_ActiveMind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
10033 pub unsafe fn get_active_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
10034 let __mi = Self::get_active_mind_method_info();
10035 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
10036 ::core::mem::transmute(__mi.method_ptr);
10037 __inner(this.into(), ::core::option::Option::None)
10038 }
10039
10040 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_GuardMenuItem`'s own `get_DeployMode`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
10041 pub unsafe fn get_deploy_mode(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
10042 let __mi = Self::get_deploy_mode_method_info();
10043 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode =
10044 ::core::mem::transmute(__mi.method_ptr);
10045 __inner(this.into(), ::core::option::Option::None)
10046 }
10047
10048 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_GuardMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
10049 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
10050 let __mi = Self::get_name_method_info();
10051 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
10052 __inner(this.into(), ::core::option::Option::None)
10053 }
10054
10055 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_GuardMenuItem`'s own `GetCommandHelp`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
10056 pub unsafe fn get_command_help(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
10057 let __mi = Self::get_command_help_method_info();
10058 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
10059 __inner(this.into(), ::core::option::Option::None)
10060 }
10061
10062 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_GuardMenuItem`'s own `GetMapAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
10063 pub unsafe fn get_map_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
10064 let __mi = Self::get_map_attribute_method_info();
10065 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
10066 ::core::mem::transmute(__mi.method_ptr);
10067 __inner(this.into(), ::core::option::Option::None)
10068 }
10069
10070 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_GuardMenuItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
10071 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
10072 let __mi = Self::a_call_method_info();
10073 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
10074 ::core::mem::transmute(__mi.method_ptr);
10075 __inner(this.into(), ::core::option::Option::None)
10076 }
10077}
10078
10079#[cfg(feature = "app-mapunitcommandmenu")]
10080impl MapUnitCommandMenu_GuardMenuItem {
10081 #[doc = "`.ctor()` — no args"]
10082 pub fn new() -> Self {
10083 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
10084 panic!(
10085 "{}
10086::{}
10087 failed to instantiate",
10088 ::core::stringify!(MapUnitCommandMenu_GuardMenuItem),
10089 ::core::stringify!(new),
10090 )
10091 });
10092 <Self as IMapUnitCommandMenu_GuardMenuItemMethods>::ctor(this);
10093 this
10094 }
10095}
10096
10097#[cfg(feature = "app-mapunitcommandmenu")]
10098pub trait IMapUnitCommandMenu_EngageCommandMenuItemMethods: IMapUnitCommandMenu_EngageCommandMenuItem {
10099 #[doc = "`get_ActiveMind()` overload"]
10100 fn get_active_mind(self) -> crate::app::mapmind::MapMind_Type {
10101 unsafe {
10102 let __receiver = <MapUnitCommandMenu_EngageCommandMenuItem as ::unity::FromIlInstance>::from_il_instance(
10103 <Self as ::unity::SystemObject>::as_instance(self),
10104 );
10105 {
10106 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
10107 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
10108 panic!(
10109 "unity: virtual slot {}
10110 out of range (vtable len {}
10111) on the runtime class behind {}
10112 (method `{}
10113`)",
10114 30usize,
10115 __vt.len(),
10116 <MapUnitCommandMenu_EngageCommandMenuItem as ::unity::ClassIdentity>::NAME,
10117 "get_ActiveMind",
10118 )
10119 });
10120 let __inner: extern "C" fn(MapUnitCommandMenu_EngageCommandMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
10121 ::core::mem::transmute(__vi.method_ptr);
10122 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
10123 __inner(__receiver, __mi)
10124 }
10125 }
10126 }
10127 #[doc = "`get_DeployMode()` overload"]
10128 fn get_deploy_mode(self) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
10129 unsafe {
10130 let __receiver = <MapUnitCommandMenu_EngageCommandMenuItem as ::unity::FromIlInstance>::from_il_instance(
10131 <Self as ::unity::SystemObject>::as_instance(self),
10132 );
10133 {
10134 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
10135 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
10136 panic!(
10137 "unity: virtual slot {}
10138 out of range (vtable len {}
10139) on the runtime class behind {}
10140 (method `{}
10141`)",
10142 31usize,
10143 __vt.len(),
10144 <MapUnitCommandMenu_EngageCommandMenuItem as ::unity::ClassIdentity>::NAME,
10145 "get_DeployMode",
10146 )
10147 });
10148 let __inner: extern "C" fn(
10149 MapUnitCommandMenu_EngageCommandMenuItem,
10150 ::unity::OptionalMethod,
10151 ) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode = ::core::mem::transmute(__vi.method_ptr);
10152 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
10153 __inner(__receiver, __mi)
10154 }
10155 }
10156 }
10157 #[doc = "`get_Mind()` overload"]
10158 fn get_mind(self) -> crate::app::mapmind::MapMind_Type {
10159 unsafe {
10160 let __receiver = <MapUnitCommandMenu_EngageCommandMenuItem as ::unity::FromIlInstance>::from_il_instance(
10161 <Self as ::unity::SystemObject>::as_instance(self),
10162 );
10163 {
10164 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
10165 let __vi = *__vt.get(37usize).unwrap_or_else(|| {
10166 panic!(
10167 "unity: virtual slot {}
10168 out of range (vtable len {}
10169) on the runtime class behind {}
10170 (method `{}
10171`)",
10172 37usize,
10173 __vt.len(),
10174 <MapUnitCommandMenu_EngageCommandMenuItem as ::unity::ClassIdentity>::NAME,
10175 "get_Mind",
10176 )
10177 });
10178 let __inner: extern "C" fn(MapUnitCommandMenu_EngageCommandMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
10179 ::core::mem::transmute(__vi.method_ptr);
10180 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
10181 __inner(__receiver, __mi)
10182 }
10183 }
10184 }
10185 #[doc = "`OnBuild()` overload"]
10186 fn on_build(self) -> () {
10187 unsafe {
10188 let __receiver = <MapUnitCommandMenu_EngageCommandMenuItem as ::unity::FromIlInstance>::from_il_instance(
10189 <Self as ::unity::SystemObject>::as_instance(self),
10190 );
10191 {
10192 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
10193 let __vi = *__vt.get(10usize).unwrap_or_else(|| {
10194 panic!(
10195 "unity: virtual slot {}
10196 out of range (vtable len {}
10197) on the runtime class behind {}
10198 (method `{}
10199`)",
10200 10usize,
10201 __vt.len(),
10202 <MapUnitCommandMenu_EngageCommandMenuItem as ::unity::ClassIdentity>::NAME,
10203 "OnBuild",
10204 )
10205 });
10206 let __inner: extern "C" fn(MapUnitCommandMenu_EngageCommandMenuItem, ::unity::OptionalMethod) -> () =
10207 ::core::mem::transmute(__vi.method_ptr);
10208 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
10209 __inner(__receiver, __mi)
10210 }
10211 }
10212 }
10213 #[doc = "`OnBuildMenuItemContent()` overload"]
10214 fn on_build_menu_item_content(self) -> () {
10215 unsafe {
10216 let __receiver = <MapUnitCommandMenu_EngageCommandMenuItem as ::unity::FromIlInstance>::from_il_instance(
10217 <Self as ::unity::SystemObject>::as_instance(self),
10218 );
10219 {
10220 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
10221 let __vi = *__vt.get(11usize).unwrap_or_else(|| {
10222 panic!(
10223 "unity: virtual slot {}
10224 out of range (vtable len {}
10225) on the runtime class behind {}
10226 (method `{}
10227`)",
10228 11usize,
10229 __vt.len(),
10230 <MapUnitCommandMenu_EngageCommandMenuItem as ::unity::ClassIdentity>::NAME,
10231 "OnBuildMenuItemContent",
10232 )
10233 });
10234 let __inner: extern "C" fn(MapUnitCommandMenu_EngageCommandMenuItem, ::unity::OptionalMethod) -> () =
10235 ::core::mem::transmute(__vi.method_ptr);
10236 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
10237 __inner(__receiver, __mi)
10238 }
10239 }
10240 }
10241 #[doc = "`ACall()` overload"]
10242 fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
10243 unsafe {
10244 let __receiver = <MapUnitCommandMenu_EngageCommandMenuItem as ::unity::FromIlInstance>::from_il_instance(
10245 <Self as ::unity::SystemObject>::as_instance(self),
10246 );
10247 {
10248 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
10249 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
10250 panic!(
10251 "unity: virtual slot {}
10252 out of range (vtable len {}
10253) on the runtime class behind {}
10254 (method `{}
10255`)",
10256 18usize,
10257 __vt.len(),
10258 <MapUnitCommandMenu_EngageCommandMenuItem as ::unity::ClassIdentity>::NAME,
10259 "ACall",
10260 )
10261 });
10262 let __inner: extern "C" fn(
10263 MapUnitCommandMenu_EngageCommandMenuItem,
10264 ::unity::OptionalMethod,
10265 ) -> crate::app::basicmenu::BasicMenu_Result = ::core::mem::transmute(__vi.method_ptr);
10266 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
10267 __inner(__receiver, __mi)
10268 }
10269 }
10270 }
10271 #[doc = "`.ctor()` overload"]
10272 fn ctor(self) -> () {
10273 unsafe {
10274 let __receiver = <MapUnitCommandMenu_EngageCommandMenuItem as ::unity::FromIlInstance>::from_il_instance(
10275 <Self as ::unity::SystemObject>::as_instance(self),
10276 );
10277 ::unity::il2cpp_call!((::unity::module_base()+0x1e4d950usize)as*mut u8,();
10278(MapUnitCommandMenu_EngageCommandMenuItem)__receiver)
10279 }
10280 }
10281}
10282
10283#[cfg(feature = "app-mapunitcommandmenu")]
10284impl<__T: IMapUnitCommandMenu_EngageCommandMenuItem> IMapUnitCommandMenu_EngageCommandMenuItemMethods for __T {}
10285
10286#[cfg(feature = "app-mapunitcommandmenu")]
10287impl MapUnitCommandMenu_EngageCommandMenuItem {
10288 pub fn get_active_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10289 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
10290 }
10291
10292 pub fn get_deploy_mode_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10293 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
10294 }
10295
10296 pub fn get_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10297 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
10298 }
10299
10300 pub fn on_build_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10301 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
10302 }
10303
10304 pub fn on_build_menu_item_content_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10305 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
10306 }
10307
10308 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10309 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
10310 }
10311
10312 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10313 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
10314 }
10315}
10316
10317#[cfg(feature = "app-mapunitcommandmenu")]
10318impl MapUnitCommandMenu_EngageCommandMenuItem {
10319 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageCommandMenuItem`'s own `get_ActiveMind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
10320 pub unsafe fn get_active_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
10321 let __mi = Self::get_active_mind_method_info();
10322 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
10323 ::core::mem::transmute(__mi.method_ptr);
10324 __inner(this.into(), ::core::option::Option::None)
10325 }
10326
10327 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageCommandMenuItem`'s own `get_DeployMode`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
10328 pub unsafe fn get_deploy_mode(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
10329 let __mi = Self::get_deploy_mode_method_info();
10330 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode =
10331 ::core::mem::transmute(__mi.method_ptr);
10332 __inner(this.into(), ::core::option::Option::None)
10333 }
10334
10335 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageCommandMenuItem`'s own `get_Mind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
10336 pub unsafe fn get_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
10337 let __mi = Self::get_mind_method_info();
10338 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
10339 ::core::mem::transmute(__mi.method_ptr);
10340 __inner(this.into(), ::core::option::Option::None)
10341 }
10342
10343 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageCommandMenuItem`'s own `OnBuild`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
10344 pub unsafe fn on_build(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
10345 let __mi = Self::on_build_method_info();
10346 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
10347 __inner(this.into(), ::core::option::Option::None)
10348 }
10349
10350 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageCommandMenuItem`'s own `OnBuildMenuItemContent`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
10351 pub unsafe fn on_build_menu_item_content(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
10352 let __mi = Self::on_build_menu_item_content_method_info();
10353 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
10354 __inner(this.into(), ::core::option::Option::None)
10355 }
10356
10357 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageCommandMenuItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
10358 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
10359 let __mi = Self::a_call_method_info();
10360 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
10361 ::core::mem::transmute(__mi.method_ptr);
10362 __inner(this.into(), ::core::option::Option::None)
10363 }
10364}
10365
10366#[cfg(feature = "app-mapunitcommandmenu")]
10367impl MapUnitCommandMenu_EngageCommandMenuItem {
10368 #[doc = "`.ctor()` — no args"]
10369 pub fn new() -> Self {
10370 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
10371 panic!(
10372 "{}
10373::{}
10374 failed to instantiate",
10375 ::core::stringify!(MapUnitCommandMenu_EngageCommandMenuItem),
10376 ::core::stringify!(new),
10377 )
10378 });
10379 <Self as IMapUnitCommandMenu_EngageCommandMenuItemMethods>::ctor(this);
10380 this
10381 }
10382}
10383
10384#[cfg(feature = "app-mapunitcommandmenu")]
10385pub trait IMapUnitCommandMenu_BreakdownMenuItemMethods: IMapUnitCommandMenu_BreakdownMenuItem {
10386 #[doc = "`GetForce()` overload"]
10387 fn get_force(self) -> crate::app::force::Force_Type {
10388 unsafe {
10389 let __receiver = <MapUnitCommandMenu_BreakdownMenuItem as ::unity::FromIlInstance>::from_il_instance(
10390 <Self as ::unity::SystemObject>::as_instance(self),
10391 );
10392 {
10393 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
10394 let __vi = *__vt.get(36usize).unwrap_or_else(|| {
10395 panic!(
10396 "unity: virtual slot {}
10397 out of range (vtable len {}
10398) on the runtime class behind {}
10399 (method `{}
10400`)",
10401 36usize,
10402 __vt.len(),
10403 <MapUnitCommandMenu_BreakdownMenuItem as ::unity::ClassIdentity>::NAME,
10404 "GetForce",
10405 )
10406 });
10407 let __inner: extern "C" fn(MapUnitCommandMenu_BreakdownMenuItem, ::unity::OptionalMethod) -> crate::app::force::Force_Type =
10408 ::core::mem::transmute(__vi.method_ptr);
10409 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
10410 __inner(__receiver, __mi)
10411 }
10412 }
10413 }
10414 #[doc = "`GetKind()` overload"]
10415 fn get_kind(self) -> crate::app::mapinspector::MapInspector_Kind {
10416 unsafe {
10417 let __receiver = <MapUnitCommandMenu_BreakdownMenuItem as ::unity::FromIlInstance>::from_il_instance(
10418 <Self as ::unity::SystemObject>::as_instance(self),
10419 );
10420 {
10421 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
10422 let __vi = *__vt.get(37usize).unwrap_or_else(|| {
10423 panic!(
10424 "unity: virtual slot {}
10425 out of range (vtable len {}
10426) on the runtime class behind {}
10427 (method `{}
10428`)",
10429 37usize,
10430 __vt.len(),
10431 <MapUnitCommandMenu_BreakdownMenuItem as ::unity::ClassIdentity>::NAME,
10432 "GetKind",
10433 )
10434 });
10435 let __inner: extern "C" fn(
10436 MapUnitCommandMenu_BreakdownMenuItem,
10437 ::unity::OptionalMethod,
10438 ) -> crate::app::mapinspector::MapInspector_Kind = ::core::mem::transmute(__vi.method_ptr);
10439 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
10440 __inner(__receiver, __mi)
10441 }
10442 }
10443 }
10444 #[doc = "`GetMind()` overload"]
10445 fn get_mind(self) -> crate::app::mapmind::MapMind_Type {
10446 unsafe {
10447 let __receiver = <MapUnitCommandMenu_BreakdownMenuItem as ::unity::FromIlInstance>::from_il_instance(
10448 <Self as ::unity::SystemObject>::as_instance(self),
10449 );
10450 {
10451 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
10452 let __vi = *__vt.get(38usize).unwrap_or_else(|| {
10453 panic!(
10454 "unity: virtual slot {}
10455 out of range (vtable len {}
10456) on the runtime class behind {}
10457 (method `{}
10458`)",
10459 38usize,
10460 __vt.len(),
10461 <MapUnitCommandMenu_BreakdownMenuItem as ::unity::ClassIdentity>::NAME,
10462 "GetMind",
10463 )
10464 });
10465 let __inner: extern "C" fn(MapUnitCommandMenu_BreakdownMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
10466 ::core::mem::transmute(__vi.method_ptr);
10467 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
10468 __inner(__receiver, __mi)
10469 }
10470 }
10471 }
10472 #[doc = "`.ctor()` overload"]
10473 fn ctor(self) -> () {
10474 unsafe {
10475 let __receiver = <MapUnitCommandMenu_BreakdownMenuItem as ::unity::FromIlInstance>::from_il_instance(
10476 <Self as ::unity::SystemObject>::as_instance(self),
10477 );
10478 ::unity::il2cpp_call!((::unity::module_base()+0x1e49b10usize)as*mut u8,();
10479(MapUnitCommandMenu_BreakdownMenuItem)__receiver)
10480 }
10481 }
10482}
10483
10484#[cfg(feature = "app-mapunitcommandmenu")]
10485impl<__T: IMapUnitCommandMenu_BreakdownMenuItem> IMapUnitCommandMenu_BreakdownMenuItemMethods for __T {}
10486
10487#[cfg(feature = "app-mapunitcommandmenu")]
10488impl MapUnitCommandMenu_BreakdownMenuItem {
10489 pub fn get_force_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10490 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
10491 }
10492
10493 pub fn get_kind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10494 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
10495 }
10496
10497 pub fn get_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10498 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
10499 }
10500
10501 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10502 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
10503 }
10504}
10505
10506#[cfg(feature = "app-mapunitcommandmenu")]
10507impl MapUnitCommandMenu_BreakdownMenuItem {
10508 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_BreakdownMenuItem`'s own `GetForce`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
10509 pub unsafe fn get_force(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::force::Force_Type {
10510 let __mi = Self::get_force_method_info();
10511 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::force::Force_Type =
10512 ::core::mem::transmute(__mi.method_ptr);
10513 __inner(this.into(), ::core::option::Option::None)
10514 }
10515
10516 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_BreakdownMenuItem`'s own `GetKind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
10517 pub unsafe fn get_kind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapinspector::MapInspector_Kind {
10518 let __mi = Self::get_kind_method_info();
10519 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapinspector::MapInspector_Kind =
10520 ::core::mem::transmute(__mi.method_ptr);
10521 __inner(this.into(), ::core::option::Option::None)
10522 }
10523
10524 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_BreakdownMenuItem`'s own `GetMind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
10525 pub unsafe fn get_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
10526 let __mi = Self::get_mind_method_info();
10527 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
10528 ::core::mem::transmute(__mi.method_ptr);
10529 __inner(this.into(), ::core::option::Option::None)
10530 }
10531}
10532
10533#[cfg(feature = "app-mapunitcommandmenu")]
10534impl MapUnitCommandMenu_BreakdownMenuItem {
10535 #[doc = "`.ctor()` — no args"]
10536 pub fn new() -> Self {
10537 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
10538 panic!(
10539 "{}
10540::{}
10541 failed to instantiate",
10542 ::core::stringify!(MapUnitCommandMenu_BreakdownMenuItem),
10543 ::core::stringify!(new),
10544 )
10545 });
10546 <Self as IMapUnitCommandMenu_BreakdownMenuItemMethods>::ctor(this);
10547 this
10548 }
10549}
10550
10551#[cfg(feature = "app-mapunitcommandmenu")]
10552pub trait IMapUnitCommandMenu_EngageChargeMenuItemMethods: IMapUnitCommandMenu_EngageChargeMenuItem {
10553 #[doc = "`get_Mind()` overload"]
10554 fn get_mind(self) -> crate::app::mapmind::MapMind_Type {
10555 unsafe {
10556 let __receiver = <MapUnitCommandMenu_EngageChargeMenuItem as ::unity::FromIlInstance>::from_il_instance(
10557 <Self as ::unity::SystemObject>::as_instance(self),
10558 );
10559 {
10560 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
10561 let __vi = *__vt.get(37usize).unwrap_or_else(|| {
10562 panic!(
10563 "unity: virtual slot {}
10564 out of range (vtable len {}
10565) on the runtime class behind {}
10566 (method `{}
10567`)",
10568 37usize,
10569 __vt.len(),
10570 <MapUnitCommandMenu_EngageChargeMenuItem as ::unity::ClassIdentity>::NAME,
10571 "get_Mind",
10572 )
10573 });
10574 let __inner: extern "C" fn(MapUnitCommandMenu_EngageChargeMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
10575 ::core::mem::transmute(__vi.method_ptr);
10576 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
10577 __inner(__receiver, __mi)
10578 }
10579 }
10580 }
10581 #[doc = "`get_ActionMask()` overload"]
10582 fn get_action_mask(self) -> crate::app::maptarget::MapTarget_ActionMask {
10583 unsafe {
10584 let __receiver = <MapUnitCommandMenu_EngageChargeMenuItem as ::unity::FromIlInstance>::from_il_instance(
10585 <Self as ::unity::SystemObject>::as_instance(self),
10586 );
10587 {
10588 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
10589 let __vi = *__vt.get(38usize).unwrap_or_else(|| {
10590 panic!(
10591 "unity: virtual slot {}
10592 out of range (vtable len {}
10593) on the runtime class behind {}
10594 (method `{}
10595`)",
10596 38usize,
10597 __vt.len(),
10598 <MapUnitCommandMenu_EngageChargeMenuItem as ::unity::ClassIdentity>::NAME,
10599 "get_ActionMask",
10600 )
10601 });
10602 let __inner: extern "C" fn(
10603 MapUnitCommandMenu_EngageChargeMenuItem,
10604 ::unity::OptionalMethod,
10605 ) -> crate::app::maptarget::MapTarget_ActionMask = ::core::mem::transmute(__vi.method_ptr);
10606 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
10607 __inner(__receiver, __mi)
10608 }
10609 }
10610 }
10611 #[doc = "`get_Label()` overload"]
10612 fn get_label(self) -> crate::app::mapsequencehuman::MapSequenceHuman_Label {
10613 unsafe {
10614 let __receiver = <MapUnitCommandMenu_EngageChargeMenuItem as ::unity::FromIlInstance>::from_il_instance(
10615 <Self as ::unity::SystemObject>::as_instance(self),
10616 );
10617 {
10618 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
10619 let __vi = *__vt.get(36usize).unwrap_or_else(|| {
10620 panic!(
10621 "unity: virtual slot {}
10622 out of range (vtable len {}
10623) on the runtime class behind {}
10624 (method `{}
10625`)",
10626 36usize,
10627 __vt.len(),
10628 <MapUnitCommandMenu_EngageChargeMenuItem as ::unity::ClassIdentity>::NAME,
10629 "get_Label",
10630 )
10631 });
10632 let __inner: extern "C" fn(
10633 MapUnitCommandMenu_EngageChargeMenuItem,
10634 ::unity::OptionalMethod,
10635 ) -> crate::app::mapsequencehuman::MapSequenceHuman_Label = ::core::mem::transmute(__vi.method_ptr);
10636 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
10637 __inner(__receiver, __mi)
10638 }
10639 }
10640 }
10641 #[doc = "`get_ActiveMind()` overload"]
10642 fn get_active_mind(self) -> crate::app::mapmind::MapMind_Type {
10643 unsafe {
10644 let __receiver = <MapUnitCommandMenu_EngageChargeMenuItem as ::unity::FromIlInstance>::from_il_instance(
10645 <Self as ::unity::SystemObject>::as_instance(self),
10646 );
10647 {
10648 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
10649 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
10650 panic!(
10651 "unity: virtual slot {}
10652 out of range (vtable len {}
10653) on the runtime class behind {}
10654 (method `{}
10655`)",
10656 30usize,
10657 __vt.len(),
10658 <MapUnitCommandMenu_EngageChargeMenuItem as ::unity::ClassIdentity>::NAME,
10659 "get_ActiveMind",
10660 )
10661 });
10662 let __inner: extern "C" fn(MapUnitCommandMenu_EngageChargeMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
10663 ::core::mem::transmute(__vi.method_ptr);
10664 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
10665 __inner(__receiver, __mi)
10666 }
10667 }
10668 }
10669 #[doc = "`get_DeployMode()` overload"]
10670 fn get_deploy_mode(self) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
10671 unsafe {
10672 let __receiver = <MapUnitCommandMenu_EngageChargeMenuItem as ::unity::FromIlInstance>::from_il_instance(
10673 <Self as ::unity::SystemObject>::as_instance(self),
10674 );
10675 {
10676 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
10677 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
10678 panic!(
10679 "unity: virtual slot {}
10680 out of range (vtable len {}
10681) on the runtime class behind {}
10682 (method `{}
10683`)",
10684 31usize,
10685 __vt.len(),
10686 <MapUnitCommandMenu_EngageChargeMenuItem as ::unity::ClassIdentity>::NAME,
10687 "get_DeployMode",
10688 )
10689 });
10690 let __inner: extern "C" fn(
10691 MapUnitCommandMenu_EngageChargeMenuItem,
10692 ::unity::OptionalMethod,
10693 ) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode = ::core::mem::transmute(__vi.method_ptr);
10694 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
10695 __inner(__receiver, __mi)
10696 }
10697 }
10698 }
10699 #[doc = "`get_IsForecast()` overload"]
10700 fn get_is_forecast(self) -> bool {
10701 unsafe {
10702 let __receiver = <MapUnitCommandMenu_EngageChargeMenuItem as ::unity::FromIlInstance>::from_il_instance(
10703 <Self as ::unity::SystemObject>::as_instance(self),
10704 );
10705 {
10706 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
10707 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
10708 panic!(
10709 "unity: virtual slot {}
10710 out of range (vtable len {}
10711) on the runtime class behind {}
10712 (method `{}
10713`)",
10714 33usize,
10715 __vt.len(),
10716 <MapUnitCommandMenu_EngageChargeMenuItem as ::unity::ClassIdentity>::NAME,
10717 "get_IsForecast",
10718 )
10719 });
10720 let __inner: extern "C" fn(MapUnitCommandMenu_EngageChargeMenuItem, ::unity::OptionalMethod) -> bool =
10721 ::core::mem::transmute(__vi.method_ptr);
10722 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
10723 __inner(__receiver, __mi)
10724 }
10725 }
10726 }
10727 #[doc = "`.ctor()` overload"]
10728 fn ctor(self) -> () {
10729 unsafe {
10730 let __receiver = <MapUnitCommandMenu_EngageChargeMenuItem as ::unity::FromIlInstance>::from_il_instance(
10731 <Self as ::unity::SystemObject>::as_instance(self),
10732 );
10733 ::unity::il2cpp_call!((::unity::module_base()+0x1e4d6e0usize)as*mut u8,();
10734(MapUnitCommandMenu_EngageChargeMenuItem)__receiver)
10735 }
10736 }
10737}
10738
10739#[cfg(feature = "app-mapunitcommandmenu")]
10740impl<__T: IMapUnitCommandMenu_EngageChargeMenuItem> IMapUnitCommandMenu_EngageChargeMenuItemMethods for __T {}
10741
10742#[cfg(feature = "app-mapunitcommandmenu")]
10743impl MapUnitCommandMenu_EngageChargeMenuItem {
10744 pub fn get_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10745 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
10746 }
10747
10748 pub fn get_action_mask_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10749 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
10750 }
10751
10752 pub fn get_label_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10753 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
10754 }
10755
10756 pub fn get_active_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10757 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
10758 }
10759
10760 pub fn get_deploy_mode_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10761 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
10762 }
10763
10764 pub fn get_is_forecast_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10765 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
10766 }
10767
10768 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10769 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
10770 }
10771}
10772
10773#[cfg(feature = "app-mapunitcommandmenu")]
10774impl MapUnitCommandMenu_EngageChargeMenuItem {
10775 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageChargeMenuItem`'s own `get_Mind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
10776 pub unsafe fn get_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
10777 let __mi = Self::get_mind_method_info();
10778 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
10779 ::core::mem::transmute(__mi.method_ptr);
10780 __inner(this.into(), ::core::option::Option::None)
10781 }
10782
10783 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageChargeMenuItem`'s own `get_ActionMask`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
10784 pub unsafe fn get_action_mask(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::maptarget::MapTarget_ActionMask {
10785 let __mi = Self::get_action_mask_method_info();
10786 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::maptarget::MapTarget_ActionMask =
10787 ::core::mem::transmute(__mi.method_ptr);
10788 __inner(this.into(), ::core::option::Option::None)
10789 }
10790
10791 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageChargeMenuItem`'s own `get_Label`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
10792 pub unsafe fn get_label(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapsequencehuman::MapSequenceHuman_Label {
10793 let __mi = Self::get_label_method_info();
10794 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapsequencehuman::MapSequenceHuman_Label =
10795 ::core::mem::transmute(__mi.method_ptr);
10796 __inner(this.into(), ::core::option::Option::None)
10797 }
10798
10799 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageChargeMenuItem`'s own `get_ActiveMind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
10800 pub unsafe fn get_active_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
10801 let __mi = Self::get_active_mind_method_info();
10802 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
10803 ::core::mem::transmute(__mi.method_ptr);
10804 __inner(this.into(), ::core::option::Option::None)
10805 }
10806
10807 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageChargeMenuItem`'s own `get_DeployMode`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
10808 pub unsafe fn get_deploy_mode(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
10809 let __mi = Self::get_deploy_mode_method_info();
10810 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode =
10811 ::core::mem::transmute(__mi.method_ptr);
10812 __inner(this.into(), ::core::option::Option::None)
10813 }
10814
10815 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageChargeMenuItem`'s own `get_IsForecast`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
10816 pub unsafe fn get_is_forecast(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
10817 let __mi = Self::get_is_forecast_method_info();
10818 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
10819 __inner(this.into(), ::core::option::Option::None)
10820 }
10821}
10822
10823#[cfg(feature = "app-mapunitcommandmenu")]
10824impl MapUnitCommandMenu_EngageChargeMenuItem {
10825 #[doc = "`.ctor()` — no args"]
10826 pub fn new() -> Self {
10827 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
10828 panic!(
10829 "{}
10830::{}
10831 failed to instantiate",
10832 ::core::stringify!(MapUnitCommandMenu_EngageChargeMenuItem),
10833 ::core::stringify!(new),
10834 )
10835 });
10836 <Self as IMapUnitCommandMenu_EngageChargeMenuItemMethods>::ctor(this);
10837 this
10838 }
10839}
10840
10841#[cfg(feature = "app-mapunitcommandmenu")]
10842pub trait IMapUnitCommandMenu_EngageAttackMenuItemMethods: IMapUnitCommandMenu_EngageAttackMenuItem {
10843 #[doc = "`get_Label()` overload"]
10844 fn get_label(self) -> crate::app::mapsequencehuman::MapSequenceHuman_Label {
10845 unsafe {
10846 let __receiver = <MapUnitCommandMenu_EngageAttackMenuItem as ::unity::FromIlInstance>::from_il_instance(
10847 <Self as ::unity::SystemObject>::as_instance(self),
10848 );
10849 {
10850 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
10851 let __vi = *__vt.get(36usize).unwrap_or_else(|| {
10852 panic!(
10853 "unity: virtual slot {}
10854 out of range (vtable len {}
10855) on the runtime class behind {}
10856 (method `{}
10857`)",
10858 36usize,
10859 __vt.len(),
10860 <MapUnitCommandMenu_EngageAttackMenuItem as ::unity::ClassIdentity>::NAME,
10861 "get_Label",
10862 )
10863 });
10864 let __inner: extern "C" fn(
10865 MapUnitCommandMenu_EngageAttackMenuItem,
10866 ::unity::OptionalMethod,
10867 ) -> crate::app::mapsequencehuman::MapSequenceHuman_Label = ::core::mem::transmute(__vi.method_ptr);
10868 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
10869 __inner(__receiver, __mi)
10870 }
10871 }
10872 }
10873 #[doc = "`get_ActionMask()` overload"]
10874 fn get_action_mask(self) -> crate::app::maptarget::MapTarget_ActionMask {
10875 unsafe {
10876 let __receiver = <MapUnitCommandMenu_EngageAttackMenuItem as ::unity::FromIlInstance>::from_il_instance(
10877 <Self as ::unity::SystemObject>::as_instance(self),
10878 );
10879 {
10880 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
10881 let __vi = *__vt.get(38usize).unwrap_or_else(|| {
10882 panic!(
10883 "unity: virtual slot {}
10884 out of range (vtable len {}
10885) on the runtime class behind {}
10886 (method `{}
10887`)",
10888 38usize,
10889 __vt.len(),
10890 <MapUnitCommandMenu_EngageAttackMenuItem as ::unity::ClassIdentity>::NAME,
10891 "get_ActionMask",
10892 )
10893 });
10894 let __inner: extern "C" fn(
10895 MapUnitCommandMenu_EngageAttackMenuItem,
10896 ::unity::OptionalMethod,
10897 ) -> crate::app::maptarget::MapTarget_ActionMask = ::core::mem::transmute(__vi.method_ptr);
10898 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
10899 __inner(__receiver, __mi)
10900 }
10901 }
10902 }
10903 #[doc = "`get_Mind()` overload"]
10904 fn get_mind(self) -> crate::app::mapmind::MapMind_Type {
10905 unsafe {
10906 let __receiver = <MapUnitCommandMenu_EngageAttackMenuItem as ::unity::FromIlInstance>::from_il_instance(
10907 <Self as ::unity::SystemObject>::as_instance(self),
10908 );
10909 {
10910 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
10911 let __vi = *__vt.get(37usize).unwrap_or_else(|| {
10912 panic!(
10913 "unity: virtual slot {}
10914 out of range (vtable len {}
10915) on the runtime class behind {}
10916 (method `{}
10917`)",
10918 37usize,
10919 __vt.len(),
10920 <MapUnitCommandMenu_EngageAttackMenuItem as ::unity::ClassIdentity>::NAME,
10921 "get_Mind",
10922 )
10923 });
10924 let __inner: extern "C" fn(MapUnitCommandMenu_EngageAttackMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
10925 ::core::mem::transmute(__vi.method_ptr);
10926 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
10927 __inner(__receiver, __mi)
10928 }
10929 }
10930 }
10931 #[doc = "`get_ActiveMind()` overload"]
10932 fn get_active_mind(self) -> crate::app::mapmind::MapMind_Type {
10933 unsafe {
10934 let __receiver = <MapUnitCommandMenu_EngageAttackMenuItem as ::unity::FromIlInstance>::from_il_instance(
10935 <Self as ::unity::SystemObject>::as_instance(self),
10936 );
10937 {
10938 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
10939 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
10940 panic!(
10941 "unity: virtual slot {}
10942 out of range (vtable len {}
10943) on the runtime class behind {}
10944 (method `{}
10945`)",
10946 30usize,
10947 __vt.len(),
10948 <MapUnitCommandMenu_EngageAttackMenuItem as ::unity::ClassIdentity>::NAME,
10949 "get_ActiveMind",
10950 )
10951 });
10952 let __inner: extern "C" fn(MapUnitCommandMenu_EngageAttackMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
10953 ::core::mem::transmute(__vi.method_ptr);
10954 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
10955 __inner(__receiver, __mi)
10956 }
10957 }
10958 }
10959 #[doc = "`get_DeployMode()` overload"]
10960 fn get_deploy_mode(self) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
10961 unsafe {
10962 let __receiver = <MapUnitCommandMenu_EngageAttackMenuItem as ::unity::FromIlInstance>::from_il_instance(
10963 <Self as ::unity::SystemObject>::as_instance(self),
10964 );
10965 {
10966 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
10967 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
10968 panic!(
10969 "unity: virtual slot {}
10970 out of range (vtable len {}
10971) on the runtime class behind {}
10972 (method `{}
10973`)",
10974 31usize,
10975 __vt.len(),
10976 <MapUnitCommandMenu_EngageAttackMenuItem as ::unity::ClassIdentity>::NAME,
10977 "get_DeployMode",
10978 )
10979 });
10980 let __inner: extern "C" fn(
10981 MapUnitCommandMenu_EngageAttackMenuItem,
10982 ::unity::OptionalMethod,
10983 ) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode = ::core::mem::transmute(__vi.method_ptr);
10984 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
10985 __inner(__receiver, __mi)
10986 }
10987 }
10988 }
10989 #[doc = "`get_IsForecast()` overload"]
10990 fn get_is_forecast(self) -> bool {
10991 unsafe {
10992 let __receiver = <MapUnitCommandMenu_EngageAttackMenuItem as ::unity::FromIlInstance>::from_il_instance(
10993 <Self as ::unity::SystemObject>::as_instance(self),
10994 );
10995 {
10996 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
10997 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
10998 panic!(
10999 "unity: virtual slot {}
11000 out of range (vtable len {}
11001) on the runtime class behind {}
11002 (method `{}
11003`)",
11004 33usize,
11005 __vt.len(),
11006 <MapUnitCommandMenu_EngageAttackMenuItem as ::unity::ClassIdentity>::NAME,
11007 "get_IsForecast",
11008 )
11009 });
11010 let __inner: extern "C" fn(MapUnitCommandMenu_EngageAttackMenuItem, ::unity::OptionalMethod) -> bool =
11011 ::core::mem::transmute(__vi.method_ptr);
11012 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
11013 __inner(__receiver, __mi)
11014 }
11015 }
11016 }
11017 #[doc = "`.ctor()` overload"]
11018 fn ctor(self) -> () {
11019 unsafe {
11020 let __receiver = <MapUnitCommandMenu_EngageAttackMenuItem as ::unity::FromIlInstance>::from_il_instance(
11021 <Self as ::unity::SystemObject>::as_instance(self),
11022 );
11023 ::unity::il2cpp_call!((::unity::module_base()+0x1e4d670usize)as*mut u8,();
11024(MapUnitCommandMenu_EngageAttackMenuItem)__receiver)
11025 }
11026 }
11027}
11028
11029#[cfg(feature = "app-mapunitcommandmenu")]
11030impl<__T: IMapUnitCommandMenu_EngageAttackMenuItem> IMapUnitCommandMenu_EngageAttackMenuItemMethods for __T {}
11031
11032#[cfg(feature = "app-mapunitcommandmenu")]
11033impl MapUnitCommandMenu_EngageAttackMenuItem {
11034 pub fn get_label_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11035 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
11036 }
11037
11038 pub fn get_action_mask_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11039 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
11040 }
11041
11042 pub fn get_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11043 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
11044 }
11045
11046 pub fn get_active_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11047 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
11048 }
11049
11050 pub fn get_deploy_mode_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11051 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
11052 }
11053
11054 pub fn get_is_forecast_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11055 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
11056 }
11057
11058 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11059 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
11060 }
11061}
11062
11063#[cfg(feature = "app-mapunitcommandmenu")]
11064impl MapUnitCommandMenu_EngageAttackMenuItem {
11065 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageAttackMenuItem`'s own `get_Label`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
11066 pub unsafe fn get_label(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapsequencehuman::MapSequenceHuman_Label {
11067 let __mi = Self::get_label_method_info();
11068 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapsequencehuman::MapSequenceHuman_Label =
11069 ::core::mem::transmute(__mi.method_ptr);
11070 __inner(this.into(), ::core::option::Option::None)
11071 }
11072
11073 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageAttackMenuItem`'s own `get_ActionMask`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
11074 pub unsafe fn get_action_mask(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::maptarget::MapTarget_ActionMask {
11075 let __mi = Self::get_action_mask_method_info();
11076 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::maptarget::MapTarget_ActionMask =
11077 ::core::mem::transmute(__mi.method_ptr);
11078 __inner(this.into(), ::core::option::Option::None)
11079 }
11080
11081 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageAttackMenuItem`'s own `get_Mind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
11082 pub unsafe fn get_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
11083 let __mi = Self::get_mind_method_info();
11084 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
11085 ::core::mem::transmute(__mi.method_ptr);
11086 __inner(this.into(), ::core::option::Option::None)
11087 }
11088
11089 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageAttackMenuItem`'s own `get_ActiveMind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
11090 pub unsafe fn get_active_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
11091 let __mi = Self::get_active_mind_method_info();
11092 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
11093 ::core::mem::transmute(__mi.method_ptr);
11094 __inner(this.into(), ::core::option::Option::None)
11095 }
11096
11097 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageAttackMenuItem`'s own `get_DeployMode`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
11098 pub unsafe fn get_deploy_mode(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
11099 let __mi = Self::get_deploy_mode_method_info();
11100 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode =
11101 ::core::mem::transmute(__mi.method_ptr);
11102 __inner(this.into(), ::core::option::Option::None)
11103 }
11104
11105 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageAttackMenuItem`'s own `get_IsForecast`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
11106 pub unsafe fn get_is_forecast(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
11107 let __mi = Self::get_is_forecast_method_info();
11108 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
11109 __inner(this.into(), ::core::option::Option::None)
11110 }
11111}
11112
11113#[cfg(feature = "app-mapunitcommandmenu")]
11114impl MapUnitCommandMenu_EngageAttackMenuItem {
11115 #[doc = "`.ctor()` — no args"]
11116 pub fn new() -> Self {
11117 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
11118 panic!(
11119 "{}
11120::{}
11121 failed to instantiate",
11122 ::core::stringify!(MapUnitCommandMenu_EngageAttackMenuItem),
11123 ::core::stringify!(new),
11124 )
11125 });
11126 <Self as IMapUnitCommandMenu_EngageAttackMenuItemMethods>::ctor(this);
11127 this
11128 }
11129}
11130
11131#[cfg(feature = "app-mapunitcommandmenu")]
11132pub trait IMapUnitCommandMenu_TalkMenuItemMethods: IMapUnitCommandMenu_TalkMenuItem {
11133 #[doc = "`OnBuild()` overload"]
11134 fn on_build(self) -> () {
11135 unsafe {
11136 let __receiver =
11137 <MapUnitCommandMenu_TalkMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
11138 {
11139 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
11140 let __vi = *__vt.get(10usize).unwrap_or_else(|| {
11141 panic!(
11142 "unity: virtual slot {}
11143 out of range (vtable len {}
11144) on the runtime class behind {}
11145 (method `{}
11146`)",
11147 10usize,
11148 __vt.len(),
11149 <MapUnitCommandMenu_TalkMenuItem as ::unity::ClassIdentity>::NAME,
11150 "OnBuild",
11151 )
11152 });
11153 let __inner: extern "C" fn(MapUnitCommandMenu_TalkMenuItem, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
11154 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
11155 __inner(__receiver, __mi)
11156 }
11157 }
11158 }
11159 #[doc = "`OnBuildMenuItemContent()` overload"]
11160 fn on_build_menu_item_content(self) -> () {
11161 unsafe {
11162 let __receiver =
11163 <MapUnitCommandMenu_TalkMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
11164 {
11165 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
11166 let __vi = *__vt.get(11usize).unwrap_or_else(|| {
11167 panic!(
11168 "unity: virtual slot {}
11169 out of range (vtable len {}
11170) on the runtime class behind {}
11171 (method `{}
11172`)",
11173 11usize,
11174 __vt.len(),
11175 <MapUnitCommandMenu_TalkMenuItem as ::unity::ClassIdentity>::NAME,
11176 "OnBuildMenuItemContent",
11177 )
11178 });
11179 let __inner: extern "C" fn(MapUnitCommandMenu_TalkMenuItem, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
11180 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
11181 __inner(__receiver, __mi)
11182 }
11183 }
11184 }
11185 #[doc = "`get_FlagID()` overload"]
11186 fn get_flag_id(self) -> ::unity::Il2CppString {
11187 unsafe {
11188 let __receiver =
11189 <MapUnitCommandMenu_TalkMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
11190 {
11191 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
11192 let __vi = *__vt.get(27usize).unwrap_or_else(|| {
11193 panic!(
11194 "unity: virtual slot {}
11195 out of range (vtable len {}
11196) on the runtime class behind {}
11197 (method `{}
11198`)",
11199 27usize,
11200 __vt.len(),
11201 <MapUnitCommandMenu_TalkMenuItem as ::unity::ClassIdentity>::NAME,
11202 "get_FlagID",
11203 )
11204 });
11205 let __inner: extern "C" fn(MapUnitCommandMenu_TalkMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
11206 ::core::mem::transmute(__vi.method_ptr);
11207 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
11208 __inner(__receiver, __mi)
11209 }
11210 }
11211 }
11212 #[doc = "`get_Mind()` overload"]
11213 fn get_mind(self) -> crate::app::mapmind::MapMind_Type {
11214 unsafe {
11215 let __receiver =
11216 <MapUnitCommandMenu_TalkMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
11217 {
11218 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
11219 let __vi = *__vt.get(36usize).unwrap_or_else(|| {
11220 panic!(
11221 "unity: virtual slot {}
11222 out of range (vtable len {}
11223) on the runtime class behind {}
11224 (method `{}
11225`)",
11226 36usize,
11227 __vt.len(),
11228 <MapUnitCommandMenu_TalkMenuItem as ::unity::ClassIdentity>::NAME,
11229 "get_Mind",
11230 )
11231 });
11232 let __inner: extern "C" fn(MapUnitCommandMenu_TalkMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
11233 ::core::mem::transmute(__vi.method_ptr);
11234 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
11235 __inner(__receiver, __mi)
11236 }
11237 }
11238 }
11239 #[doc = "`get_ActiveMind()` overload"]
11240 fn get_active_mind(self) -> crate::app::mapmind::MapMind_Type {
11241 unsafe {
11242 let __receiver =
11243 <MapUnitCommandMenu_TalkMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
11244 {
11245 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
11246 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
11247 panic!(
11248 "unity: virtual slot {}
11249 out of range (vtable len {}
11250) on the runtime class behind {}
11251 (method `{}
11252`)",
11253 30usize,
11254 __vt.len(),
11255 <MapUnitCommandMenu_TalkMenuItem as ::unity::ClassIdentity>::NAME,
11256 "get_ActiveMind",
11257 )
11258 });
11259 let __inner: extern "C" fn(MapUnitCommandMenu_TalkMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
11260 ::core::mem::transmute(__vi.method_ptr);
11261 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
11262 __inner(__receiver, __mi)
11263 }
11264 }
11265 }
11266 #[doc = "`get_DeployMode()` overload"]
11267 fn get_deploy_mode(self) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
11268 unsafe {
11269 let __receiver =
11270 <MapUnitCommandMenu_TalkMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
11271 {
11272 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
11273 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
11274 panic!(
11275 "unity: virtual slot {}
11276 out of range (vtable len {}
11277) on the runtime class behind {}
11278 (method `{}
11279`)",
11280 31usize,
11281 __vt.len(),
11282 <MapUnitCommandMenu_TalkMenuItem as ::unity::ClassIdentity>::NAME,
11283 "get_DeployMode",
11284 )
11285 });
11286 let __inner: extern "C" fn(
11287 MapUnitCommandMenu_TalkMenuItem,
11288 ::unity::OptionalMethod,
11289 ) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode = ::core::mem::transmute(__vi.method_ptr);
11290 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
11291 __inner(__receiver, __mi)
11292 }
11293 }
11294 }
11295 #[doc = "`GetName()` overload"]
11296 fn get_name(self) -> ::unity::Il2CppString {
11297 unsafe {
11298 let __receiver =
11299 <MapUnitCommandMenu_TalkMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
11300 {
11301 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
11302 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
11303 panic!(
11304 "unity: virtual slot {}
11305 out of range (vtable len {}
11306) on the runtime class behind {}
11307 (method `{}
11308`)",
11309 4usize,
11310 __vt.len(),
11311 <MapUnitCommandMenu_TalkMenuItem as ::unity::ClassIdentity>::NAME,
11312 "GetName",
11313 )
11314 });
11315 let __inner: extern "C" fn(MapUnitCommandMenu_TalkMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
11316 ::core::mem::transmute(__vi.method_ptr);
11317 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
11318 __inner(__receiver, __mi)
11319 }
11320 }
11321 }
11322 #[doc = "`GetCommandHelp()` overload"]
11323 fn get_command_help(self) -> ::unity::Il2CppString {
11324 unsafe {
11325 let __receiver =
11326 <MapUnitCommandMenu_TalkMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
11327 {
11328 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
11329 let __vi = *__vt.get(34usize).unwrap_or_else(|| {
11330 panic!(
11331 "unity: virtual slot {}
11332 out of range (vtable len {}
11333) on the runtime class behind {}
11334 (method `{}
11335`)",
11336 34usize,
11337 __vt.len(),
11338 <MapUnitCommandMenu_TalkMenuItem as ::unity::ClassIdentity>::NAME,
11339 "GetCommandHelp",
11340 )
11341 });
11342 let __inner: extern "C" fn(MapUnitCommandMenu_TalkMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
11343 ::core::mem::transmute(__vi.method_ptr);
11344 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
11345 __inner(__receiver, __mi)
11346 }
11347 }
11348 }
11349 #[doc = "`GetMapAttribute()` overload"]
11350 fn get_map_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
11351 unsafe {
11352 let __receiver =
11353 <MapUnitCommandMenu_TalkMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
11354 {
11355 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
11356 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
11357 panic!(
11358 "unity: virtual slot {}
11359 out of range (vtable len {}
11360) on the runtime class behind {}
11361 (method `{}
11362`)",
11363 29usize,
11364 __vt.len(),
11365 <MapUnitCommandMenu_TalkMenuItem as ::unity::ClassIdentity>::NAME,
11366 "GetMapAttribute",
11367 )
11368 });
11369 let __inner: extern "C" fn(
11370 MapUnitCommandMenu_TalkMenuItem,
11371 ::unity::OptionalMethod,
11372 ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
11373 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
11374 __inner(__receiver, __mi)
11375 }
11376 }
11377 }
11378 #[doc = "`.ctor()` overload"]
11379 fn ctor(self) -> () {
11380 unsafe {
11381 let __receiver =
11382 <MapUnitCommandMenu_TalkMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
11383 ::unity::il2cpp_call!((::unity::module_base()+0x1e51160usize)as*mut u8,();
11384(MapUnitCommandMenu_TalkMenuItem)__receiver)
11385 }
11386 }
11387}
11388
11389#[cfg(feature = "app-mapunitcommandmenu")]
11390impl<__T: IMapUnitCommandMenu_TalkMenuItem> IMapUnitCommandMenu_TalkMenuItemMethods for __T {}
11391
11392#[cfg(feature = "app-mapunitcommandmenu")]
11393impl MapUnitCommandMenu_TalkMenuItem {
11394 pub fn on_build_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11395 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
11396 }
11397
11398 pub fn on_build_menu_item_content_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11399 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
11400 }
11401
11402 pub fn get_flag_id_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11403 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
11404 }
11405
11406 pub fn get_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11407 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
11408 }
11409
11410 pub fn get_active_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11411 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
11412 }
11413
11414 pub fn get_deploy_mode_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11415 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
11416 }
11417
11418 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11419 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
11420 }
11421
11422 pub fn get_command_help_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11423 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
11424 }
11425
11426 pub fn get_map_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11427 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
11428 }
11429
11430 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11431 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
11432 }
11433}
11434
11435#[cfg(feature = "app-mapunitcommandmenu")]
11436impl MapUnitCommandMenu_TalkMenuItem {
11437 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_TalkMenuItem`'s own `OnBuild`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
11438 pub unsafe fn on_build(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
11439 let __mi = Self::on_build_method_info();
11440 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
11441 __inner(this.into(), ::core::option::Option::None)
11442 }
11443
11444 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_TalkMenuItem`'s own `OnBuildMenuItemContent`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
11445 pub unsafe fn on_build_menu_item_content(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
11446 let __mi = Self::on_build_menu_item_content_method_info();
11447 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
11448 __inner(this.into(), ::core::option::Option::None)
11449 }
11450
11451 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_TalkMenuItem`'s own `get_FlagID`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
11452 pub unsafe fn get_flag_id(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
11453 let __mi = Self::get_flag_id_method_info();
11454 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
11455 __inner(this.into(), ::core::option::Option::None)
11456 }
11457
11458 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_TalkMenuItem`'s own `get_Mind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
11459 pub unsafe fn get_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
11460 let __mi = Self::get_mind_method_info();
11461 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
11462 ::core::mem::transmute(__mi.method_ptr);
11463 __inner(this.into(), ::core::option::Option::None)
11464 }
11465
11466 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_TalkMenuItem`'s own `get_ActiveMind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
11467 pub unsafe fn get_active_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
11468 let __mi = Self::get_active_mind_method_info();
11469 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
11470 ::core::mem::transmute(__mi.method_ptr);
11471 __inner(this.into(), ::core::option::Option::None)
11472 }
11473
11474 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_TalkMenuItem`'s own `get_DeployMode`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
11475 pub unsafe fn get_deploy_mode(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
11476 let __mi = Self::get_deploy_mode_method_info();
11477 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode =
11478 ::core::mem::transmute(__mi.method_ptr);
11479 __inner(this.into(), ::core::option::Option::None)
11480 }
11481
11482 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_TalkMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
11483 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
11484 let __mi = Self::get_name_method_info();
11485 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
11486 __inner(this.into(), ::core::option::Option::None)
11487 }
11488
11489 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_TalkMenuItem`'s own `GetCommandHelp`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
11490 pub unsafe fn get_command_help(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
11491 let __mi = Self::get_command_help_method_info();
11492 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
11493 __inner(this.into(), ::core::option::Option::None)
11494 }
11495
11496 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_TalkMenuItem`'s own `GetMapAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
11497 pub unsafe fn get_map_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
11498 let __mi = Self::get_map_attribute_method_info();
11499 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
11500 ::core::mem::transmute(__mi.method_ptr);
11501 __inner(this.into(), ::core::option::Option::None)
11502 }
11503}
11504
11505#[cfg(feature = "app-mapunitcommandmenu")]
11506impl MapUnitCommandMenu_TalkMenuItem {
11507 #[doc = "`.ctor()` — no args"]
11508 pub fn new() -> Self {
11509 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
11510 panic!(
11511 "{}
11512::{}
11513 failed to instantiate",
11514 ::core::stringify!(MapUnitCommandMenu_TalkMenuItem),
11515 ::core::stringify!(new),
11516 )
11517 });
11518 <Self as IMapUnitCommandMenu_TalkMenuItemMethods>::ctor(this);
11519 this
11520 }
11521}
11522
11523#[cfg(feature = "app-mapunitcommandmenu")]
11524pub trait IMapUnitCommandMenu_CommandSkillMenuItemMethods: IMapUnitCommandMenu_CommandSkillMenuItem {
11525 #[doc = "`.ctor(crate::app::skilldata::SkillData)` overload"]
11526 fn ctor(self, command_skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>) -> () {
11527 unsafe {
11528 let __receiver = <MapUnitCommandMenu_CommandSkillMenuItem as ::unity::FromIlInstance>::from_il_instance(
11529 <Self as ::unity::SystemObject>::as_instance(self),
11530 );
11531 ::unity::il2cpp_call!((::unity::module_base()+0x1e4b280usize)as*mut u8,();
11532(MapUnitCommandMenu_CommandSkillMenuItem)__receiver,(crate::app::skilldata::SkillData)::core::convert::Into::into(command_skill))
11533 }
11534 }
11535 #[doc = "`get_FlagID()` overload"]
11536 fn get_flag_id(self) -> ::unity::Il2CppString {
11537 unsafe {
11538 let __receiver = <MapUnitCommandMenu_CommandSkillMenuItem as ::unity::FromIlInstance>::from_il_instance(
11539 <Self as ::unity::SystemObject>::as_instance(self),
11540 );
11541 {
11542 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
11543 let __vi = *__vt.get(27usize).unwrap_or_else(|| {
11544 panic!(
11545 "unity: virtual slot {}
11546 out of range (vtable len {}
11547) on the runtime class behind {}
11548 (method `{}
11549`)",
11550 27usize,
11551 __vt.len(),
11552 <MapUnitCommandMenu_CommandSkillMenuItem as ::unity::ClassIdentity>::NAME,
11553 "get_FlagID",
11554 )
11555 });
11556 let __inner: extern "C" fn(MapUnitCommandMenu_CommandSkillMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
11557 ::core::mem::transmute(__vi.method_ptr);
11558 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
11559 __inner(__receiver, __mi)
11560 }
11561 }
11562 }
11563 #[doc = "`get_Mind()` overload"]
11564 fn get_mind(self) -> crate::app::mapmind::MapMind_Type {
11565 unsafe {
11566 let __receiver = <MapUnitCommandMenu_CommandSkillMenuItem as ::unity::FromIlInstance>::from_il_instance(
11567 <Self as ::unity::SystemObject>::as_instance(self),
11568 );
11569 {
11570 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
11571 let __vi = *__vt.get(36usize).unwrap_or_else(|| {
11572 panic!(
11573 "unity: virtual slot {}
11574 out of range (vtable len {}
11575) on the runtime class behind {}
11576 (method `{}
11577`)",
11578 36usize,
11579 __vt.len(),
11580 <MapUnitCommandMenu_CommandSkillMenuItem as ::unity::ClassIdentity>::NAME,
11581 "get_Mind",
11582 )
11583 });
11584 let __inner: extern "C" fn(MapUnitCommandMenu_CommandSkillMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
11585 ::core::mem::transmute(__vi.method_ptr);
11586 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
11587 __inner(__receiver, __mi)
11588 }
11589 }
11590 }
11591 #[doc = "`get_ActiveMind()` overload"]
11592 fn get_active_mind(self) -> crate::app::mapmind::MapMind_Type {
11593 unsafe {
11594 let __receiver = <MapUnitCommandMenu_CommandSkillMenuItem as ::unity::FromIlInstance>::from_il_instance(
11595 <Self as ::unity::SystemObject>::as_instance(self),
11596 );
11597 {
11598 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
11599 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
11600 panic!(
11601 "unity: virtual slot {}
11602 out of range (vtable len {}
11603) on the runtime class behind {}
11604 (method `{}
11605`)",
11606 30usize,
11607 __vt.len(),
11608 <MapUnitCommandMenu_CommandSkillMenuItem as ::unity::ClassIdentity>::NAME,
11609 "get_ActiveMind",
11610 )
11611 });
11612 let __inner: extern "C" fn(MapUnitCommandMenu_CommandSkillMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
11613 ::core::mem::transmute(__vi.method_ptr);
11614 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
11615 __inner(__receiver, __mi)
11616 }
11617 }
11618 }
11619 #[doc = "`get_DeployMode()` overload"]
11620 fn get_deploy_mode(self) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
11621 unsafe {
11622 let __receiver = <MapUnitCommandMenu_CommandSkillMenuItem as ::unity::FromIlInstance>::from_il_instance(
11623 <Self as ::unity::SystemObject>::as_instance(self),
11624 );
11625 {
11626 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
11627 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
11628 panic!(
11629 "unity: virtual slot {}
11630 out of range (vtable len {}
11631) on the runtime class behind {}
11632 (method `{}
11633`)",
11634 31usize,
11635 __vt.len(),
11636 <MapUnitCommandMenu_CommandSkillMenuItem as ::unity::ClassIdentity>::NAME,
11637 "get_DeployMode",
11638 )
11639 });
11640 let __inner: extern "C" fn(
11641 MapUnitCommandMenu_CommandSkillMenuItem,
11642 ::unity::OptionalMethod,
11643 ) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode = ::core::mem::transmute(__vi.method_ptr);
11644 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
11645 __inner(__receiver, __mi)
11646 }
11647 }
11648 }
11649 #[doc = "`get_CommandSkill()` overload"]
11650 fn get_command_skill(self) -> crate::app::skilldata::SkillData {
11651 unsafe {
11652 let __receiver = <MapUnitCommandMenu_CommandSkillMenuItem as ::unity::FromIlInstance>::from_il_instance(
11653 <Self as ::unity::SystemObject>::as_instance(self),
11654 );
11655 {
11656 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
11657 let __vi = *__vt.get(32usize).unwrap_or_else(|| {
11658 panic!(
11659 "unity: virtual slot {}
11660 out of range (vtable len {}
11661) on the runtime class behind {}
11662 (method `{}
11663`)",
11664 32usize,
11665 __vt.len(),
11666 <MapUnitCommandMenu_CommandSkillMenuItem as ::unity::ClassIdentity>::NAME,
11667 "get_CommandSkill",
11668 )
11669 });
11670 let __inner: extern "C" fn(MapUnitCommandMenu_CommandSkillMenuItem, ::unity::OptionalMethod) -> crate::app::skilldata::SkillData =
11671 ::core::mem::transmute(__vi.method_ptr);
11672 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
11673 __inner(__receiver, __mi)
11674 }
11675 }
11676 }
11677 #[doc = "`GetName()` overload"]
11678 fn get_name(self) -> ::unity::Il2CppString {
11679 unsafe {
11680 let __receiver = <MapUnitCommandMenu_CommandSkillMenuItem as ::unity::FromIlInstance>::from_il_instance(
11681 <Self as ::unity::SystemObject>::as_instance(self),
11682 );
11683 {
11684 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
11685 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
11686 panic!(
11687 "unity: virtual slot {}
11688 out of range (vtable len {}
11689) on the runtime class behind {}
11690 (method `{}
11691`)",
11692 4usize,
11693 __vt.len(),
11694 <MapUnitCommandMenu_CommandSkillMenuItem as ::unity::ClassIdentity>::NAME,
11695 "GetName",
11696 )
11697 });
11698 let __inner: extern "C" fn(MapUnitCommandMenu_CommandSkillMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
11699 ::core::mem::transmute(__vi.method_ptr);
11700 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
11701 __inner(__receiver, __mi)
11702 }
11703 }
11704 }
11705 #[doc = "`GetCommandHelp()` overload"]
11706 fn get_command_help(self) -> ::unity::Il2CppString {
11707 unsafe {
11708 let __receiver = <MapUnitCommandMenu_CommandSkillMenuItem as ::unity::FromIlInstance>::from_il_instance(
11709 <Self as ::unity::SystemObject>::as_instance(self),
11710 );
11711 {
11712 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
11713 let __vi = *__vt.get(34usize).unwrap_or_else(|| {
11714 panic!(
11715 "unity: virtual slot {}
11716 out of range (vtable len {}
11717) on the runtime class behind {}
11718 (method `{}
11719`)",
11720 34usize,
11721 __vt.len(),
11722 <MapUnitCommandMenu_CommandSkillMenuItem as ::unity::ClassIdentity>::NAME,
11723 "GetCommandHelp",
11724 )
11725 });
11726 let __inner: extern "C" fn(MapUnitCommandMenu_CommandSkillMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
11727 ::core::mem::transmute(__vi.method_ptr);
11728 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
11729 __inner(__receiver, __mi)
11730 }
11731 }
11732 }
11733 #[doc = "`GetMapAttribute()` overload"]
11734 fn get_map_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
11735 unsafe {
11736 let __receiver = <MapUnitCommandMenu_CommandSkillMenuItem as ::unity::FromIlInstance>::from_il_instance(
11737 <Self as ::unity::SystemObject>::as_instance(self),
11738 );
11739 {
11740 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
11741 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
11742 panic!(
11743 "unity: virtual slot {}
11744 out of range (vtable len {}
11745) on the runtime class behind {}
11746 (method `{}
11747`)",
11748 29usize,
11749 __vt.len(),
11750 <MapUnitCommandMenu_CommandSkillMenuItem as ::unity::ClassIdentity>::NAME,
11751 "GetMapAttribute",
11752 )
11753 });
11754 let __inner: extern "C" fn(
11755 MapUnitCommandMenu_CommandSkillMenuItem,
11756 ::unity::OptionalMethod,
11757 ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
11758 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
11759 __inner(__receiver, __mi)
11760 }
11761 }
11762 }
11763 #[doc = "`ACall()` overload"]
11764 fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
11765 unsafe {
11766 let __receiver = <MapUnitCommandMenu_CommandSkillMenuItem as ::unity::FromIlInstance>::from_il_instance(
11767 <Self as ::unity::SystemObject>::as_instance(self),
11768 );
11769 {
11770 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
11771 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
11772 panic!(
11773 "unity: virtual slot {}
11774 out of range (vtable len {}
11775) on the runtime class behind {}
11776 (method `{}
11777`)",
11778 18usize,
11779 __vt.len(),
11780 <MapUnitCommandMenu_CommandSkillMenuItem as ::unity::ClassIdentity>::NAME,
11781 "ACall",
11782 )
11783 });
11784 let __inner: extern "C" fn(
11785 MapUnitCommandMenu_CommandSkillMenuItem,
11786 ::unity::OptionalMethod,
11787 ) -> crate::app::basicmenu::BasicMenu_Result = ::core::mem::transmute(__vi.method_ptr);
11788 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
11789 __inner(__receiver, __mi)
11790 }
11791 }
11792 }
11793}
11794
11795#[cfg(feature = "app-mapunitcommandmenu")]
11796impl<__T: IMapUnitCommandMenu_CommandSkillMenuItem> IMapUnitCommandMenu_CommandSkillMenuItemMethods for __T {}
11797
11798#[cfg(feature = "app-mapunitcommandmenu")]
11799impl MapUnitCommandMenu_CommandSkillMenuItem {
11800 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11801 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
11802 }
11803
11804 pub fn get_flag_id_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11805 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
11806 }
11807
11808 pub fn get_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11809 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
11810 }
11811
11812 pub fn get_active_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11813 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
11814 }
11815
11816 pub fn get_deploy_mode_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11817 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
11818 }
11819
11820 pub fn get_command_skill_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11821 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
11822 }
11823
11824 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11825 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
11826 }
11827
11828 pub fn get_command_help_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11829 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
11830 }
11831
11832 pub fn get_map_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11833 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
11834 }
11835
11836 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11837 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
11838 }
11839}
11840
11841#[cfg(feature = "app-mapunitcommandmenu")]
11842impl MapUnitCommandMenu_CommandSkillMenuItem {
11843 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_CommandSkillMenuItem`'s own `get_FlagID`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
11844 pub unsafe fn get_flag_id(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
11845 let __mi = Self::get_flag_id_method_info();
11846 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
11847 __inner(this.into(), ::core::option::Option::None)
11848 }
11849
11850 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_CommandSkillMenuItem`'s own `get_Mind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
11851 pub unsafe fn get_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
11852 let __mi = Self::get_mind_method_info();
11853 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
11854 ::core::mem::transmute(__mi.method_ptr);
11855 __inner(this.into(), ::core::option::Option::None)
11856 }
11857
11858 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_CommandSkillMenuItem`'s own `get_ActiveMind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
11859 pub unsafe fn get_active_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
11860 let __mi = Self::get_active_mind_method_info();
11861 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
11862 ::core::mem::transmute(__mi.method_ptr);
11863 __inner(this.into(), ::core::option::Option::None)
11864 }
11865
11866 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_CommandSkillMenuItem`'s own `get_DeployMode`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
11867 pub unsafe fn get_deploy_mode(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
11868 let __mi = Self::get_deploy_mode_method_info();
11869 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode =
11870 ::core::mem::transmute(__mi.method_ptr);
11871 __inner(this.into(), ::core::option::Option::None)
11872 }
11873
11874 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_CommandSkillMenuItem`'s own `get_CommandSkill`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
11875 pub unsafe fn get_command_skill(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::skilldata::SkillData {
11876 let __mi = Self::get_command_skill_method_info();
11877 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::skilldata::SkillData =
11878 ::core::mem::transmute(__mi.method_ptr);
11879 __inner(this.into(), ::core::option::Option::None)
11880 }
11881
11882 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_CommandSkillMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
11883 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
11884 let __mi = Self::get_name_method_info();
11885 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
11886 __inner(this.into(), ::core::option::Option::None)
11887 }
11888
11889 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_CommandSkillMenuItem`'s own `GetCommandHelp`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
11890 pub unsafe fn get_command_help(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
11891 let __mi = Self::get_command_help_method_info();
11892 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
11893 __inner(this.into(), ::core::option::Option::None)
11894 }
11895
11896 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_CommandSkillMenuItem`'s own `GetMapAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
11897 pub unsafe fn get_map_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
11898 let __mi = Self::get_map_attribute_method_info();
11899 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
11900 ::core::mem::transmute(__mi.method_ptr);
11901 __inner(this.into(), ::core::option::Option::None)
11902 }
11903
11904 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_CommandSkillMenuItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
11905 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
11906 let __mi = Self::a_call_method_info();
11907 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
11908 ::core::mem::transmute(__mi.method_ptr);
11909 __inner(this.into(), ::core::option::Option::None)
11910 }
11911}
11912
11913#[cfg(feature = "app-mapunitcommandmenu")]
11914impl MapUnitCommandMenu_CommandSkillMenuItem {
11915 #[doc = "`.ctor(crate::app::skilldata::SkillData)` — overload selector"]
11916 pub fn new(command_skill: crate::app::skilldata::SkillData) -> Self {
11917 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
11918 panic!(
11919 "{}
11920::{}
11921 failed to instantiate",
11922 ::core::stringify!(MapUnitCommandMenu_CommandSkillMenuItem),
11923 ::core::stringify!(new),
11924 )
11925 });
11926 <Self as IMapUnitCommandMenu_CommandSkillMenuItemMethods>::ctor(this, command_skill);
11927 this
11928 }
11929}
11930
11931#[cfg(feature = "app-mapunitcommandmenu")]
11932pub trait IMapUnitCommandMenu_EngageRewarpMenuItemMethods: IMapUnitCommandMenu_EngageRewarpMenuItem {
11933 #[doc = "`get_Mind()` overload"]
11934 fn get_mind(self) -> crate::app::mapmind::MapMind_Type {
11935 unsafe {
11936 let __receiver = <MapUnitCommandMenu_EngageRewarpMenuItem as ::unity::FromIlInstance>::from_il_instance(
11937 <Self as ::unity::SystemObject>::as_instance(self),
11938 );
11939 {
11940 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
11941 let __vi = *__vt.get(37usize).unwrap_or_else(|| {
11942 panic!(
11943 "unity: virtual slot {}
11944 out of range (vtable len {}
11945) on the runtime class behind {}
11946 (method `{}
11947`)",
11948 37usize,
11949 __vt.len(),
11950 <MapUnitCommandMenu_EngageRewarpMenuItem as ::unity::ClassIdentity>::NAME,
11951 "get_Mind",
11952 )
11953 });
11954 let __inner: extern "C" fn(MapUnitCommandMenu_EngageRewarpMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
11955 ::core::mem::transmute(__vi.method_ptr);
11956 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
11957 __inner(__receiver, __mi)
11958 }
11959 }
11960 }
11961 #[doc = "`get_Label()` overload"]
11962 fn get_label(self) -> crate::app::mapsequencehuman::MapSequenceHuman_Label {
11963 unsafe {
11964 let __receiver = <MapUnitCommandMenu_EngageRewarpMenuItem as ::unity::FromIlInstance>::from_il_instance(
11965 <Self as ::unity::SystemObject>::as_instance(self),
11966 );
11967 {
11968 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
11969 let __vi = *__vt.get(36usize).unwrap_or_else(|| {
11970 panic!(
11971 "unity: virtual slot {}
11972 out of range (vtable len {}
11973) on the runtime class behind {}
11974 (method `{}
11975`)",
11976 36usize,
11977 __vt.len(),
11978 <MapUnitCommandMenu_EngageRewarpMenuItem as ::unity::ClassIdentity>::NAME,
11979 "get_Label",
11980 )
11981 });
11982 let __inner: extern "C" fn(
11983 MapUnitCommandMenu_EngageRewarpMenuItem,
11984 ::unity::OptionalMethod,
11985 ) -> crate::app::mapsequencehuman::MapSequenceHuman_Label = ::core::mem::transmute(__vi.method_ptr);
11986 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
11987 __inner(__receiver, __mi)
11988 }
11989 }
11990 }
11991 #[doc = "`get_ActiveMind()` overload"]
11992 fn get_active_mind(self) -> crate::app::mapmind::MapMind_Type {
11993 unsafe {
11994 let __receiver = <MapUnitCommandMenu_EngageRewarpMenuItem as ::unity::FromIlInstance>::from_il_instance(
11995 <Self as ::unity::SystemObject>::as_instance(self),
11996 );
11997 {
11998 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
11999 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
12000 panic!(
12001 "unity: virtual slot {}
12002 out of range (vtable len {}
12003) on the runtime class behind {}
12004 (method `{}
12005`)",
12006 30usize,
12007 __vt.len(),
12008 <MapUnitCommandMenu_EngageRewarpMenuItem as ::unity::ClassIdentity>::NAME,
12009 "get_ActiveMind",
12010 )
12011 });
12012 let __inner: extern "C" fn(MapUnitCommandMenu_EngageRewarpMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
12013 ::core::mem::transmute(__vi.method_ptr);
12014 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
12015 __inner(__receiver, __mi)
12016 }
12017 }
12018 }
12019 #[doc = "`get_DeployMode()` overload"]
12020 fn get_deploy_mode(self) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
12021 unsafe {
12022 let __receiver = <MapUnitCommandMenu_EngageRewarpMenuItem as ::unity::FromIlInstance>::from_il_instance(
12023 <Self as ::unity::SystemObject>::as_instance(self),
12024 );
12025 {
12026 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
12027 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
12028 panic!(
12029 "unity: virtual slot {}
12030 out of range (vtable len {}
12031) on the runtime class behind {}
12032 (method `{}
12033`)",
12034 31usize,
12035 __vt.len(),
12036 <MapUnitCommandMenu_EngageRewarpMenuItem as ::unity::ClassIdentity>::NAME,
12037 "get_DeployMode",
12038 )
12039 });
12040 let __inner: extern "C" fn(
12041 MapUnitCommandMenu_EngageRewarpMenuItem,
12042 ::unity::OptionalMethod,
12043 ) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode = ::core::mem::transmute(__vi.method_ptr);
12044 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
12045 __inner(__receiver, __mi)
12046 }
12047 }
12048 }
12049 #[doc = "`GetMapAttribute()` overload"]
12050 fn get_map_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
12051 unsafe {
12052 let __receiver = <MapUnitCommandMenu_EngageRewarpMenuItem as ::unity::FromIlInstance>::from_il_instance(
12053 <Self as ::unity::SystemObject>::as_instance(self),
12054 );
12055 {
12056 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
12057 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
12058 panic!(
12059 "unity: virtual slot {}
12060 out of range (vtable len {}
12061) on the runtime class behind {}
12062 (method `{}
12063`)",
12064 29usize,
12065 __vt.len(),
12066 <MapUnitCommandMenu_EngageRewarpMenuItem as ::unity::ClassIdentity>::NAME,
12067 "GetMapAttribute",
12068 )
12069 });
12070 let __inner: extern "C" fn(
12071 MapUnitCommandMenu_EngageRewarpMenuItem,
12072 ::unity::OptionalMethod,
12073 ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
12074 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
12075 __inner(__receiver, __mi)
12076 }
12077 }
12078 }
12079 #[doc = "`ACall()` overload"]
12080 fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
12081 unsafe {
12082 let __receiver = <MapUnitCommandMenu_EngageRewarpMenuItem as ::unity::FromIlInstance>::from_il_instance(
12083 <Self as ::unity::SystemObject>::as_instance(self),
12084 );
12085 {
12086 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
12087 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
12088 panic!(
12089 "unity: virtual slot {}
12090 out of range (vtable len {}
12091) on the runtime class behind {}
12092 (method `{}
12093`)",
12094 18usize,
12095 __vt.len(),
12096 <MapUnitCommandMenu_EngageRewarpMenuItem as ::unity::ClassIdentity>::NAME,
12097 "ACall",
12098 )
12099 });
12100 let __inner: extern "C" fn(
12101 MapUnitCommandMenu_EngageRewarpMenuItem,
12102 ::unity::OptionalMethod,
12103 ) -> crate::app::basicmenu::BasicMenu_Result = ::core::mem::transmute(__vi.method_ptr);
12104 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
12105 __inner(__receiver, __mi)
12106 }
12107 }
12108 }
12109 #[doc = "`.ctor()` overload"]
12110 fn ctor(self) -> () {
12111 unsafe {
12112 let __receiver = <MapUnitCommandMenu_EngageRewarpMenuItem as ::unity::FromIlInstance>::from_il_instance(
12113 <Self as ::unity::SystemObject>::as_instance(self),
12114 );
12115 ::unity::il2cpp_call!((::unity::module_base()+0x1e4dfb0usize)as*mut u8,();
12116(MapUnitCommandMenu_EngageRewarpMenuItem)__receiver)
12117 }
12118 }
12119}
12120
12121#[cfg(feature = "app-mapunitcommandmenu")]
12122impl<__T: IMapUnitCommandMenu_EngageRewarpMenuItem> IMapUnitCommandMenu_EngageRewarpMenuItemMethods for __T {}
12123
12124#[cfg(feature = "app-mapunitcommandmenu")]
12125impl MapUnitCommandMenu_EngageRewarpMenuItem {
12126 pub fn get_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
12127 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
12128 }
12129
12130 pub fn get_label_method_info() -> &'static ::unity::il2cpp::MethodInfo {
12131 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
12132 }
12133
12134 pub fn get_active_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
12135 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
12136 }
12137
12138 pub fn get_deploy_mode_method_info() -> &'static ::unity::il2cpp::MethodInfo {
12139 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
12140 }
12141
12142 pub fn get_map_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
12143 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
12144 }
12145
12146 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
12147 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
12148 }
12149
12150 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
12151 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
12152 }
12153}
12154
12155#[cfg(feature = "app-mapunitcommandmenu")]
12156impl MapUnitCommandMenu_EngageRewarpMenuItem {
12157 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageRewarpMenuItem`'s own `get_Mind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
12158 pub unsafe fn get_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
12159 let __mi = Self::get_mind_method_info();
12160 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
12161 ::core::mem::transmute(__mi.method_ptr);
12162 __inner(this.into(), ::core::option::Option::None)
12163 }
12164
12165 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageRewarpMenuItem`'s own `get_Label`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
12166 pub unsafe fn get_label(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapsequencehuman::MapSequenceHuman_Label {
12167 let __mi = Self::get_label_method_info();
12168 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapsequencehuman::MapSequenceHuman_Label =
12169 ::core::mem::transmute(__mi.method_ptr);
12170 __inner(this.into(), ::core::option::Option::None)
12171 }
12172
12173 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageRewarpMenuItem`'s own `get_ActiveMind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
12174 pub unsafe fn get_active_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
12175 let __mi = Self::get_active_mind_method_info();
12176 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
12177 ::core::mem::transmute(__mi.method_ptr);
12178 __inner(this.into(), ::core::option::Option::None)
12179 }
12180
12181 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageRewarpMenuItem`'s own `get_DeployMode`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
12182 pub unsafe fn get_deploy_mode(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
12183 let __mi = Self::get_deploy_mode_method_info();
12184 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode =
12185 ::core::mem::transmute(__mi.method_ptr);
12186 __inner(this.into(), ::core::option::Option::None)
12187 }
12188
12189 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageRewarpMenuItem`'s own `GetMapAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
12190 pub unsafe fn get_map_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
12191 let __mi = Self::get_map_attribute_method_info();
12192 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
12193 ::core::mem::transmute(__mi.method_ptr);
12194 __inner(this.into(), ::core::option::Option::None)
12195 }
12196
12197 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageRewarpMenuItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
12198 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
12199 let __mi = Self::a_call_method_info();
12200 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
12201 ::core::mem::transmute(__mi.method_ptr);
12202 __inner(this.into(), ::core::option::Option::None)
12203 }
12204}
12205
12206#[cfg(feature = "app-mapunitcommandmenu")]
12207impl MapUnitCommandMenu_EngageRewarpMenuItem {
12208 #[doc = "`.ctor()` — no args"]
12209 pub fn new() -> Self {
12210 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
12211 panic!(
12212 "{}
12213::{}
12214 failed to instantiate",
12215 ::core::stringify!(MapUnitCommandMenu_EngageRewarpMenuItem),
12216 ::core::stringify!(new),
12217 )
12218 });
12219 <Self as IMapUnitCommandMenu_EngageRewarpMenuItemMethods>::ctor(this);
12220 this
12221 }
12222}
12223
12224#[cfg(feature = "app-mapunitcommandmenu")]
12225pub trait IMapUnitCommandMenu_DoorMenuItemMethods: IMapUnitCommandMenu_DoorMenuItem {
12226 #[doc = "`OnBuild()` overload"]
12227 fn on_build(self) -> () {
12228 unsafe {
12229 let __receiver =
12230 <MapUnitCommandMenu_DoorMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
12231 {
12232 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
12233 let __vi = *__vt.get(10usize).unwrap_or_else(|| {
12234 panic!(
12235 "unity: virtual slot {}
12236 out of range (vtable len {}
12237) on the runtime class behind {}
12238 (method `{}
12239`)",
12240 10usize,
12241 __vt.len(),
12242 <MapUnitCommandMenu_DoorMenuItem as ::unity::ClassIdentity>::NAME,
12243 "OnBuild",
12244 )
12245 });
12246 let __inner: extern "C" fn(MapUnitCommandMenu_DoorMenuItem, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
12247 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
12248 __inner(__receiver, __mi)
12249 }
12250 }
12251 }
12252 #[doc = "`OnBuildMenuItemContent()` overload"]
12253 fn on_build_menu_item_content(self) -> () {
12254 unsafe {
12255 let __receiver =
12256 <MapUnitCommandMenu_DoorMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
12257 {
12258 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
12259 let __vi = *__vt.get(11usize).unwrap_or_else(|| {
12260 panic!(
12261 "unity: virtual slot {}
12262 out of range (vtable len {}
12263) on the runtime class behind {}
12264 (method `{}
12265`)",
12266 11usize,
12267 __vt.len(),
12268 <MapUnitCommandMenu_DoorMenuItem as ::unity::ClassIdentity>::NAME,
12269 "OnBuildMenuItemContent",
12270 )
12271 });
12272 let __inner: extern "C" fn(MapUnitCommandMenu_DoorMenuItem, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
12273 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
12274 __inner(__receiver, __mi)
12275 }
12276 }
12277 }
12278 #[doc = "`get_FlagID()` overload"]
12279 fn get_flag_id(self) -> ::unity::Il2CppString {
12280 unsafe {
12281 let __receiver =
12282 <MapUnitCommandMenu_DoorMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
12283 {
12284 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
12285 let __vi = *__vt.get(27usize).unwrap_or_else(|| {
12286 panic!(
12287 "unity: virtual slot {}
12288 out of range (vtable len {}
12289) on the runtime class behind {}
12290 (method `{}
12291`)",
12292 27usize,
12293 __vt.len(),
12294 <MapUnitCommandMenu_DoorMenuItem as ::unity::ClassIdentity>::NAME,
12295 "get_FlagID",
12296 )
12297 });
12298 let __inner: extern "C" fn(MapUnitCommandMenu_DoorMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
12299 ::core::mem::transmute(__vi.method_ptr);
12300 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
12301 __inner(__receiver, __mi)
12302 }
12303 }
12304 }
12305 #[doc = "`get_ActiveMind()` overload"]
12306 fn get_active_mind(self) -> crate::app::mapmind::MapMind_Type {
12307 unsafe {
12308 let __receiver =
12309 <MapUnitCommandMenu_DoorMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
12310 {
12311 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
12312 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
12313 panic!(
12314 "unity: virtual slot {}
12315 out of range (vtable len {}
12316) on the runtime class behind {}
12317 (method `{}
12318`)",
12319 30usize,
12320 __vt.len(),
12321 <MapUnitCommandMenu_DoorMenuItem as ::unity::ClassIdentity>::NAME,
12322 "get_ActiveMind",
12323 )
12324 });
12325 let __inner: extern "C" fn(MapUnitCommandMenu_DoorMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
12326 ::core::mem::transmute(__vi.method_ptr);
12327 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
12328 __inner(__receiver, __mi)
12329 }
12330 }
12331 }
12332 #[doc = "`get_DeployMode()` overload"]
12333 fn get_deploy_mode(self) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
12334 unsafe {
12335 let __receiver =
12336 <MapUnitCommandMenu_DoorMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
12337 {
12338 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
12339 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
12340 panic!(
12341 "unity: virtual slot {}
12342 out of range (vtable len {}
12343) on the runtime class behind {}
12344 (method `{}
12345`)",
12346 31usize,
12347 __vt.len(),
12348 <MapUnitCommandMenu_DoorMenuItem as ::unity::ClassIdentity>::NAME,
12349 "get_DeployMode",
12350 )
12351 });
12352 let __inner: extern "C" fn(
12353 MapUnitCommandMenu_DoorMenuItem,
12354 ::unity::OptionalMethod,
12355 ) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode = ::core::mem::transmute(__vi.method_ptr);
12356 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
12357 __inner(__receiver, __mi)
12358 }
12359 }
12360 }
12361 #[doc = "`GetName()` overload"]
12362 fn get_name(self) -> ::unity::Il2CppString {
12363 unsafe {
12364 let __receiver =
12365 <MapUnitCommandMenu_DoorMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
12366 {
12367 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
12368 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
12369 panic!(
12370 "unity: virtual slot {}
12371 out of range (vtable len {}
12372) on the runtime class behind {}
12373 (method `{}
12374`)",
12375 4usize,
12376 __vt.len(),
12377 <MapUnitCommandMenu_DoorMenuItem as ::unity::ClassIdentity>::NAME,
12378 "GetName",
12379 )
12380 });
12381 let __inner: extern "C" fn(MapUnitCommandMenu_DoorMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
12382 ::core::mem::transmute(__vi.method_ptr);
12383 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
12384 __inner(__receiver, __mi)
12385 }
12386 }
12387 }
12388 #[doc = "`GetCommandHelp()` overload"]
12389 fn get_command_help(self) -> ::unity::Il2CppString {
12390 unsafe {
12391 let __receiver =
12392 <MapUnitCommandMenu_DoorMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
12393 {
12394 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
12395 let __vi = *__vt.get(34usize).unwrap_or_else(|| {
12396 panic!(
12397 "unity: virtual slot {}
12398 out of range (vtable len {}
12399) on the runtime class behind {}
12400 (method `{}
12401`)",
12402 34usize,
12403 __vt.len(),
12404 <MapUnitCommandMenu_DoorMenuItem as ::unity::ClassIdentity>::NAME,
12405 "GetCommandHelp",
12406 )
12407 });
12408 let __inner: extern "C" fn(MapUnitCommandMenu_DoorMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
12409 ::core::mem::transmute(__vi.method_ptr);
12410 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
12411 __inner(__receiver, __mi)
12412 }
12413 }
12414 }
12415 #[doc = "`GetMapAttribute()` overload"]
12416 fn get_map_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
12417 unsafe {
12418 let __receiver =
12419 <MapUnitCommandMenu_DoorMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
12420 {
12421 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
12422 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
12423 panic!(
12424 "unity: virtual slot {}
12425 out of range (vtable len {}
12426) on the runtime class behind {}
12427 (method `{}
12428`)",
12429 29usize,
12430 __vt.len(),
12431 <MapUnitCommandMenu_DoorMenuItem as ::unity::ClassIdentity>::NAME,
12432 "GetMapAttribute",
12433 )
12434 });
12435 let __inner: extern "C" fn(
12436 MapUnitCommandMenu_DoorMenuItem,
12437 ::unity::OptionalMethod,
12438 ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
12439 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
12440 __inner(__receiver, __mi)
12441 }
12442 }
12443 }
12444 #[doc = "`ACall()` overload"]
12445 fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
12446 unsafe {
12447 let __receiver =
12448 <MapUnitCommandMenu_DoorMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
12449 {
12450 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
12451 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
12452 panic!(
12453 "unity: virtual slot {}
12454 out of range (vtable len {}
12455) on the runtime class behind {}
12456 (method `{}
12457`)",
12458 18usize,
12459 __vt.len(),
12460 <MapUnitCommandMenu_DoorMenuItem as ::unity::ClassIdentity>::NAME,
12461 "ACall",
12462 )
12463 });
12464 let __inner: extern "C" fn(MapUnitCommandMenu_DoorMenuItem, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
12465 ::core::mem::transmute(__vi.method_ptr);
12466 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
12467 __inner(__receiver, __mi)
12468 }
12469 }
12470 }
12471 #[doc = "`.ctor()` overload"]
12472 fn ctor(self) -> () {
12473 unsafe {
12474 let __receiver =
12475 <MapUnitCommandMenu_DoorMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
12476 ::unity::il2cpp_call!((::unity::module_base()+0x1e4c6e0usize)as*mut u8,();
12477(MapUnitCommandMenu_DoorMenuItem)__receiver)
12478 }
12479 }
12480}
12481
12482#[cfg(feature = "app-mapunitcommandmenu")]
12483impl<__T: IMapUnitCommandMenu_DoorMenuItem> IMapUnitCommandMenu_DoorMenuItemMethods for __T {}
12484
12485#[cfg(feature = "app-mapunitcommandmenu")]
12486impl MapUnitCommandMenu_DoorMenuItem {
12487 pub fn on_build_method_info() -> &'static ::unity::il2cpp::MethodInfo {
12488 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
12489 }
12490
12491 pub fn on_build_menu_item_content_method_info() -> &'static ::unity::il2cpp::MethodInfo {
12492 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
12493 }
12494
12495 pub fn get_flag_id_method_info() -> &'static ::unity::il2cpp::MethodInfo {
12496 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
12497 }
12498
12499 pub fn get_active_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
12500 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
12501 }
12502
12503 pub fn get_deploy_mode_method_info() -> &'static ::unity::il2cpp::MethodInfo {
12504 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
12505 }
12506
12507 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
12508 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
12509 }
12510
12511 pub fn get_command_help_method_info() -> &'static ::unity::il2cpp::MethodInfo {
12512 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
12513 }
12514
12515 pub fn get_map_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
12516 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
12517 }
12518
12519 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
12520 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
12521 }
12522
12523 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
12524 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
12525 }
12526}
12527
12528#[cfg(feature = "app-mapunitcommandmenu")]
12529impl MapUnitCommandMenu_DoorMenuItem {
12530 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_DoorMenuItem`'s own `OnBuild`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
12531 pub unsafe fn on_build(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
12532 let __mi = Self::on_build_method_info();
12533 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
12534 __inner(this.into(), ::core::option::Option::None)
12535 }
12536
12537 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_DoorMenuItem`'s own `OnBuildMenuItemContent`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
12538 pub unsafe fn on_build_menu_item_content(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
12539 let __mi = Self::on_build_menu_item_content_method_info();
12540 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
12541 __inner(this.into(), ::core::option::Option::None)
12542 }
12543
12544 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_DoorMenuItem`'s own `get_FlagID`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
12545 pub unsafe fn get_flag_id(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
12546 let __mi = Self::get_flag_id_method_info();
12547 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
12548 __inner(this.into(), ::core::option::Option::None)
12549 }
12550
12551 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_DoorMenuItem`'s own `get_ActiveMind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
12552 pub unsafe fn get_active_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
12553 let __mi = Self::get_active_mind_method_info();
12554 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
12555 ::core::mem::transmute(__mi.method_ptr);
12556 __inner(this.into(), ::core::option::Option::None)
12557 }
12558
12559 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_DoorMenuItem`'s own `get_DeployMode`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
12560 pub unsafe fn get_deploy_mode(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
12561 let __mi = Self::get_deploy_mode_method_info();
12562 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode =
12563 ::core::mem::transmute(__mi.method_ptr);
12564 __inner(this.into(), ::core::option::Option::None)
12565 }
12566
12567 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_DoorMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
12568 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
12569 let __mi = Self::get_name_method_info();
12570 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
12571 __inner(this.into(), ::core::option::Option::None)
12572 }
12573
12574 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_DoorMenuItem`'s own `GetCommandHelp`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
12575 pub unsafe fn get_command_help(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
12576 let __mi = Self::get_command_help_method_info();
12577 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
12578 __inner(this.into(), ::core::option::Option::None)
12579 }
12580
12581 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_DoorMenuItem`'s own `GetMapAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
12582 pub unsafe fn get_map_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
12583 let __mi = Self::get_map_attribute_method_info();
12584 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
12585 ::core::mem::transmute(__mi.method_ptr);
12586 __inner(this.into(), ::core::option::Option::None)
12587 }
12588
12589 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_DoorMenuItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
12590 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
12591 let __mi = Self::a_call_method_info();
12592 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
12593 ::core::mem::transmute(__mi.method_ptr);
12594 __inner(this.into(), ::core::option::Option::None)
12595 }
12596}
12597
12598#[cfg(feature = "app-mapunitcommandmenu")]
12599impl MapUnitCommandMenu_DoorMenuItem {
12600 #[doc = "`.ctor()` — no args"]
12601 pub fn new() -> Self {
12602 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
12603 panic!(
12604 "{}
12605::{}
12606 failed to instantiate",
12607 ::core::stringify!(MapUnitCommandMenu_DoorMenuItem),
12608 ::core::stringify!(new),
12609 )
12610 });
12611 <Self as IMapUnitCommandMenu_DoorMenuItemMethods>::ctor(this);
12612 this
12613 }
12614}
12615
12616#[cfg(feature = "app-mapunitcommandmenu")]
12617pub trait IMapUnitCommandMenu_BreakthroughMenuItemMethods: IMapUnitCommandMenu_BreakthroughMenuItem {
12618 #[doc = "`OnBuild()` overload"]
12619 fn on_build(self) -> () {
12620 unsafe {
12621 let __receiver = <MapUnitCommandMenu_BreakthroughMenuItem as ::unity::FromIlInstance>::from_il_instance(
12622 <Self as ::unity::SystemObject>::as_instance(self),
12623 );
12624 {
12625 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
12626 let __vi = *__vt.get(10usize).unwrap_or_else(|| {
12627 panic!(
12628 "unity: virtual slot {}
12629 out of range (vtable len {}
12630) on the runtime class behind {}
12631 (method `{}
12632`)",
12633 10usize,
12634 __vt.len(),
12635 <MapUnitCommandMenu_BreakthroughMenuItem as ::unity::ClassIdentity>::NAME,
12636 "OnBuild",
12637 )
12638 });
12639 let __inner: extern "C" fn(MapUnitCommandMenu_BreakthroughMenuItem, ::unity::OptionalMethod) -> () =
12640 ::core::mem::transmute(__vi.method_ptr);
12641 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
12642 __inner(__receiver, __mi)
12643 }
12644 }
12645 }
12646 #[doc = "`OnBuildMenuItemContent()` overload"]
12647 fn on_build_menu_item_content(self) -> () {
12648 unsafe {
12649 let __receiver = <MapUnitCommandMenu_BreakthroughMenuItem as ::unity::FromIlInstance>::from_il_instance(
12650 <Self as ::unity::SystemObject>::as_instance(self),
12651 );
12652 {
12653 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
12654 let __vi = *__vt.get(11usize).unwrap_or_else(|| {
12655 panic!(
12656 "unity: virtual slot {}
12657 out of range (vtable len {}
12658) on the runtime class behind {}
12659 (method `{}
12660`)",
12661 11usize,
12662 __vt.len(),
12663 <MapUnitCommandMenu_BreakthroughMenuItem as ::unity::ClassIdentity>::NAME,
12664 "OnBuildMenuItemContent",
12665 )
12666 });
12667 let __inner: extern "C" fn(MapUnitCommandMenu_BreakthroughMenuItem, ::unity::OptionalMethod) -> () =
12668 ::core::mem::transmute(__vi.method_ptr);
12669 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
12670 __inner(__receiver, __mi)
12671 }
12672 }
12673 }
12674 #[doc = "`get_FlagID()` overload"]
12675 fn get_flag_id(self) -> ::unity::Il2CppString {
12676 unsafe {
12677 let __receiver = <MapUnitCommandMenu_BreakthroughMenuItem as ::unity::FromIlInstance>::from_il_instance(
12678 <Self as ::unity::SystemObject>::as_instance(self),
12679 );
12680 {
12681 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
12682 let __vi = *__vt.get(27usize).unwrap_or_else(|| {
12683 panic!(
12684 "unity: virtual slot {}
12685 out of range (vtable len {}
12686) on the runtime class behind {}
12687 (method `{}
12688`)",
12689 27usize,
12690 __vt.len(),
12691 <MapUnitCommandMenu_BreakthroughMenuItem as ::unity::ClassIdentity>::NAME,
12692 "get_FlagID",
12693 )
12694 });
12695 let __inner: extern "C" fn(MapUnitCommandMenu_BreakthroughMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
12696 ::core::mem::transmute(__vi.method_ptr);
12697 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
12698 __inner(__receiver, __mi)
12699 }
12700 }
12701 }
12702 #[doc = "`GetName()` overload"]
12703 fn get_name(self) -> ::unity::Il2CppString {
12704 unsafe {
12705 let __receiver = <MapUnitCommandMenu_BreakthroughMenuItem as ::unity::FromIlInstance>::from_il_instance(
12706 <Self as ::unity::SystemObject>::as_instance(self),
12707 );
12708 {
12709 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
12710 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
12711 panic!(
12712 "unity: virtual slot {}
12713 out of range (vtable len {}
12714) on the runtime class behind {}
12715 (method `{}
12716`)",
12717 4usize,
12718 __vt.len(),
12719 <MapUnitCommandMenu_BreakthroughMenuItem as ::unity::ClassIdentity>::NAME,
12720 "GetName",
12721 )
12722 });
12723 let __inner: extern "C" fn(MapUnitCommandMenu_BreakthroughMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
12724 ::core::mem::transmute(__vi.method_ptr);
12725 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
12726 __inner(__receiver, __mi)
12727 }
12728 }
12729 }
12730 #[doc = "`GetCommandHelp()` overload"]
12731 fn get_command_help(self) -> ::unity::Il2CppString {
12732 unsafe {
12733 let __receiver = <MapUnitCommandMenu_BreakthroughMenuItem as ::unity::FromIlInstance>::from_il_instance(
12734 <Self as ::unity::SystemObject>::as_instance(self),
12735 );
12736 {
12737 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
12738 let __vi = *__vt.get(34usize).unwrap_or_else(|| {
12739 panic!(
12740 "unity: virtual slot {}
12741 out of range (vtable len {}
12742) on the runtime class behind {}
12743 (method `{}
12744`)",
12745 34usize,
12746 __vt.len(),
12747 <MapUnitCommandMenu_BreakthroughMenuItem as ::unity::ClassIdentity>::NAME,
12748 "GetCommandHelp",
12749 )
12750 });
12751 let __inner: extern "C" fn(MapUnitCommandMenu_BreakthroughMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
12752 ::core::mem::transmute(__vi.method_ptr);
12753 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
12754 __inner(__receiver, __mi)
12755 }
12756 }
12757 }
12758 #[doc = "`GetMapAttribute()` overload"]
12759 fn get_map_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
12760 unsafe {
12761 let __receiver = <MapUnitCommandMenu_BreakthroughMenuItem as ::unity::FromIlInstance>::from_il_instance(
12762 <Self as ::unity::SystemObject>::as_instance(self),
12763 );
12764 {
12765 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
12766 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
12767 panic!(
12768 "unity: virtual slot {}
12769 out of range (vtable len {}
12770) on the runtime class behind {}
12771 (method `{}
12772`)",
12773 29usize,
12774 __vt.len(),
12775 <MapUnitCommandMenu_BreakthroughMenuItem as ::unity::ClassIdentity>::NAME,
12776 "GetMapAttribute",
12777 )
12778 });
12779 let __inner: extern "C" fn(
12780 MapUnitCommandMenu_BreakthroughMenuItem,
12781 ::unity::OptionalMethod,
12782 ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
12783 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
12784 __inner(__receiver, __mi)
12785 }
12786 }
12787 }
12788 #[doc = "`ACall()` overload"]
12789 fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
12790 unsafe {
12791 let __receiver = <MapUnitCommandMenu_BreakthroughMenuItem as ::unity::FromIlInstance>::from_il_instance(
12792 <Self as ::unity::SystemObject>::as_instance(self),
12793 );
12794 {
12795 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
12796 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
12797 panic!(
12798 "unity: virtual slot {}
12799 out of range (vtable len {}
12800) on the runtime class behind {}
12801 (method `{}
12802`)",
12803 18usize,
12804 __vt.len(),
12805 <MapUnitCommandMenu_BreakthroughMenuItem as ::unity::ClassIdentity>::NAME,
12806 "ACall",
12807 )
12808 });
12809 let __inner: extern "C" fn(
12810 MapUnitCommandMenu_BreakthroughMenuItem,
12811 ::unity::OptionalMethod,
12812 ) -> crate::app::basicmenu::BasicMenu_Result = ::core::mem::transmute(__vi.method_ptr);
12813 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
12814 __inner(__receiver, __mi)
12815 }
12816 }
12817 }
12818 #[doc = "`.ctor()` overload"]
12819 fn ctor(self) -> () {
12820 unsafe {
12821 let __receiver = <MapUnitCommandMenu_BreakthroughMenuItem as ::unity::FromIlInstance>::from_il_instance(
12822 <Self as ::unity::SystemObject>::as_instance(self),
12823 );
12824 ::unity::il2cpp_call!((::unity::module_base()+0x1e49e20usize)as*mut u8,();
12825(MapUnitCommandMenu_BreakthroughMenuItem)__receiver)
12826 }
12827 }
12828}
12829
12830#[cfg(feature = "app-mapunitcommandmenu")]
12831impl<__T: IMapUnitCommandMenu_BreakthroughMenuItem> IMapUnitCommandMenu_BreakthroughMenuItemMethods for __T {}
12832
12833#[cfg(feature = "app-mapunitcommandmenu")]
12834impl MapUnitCommandMenu_BreakthroughMenuItem {
12835 pub fn on_build_method_info() -> &'static ::unity::il2cpp::MethodInfo {
12836 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
12837 }
12838
12839 pub fn on_build_menu_item_content_method_info() -> &'static ::unity::il2cpp::MethodInfo {
12840 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
12841 }
12842
12843 pub fn get_flag_id_method_info() -> &'static ::unity::il2cpp::MethodInfo {
12844 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
12845 }
12846
12847 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
12848 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
12849 }
12850
12851 pub fn get_command_help_method_info() -> &'static ::unity::il2cpp::MethodInfo {
12852 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
12853 }
12854
12855 pub fn get_map_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
12856 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
12857 }
12858
12859 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
12860 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
12861 }
12862
12863 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
12864 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
12865 }
12866}
12867
12868#[cfg(feature = "app-mapunitcommandmenu")]
12869impl MapUnitCommandMenu_BreakthroughMenuItem {
12870 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_BreakthroughMenuItem`'s own `OnBuild`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
12871 pub unsafe fn on_build(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
12872 let __mi = Self::on_build_method_info();
12873 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
12874 __inner(this.into(), ::core::option::Option::None)
12875 }
12876
12877 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_BreakthroughMenuItem`'s own `OnBuildMenuItemContent`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
12878 pub unsafe fn on_build_menu_item_content(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
12879 let __mi = Self::on_build_menu_item_content_method_info();
12880 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
12881 __inner(this.into(), ::core::option::Option::None)
12882 }
12883
12884 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_BreakthroughMenuItem`'s own `get_FlagID`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
12885 pub unsafe fn get_flag_id(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
12886 let __mi = Self::get_flag_id_method_info();
12887 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
12888 __inner(this.into(), ::core::option::Option::None)
12889 }
12890
12891 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_BreakthroughMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
12892 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
12893 let __mi = Self::get_name_method_info();
12894 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
12895 __inner(this.into(), ::core::option::Option::None)
12896 }
12897
12898 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_BreakthroughMenuItem`'s own `GetCommandHelp`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
12899 pub unsafe fn get_command_help(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
12900 let __mi = Self::get_command_help_method_info();
12901 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
12902 __inner(this.into(), ::core::option::Option::None)
12903 }
12904
12905 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_BreakthroughMenuItem`'s own `GetMapAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
12906 pub unsafe fn get_map_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
12907 let __mi = Self::get_map_attribute_method_info();
12908 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
12909 ::core::mem::transmute(__mi.method_ptr);
12910 __inner(this.into(), ::core::option::Option::None)
12911 }
12912
12913 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_BreakthroughMenuItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
12914 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
12915 let __mi = Self::a_call_method_info();
12916 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
12917 ::core::mem::transmute(__mi.method_ptr);
12918 __inner(this.into(), ::core::option::Option::None)
12919 }
12920}
12921
12922#[cfg(feature = "app-mapunitcommandmenu")]
12923impl MapUnitCommandMenu_BreakthroughMenuItem {
12924 #[doc = "`.ctor()` — no args"]
12925 pub fn new() -> Self {
12926 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
12927 panic!(
12928 "{}
12929::{}
12930 failed to instantiate",
12931 ::core::stringify!(MapUnitCommandMenu_BreakthroughMenuItem),
12932 ::core::stringify!(new),
12933 )
12934 });
12935 <Self as IMapUnitCommandMenu_BreakthroughMenuItemMethods>::ctor(this);
12936 this
12937 }
12938}
12939
12940#[cfg(feature = "app-mapunitcommandmenu")]
12941pub trait IMapUnitCommandMenu_BreakdownBaseMenuItemMethods: IMapUnitCommandMenu_BreakdownBaseMenuItem {
12942 #[doc = "`OnBuild()` overload"]
12943 fn on_build(self) -> () {
12944 unsafe {
12945 let __receiver = <MapUnitCommandMenu_BreakdownBaseMenuItem as ::unity::FromIlInstance>::from_il_instance(
12946 <Self as ::unity::SystemObject>::as_instance(self),
12947 );
12948 {
12949 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
12950 let __vi = *__vt.get(10usize).unwrap_or_else(|| {
12951 panic!(
12952 "unity: virtual slot {}
12953 out of range (vtable len {}
12954) on the runtime class behind {}
12955 (method `{}
12956`)",
12957 10usize,
12958 __vt.len(),
12959 <MapUnitCommandMenu_BreakdownBaseMenuItem as ::unity::ClassIdentity>::NAME,
12960 "OnBuild",
12961 )
12962 });
12963 let __inner: extern "C" fn(MapUnitCommandMenu_BreakdownBaseMenuItem, ::unity::OptionalMethod) -> () =
12964 ::core::mem::transmute(__vi.method_ptr);
12965 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
12966 __inner(__receiver, __mi)
12967 }
12968 }
12969 }
12970 #[doc = "`OnBuildMenuItemContent()` overload"]
12971 fn on_build_menu_item_content(self) -> () {
12972 unsafe {
12973 let __receiver = <MapUnitCommandMenu_BreakdownBaseMenuItem as ::unity::FromIlInstance>::from_il_instance(
12974 <Self as ::unity::SystemObject>::as_instance(self),
12975 );
12976 {
12977 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
12978 let __vi = *__vt.get(11usize).unwrap_or_else(|| {
12979 panic!(
12980 "unity: virtual slot {}
12981 out of range (vtable len {}
12982) on the runtime class behind {}
12983 (method `{}
12984`)",
12985 11usize,
12986 __vt.len(),
12987 <MapUnitCommandMenu_BreakdownBaseMenuItem as ::unity::ClassIdentity>::NAME,
12988 "OnBuildMenuItemContent",
12989 )
12990 });
12991 let __inner: extern "C" fn(MapUnitCommandMenu_BreakdownBaseMenuItem, ::unity::OptionalMethod) -> () =
12992 ::core::mem::transmute(__vi.method_ptr);
12993 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
12994 __inner(__receiver, __mi)
12995 }
12996 }
12997 }
12998 #[doc = "`get_FlagID()` overload"]
12999 fn get_flag_id(self) -> ::unity::Il2CppString {
13000 unsafe {
13001 let __receiver = <MapUnitCommandMenu_BreakdownBaseMenuItem as ::unity::FromIlInstance>::from_il_instance(
13002 <Self as ::unity::SystemObject>::as_instance(self),
13003 );
13004 {
13005 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
13006 let __vi = *__vt.get(27usize).unwrap_or_else(|| {
13007 panic!(
13008 "unity: virtual slot {}
13009 out of range (vtable len {}
13010) on the runtime class behind {}
13011 (method `{}
13012`)",
13013 27usize,
13014 __vt.len(),
13015 <MapUnitCommandMenu_BreakdownBaseMenuItem as ::unity::ClassIdentity>::NAME,
13016 "get_FlagID",
13017 )
13018 });
13019 let __inner: extern "C" fn(MapUnitCommandMenu_BreakdownBaseMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
13020 ::core::mem::transmute(__vi.method_ptr);
13021 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
13022 __inner(__receiver, __mi)
13023 }
13024 }
13025 }
13026 #[doc = "`GetName()` overload"]
13027 fn get_name(self) -> ::unity::Il2CppString {
13028 unsafe {
13029 let __receiver = <MapUnitCommandMenu_BreakdownBaseMenuItem as ::unity::FromIlInstance>::from_il_instance(
13030 <Self as ::unity::SystemObject>::as_instance(self),
13031 );
13032 {
13033 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
13034 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
13035 panic!(
13036 "unity: virtual slot {}
13037 out of range (vtable len {}
13038) on the runtime class behind {}
13039 (method `{}
13040`)",
13041 4usize,
13042 __vt.len(),
13043 <MapUnitCommandMenu_BreakdownBaseMenuItem as ::unity::ClassIdentity>::NAME,
13044 "GetName",
13045 )
13046 });
13047 let __inner: extern "C" fn(MapUnitCommandMenu_BreakdownBaseMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
13048 ::core::mem::transmute(__vi.method_ptr);
13049 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
13050 __inner(__receiver, __mi)
13051 }
13052 }
13053 }
13054 #[doc = "`GetCommandHelp()` overload"]
13055 fn get_command_help(self) -> ::unity::Il2CppString {
13056 unsafe {
13057 let __receiver = <MapUnitCommandMenu_BreakdownBaseMenuItem as ::unity::FromIlInstance>::from_il_instance(
13058 <Self as ::unity::SystemObject>::as_instance(self),
13059 );
13060 {
13061 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
13062 let __vi = *__vt.get(34usize).unwrap_or_else(|| {
13063 panic!(
13064 "unity: virtual slot {}
13065 out of range (vtable len {}
13066) on the runtime class behind {}
13067 (method `{}
13068`)",
13069 34usize,
13070 __vt.len(),
13071 <MapUnitCommandMenu_BreakdownBaseMenuItem as ::unity::ClassIdentity>::NAME,
13072 "GetCommandHelp",
13073 )
13074 });
13075 let __inner: extern "C" fn(MapUnitCommandMenu_BreakdownBaseMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
13076 ::core::mem::transmute(__vi.method_ptr);
13077 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
13078 __inner(__receiver, __mi)
13079 }
13080 }
13081 }
13082 #[doc = "`GetForce()` overload"]
13083 fn get_force(self) -> crate::app::force::Force_Type {
13084 unsafe {
13085 let __receiver = <MapUnitCommandMenu_BreakdownBaseMenuItem as ::unity::FromIlInstance>::from_il_instance(
13086 <Self as ::unity::SystemObject>::as_instance(self),
13087 );
13088 {
13089 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
13090 let __vi = *__vt.get(36usize).unwrap_or_else(|| {
13091 panic!(
13092 "unity: virtual slot {}
13093 out of range (vtable len {}
13094) on the runtime class behind {}
13095 (method `{}
13096`)",
13097 36usize,
13098 __vt.len(),
13099 <MapUnitCommandMenu_BreakdownBaseMenuItem as ::unity::ClassIdentity>::NAME,
13100 "GetForce",
13101 )
13102 });
13103 let __inner: extern "C" fn(MapUnitCommandMenu_BreakdownBaseMenuItem, ::unity::OptionalMethod) -> crate::app::force::Force_Type =
13104 ::core::mem::transmute(__vi.method_ptr);
13105 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
13106 __inner(__receiver, __mi)
13107 }
13108 }
13109 }
13110 #[doc = "`GetKind()` overload"]
13111 fn get_kind(self) -> crate::app::mapinspector::MapInspector_Kind {
13112 unsafe {
13113 let __receiver = <MapUnitCommandMenu_BreakdownBaseMenuItem as ::unity::FromIlInstance>::from_il_instance(
13114 <Self as ::unity::SystemObject>::as_instance(self),
13115 );
13116 {
13117 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
13118 let __vi = *__vt.get(37usize).unwrap_or_else(|| {
13119 panic!(
13120 "unity: virtual slot {}
13121 out of range (vtable len {}
13122) on the runtime class behind {}
13123 (method `{}
13124`)",
13125 37usize,
13126 __vt.len(),
13127 <MapUnitCommandMenu_BreakdownBaseMenuItem as ::unity::ClassIdentity>::NAME,
13128 "GetKind",
13129 )
13130 });
13131 let __inner: extern "C" fn(
13132 MapUnitCommandMenu_BreakdownBaseMenuItem,
13133 ::unity::OptionalMethod,
13134 ) -> crate::app::mapinspector::MapInspector_Kind = ::core::mem::transmute(__vi.method_ptr);
13135 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
13136 __inner(__receiver, __mi)
13137 }
13138 }
13139 }
13140 #[doc = "`GetMind()` overload"]
13141 fn get_mind(self) -> crate::app::mapmind::MapMind_Type {
13142 unsafe {
13143 let __receiver = <MapUnitCommandMenu_BreakdownBaseMenuItem as ::unity::FromIlInstance>::from_il_instance(
13144 <Self as ::unity::SystemObject>::as_instance(self),
13145 );
13146 {
13147 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
13148 let __vi = *__vt.get(38usize).unwrap_or_else(|| {
13149 panic!(
13150 "unity: virtual slot {}
13151 out of range (vtable len {}
13152) on the runtime class behind {}
13153 (method `{}
13154`)",
13155 38usize,
13156 __vt.len(),
13157 <MapUnitCommandMenu_BreakdownBaseMenuItem as ::unity::ClassIdentity>::NAME,
13158 "GetMind",
13159 )
13160 });
13161 let __inner: extern "C" fn(MapUnitCommandMenu_BreakdownBaseMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
13162 ::core::mem::transmute(__vi.method_ptr);
13163 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
13164 __inner(__receiver, __mi)
13165 }
13166 }
13167 }
13168 #[doc = "`GetMapAttribute()` overload"]
13169 fn get_map_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
13170 unsafe {
13171 let __receiver = <MapUnitCommandMenu_BreakdownBaseMenuItem as ::unity::FromIlInstance>::from_il_instance(
13172 <Self as ::unity::SystemObject>::as_instance(self),
13173 );
13174 {
13175 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
13176 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
13177 panic!(
13178 "unity: virtual slot {}
13179 out of range (vtable len {}
13180) on the runtime class behind {}
13181 (method `{}
13182`)",
13183 29usize,
13184 __vt.len(),
13185 <MapUnitCommandMenu_BreakdownBaseMenuItem as ::unity::ClassIdentity>::NAME,
13186 "GetMapAttribute",
13187 )
13188 });
13189 let __inner: extern "C" fn(
13190 MapUnitCommandMenu_BreakdownBaseMenuItem,
13191 ::unity::OptionalMethod,
13192 ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
13193 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
13194 __inner(__receiver, __mi)
13195 }
13196 }
13197 }
13198 #[doc = "`ACall()` overload"]
13199 fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
13200 unsafe {
13201 let __receiver = <MapUnitCommandMenu_BreakdownBaseMenuItem as ::unity::FromIlInstance>::from_il_instance(
13202 <Self as ::unity::SystemObject>::as_instance(self),
13203 );
13204 {
13205 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
13206 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
13207 panic!(
13208 "unity: virtual slot {}
13209 out of range (vtable len {}
13210) on the runtime class behind {}
13211 (method `{}
13212`)",
13213 18usize,
13214 __vt.len(),
13215 <MapUnitCommandMenu_BreakdownBaseMenuItem as ::unity::ClassIdentity>::NAME,
13216 "ACall",
13217 )
13218 });
13219 let __inner: extern "C" fn(
13220 MapUnitCommandMenu_BreakdownBaseMenuItem,
13221 ::unity::OptionalMethod,
13222 ) -> crate::app::basicmenu::BasicMenu_Result = ::core::mem::transmute(__vi.method_ptr);
13223 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
13224 __inner(__receiver, __mi)
13225 }
13226 }
13227 }
13228 #[doc = "`.ctor()` overload"]
13229 fn ctor(self) -> () {
13230 unsafe {
13231 let __receiver = <MapUnitCommandMenu_BreakdownBaseMenuItem as ::unity::FromIlInstance>::from_il_instance(
13232 <Self as ::unity::SystemObject>::as_instance(self),
13233 );
13234 ::unity::il2cpp_call!((::unity::module_base()+0x1e49a90usize)as*mut u8,();
13235(MapUnitCommandMenu_BreakdownBaseMenuItem)__receiver)
13236 }
13237 }
13238}
13239
13240#[cfg(feature = "app-mapunitcommandmenu")]
13241impl<__T: IMapUnitCommandMenu_BreakdownBaseMenuItem> IMapUnitCommandMenu_BreakdownBaseMenuItemMethods for __T {}
13242
13243#[cfg(feature = "app-mapunitcommandmenu")]
13244impl MapUnitCommandMenu_BreakdownBaseMenuItem {
13245 pub fn on_build_method_info() -> &'static ::unity::il2cpp::MethodInfo {
13246 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
13247 }
13248
13249 pub fn on_build_menu_item_content_method_info() -> &'static ::unity::il2cpp::MethodInfo {
13250 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
13251 }
13252
13253 pub fn get_flag_id_method_info() -> &'static ::unity::il2cpp::MethodInfo {
13254 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
13255 }
13256
13257 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
13258 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
13259 }
13260
13261 pub fn get_command_help_method_info() -> &'static ::unity::il2cpp::MethodInfo {
13262 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
13263 }
13264
13265 pub fn get_force_method_info() -> &'static ::unity::il2cpp::MethodInfo {
13266 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
13267 }
13268
13269 pub fn get_kind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
13270 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
13271 }
13272
13273 pub fn get_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
13274 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
13275 }
13276
13277 pub fn get_map_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
13278 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
13279 }
13280
13281 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
13282 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
13283 }
13284
13285 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
13286 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
13287 }
13288}
13289
13290#[cfg(feature = "app-mapunitcommandmenu")]
13291impl MapUnitCommandMenu_BreakdownBaseMenuItem {
13292 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_BreakdownBaseMenuItem`'s own `OnBuild`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
13293 pub unsafe fn on_build(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
13294 let __mi = Self::on_build_method_info();
13295 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
13296 __inner(this.into(), ::core::option::Option::None)
13297 }
13298
13299 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_BreakdownBaseMenuItem`'s own `OnBuildMenuItemContent`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
13300 pub unsafe fn on_build_menu_item_content(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
13301 let __mi = Self::on_build_menu_item_content_method_info();
13302 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
13303 __inner(this.into(), ::core::option::Option::None)
13304 }
13305
13306 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_BreakdownBaseMenuItem`'s own `get_FlagID`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
13307 pub unsafe fn get_flag_id(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
13308 let __mi = Self::get_flag_id_method_info();
13309 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
13310 __inner(this.into(), ::core::option::Option::None)
13311 }
13312
13313 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_BreakdownBaseMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
13314 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
13315 let __mi = Self::get_name_method_info();
13316 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
13317 __inner(this.into(), ::core::option::Option::None)
13318 }
13319
13320 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_BreakdownBaseMenuItem`'s own `GetCommandHelp`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
13321 pub unsafe fn get_command_help(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
13322 let __mi = Self::get_command_help_method_info();
13323 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
13324 __inner(this.into(), ::core::option::Option::None)
13325 }
13326
13327 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_BreakdownBaseMenuItem`'s own `GetForce`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
13328 pub unsafe fn get_force(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::force::Force_Type {
13329 let __mi = Self::get_force_method_info();
13330 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::force::Force_Type =
13331 ::core::mem::transmute(__mi.method_ptr);
13332 __inner(this.into(), ::core::option::Option::None)
13333 }
13334
13335 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_BreakdownBaseMenuItem`'s own `GetKind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
13336 pub unsafe fn get_kind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapinspector::MapInspector_Kind {
13337 let __mi = Self::get_kind_method_info();
13338 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapinspector::MapInspector_Kind =
13339 ::core::mem::transmute(__mi.method_ptr);
13340 __inner(this.into(), ::core::option::Option::None)
13341 }
13342
13343 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_BreakdownBaseMenuItem`'s own `GetMind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
13344 pub unsafe fn get_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
13345 let __mi = Self::get_mind_method_info();
13346 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
13347 ::core::mem::transmute(__mi.method_ptr);
13348 __inner(this.into(), ::core::option::Option::None)
13349 }
13350
13351 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_BreakdownBaseMenuItem`'s own `GetMapAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
13352 pub unsafe fn get_map_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
13353 let __mi = Self::get_map_attribute_method_info();
13354 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
13355 ::core::mem::transmute(__mi.method_ptr);
13356 __inner(this.into(), ::core::option::Option::None)
13357 }
13358
13359 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_BreakdownBaseMenuItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
13360 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
13361 let __mi = Self::a_call_method_info();
13362 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
13363 ::core::mem::transmute(__mi.method_ptr);
13364 __inner(this.into(), ::core::option::Option::None)
13365 }
13366}
13367
13368#[cfg(feature = "app-mapunitcommandmenu")]
13369impl MapUnitCommandMenu_BreakdownBaseMenuItem {
13370 #[doc = "`.ctor()` — no args"]
13371 pub fn new() -> Self {
13372 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
13373 panic!(
13374 "{}
13375::{}
13376 failed to instantiate",
13377 ::core::stringify!(MapUnitCommandMenu_BreakdownBaseMenuItem),
13378 ::core::stringify!(new),
13379 )
13380 });
13381 <Self as IMapUnitCommandMenu_BreakdownBaseMenuItemMethods>::ctor(this);
13382 this
13383 }
13384}
13385
13386#[cfg(feature = "app-mapunitcommandmenu")]
13387pub trait IMapUnitCommandMenu_FixedMenuItemMethods: IMapUnitCommandMenu_FixedMenuItem {
13388 #[doc = "`get_FlagID()` overload"]
13389 fn get_flag_id(self) -> ::unity::Il2CppString {
13390 unsafe {
13391 let __receiver =
13392 <MapUnitCommandMenu_FixedMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
13393 {
13394 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
13395 let __vi = *__vt.get(27usize).unwrap_or_else(|| {
13396 panic!(
13397 "unity: virtual slot {}
13398 out of range (vtable len {}
13399) on the runtime class behind {}
13400 (method `{}
13401`)",
13402 27usize,
13403 __vt.len(),
13404 <MapUnitCommandMenu_FixedMenuItem as ::unity::ClassIdentity>::NAME,
13405 "get_FlagID",
13406 )
13407 });
13408 let __inner: extern "C" fn(MapUnitCommandMenu_FixedMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
13409 ::core::mem::transmute(__vi.method_ptr);
13410 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
13411 __inner(__receiver, __mi)
13412 }
13413 }
13414 }
13415 #[doc = "`get_ActiveMind()` overload"]
13416 fn get_active_mind(self) -> crate::app::mapmind::MapMind_Type {
13417 unsafe {
13418 let __receiver =
13419 <MapUnitCommandMenu_FixedMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
13420 {
13421 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
13422 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
13423 panic!(
13424 "unity: virtual slot {}
13425 out of range (vtable len {}
13426) on the runtime class behind {}
13427 (method `{}
13428`)",
13429 30usize,
13430 __vt.len(),
13431 <MapUnitCommandMenu_FixedMenuItem as ::unity::ClassIdentity>::NAME,
13432 "get_ActiveMind",
13433 )
13434 });
13435 let __inner: extern "C" fn(MapUnitCommandMenu_FixedMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
13436 ::core::mem::transmute(__vi.method_ptr);
13437 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
13438 __inner(__receiver, __mi)
13439 }
13440 }
13441 }
13442 #[doc = "`GetName()` overload"]
13443 fn get_name(self) -> ::unity::Il2CppString {
13444 unsafe {
13445 let __receiver =
13446 <MapUnitCommandMenu_FixedMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
13447 {
13448 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
13449 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
13450 panic!(
13451 "unity: virtual slot {}
13452 out of range (vtable len {}
13453) on the runtime class behind {}
13454 (method `{}
13455`)",
13456 4usize,
13457 __vt.len(),
13458 <MapUnitCommandMenu_FixedMenuItem as ::unity::ClassIdentity>::NAME,
13459 "GetName",
13460 )
13461 });
13462 let __inner: extern "C" fn(MapUnitCommandMenu_FixedMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
13463 ::core::mem::transmute(__vi.method_ptr);
13464 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
13465 __inner(__receiver, __mi)
13466 }
13467 }
13468 }
13469 #[doc = "`GetCommandHelp()` overload"]
13470 fn get_command_help(self) -> ::unity::Il2CppString {
13471 unsafe {
13472 let __receiver =
13473 <MapUnitCommandMenu_FixedMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
13474 {
13475 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
13476 let __vi = *__vt.get(34usize).unwrap_or_else(|| {
13477 panic!(
13478 "unity: virtual slot {}
13479 out of range (vtable len {}
13480) on the runtime class behind {}
13481 (method `{}
13482`)",
13483 34usize,
13484 __vt.len(),
13485 <MapUnitCommandMenu_FixedMenuItem as ::unity::ClassIdentity>::NAME,
13486 "GetCommandHelp",
13487 )
13488 });
13489 let __inner: extern "C" fn(MapUnitCommandMenu_FixedMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
13490 ::core::mem::transmute(__vi.method_ptr);
13491 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
13492 __inner(__receiver, __mi)
13493 }
13494 }
13495 }
13496 #[doc = "`GetMapAttribute()` overload"]
13497 fn get_map_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
13498 unsafe {
13499 let __receiver =
13500 <MapUnitCommandMenu_FixedMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
13501 {
13502 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
13503 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
13504 panic!(
13505 "unity: virtual slot {}
13506 out of range (vtable len {}
13507) on the runtime class behind {}
13508 (method `{}
13509`)",
13510 29usize,
13511 __vt.len(),
13512 <MapUnitCommandMenu_FixedMenuItem as ::unity::ClassIdentity>::NAME,
13513 "GetMapAttribute",
13514 )
13515 });
13516 let __inner: extern "C" fn(
13517 MapUnitCommandMenu_FixedMenuItem,
13518 ::unity::OptionalMethod,
13519 ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
13520 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
13521 __inner(__receiver, __mi)
13522 }
13523 }
13524 }
13525 #[doc = "`ACall()` overload"]
13526 fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
13527 unsafe {
13528 let __receiver =
13529 <MapUnitCommandMenu_FixedMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
13530 {
13531 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
13532 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
13533 panic!(
13534 "unity: virtual slot {}
13535 out of range (vtable len {}
13536) on the runtime class behind {}
13537 (method `{}
13538`)",
13539 18usize,
13540 __vt.len(),
13541 <MapUnitCommandMenu_FixedMenuItem as ::unity::ClassIdentity>::NAME,
13542 "ACall",
13543 )
13544 });
13545 let __inner: extern "C" fn(MapUnitCommandMenu_FixedMenuItem, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
13546 ::core::mem::transmute(__vi.method_ptr);
13547 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
13548 __inner(__receiver, __mi)
13549 }
13550 }
13551 }
13552 #[doc = "`.ctor()` overload"]
13553 fn ctor(self) -> () {
13554 unsafe {
13555 let __receiver =
13556 <MapUnitCommandMenu_FixedMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
13557 ::unity::il2cpp_call!((::unity::module_base()+0x1e4e910usize)as*mut u8,();
13558(MapUnitCommandMenu_FixedMenuItem)__receiver)
13559 }
13560 }
13561}
13562
13563#[cfg(feature = "app-mapunitcommandmenu")]
13564impl<__T: IMapUnitCommandMenu_FixedMenuItem> IMapUnitCommandMenu_FixedMenuItemMethods for __T {}
13565
13566#[cfg(feature = "app-mapunitcommandmenu")]
13567impl MapUnitCommandMenu_FixedMenuItem {
13568 pub fn get_flag_id_method_info() -> &'static ::unity::il2cpp::MethodInfo {
13569 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
13570 }
13571
13572 pub fn get_active_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
13573 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
13574 }
13575
13576 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
13577 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
13578 }
13579
13580 pub fn get_command_help_method_info() -> &'static ::unity::il2cpp::MethodInfo {
13581 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
13582 }
13583
13584 pub fn get_map_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
13585 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
13586 }
13587
13588 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
13589 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
13590 }
13591
13592 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
13593 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
13594 }
13595}
13596
13597#[cfg(feature = "app-mapunitcommandmenu")]
13598impl MapUnitCommandMenu_FixedMenuItem {
13599 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_FixedMenuItem`'s own `get_FlagID`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
13600 pub unsafe fn get_flag_id(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
13601 let __mi = Self::get_flag_id_method_info();
13602 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
13603 __inner(this.into(), ::core::option::Option::None)
13604 }
13605
13606 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_FixedMenuItem`'s own `get_ActiveMind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
13607 pub unsafe fn get_active_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
13608 let __mi = Self::get_active_mind_method_info();
13609 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
13610 ::core::mem::transmute(__mi.method_ptr);
13611 __inner(this.into(), ::core::option::Option::None)
13612 }
13613
13614 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_FixedMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
13615 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
13616 let __mi = Self::get_name_method_info();
13617 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
13618 __inner(this.into(), ::core::option::Option::None)
13619 }
13620
13621 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_FixedMenuItem`'s own `GetCommandHelp`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
13622 pub unsafe fn get_command_help(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
13623 let __mi = Self::get_command_help_method_info();
13624 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
13625 __inner(this.into(), ::core::option::Option::None)
13626 }
13627
13628 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_FixedMenuItem`'s own `GetMapAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
13629 pub unsafe fn get_map_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
13630 let __mi = Self::get_map_attribute_method_info();
13631 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
13632 ::core::mem::transmute(__mi.method_ptr);
13633 __inner(this.into(), ::core::option::Option::None)
13634 }
13635
13636 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_FixedMenuItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
13637 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
13638 let __mi = Self::a_call_method_info();
13639 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
13640 ::core::mem::transmute(__mi.method_ptr);
13641 __inner(this.into(), ::core::option::Option::None)
13642 }
13643}
13644
13645#[cfg(feature = "app-mapunitcommandmenu")]
13646impl MapUnitCommandMenu_FixedMenuItem {
13647 #[doc = "`.ctor()` — no args"]
13648 pub fn new() -> Self {
13649 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
13650 panic!(
13651 "{}
13652::{}
13653 failed to instantiate",
13654 ::core::stringify!(MapUnitCommandMenu_FixedMenuItem),
13655 ::core::stringify!(new),
13656 )
13657 });
13658 <Self as IMapUnitCommandMenu_FixedMenuItemMethods>::ctor(this);
13659 this
13660 }
13661}
13662
13663#[cfg(feature = "app-mapunitcommandmenu")]
13664pub trait IMapUnitCommandMenu_TargetSelectMenuItemMethods: IMapUnitCommandMenu_TargetSelectMenuItem {
13665 #[doc = "`get_Mind()` overload"]
13666 fn get_mind(self) -> crate::app::mapmind::MapMind_Type {
13667 unsafe {
13668 let __receiver = <MapUnitCommandMenu_TargetSelectMenuItem as ::unity::FromIlInstance>::from_il_instance(
13669 <Self as ::unity::SystemObject>::as_instance(self),
13670 );
13671 {
13672 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
13673 let __vi = *__vt.get(36usize).unwrap_or_else(|| {
13674 panic!(
13675 "unity: virtual slot {}
13676 out of range (vtable len {}
13677) on the runtime class behind {}
13678 (method `{}
13679`)",
13680 36usize,
13681 __vt.len(),
13682 <MapUnitCommandMenu_TargetSelectMenuItem as ::unity::ClassIdentity>::NAME,
13683 "get_Mind",
13684 )
13685 });
13686 let __inner: extern "C" fn(MapUnitCommandMenu_TargetSelectMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
13687 ::core::mem::transmute(__vi.method_ptr);
13688 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
13689 __inner(__receiver, __mi)
13690 }
13691 }
13692 }
13693 #[doc = "`Enumerate(crate::app::skilldata::SkillData)` overload"]
13694 fn enumerate(self, skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>) -> i32 {
13695 unsafe {
13696 let __receiver = <MapUnitCommandMenu_TargetSelectMenuItem as ::unity::FromIlInstance>::from_il_instance(
13697 <Self as ::unity::SystemObject>::as_instance(self),
13698 );
13699 ::unity::il2cpp_call!((::unity::module_base()+0x1e4b5e0usize)as*mut u8,i32;
13700(MapUnitCommandMenu_TargetSelectMenuItem)__receiver,(crate::app::skilldata::SkillData)::core::convert::Into::into(skill))
13701 }
13702 }
13703 #[doc = "`ACall()` overload"]
13704 fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
13705 unsafe {
13706 let __receiver = <MapUnitCommandMenu_TargetSelectMenuItem as ::unity::FromIlInstance>::from_il_instance(
13707 <Self as ::unity::SystemObject>::as_instance(self),
13708 );
13709 {
13710 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
13711 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
13712 panic!(
13713 "unity: virtual slot {}
13714 out of range (vtable len {}
13715) on the runtime class behind {}
13716 (method `{}
13717`)",
13718 18usize,
13719 __vt.len(),
13720 <MapUnitCommandMenu_TargetSelectMenuItem as ::unity::ClassIdentity>::NAME,
13721 "ACall",
13722 )
13723 });
13724 let __inner: extern "C" fn(
13725 MapUnitCommandMenu_TargetSelectMenuItem,
13726 ::unity::OptionalMethod,
13727 ) -> crate::app::basicmenu::BasicMenu_Result = ::core::mem::transmute(__vi.method_ptr);
13728 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
13729 __inner(__receiver, __mi)
13730 }
13731 }
13732 }
13733 #[doc = "`.ctor()` overload"]
13734 fn ctor(self) -> () {
13735 unsafe {
13736 let __receiver = <MapUnitCommandMenu_TargetSelectMenuItem as ::unity::FromIlInstance>::from_il_instance(
13737 <Self as ::unity::SystemObject>::as_instance(self),
13738 );
13739 ::unity::il2cpp_call!((::unity::module_base()+0x1e4b2c0usize)as*mut u8,();
13740(MapUnitCommandMenu_TargetSelectMenuItem)__receiver)
13741 }
13742 }
13743}
13744
13745#[cfg(feature = "app-mapunitcommandmenu")]
13746impl<__T: IMapUnitCommandMenu_TargetSelectMenuItem> IMapUnitCommandMenu_TargetSelectMenuItemMethods for __T {}
13747
13748#[cfg(feature = "app-mapunitcommandmenu")]
13749impl MapUnitCommandMenu_TargetSelectMenuItem {
13750 pub fn get_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
13751 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
13752 }
13753
13754 pub fn enumerate_method_info() -> &'static ::unity::il2cpp::MethodInfo {
13755 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
13756 }
13757
13758 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
13759 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
13760 }
13761
13762 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
13763 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
13764 }
13765}
13766
13767#[cfg(feature = "app-mapunitcommandmenu")]
13768impl MapUnitCommandMenu_TargetSelectMenuItem {
13769 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_TargetSelectMenuItem`'s own `get_Mind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
13770 pub unsafe fn get_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
13771 let __mi = Self::get_mind_method_info();
13772 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
13773 ::core::mem::transmute(__mi.method_ptr);
13774 __inner(this.into(), ::core::option::Option::None)
13775 }
13776
13777 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_TargetSelectMenuItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
13778 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
13779 let __mi = Self::a_call_method_info();
13780 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
13781 ::core::mem::transmute(__mi.method_ptr);
13782 __inner(this.into(), ::core::option::Option::None)
13783 }
13784}
13785
13786#[cfg(feature = "app-mapunitcommandmenu")]
13787impl MapUnitCommandMenu_TargetSelectMenuItem {
13788 #[doc = "`.ctor()` — no args"]
13789 pub fn new() -> Self {
13790 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
13791 panic!(
13792 "{}
13793::{}
13794 failed to instantiate",
13795 ::core::stringify!(MapUnitCommandMenu_TargetSelectMenuItem),
13796 ::core::stringify!(new),
13797 )
13798 });
13799 <Self as IMapUnitCommandMenu_TargetSelectMenuItemMethods>::ctor(this);
13800 this
13801 }
13802}
13803
13804#[cfg(feature = "app-mapunitcommandmenu")]
13805pub trait IMapUnitCommandMenu_VisionDeleteMenuItemMethods: IMapUnitCommandMenu_VisionDeleteMenuItem {
13806 #[doc = "`get_FlagID()` overload"]
13807 fn get_flag_id(self) -> ::unity::Il2CppString {
13808 unsafe {
13809 let __receiver = <MapUnitCommandMenu_VisionDeleteMenuItem as ::unity::FromIlInstance>::from_il_instance(
13810 <Self as ::unity::SystemObject>::as_instance(self),
13811 );
13812 {
13813 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
13814 let __vi = *__vt.get(27usize).unwrap_or_else(|| {
13815 panic!(
13816 "unity: virtual slot {}
13817 out of range (vtable len {}
13818) on the runtime class behind {}
13819 (method `{}
13820`)",
13821 27usize,
13822 __vt.len(),
13823 <MapUnitCommandMenu_VisionDeleteMenuItem as ::unity::ClassIdentity>::NAME,
13824 "get_FlagID",
13825 )
13826 });
13827 let __inner: extern "C" fn(MapUnitCommandMenu_VisionDeleteMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
13828 ::core::mem::transmute(__vi.method_ptr);
13829 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
13830 __inner(__receiver, __mi)
13831 }
13832 }
13833 }
13834 #[doc = "`get_Mind()` overload"]
13835 fn get_mind(self) -> crate::app::mapmind::MapMind_Type {
13836 unsafe {
13837 let __receiver = <MapUnitCommandMenu_VisionDeleteMenuItem as ::unity::FromIlInstance>::from_il_instance(
13838 <Self as ::unity::SystemObject>::as_instance(self),
13839 );
13840 {
13841 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
13842 let __vi = *__vt.get(36usize).unwrap_or_else(|| {
13843 panic!(
13844 "unity: virtual slot {}
13845 out of range (vtable len {}
13846) on the runtime class behind {}
13847 (method `{}
13848`)",
13849 36usize,
13850 __vt.len(),
13851 <MapUnitCommandMenu_VisionDeleteMenuItem as ::unity::ClassIdentity>::NAME,
13852 "get_Mind",
13853 )
13854 });
13855 let __inner: extern "C" fn(MapUnitCommandMenu_VisionDeleteMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
13856 ::core::mem::transmute(__vi.method_ptr);
13857 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
13858 __inner(__receiver, __mi)
13859 }
13860 }
13861 }
13862 #[doc = "`get_ActiveMind()` overload"]
13863 fn get_active_mind(self) -> crate::app::mapmind::MapMind_Type {
13864 unsafe {
13865 let __receiver = <MapUnitCommandMenu_VisionDeleteMenuItem as ::unity::FromIlInstance>::from_il_instance(
13866 <Self as ::unity::SystemObject>::as_instance(self),
13867 );
13868 {
13869 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
13870 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
13871 panic!(
13872 "unity: virtual slot {}
13873 out of range (vtable len {}
13874) on the runtime class behind {}
13875 (method `{}
13876`)",
13877 30usize,
13878 __vt.len(),
13879 <MapUnitCommandMenu_VisionDeleteMenuItem as ::unity::ClassIdentity>::NAME,
13880 "get_ActiveMind",
13881 )
13882 });
13883 let __inner: extern "C" fn(MapUnitCommandMenu_VisionDeleteMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
13884 ::core::mem::transmute(__vi.method_ptr);
13885 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
13886 __inner(__receiver, __mi)
13887 }
13888 }
13889 }
13890 #[doc = "`get_DeployMode()` overload"]
13891 fn get_deploy_mode(self) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
13892 unsafe {
13893 let __receiver = <MapUnitCommandMenu_VisionDeleteMenuItem as ::unity::FromIlInstance>::from_il_instance(
13894 <Self as ::unity::SystemObject>::as_instance(self),
13895 );
13896 {
13897 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
13898 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
13899 panic!(
13900 "unity: virtual slot {}
13901 out of range (vtable len {}
13902) on the runtime class behind {}
13903 (method `{}
13904`)",
13905 31usize,
13906 __vt.len(),
13907 <MapUnitCommandMenu_VisionDeleteMenuItem as ::unity::ClassIdentity>::NAME,
13908 "get_DeployMode",
13909 )
13910 });
13911 let __inner: extern "C" fn(
13912 MapUnitCommandMenu_VisionDeleteMenuItem,
13913 ::unity::OptionalMethod,
13914 ) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode = ::core::mem::transmute(__vi.method_ptr);
13915 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
13916 __inner(__receiver, __mi)
13917 }
13918 }
13919 }
13920 #[doc = "`GetName()` overload"]
13921 fn get_name(self) -> ::unity::Il2CppString {
13922 unsafe {
13923 let __receiver = <MapUnitCommandMenu_VisionDeleteMenuItem as ::unity::FromIlInstance>::from_il_instance(
13924 <Self as ::unity::SystemObject>::as_instance(self),
13925 );
13926 {
13927 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
13928 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
13929 panic!(
13930 "unity: virtual slot {}
13931 out of range (vtable len {}
13932) on the runtime class behind {}
13933 (method `{}
13934`)",
13935 4usize,
13936 __vt.len(),
13937 <MapUnitCommandMenu_VisionDeleteMenuItem as ::unity::ClassIdentity>::NAME,
13938 "GetName",
13939 )
13940 });
13941 let __inner: extern "C" fn(MapUnitCommandMenu_VisionDeleteMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
13942 ::core::mem::transmute(__vi.method_ptr);
13943 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
13944 __inner(__receiver, __mi)
13945 }
13946 }
13947 }
13948 #[doc = "`GetCommandHelp()` overload"]
13949 fn get_command_help(self) -> ::unity::Il2CppString {
13950 unsafe {
13951 let __receiver = <MapUnitCommandMenu_VisionDeleteMenuItem as ::unity::FromIlInstance>::from_il_instance(
13952 <Self as ::unity::SystemObject>::as_instance(self),
13953 );
13954 {
13955 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
13956 let __vi = *__vt.get(34usize).unwrap_or_else(|| {
13957 panic!(
13958 "unity: virtual slot {}
13959 out of range (vtable len {}
13960) on the runtime class behind {}
13961 (method `{}
13962`)",
13963 34usize,
13964 __vt.len(),
13965 <MapUnitCommandMenu_VisionDeleteMenuItem as ::unity::ClassIdentity>::NAME,
13966 "GetCommandHelp",
13967 )
13968 });
13969 let __inner: extern "C" fn(MapUnitCommandMenu_VisionDeleteMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
13970 ::core::mem::transmute(__vi.method_ptr);
13971 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
13972 __inner(__receiver, __mi)
13973 }
13974 }
13975 }
13976 #[doc = "`GetMapAttribute()` overload"]
13977 fn get_map_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
13978 unsafe {
13979 let __receiver = <MapUnitCommandMenu_VisionDeleteMenuItem as ::unity::FromIlInstance>::from_il_instance(
13980 <Self as ::unity::SystemObject>::as_instance(self),
13981 );
13982 {
13983 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
13984 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
13985 panic!(
13986 "unity: virtual slot {}
13987 out of range (vtable len {}
13988) on the runtime class behind {}
13989 (method `{}
13990`)",
13991 29usize,
13992 __vt.len(),
13993 <MapUnitCommandMenu_VisionDeleteMenuItem as ::unity::ClassIdentity>::NAME,
13994 "GetMapAttribute",
13995 )
13996 });
13997 let __inner: extern "C" fn(
13998 MapUnitCommandMenu_VisionDeleteMenuItem,
13999 ::unity::OptionalMethod,
14000 ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
14001 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
14002 __inner(__receiver, __mi)
14003 }
14004 }
14005 }
14006 #[doc = "`.ctor()` overload"]
14007 fn ctor(self) -> () {
14008 unsafe {
14009 let __receiver = <MapUnitCommandMenu_VisionDeleteMenuItem as ::unity::FromIlInstance>::from_il_instance(
14010 <Self as ::unity::SystemObject>::as_instance(self),
14011 );
14012 ::unity::il2cpp_call!((::unity::module_base()+0x1e52f00usize)as*mut u8,();
14013(MapUnitCommandMenu_VisionDeleteMenuItem)__receiver)
14014 }
14015 }
14016}
14017
14018#[cfg(feature = "app-mapunitcommandmenu")]
14019impl<__T: IMapUnitCommandMenu_VisionDeleteMenuItem> IMapUnitCommandMenu_VisionDeleteMenuItemMethods for __T {}
14020
14021#[cfg(feature = "app-mapunitcommandmenu")]
14022impl MapUnitCommandMenu_VisionDeleteMenuItem {
14023 pub fn get_flag_id_method_info() -> &'static ::unity::il2cpp::MethodInfo {
14024 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
14025 }
14026
14027 pub fn get_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
14028 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
14029 }
14030
14031 pub fn get_active_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
14032 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
14033 }
14034
14035 pub fn get_deploy_mode_method_info() -> &'static ::unity::il2cpp::MethodInfo {
14036 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
14037 }
14038
14039 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
14040 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
14041 }
14042
14043 pub fn get_command_help_method_info() -> &'static ::unity::il2cpp::MethodInfo {
14044 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
14045 }
14046
14047 pub fn get_map_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
14048 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
14049 }
14050
14051 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
14052 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
14053 }
14054}
14055
14056#[cfg(feature = "app-mapunitcommandmenu")]
14057impl MapUnitCommandMenu_VisionDeleteMenuItem {
14058 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_VisionDeleteMenuItem`'s own `get_FlagID`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
14059 pub unsafe fn get_flag_id(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
14060 let __mi = Self::get_flag_id_method_info();
14061 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
14062 __inner(this.into(), ::core::option::Option::None)
14063 }
14064
14065 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_VisionDeleteMenuItem`'s own `get_Mind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
14066 pub unsafe fn get_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
14067 let __mi = Self::get_mind_method_info();
14068 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
14069 ::core::mem::transmute(__mi.method_ptr);
14070 __inner(this.into(), ::core::option::Option::None)
14071 }
14072
14073 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_VisionDeleteMenuItem`'s own `get_ActiveMind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
14074 pub unsafe fn get_active_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
14075 let __mi = Self::get_active_mind_method_info();
14076 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
14077 ::core::mem::transmute(__mi.method_ptr);
14078 __inner(this.into(), ::core::option::Option::None)
14079 }
14080
14081 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_VisionDeleteMenuItem`'s own `get_DeployMode`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
14082 pub unsafe fn get_deploy_mode(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
14083 let __mi = Self::get_deploy_mode_method_info();
14084 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode =
14085 ::core::mem::transmute(__mi.method_ptr);
14086 __inner(this.into(), ::core::option::Option::None)
14087 }
14088
14089 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_VisionDeleteMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
14090 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
14091 let __mi = Self::get_name_method_info();
14092 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
14093 __inner(this.into(), ::core::option::Option::None)
14094 }
14095
14096 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_VisionDeleteMenuItem`'s own `GetCommandHelp`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
14097 pub unsafe fn get_command_help(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
14098 let __mi = Self::get_command_help_method_info();
14099 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
14100 __inner(this.into(), ::core::option::Option::None)
14101 }
14102
14103 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_VisionDeleteMenuItem`'s own `GetMapAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
14104 pub unsafe fn get_map_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
14105 let __mi = Self::get_map_attribute_method_info();
14106 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
14107 ::core::mem::transmute(__mi.method_ptr);
14108 __inner(this.into(), ::core::option::Option::None)
14109 }
14110}
14111
14112#[cfg(feature = "app-mapunitcommandmenu")]
14113impl MapUnitCommandMenu_VisionDeleteMenuItem {
14114 #[doc = "`.ctor()` — no args"]
14115 pub fn new() -> Self {
14116 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
14117 panic!(
14118 "{}
14119::{}
14120 failed to instantiate",
14121 ::core::stringify!(MapUnitCommandMenu_VisionDeleteMenuItem),
14122 ::core::stringify!(new),
14123 )
14124 });
14125 <Self as IMapUnitCommandMenu_VisionDeleteMenuItemMethods>::ctor(this);
14126 this
14127 }
14128}
14129
14130#[cfg(feature = "app-mapunitcommandmenu")]
14131pub trait IMapUnitCommandMenu_EngageSummonMenuItemMethods: IMapUnitCommandMenu_EngageSummonMenuItem {
14132 #[doc = "`get_Mind()` overload"]
14133 fn get_mind(self) -> crate::app::mapmind::MapMind_Type {
14134 unsafe {
14135 let __receiver = <MapUnitCommandMenu_EngageSummonMenuItem as ::unity::FromIlInstance>::from_il_instance(
14136 <Self as ::unity::SystemObject>::as_instance(self),
14137 );
14138 {
14139 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
14140 let __vi = *__vt.get(37usize).unwrap_or_else(|| {
14141 panic!(
14142 "unity: virtual slot {}
14143 out of range (vtable len {}
14144) on the runtime class behind {}
14145 (method `{}
14146`)",
14147 37usize,
14148 __vt.len(),
14149 <MapUnitCommandMenu_EngageSummonMenuItem as ::unity::ClassIdentity>::NAME,
14150 "get_Mind",
14151 )
14152 });
14153 let __inner: extern "C" fn(MapUnitCommandMenu_EngageSummonMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
14154 ::core::mem::transmute(__vi.method_ptr);
14155 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
14156 __inner(__receiver, __mi)
14157 }
14158 }
14159 }
14160 #[doc = "`get_ActionMask()` overload"]
14161 fn get_action_mask(self) -> crate::app::maptarget::MapTarget_ActionMask {
14162 unsafe {
14163 let __receiver = <MapUnitCommandMenu_EngageSummonMenuItem as ::unity::FromIlInstance>::from_il_instance(
14164 <Self as ::unity::SystemObject>::as_instance(self),
14165 );
14166 {
14167 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
14168 let __vi = *__vt.get(38usize).unwrap_or_else(|| {
14169 panic!(
14170 "unity: virtual slot {}
14171 out of range (vtable len {}
14172) on the runtime class behind {}
14173 (method `{}
14174`)",
14175 38usize,
14176 __vt.len(),
14177 <MapUnitCommandMenu_EngageSummonMenuItem as ::unity::ClassIdentity>::NAME,
14178 "get_ActionMask",
14179 )
14180 });
14181 let __inner: extern "C" fn(
14182 MapUnitCommandMenu_EngageSummonMenuItem,
14183 ::unity::OptionalMethod,
14184 ) -> crate::app::maptarget::MapTarget_ActionMask = ::core::mem::transmute(__vi.method_ptr);
14185 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
14186 __inner(__receiver, __mi)
14187 }
14188 }
14189 }
14190 #[doc = "`get_Label()` overload"]
14191 fn get_label(self) -> crate::app::mapsequencehuman::MapSequenceHuman_Label {
14192 unsafe {
14193 let __receiver = <MapUnitCommandMenu_EngageSummonMenuItem as ::unity::FromIlInstance>::from_il_instance(
14194 <Self as ::unity::SystemObject>::as_instance(self),
14195 );
14196 {
14197 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
14198 let __vi = *__vt.get(36usize).unwrap_or_else(|| {
14199 panic!(
14200 "unity: virtual slot {}
14201 out of range (vtable len {}
14202) on the runtime class behind {}
14203 (method `{}
14204`)",
14205 36usize,
14206 __vt.len(),
14207 <MapUnitCommandMenu_EngageSummonMenuItem as ::unity::ClassIdentity>::NAME,
14208 "get_Label",
14209 )
14210 });
14211 let __inner: extern "C" fn(
14212 MapUnitCommandMenu_EngageSummonMenuItem,
14213 ::unity::OptionalMethod,
14214 ) -> crate::app::mapsequencehuman::MapSequenceHuman_Label = ::core::mem::transmute(__vi.method_ptr);
14215 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
14216 __inner(__receiver, __mi)
14217 }
14218 }
14219 }
14220 #[doc = "`get_ActiveMind()` overload"]
14221 fn get_active_mind(self) -> crate::app::mapmind::MapMind_Type {
14222 unsafe {
14223 let __receiver = <MapUnitCommandMenu_EngageSummonMenuItem as ::unity::FromIlInstance>::from_il_instance(
14224 <Self as ::unity::SystemObject>::as_instance(self),
14225 );
14226 {
14227 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
14228 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
14229 panic!(
14230 "unity: virtual slot {}
14231 out of range (vtable len {}
14232) on the runtime class behind {}
14233 (method `{}
14234`)",
14235 30usize,
14236 __vt.len(),
14237 <MapUnitCommandMenu_EngageSummonMenuItem as ::unity::ClassIdentity>::NAME,
14238 "get_ActiveMind",
14239 )
14240 });
14241 let __inner: extern "C" fn(MapUnitCommandMenu_EngageSummonMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
14242 ::core::mem::transmute(__vi.method_ptr);
14243 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
14244 __inner(__receiver, __mi)
14245 }
14246 }
14247 }
14248 #[doc = "`get_DeployMode()` overload"]
14249 fn get_deploy_mode(self) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
14250 unsafe {
14251 let __receiver = <MapUnitCommandMenu_EngageSummonMenuItem as ::unity::FromIlInstance>::from_il_instance(
14252 <Self as ::unity::SystemObject>::as_instance(self),
14253 );
14254 {
14255 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
14256 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
14257 panic!(
14258 "unity: virtual slot {}
14259 out of range (vtable len {}
14260) on the runtime class behind {}
14261 (method `{}
14262`)",
14263 31usize,
14264 __vt.len(),
14265 <MapUnitCommandMenu_EngageSummonMenuItem as ::unity::ClassIdentity>::NAME,
14266 "get_DeployMode",
14267 )
14268 });
14269 let __inner: extern "C" fn(
14270 MapUnitCommandMenu_EngageSummonMenuItem,
14271 ::unity::OptionalMethod,
14272 ) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode = ::core::mem::transmute(__vi.method_ptr);
14273 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
14274 __inner(__receiver, __mi)
14275 }
14276 }
14277 }
14278 #[doc = "`get_IsForecast()` overload"]
14279 fn get_is_forecast(self) -> bool {
14280 unsafe {
14281 let __receiver = <MapUnitCommandMenu_EngageSummonMenuItem as ::unity::FromIlInstance>::from_il_instance(
14282 <Self as ::unity::SystemObject>::as_instance(self),
14283 );
14284 {
14285 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
14286 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
14287 panic!(
14288 "unity: virtual slot {}
14289 out of range (vtable len {}
14290) on the runtime class behind {}
14291 (method `{}
14292`)",
14293 33usize,
14294 __vt.len(),
14295 <MapUnitCommandMenu_EngageSummonMenuItem as ::unity::ClassIdentity>::NAME,
14296 "get_IsForecast",
14297 )
14298 });
14299 let __inner: extern "C" fn(MapUnitCommandMenu_EngageSummonMenuItem, ::unity::OptionalMethod) -> bool =
14300 ::core::mem::transmute(__vi.method_ptr);
14301 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
14302 __inner(__receiver, __mi)
14303 }
14304 }
14305 }
14306 #[doc = "`.ctor()` overload"]
14307 fn ctor(self) -> () {
14308 unsafe {
14309 let __receiver = <MapUnitCommandMenu_EngageSummonMenuItem as ::unity::FromIlInstance>::from_il_instance(
14310 <Self as ::unity::SystemObject>::as_instance(self),
14311 );
14312 ::unity::il2cpp_call!((::unity::module_base()+0x1e4e380usize)as*mut u8,();
14313(MapUnitCommandMenu_EngageSummonMenuItem)__receiver)
14314 }
14315 }
14316}
14317
14318#[cfg(feature = "app-mapunitcommandmenu")]
14319impl<__T: IMapUnitCommandMenu_EngageSummonMenuItem> IMapUnitCommandMenu_EngageSummonMenuItemMethods for __T {}
14320
14321#[cfg(feature = "app-mapunitcommandmenu")]
14322impl MapUnitCommandMenu_EngageSummonMenuItem {
14323 pub fn get_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
14324 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
14325 }
14326
14327 pub fn get_action_mask_method_info() -> &'static ::unity::il2cpp::MethodInfo {
14328 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
14329 }
14330
14331 pub fn get_label_method_info() -> &'static ::unity::il2cpp::MethodInfo {
14332 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
14333 }
14334
14335 pub fn get_active_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
14336 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
14337 }
14338
14339 pub fn get_deploy_mode_method_info() -> &'static ::unity::il2cpp::MethodInfo {
14340 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
14341 }
14342
14343 pub fn get_is_forecast_method_info() -> &'static ::unity::il2cpp::MethodInfo {
14344 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
14345 }
14346
14347 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
14348 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
14349 }
14350}
14351
14352#[cfg(feature = "app-mapunitcommandmenu")]
14353impl MapUnitCommandMenu_EngageSummonMenuItem {
14354 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageSummonMenuItem`'s own `get_Mind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
14355 pub unsafe fn get_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
14356 let __mi = Self::get_mind_method_info();
14357 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
14358 ::core::mem::transmute(__mi.method_ptr);
14359 __inner(this.into(), ::core::option::Option::None)
14360 }
14361
14362 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageSummonMenuItem`'s own `get_ActionMask`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
14363 pub unsafe fn get_action_mask(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::maptarget::MapTarget_ActionMask {
14364 let __mi = Self::get_action_mask_method_info();
14365 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::maptarget::MapTarget_ActionMask =
14366 ::core::mem::transmute(__mi.method_ptr);
14367 __inner(this.into(), ::core::option::Option::None)
14368 }
14369
14370 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageSummonMenuItem`'s own `get_Label`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
14371 pub unsafe fn get_label(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapsequencehuman::MapSequenceHuman_Label {
14372 let __mi = Self::get_label_method_info();
14373 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapsequencehuman::MapSequenceHuman_Label =
14374 ::core::mem::transmute(__mi.method_ptr);
14375 __inner(this.into(), ::core::option::Option::None)
14376 }
14377
14378 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageSummonMenuItem`'s own `get_ActiveMind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
14379 pub unsafe fn get_active_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
14380 let __mi = Self::get_active_mind_method_info();
14381 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
14382 ::core::mem::transmute(__mi.method_ptr);
14383 __inner(this.into(), ::core::option::Option::None)
14384 }
14385
14386 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageSummonMenuItem`'s own `get_DeployMode`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
14387 pub unsafe fn get_deploy_mode(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
14388 let __mi = Self::get_deploy_mode_method_info();
14389 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode =
14390 ::core::mem::transmute(__mi.method_ptr);
14391 __inner(this.into(), ::core::option::Option::None)
14392 }
14393
14394 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EngageSummonMenuItem`'s own `get_IsForecast`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
14395 pub unsafe fn get_is_forecast(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
14396 let __mi = Self::get_is_forecast_method_info();
14397 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
14398 __inner(this.into(), ::core::option::Option::None)
14399 }
14400}
14401
14402#[cfg(feature = "app-mapunitcommandmenu")]
14403impl MapUnitCommandMenu_EngageSummonMenuItem {
14404 #[doc = "`.ctor()` — no args"]
14405 pub fn new() -> Self {
14406 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
14407 panic!(
14408 "{}
14409::{}
14410 failed to instantiate",
14411 ::core::stringify!(MapUnitCommandMenu_EngageSummonMenuItem),
14412 ::core::stringify!(new),
14413 )
14414 });
14415 <Self as IMapUnitCommandMenu_EngageSummonMenuItemMethods>::ctor(this);
14416 this
14417 }
14418}
14419
14420#[cfg(feature = "app-mapunitcommandmenu")]
14421pub trait IMapUnitCommandMenu_JumpToMenuItemMethods: IMapUnitCommandMenu_JumpToMenuItem {
14422 #[doc = "`get_Label()` overload"]
14423 fn get_label(self) -> crate::app::mapsequencehuman::MapSequenceHuman_Label {
14424 unsafe {
14425 let __receiver =
14426 <MapUnitCommandMenu_JumpToMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
14427 {
14428 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
14429 let __vi = *__vt.get(36usize).unwrap_or_else(|| {
14430 panic!(
14431 "unity: virtual slot {}
14432 out of range (vtable len {}
14433) on the runtime class behind {}
14434 (method `{}
14435`)",
14436 36usize,
14437 __vt.len(),
14438 <MapUnitCommandMenu_JumpToMenuItem as ::unity::ClassIdentity>::NAME,
14439 "get_Label",
14440 )
14441 });
14442 let __inner: extern "C" fn(
14443 MapUnitCommandMenu_JumpToMenuItem,
14444 ::unity::OptionalMethod,
14445 ) -> crate::app::mapsequencehuman::MapSequenceHuman_Label = ::core::mem::transmute(__vi.method_ptr);
14446 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
14447 __inner(__receiver, __mi)
14448 }
14449 }
14450 }
14451 #[doc = "`JumpSequence()` overload"]
14452 fn jump_sequence(self) -> () {
14453 unsafe {
14454 let __receiver =
14455 <MapUnitCommandMenu_JumpToMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
14456 ::unity::il2cpp_call!((::unity::module_base()+0x1e48aa0usize)as*mut u8,();
14457(MapUnitCommandMenu_JumpToMenuItem)__receiver)
14458 }
14459 }
14460 #[doc = "`ACall()` overload"]
14461 fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
14462 unsafe {
14463 let __receiver =
14464 <MapUnitCommandMenu_JumpToMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
14465 {
14466 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
14467 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
14468 panic!(
14469 "unity: virtual slot {}
14470 out of range (vtable len {}
14471) on the runtime class behind {}
14472 (method `{}
14473`)",
14474 18usize,
14475 __vt.len(),
14476 <MapUnitCommandMenu_JumpToMenuItem as ::unity::ClassIdentity>::NAME,
14477 "ACall",
14478 )
14479 });
14480 let __inner: extern "C" fn(MapUnitCommandMenu_JumpToMenuItem, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
14481 ::core::mem::transmute(__vi.method_ptr);
14482 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
14483 __inner(__receiver, __mi)
14484 }
14485 }
14486 }
14487 #[doc = "`Enumerate(crate::app::mapmind::MapMind_Type, crate::app::maptarget::MapTarget_ActionMask)` overload"]
14488 fn enumerate(
14489 self,
14490 mind: impl ::core::convert::Into<crate::app::mapmind::MapMind_Type>,
14491 action_mask: impl ::core::convert::Into<crate::app::maptarget::MapTarget_ActionMask>,
14492 ) -> i32 {
14493 unsafe {
14494 let __receiver =
14495 <MapUnitCommandMenu_JumpToMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
14496 ::unity::il2cpp_call!((::unity::module_base()+0x1e48660usize)as*mut u8,i32;
14497(MapUnitCommandMenu_JumpToMenuItem)__receiver,(crate::app::mapmind::MapMind_Type)::core::convert::Into::into(mind),(crate::app::maptarget::MapTarget_ActionMask)::core::convert::Into::into(action_mask))
14498 }
14499 }
14500 #[doc = "`.ctor()` overload"]
14501 fn ctor(self) -> () {
14502 unsafe {
14503 let __receiver =
14504 <MapUnitCommandMenu_JumpToMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
14505 ::unity::il2cpp_call!((::unity::module_base()+0x1e48af0usize)as*mut u8,();
14506(MapUnitCommandMenu_JumpToMenuItem)__receiver)
14507 }
14508 }
14509}
14510
14511#[cfg(feature = "app-mapunitcommandmenu")]
14512impl<__T: IMapUnitCommandMenu_JumpToMenuItem> IMapUnitCommandMenu_JumpToMenuItemMethods for __T {}
14513
14514#[cfg(feature = "app-mapunitcommandmenu")]
14515impl MapUnitCommandMenu_JumpToMenuItem {
14516 pub fn get_label_method_info() -> &'static ::unity::il2cpp::MethodInfo {
14517 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
14518 }
14519
14520 pub fn jump_sequence_method_info() -> &'static ::unity::il2cpp::MethodInfo {
14521 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
14522 }
14523
14524 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
14525 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
14526 }
14527
14528 pub fn enumerate_method_info() -> &'static ::unity::il2cpp::MethodInfo {
14529 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
14530 }
14531
14532 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
14533 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
14534 }
14535}
14536
14537#[cfg(feature = "app-mapunitcommandmenu")]
14538impl MapUnitCommandMenu_JumpToMenuItem {
14539 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_JumpToMenuItem`'s own `get_Label`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
14540 pub unsafe fn get_label(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapsequencehuman::MapSequenceHuman_Label {
14541 let __mi = Self::get_label_method_info();
14542 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapsequencehuman::MapSequenceHuman_Label =
14543 ::core::mem::transmute(__mi.method_ptr);
14544 __inner(this.into(), ::core::option::Option::None)
14545 }
14546
14547 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_JumpToMenuItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
14548 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
14549 let __mi = Self::a_call_method_info();
14550 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
14551 ::core::mem::transmute(__mi.method_ptr);
14552 __inner(this.into(), ::core::option::Option::None)
14553 }
14554}
14555
14556#[cfg(feature = "app-mapunitcommandmenu")]
14557impl MapUnitCommandMenu_JumpToMenuItem {
14558 #[doc = "`.ctor()` — no args"]
14559 pub fn new() -> Self {
14560 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
14561 panic!(
14562 "{}
14563::{}
14564 failed to instantiate",
14565 ::core::stringify!(MapUnitCommandMenu_JumpToMenuItem),
14566 ::core::stringify!(new),
14567 )
14568 });
14569 <Self as IMapUnitCommandMenu_JumpToMenuItemMethods>::ctor(this);
14570 this
14571 }
14572}
14573
14574#[cfg(feature = "app-mapunitcommandmenu")]
14575pub trait IMapUnitCommandMenu_ContractMenuItemMethods: IMapUnitCommandMenu_ContractMenuItem {
14576 #[doc = "`get_FlagID()` overload"]
14577 fn get_flag_id(self) -> ::unity::Il2CppString {
14578 unsafe {
14579 let __receiver = <MapUnitCommandMenu_ContractMenuItem as ::unity::FromIlInstance>::from_il_instance(
14580 <Self as ::unity::SystemObject>::as_instance(self),
14581 );
14582 {
14583 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
14584 let __vi = *__vt.get(27usize).unwrap_or_else(|| {
14585 panic!(
14586 "unity: virtual slot {}
14587 out of range (vtable len {}
14588) on the runtime class behind {}
14589 (method `{}
14590`)",
14591 27usize,
14592 __vt.len(),
14593 <MapUnitCommandMenu_ContractMenuItem as ::unity::ClassIdentity>::NAME,
14594 "get_FlagID",
14595 )
14596 });
14597 let __inner: extern "C" fn(MapUnitCommandMenu_ContractMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
14598 ::core::mem::transmute(__vi.method_ptr);
14599 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
14600 __inner(__receiver, __mi)
14601 }
14602 }
14603 }
14604 #[doc = "`get_Mind()` overload"]
14605 fn get_mind(self) -> crate::app::mapmind::MapMind_Type {
14606 unsafe {
14607 let __receiver = <MapUnitCommandMenu_ContractMenuItem as ::unity::FromIlInstance>::from_il_instance(
14608 <Self as ::unity::SystemObject>::as_instance(self),
14609 );
14610 {
14611 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
14612 let __vi = *__vt.get(36usize).unwrap_or_else(|| {
14613 panic!(
14614 "unity: virtual slot {}
14615 out of range (vtable len {}
14616) on the runtime class behind {}
14617 (method `{}
14618`)",
14619 36usize,
14620 __vt.len(),
14621 <MapUnitCommandMenu_ContractMenuItem as ::unity::ClassIdentity>::NAME,
14622 "get_Mind",
14623 )
14624 });
14625 let __inner: extern "C" fn(MapUnitCommandMenu_ContractMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
14626 ::core::mem::transmute(__vi.method_ptr);
14627 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
14628 __inner(__receiver, __mi)
14629 }
14630 }
14631 }
14632 #[doc = "`get_ActiveMind()` overload"]
14633 fn get_active_mind(self) -> crate::app::mapmind::MapMind_Type {
14634 unsafe {
14635 let __receiver = <MapUnitCommandMenu_ContractMenuItem as ::unity::FromIlInstance>::from_il_instance(
14636 <Self as ::unity::SystemObject>::as_instance(self),
14637 );
14638 {
14639 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
14640 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
14641 panic!(
14642 "unity: virtual slot {}
14643 out of range (vtable len {}
14644) on the runtime class behind {}
14645 (method `{}
14646`)",
14647 30usize,
14648 __vt.len(),
14649 <MapUnitCommandMenu_ContractMenuItem as ::unity::ClassIdentity>::NAME,
14650 "get_ActiveMind",
14651 )
14652 });
14653 let __inner: extern "C" fn(MapUnitCommandMenu_ContractMenuItem, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
14654 ::core::mem::transmute(__vi.method_ptr);
14655 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
14656 __inner(__receiver, __mi)
14657 }
14658 }
14659 }
14660 #[doc = "`get_DeployMode()` overload"]
14661 fn get_deploy_mode(self) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
14662 unsafe {
14663 let __receiver = <MapUnitCommandMenu_ContractMenuItem as ::unity::FromIlInstance>::from_il_instance(
14664 <Self as ::unity::SystemObject>::as_instance(self),
14665 );
14666 {
14667 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
14668 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
14669 panic!(
14670 "unity: virtual slot {}
14671 out of range (vtable len {}
14672) on the runtime class behind {}
14673 (method `{}
14674`)",
14675 31usize,
14676 __vt.len(),
14677 <MapUnitCommandMenu_ContractMenuItem as ::unity::ClassIdentity>::NAME,
14678 "get_DeployMode",
14679 )
14680 });
14681 let __inner: extern "C" fn(
14682 MapUnitCommandMenu_ContractMenuItem,
14683 ::unity::OptionalMethod,
14684 ) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode = ::core::mem::transmute(__vi.method_ptr);
14685 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
14686 __inner(__receiver, __mi)
14687 }
14688 }
14689 }
14690 #[doc = "`.ctor()` overload"]
14691 fn ctor(self) -> () {
14692 unsafe {
14693 let __receiver = <MapUnitCommandMenu_ContractMenuItem as ::unity::FromIlInstance>::from_il_instance(
14694 <Self as ::unity::SystemObject>::as_instance(self),
14695 );
14696 ::unity::il2cpp_call!((::unity::module_base()+0x1e4b890usize)as*mut u8,();
14697(MapUnitCommandMenu_ContractMenuItem)__receiver)
14698 }
14699 }
14700 #[doc = "`GetName()` overload"]
14701 fn get_name(self) -> ::unity::Il2CppString {
14702 unsafe {
14703 let __receiver = <MapUnitCommandMenu_ContractMenuItem as ::unity::FromIlInstance>::from_il_instance(
14704 <Self as ::unity::SystemObject>::as_instance(self),
14705 );
14706 {
14707 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
14708 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
14709 panic!(
14710 "unity: virtual slot {}
14711 out of range (vtable len {}
14712) on the runtime class behind {}
14713 (method `{}
14714`)",
14715 4usize,
14716 __vt.len(),
14717 <MapUnitCommandMenu_ContractMenuItem as ::unity::ClassIdentity>::NAME,
14718 "GetName",
14719 )
14720 });
14721 let __inner: extern "C" fn(MapUnitCommandMenu_ContractMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
14722 ::core::mem::transmute(__vi.method_ptr);
14723 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
14724 __inner(__receiver, __mi)
14725 }
14726 }
14727 }
14728 #[doc = "`GetCommandHelp()` overload"]
14729 fn get_command_help(self) -> ::unity::Il2CppString {
14730 unsafe {
14731 let __receiver = <MapUnitCommandMenu_ContractMenuItem as ::unity::FromIlInstance>::from_il_instance(
14732 <Self as ::unity::SystemObject>::as_instance(self),
14733 );
14734 {
14735 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
14736 let __vi = *__vt.get(34usize).unwrap_or_else(|| {
14737 panic!(
14738 "unity: virtual slot {}
14739 out of range (vtable len {}
14740) on the runtime class behind {}
14741 (method `{}
14742`)",
14743 34usize,
14744 __vt.len(),
14745 <MapUnitCommandMenu_ContractMenuItem as ::unity::ClassIdentity>::NAME,
14746 "GetCommandHelp",
14747 )
14748 });
14749 let __inner: extern "C" fn(MapUnitCommandMenu_ContractMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
14750 ::core::mem::transmute(__vi.method_ptr);
14751 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
14752 __inner(__receiver, __mi)
14753 }
14754 }
14755 }
14756 #[doc = "`GetMapAttribute()` overload"]
14757 fn get_map_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
14758 unsafe {
14759 let __receiver = <MapUnitCommandMenu_ContractMenuItem as ::unity::FromIlInstance>::from_il_instance(
14760 <Self as ::unity::SystemObject>::as_instance(self),
14761 );
14762 {
14763 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
14764 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
14765 panic!(
14766 "unity: virtual slot {}
14767 out of range (vtable len {}
14768) on the runtime class behind {}
14769 (method `{}
14770`)",
14771 29usize,
14772 __vt.len(),
14773 <MapUnitCommandMenu_ContractMenuItem as ::unity::ClassIdentity>::NAME,
14774 "GetMapAttribute",
14775 )
14776 });
14777 let __inner: extern "C" fn(
14778 MapUnitCommandMenu_ContractMenuItem,
14779 ::unity::OptionalMethod,
14780 ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
14781 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
14782 __inner(__receiver, __mi)
14783 }
14784 }
14785 }
14786}
14787
14788#[cfg(feature = "app-mapunitcommandmenu")]
14789impl<__T: IMapUnitCommandMenu_ContractMenuItem> IMapUnitCommandMenu_ContractMenuItemMethods for __T {}
14790
14791#[cfg(feature = "app-mapunitcommandmenu")]
14792impl MapUnitCommandMenu_ContractMenuItem {
14793 pub fn get_flag_id_method_info() -> &'static ::unity::il2cpp::MethodInfo {
14794 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
14795 }
14796
14797 pub fn get_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
14798 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
14799 }
14800
14801 pub fn get_active_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
14802 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
14803 }
14804
14805 pub fn get_deploy_mode_method_info() -> &'static ::unity::il2cpp::MethodInfo {
14806 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
14807 }
14808
14809 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
14810 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
14811 }
14812
14813 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
14814 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
14815 }
14816
14817 pub fn get_command_help_method_info() -> &'static ::unity::il2cpp::MethodInfo {
14818 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
14819 }
14820
14821 pub fn get_map_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
14822 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
14823 }
14824}
14825
14826#[cfg(feature = "app-mapunitcommandmenu")]
14827impl MapUnitCommandMenu_ContractMenuItem {
14828 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_ContractMenuItem`'s own `get_FlagID`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
14829 pub unsafe fn get_flag_id(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
14830 let __mi = Self::get_flag_id_method_info();
14831 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
14832 __inner(this.into(), ::core::option::Option::None)
14833 }
14834
14835 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_ContractMenuItem`'s own `get_Mind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
14836 pub unsafe fn get_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
14837 let __mi = Self::get_mind_method_info();
14838 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
14839 ::core::mem::transmute(__mi.method_ptr);
14840 __inner(this.into(), ::core::option::Option::None)
14841 }
14842
14843 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_ContractMenuItem`'s own `get_ActiveMind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
14844 pub unsafe fn get_active_mind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapmind::MapMind_Type {
14845 let __mi = Self::get_active_mind_method_info();
14846 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapmind::MapMind_Type =
14847 ::core::mem::transmute(__mi.method_ptr);
14848 __inner(this.into(), ::core::option::Option::None)
14849 }
14850
14851 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_ContractMenuItem`'s own `get_DeployMode`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
14852 pub unsafe fn get_deploy_mode(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode {
14853 let __mi = Self::get_deploy_mode_method_info();
14854 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mappaneldeploy::MapPanelDeploy_Mode =
14855 ::core::mem::transmute(__mi.method_ptr);
14856 __inner(this.into(), ::core::option::Option::None)
14857 }
14858
14859 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_ContractMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
14860 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
14861 let __mi = Self::get_name_method_info();
14862 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
14863 __inner(this.into(), ::core::option::Option::None)
14864 }
14865
14866 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_ContractMenuItem`'s own `GetCommandHelp`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
14867 pub unsafe fn get_command_help(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
14868 let __mi = Self::get_command_help_method_info();
14869 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
14870 __inner(this.into(), ::core::option::Option::None)
14871 }
14872
14873 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_ContractMenuItem`'s own `GetMapAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
14874 pub unsafe fn get_map_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
14875 let __mi = Self::get_map_attribute_method_info();
14876 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
14877 ::core::mem::transmute(__mi.method_ptr);
14878 __inner(this.into(), ::core::option::Option::None)
14879 }
14880}
14881
14882#[cfg(feature = "app-mapunitcommandmenu")]
14883impl MapUnitCommandMenu_ContractMenuItem {
14884 #[doc = "`.ctor()` — no args"]
14885 pub fn new() -> Self {
14886 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
14887 panic!(
14888 "{}
14889::{}
14890 failed to instantiate",
14891 ::core::stringify!(MapUnitCommandMenu_ContractMenuItem),
14892 ::core::stringify!(new),
14893 )
14894 });
14895 <Self as IMapUnitCommandMenu_ContractMenuItemMethods>::ctor(this);
14896 this
14897 }
14898}
14899
14900#[cfg(feature = "app-mapunitcommandmenu")]
14901pub trait IMapUnitCommandMenu_EnchantWeaponMenuItemMethods: IMapUnitCommandMenu_EnchantWeaponMenuItem {
14902 #[doc = "`get_Label()` overload"]
14903 fn get_label(self) -> crate::app::mapsequencehuman::MapSequenceHuman_Label {
14904 unsafe {
14905 let __receiver = <MapUnitCommandMenu_EnchantWeaponMenuItem as ::unity::FromIlInstance>::from_il_instance(
14906 <Self as ::unity::SystemObject>::as_instance(self),
14907 );
14908 {
14909 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
14910 let __vi = *__vt.get(36usize).unwrap_or_else(|| {
14911 panic!(
14912 "unity: virtual slot {}
14913 out of range (vtable len {}
14914) on the runtime class behind {}
14915 (method `{}
14916`)",
14917 36usize,
14918 __vt.len(),
14919 <MapUnitCommandMenu_EnchantWeaponMenuItem as ::unity::ClassIdentity>::NAME,
14920 "get_Label",
14921 )
14922 });
14923 let __inner: extern "C" fn(
14924 MapUnitCommandMenu_EnchantWeaponMenuItem,
14925 ::unity::OptionalMethod,
14926 ) -> crate::app::mapsequencehuman::MapSequenceHuman_Label = ::core::mem::transmute(__vi.method_ptr);
14927 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
14928 __inner(__receiver, __mi)
14929 }
14930 }
14931 }
14932 #[doc = "`get_IsWeapon()` overload"]
14933 fn get_is_weapon(self) -> bool {
14934 unsafe {
14935 let __receiver = <MapUnitCommandMenu_EnchantWeaponMenuItem as ::unity::FromIlInstance>::from_il_instance(
14936 <Self as ::unity::SystemObject>::as_instance(self),
14937 );
14938 {
14939 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
14940 let __vi = *__vt.get(37usize).unwrap_or_else(|| {
14941 panic!(
14942 "unity: virtual slot {}
14943 out of range (vtable len {}
14944) on the runtime class behind {}
14945 (method `{}
14946`)",
14947 37usize,
14948 __vt.len(),
14949 <MapUnitCommandMenu_EnchantWeaponMenuItem as ::unity::ClassIdentity>::NAME,
14950 "get_IsWeapon",
14951 )
14952 });
14953 let __inner: extern "C" fn(MapUnitCommandMenu_EnchantWeaponMenuItem, ::unity::OptionalMethod) -> bool =
14954 ::core::mem::transmute(__vi.method_ptr);
14955 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
14956 __inner(__receiver, __mi)
14957 }
14958 }
14959 }
14960 #[doc = "`GetName()` overload"]
14961 fn get_name(self) -> ::unity::Il2CppString {
14962 unsafe {
14963 let __receiver = <MapUnitCommandMenu_EnchantWeaponMenuItem as ::unity::FromIlInstance>::from_il_instance(
14964 <Self as ::unity::SystemObject>::as_instance(self),
14965 );
14966 {
14967 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
14968 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
14969 panic!(
14970 "unity: virtual slot {}
14971 out of range (vtable len {}
14972) on the runtime class behind {}
14973 (method `{}
14974`)",
14975 4usize,
14976 __vt.len(),
14977 <MapUnitCommandMenu_EnchantWeaponMenuItem as ::unity::ClassIdentity>::NAME,
14978 "GetName",
14979 )
14980 });
14981 let __inner: extern "C" fn(MapUnitCommandMenu_EnchantWeaponMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
14982 ::core::mem::transmute(__vi.method_ptr);
14983 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
14984 __inner(__receiver, __mi)
14985 }
14986 }
14987 }
14988 #[doc = "`GetCommandHelp()` overload"]
14989 fn get_command_help(self) -> ::unity::Il2CppString {
14990 unsafe {
14991 let __receiver = <MapUnitCommandMenu_EnchantWeaponMenuItem as ::unity::FromIlInstance>::from_il_instance(
14992 <Self as ::unity::SystemObject>::as_instance(self),
14993 );
14994 {
14995 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
14996 let __vi = *__vt.get(34usize).unwrap_or_else(|| {
14997 panic!(
14998 "unity: virtual slot {}
14999 out of range (vtable len {}
15000) on the runtime class behind {}
15001 (method `{}
15002`)",
15003 34usize,
15004 __vt.len(),
15005 <MapUnitCommandMenu_EnchantWeaponMenuItem as ::unity::ClassIdentity>::NAME,
15006 "GetCommandHelp",
15007 )
15008 });
15009 let __inner: extern "C" fn(MapUnitCommandMenu_EnchantWeaponMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
15010 ::core::mem::transmute(__vi.method_ptr);
15011 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
15012 __inner(__receiver, __mi)
15013 }
15014 }
15015 }
15016 #[doc = "`.ctor()` overload"]
15017 fn ctor(self) -> () {
15018 unsafe {
15019 let __receiver = <MapUnitCommandMenu_EnchantWeaponMenuItem as ::unity::FromIlInstance>::from_il_instance(
15020 <Self as ::unity::SystemObject>::as_instance(self),
15021 );
15022 ::unity::il2cpp_call!((::unity::module_base()+0x1e4d180usize)as*mut u8,();
15023(MapUnitCommandMenu_EnchantWeaponMenuItem)__receiver)
15024 }
15025 }
15026}
15027
15028#[cfg(feature = "app-mapunitcommandmenu")]
15029impl<__T: IMapUnitCommandMenu_EnchantWeaponMenuItem> IMapUnitCommandMenu_EnchantWeaponMenuItemMethods for __T {}
15030
15031#[cfg(feature = "app-mapunitcommandmenu")]
15032impl MapUnitCommandMenu_EnchantWeaponMenuItem {
15033 pub fn get_label_method_info() -> &'static ::unity::il2cpp::MethodInfo {
15034 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
15035 }
15036
15037 pub fn get_is_weapon_method_info() -> &'static ::unity::il2cpp::MethodInfo {
15038 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
15039 }
15040
15041 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
15042 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
15043 }
15044
15045 pub fn get_command_help_method_info() -> &'static ::unity::il2cpp::MethodInfo {
15046 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
15047 }
15048
15049 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
15050 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
15051 }
15052}
15053
15054#[cfg(feature = "app-mapunitcommandmenu")]
15055impl MapUnitCommandMenu_EnchantWeaponMenuItem {
15056 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EnchantWeaponMenuItem`'s own `get_Label`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
15057 pub unsafe fn get_label(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::mapsequencehuman::MapSequenceHuman_Label {
15058 let __mi = Self::get_label_method_info();
15059 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::mapsequencehuman::MapSequenceHuman_Label =
15060 ::core::mem::transmute(__mi.method_ptr);
15061 __inner(this.into(), ::core::option::Option::None)
15062 }
15063
15064 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EnchantWeaponMenuItem`'s own `get_IsWeapon`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
15065 pub unsafe fn get_is_weapon(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
15066 let __mi = Self::get_is_weapon_method_info();
15067 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
15068 __inner(this.into(), ::core::option::Option::None)
15069 }
15070
15071 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EnchantWeaponMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
15072 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
15073 let __mi = Self::get_name_method_info();
15074 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
15075 __inner(this.into(), ::core::option::Option::None)
15076 }
15077
15078 #[doc = "Direct (non-virtual) call to `MapUnitCommandMenu_EnchantWeaponMenuItem`'s own `GetCommandHelp`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
15079 pub unsafe fn get_command_help(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
15080 let __mi = Self::get_command_help_method_info();
15081 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
15082 __inner(this.into(), ::core::option::Option::None)
15083 }
15084}
15085
15086#[cfg(feature = "app-mapunitcommandmenu")]
15087impl MapUnitCommandMenu_EnchantWeaponMenuItem {
15088 #[doc = "`.ctor()` — no args"]
15089 pub fn new() -> Self {
15090 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
15091 panic!(
15092 "{}
15093::{}
15094 failed to instantiate",
15095 ::core::stringify!(MapUnitCommandMenu_EnchantWeaponMenuItem),
15096 ::core::stringify!(new),
15097 )
15098 });
15099 <Self as IMapUnitCommandMenu_EnchantWeaponMenuItemMethods>::ctor(this);
15100 this
15101 }
15102}
15103
15104#[cfg(feature = "app-mapunitcommandmenu")]
15105#[doc(hidden)]
15106pub mod prelude {
15107 pub use super::{
15108 IMapUnitCommandMenu, IMapUnitCommandMenuMethods, IMapUnitCommandMenu_AttackMenuItem, IMapUnitCommandMenu_AttackMenuItemMethods,
15109 IMapUnitCommandMenu_BaseMenuItem, IMapUnitCommandMenu_BaseMenuItemMethods, IMapUnitCommandMenu_BreakdownBaseMenuItem,
15110 IMapUnitCommandMenu_BreakdownBaseMenuItemMethods, IMapUnitCommandMenu_BreakdownEnemyMenuItem,
15111 IMapUnitCommandMenu_BreakdownEnemyMenuItemMethods, IMapUnitCommandMenu_BreakdownMenuItem, IMapUnitCommandMenu_BreakdownMenuItemMethods,
15112 IMapUnitCommandMenu_BreakthroughMenuItem, IMapUnitCommandMenu_BreakthroughMenuItemMethods, IMapUnitCommandMenu_CannonMenuItem,
15113 IMapUnitCommandMenu_CannonMenuItemMethods, IMapUnitCommandMenu_CommandSkillMenuItem, IMapUnitCommandMenu_CommandSkillMenuItemMethods,
15114 IMapUnitCommandMenu_ContractMenuItem, IMapUnitCommandMenu_ContractMenuItemMethods, IMapUnitCommandMenu_DanceMenuItem,
15115 IMapUnitCommandMenu_DanceMenuItemMethods, IMapUnitCommandMenu_DestroyMenuItem, IMapUnitCommandMenu_DestroyMenuItemMethods,
15116 IMapUnitCommandMenu_DoorMenuItem, IMapUnitCommandMenu_DoorMenuItemMethods, IMapUnitCommandMenu_EnchantItemMenuItem,
15117 IMapUnitCommandMenu_EnchantItemMenuItemMethods, IMapUnitCommandMenu_EnchantMenuItem, IMapUnitCommandMenu_EnchantMenuItemMethods,
15118 IMapUnitCommandMenu_EnchantWeaponMenuItem, IMapUnitCommandMenu_EnchantWeaponMenuItemMethods, IMapUnitCommandMenu_EngageActionBaseMenuItem,
15119 IMapUnitCommandMenu_EngageActionBaseMenuItemMethods, IMapUnitCommandMenu_EngageAttackMenuItem,
15120 IMapUnitCommandMenu_EngageAttackMenuItemMethods, IMapUnitCommandMenu_EngageChargeMenuItem, IMapUnitCommandMenu_EngageChargeMenuItemMethods,
15121 IMapUnitCommandMenu_EngageCommandMenuItem, IMapUnitCommandMenu_EngageCommandMenuItemMethods, IMapUnitCommandMenu_EngageLinkMenuItem,
15122 IMapUnitCommandMenu_EngageLinkMenuItemMethods, IMapUnitCommandMenu_EngageRewarpMenuItem, IMapUnitCommandMenu_EngageRewarpMenuItemMethods,
15123 IMapUnitCommandMenu_EngageRodMenuItem, IMapUnitCommandMenu_EngageRodMenuItemMethods, IMapUnitCommandMenu_EngageStartMenuItem,
15124 IMapUnitCommandMenu_EngageStartMenuItemMethods, IMapUnitCommandMenu_EngageSummonMenuItem, IMapUnitCommandMenu_EngageSummonMenuItemMethods,
15125 IMapUnitCommandMenu_EngageWaitMenuItem, IMapUnitCommandMenu_EngageWaitMenuItemMethods, IMapUnitCommandMenu_EscapeMenuItem,
15126 IMapUnitCommandMenu_EscapeMenuItemMethods, IMapUnitCommandMenu_FixedMenuItem, IMapUnitCommandMenu_FixedMenuItemMethods,
15127 IMapUnitCommandMenu_GodChangeMenuItem, IMapUnitCommandMenu_GodChangeMenuItemMethods, IMapUnitCommandMenu_GuardMenuItem,
15128 IMapUnitCommandMenu_GuardMenuItemMethods, IMapUnitCommandMenu_ItemMenuItem, IMapUnitCommandMenu_ItemMenuItemMethods,
15129 IMapUnitCommandMenu_JumpToMenuItem, IMapUnitCommandMenu_JumpToMenuItemMethods, IMapUnitCommandMenu_NoCancelFixedMenuItem,
15130 IMapUnitCommandMenu_NoCancelFixedMenuItemMethods, IMapUnitCommandMenu_NoCancelMagicMenuItem,
15131 IMapUnitCommandMenu_NoCancelMagicMenuItemMethods, IMapUnitCommandMenu_OverlapSkillMenuItem, IMapUnitCommandMenu_OverlapSkillMenuItemMethods,
15132 IMapUnitCommandMenu_RodMenuItem, IMapUnitCommandMenu_RodMenuItemMethods, IMapUnitCommandMenu_SkillAttackMenuItem,
15133 IMapUnitCommandMenu_SkillAttackMenuItemMethods, IMapUnitCommandMenu_SubMenuItem, IMapUnitCommandMenu_SubMenuItemMethods,
15134 IMapUnitCommandMenu_TalkMenuItem, IMapUnitCommandMenu_TalkMenuItemMethods, IMapUnitCommandMenu_TargetSelectMenuItem,
15135 IMapUnitCommandMenu_TargetSelectMenuItemMethods, IMapUnitCommandMenu_TorchOnMenuItem, IMapUnitCommandMenu_TorchOnMenuItemMethods,
15136 IMapUnitCommandMenu_TradeMenuItem, IMapUnitCommandMenu_TradeMenuItemMethods, IMapUnitCommandMenu_TransporterMenuItem,
15137 IMapUnitCommandMenu_TransporterMenuItemMethods, IMapUnitCommandMenu_TreasureBoxMenuItem, IMapUnitCommandMenu_TreasureBoxMenuItemMethods,
15138 IMapUnitCommandMenu_VisionCreateMenuItem, IMapUnitCommandMenu_VisionCreateMenuItemMethods, IMapUnitCommandMenu_VisionDeleteMenuItem,
15139 IMapUnitCommandMenu_VisionDeleteMenuItemMethods, IMapUnitCommandMenu_VisitMenuItem, IMapUnitCommandMenu_VisitMenuItemMethods,
15140 MapUnitCommandMenu, MapUnitCommandMenu_AttackMenuItem, MapUnitCommandMenu_BaseMenuItem, MapUnitCommandMenu_BreakdownBaseMenuItem,
15141 MapUnitCommandMenu_BreakdownEnemyMenuItem, MapUnitCommandMenu_BreakdownMenuItem, MapUnitCommandMenu_BreakthroughMenuItem,
15142 MapUnitCommandMenu_CannonMenuItem, MapUnitCommandMenu_CannonMenuItem_States, MapUnitCommandMenu_CommandSkillMenuItem,
15143 MapUnitCommandMenu_ContractMenuItem, MapUnitCommandMenu_DanceMenuItem, MapUnitCommandMenu_DestroyMenuItem, MapUnitCommandMenu_DoorMenuItem,
15144 MapUnitCommandMenu_EnchantItemMenuItem, MapUnitCommandMenu_EnchantMenuItem, MapUnitCommandMenu_EnchantWeaponMenuItem,
15145 MapUnitCommandMenu_EngageActionBaseMenuItem, MapUnitCommandMenu_EngageAttackMenuItem, MapUnitCommandMenu_EngageChargeMenuItem,
15146 MapUnitCommandMenu_EngageCommandMenuItem, MapUnitCommandMenu_EngageLinkMenuItem, MapUnitCommandMenu_EngageRewarpMenuItem,
15147 MapUnitCommandMenu_EngageRodMenuItem, MapUnitCommandMenu_EngageStartMenuItem, MapUnitCommandMenu_EngageSummonMenuItem,
15148 MapUnitCommandMenu_EngageWaitMenuItem, MapUnitCommandMenu_EscapeMenuItem, MapUnitCommandMenu_FixedMenuItem,
15149 MapUnitCommandMenu_GodChangeMenuItem, MapUnitCommandMenu_GuardMenuItem, MapUnitCommandMenu_ItemMenuItem, MapUnitCommandMenu_JumpToMenuItem,
15150 MapUnitCommandMenu_NoCancelFixedMenuItem, MapUnitCommandMenu_NoCancelMagicMenuItem, MapUnitCommandMenu_OverlapSkillMenuItem,
15151 MapUnitCommandMenu_RodMenuItem, MapUnitCommandMenu_SkillAttackMenuItem, MapUnitCommandMenu_SubMenuItem, MapUnitCommandMenu_TalkMenuItem,
15152 MapUnitCommandMenu_TargetSelectMenuItem, MapUnitCommandMenu_TorchOnMenuItem, MapUnitCommandMenu_TradeMenuItem,
15153 MapUnitCommandMenu_TransporterMenuItem, MapUnitCommandMenu_TreasureBoxMenuItem, MapUnitCommandMenu_VisionCreateMenuItem,
15154 MapUnitCommandMenu_VisionDeleteMenuItem, MapUnitCommandMenu_VisitMenuItem,
15155 };
15156 #[cfg(feature = "app-basicmenu")]
15157 pub use crate::app::basicmenu::IBasicMenuMethods;
15158 #[cfg(feature = "app-basicmenuitem")]
15159 pub use crate::app::basicmenuitem::IBasicMenuItemMethods;
15160 #[cfg(feature = "app-mapbasicmenu")]
15161 pub use crate::app::mapbasicmenu::IMapBasicMenuMethods;
15162 #[cfg(feature = "app-mapbasicmenuitem")]
15163 pub use crate::app::mapbasicmenuitem::IMapBasicMenuItemMethods;
15164 #[cfg(feature = "app-procinst")]
15165 pub use crate::app::procinst::IProcInstMethods;
15166 #[cfg(feature = "system-object")]
15167 pub use crate::system::object::IObjectMethods;
15168 #[cfg(feature = "system-enum")]
15169 pub use crate::system::r#enum::IEnumMethods;
15170 #[cfg(feature = "system-valuetype")]
15171 pub use crate::system::valuetype::IValueTypeMethods;
15172 pub use crate::{
15173 app::{
15174 basicmenu::IBasicMenu, basicmenuitem::IBasicMenuItem, mapbasicmenu::IMapBasicMenu, mapbasicmenuitem::IMapBasicMenuItem,
15175 procinst::IProcInst,
15176 },
15177 system::{object::IObject, r#enum::IEnum, valuetype::IValueType},
15178 };
15179}