1#[cfg(feature = "app-aithink-types")]
4mod __types {
5 #[allow(unused_imports)] use ::unity::prelude::*;
6
7 use super::*;
8 use crate::{
9 app::{
10 bitfield32::{BitField32, IBitField32},
11 bitfieldcommon::{BitFieldCommon, IBitFieldCommon},
12 mapimagecore_1::{IMapImageCore_1, MapImageCore_1},
13 mapimageindex::{IMapImageIndex, MapImageIndex},
14 },
15 system::{
16 delegate::{Delegate, IDelegate},
17 multicastdelegate::{IMulticastDelegate, MulticastDelegate},
18 object::{IObject, Object},
19 r#enum::{Enum, IEnum},
20 valuetype::{IValueType, ValueType},
21 },
22 };
23
24 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/aithink/AIThink_EnchantThink_Desc.md"))]
25 #[repr(C)]
26 #[derive(::core::clone::Clone, ::core::marker::Copy)]
27 pub struct AIThink_EnchantThink_Desc {
28 pub priority: i32,
29 pub calc_unit_score: crate::app::aithink::AIThink_EnchantThink_CalcUnitScoreFunction,
30 }
31 impl ::unity::ClassIdentity for AIThink_EnchantThink_Desc {
32 const NAME: &'static str = "AIThink.EnchantThink.Desc";
33 const NAMESPACE: &'static str = "App";
34
35 fn class() -> ::unity::Class {
36 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
37 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
38 }
39 }
40 impl ::unity::IlType for AIThink_EnchantThink_Desc {
41 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
42 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
43 }
44 }
45
46 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/aithink/AIThink_AttackFlag.md"))]
47 #[::unity::class(namespace = "App", name = "AIThink.AttackFlag")]
48 #[parent(crate::app::bitfield32::BitField32)]
49 pub struct AIThink_AttackFlag {
50 #[static_field]
51 #[rename(name = "Side")]
52 pub side: i32,
53 #[static_field]
54 #[rename(name = "Nearest")]
55 pub nearest: i32,
56 #[static_field]
57 #[rename(name = "AheadIgnore")]
58 pub ahead_ignore: i32,
59 #[static_field]
60 #[rename(name = "__IgnoreSilent")]
61 pub ignore_silent: i32,
62 #[static_field]
63 #[rename(name = "__DestroyTargetCastleOffset")]
64 pub destroy_target_castle_offset: i32,
65 #[static_field]
66 #[rename(name = "ScoreExpectation")]
67 pub score_expectation: i32,
68 #[static_field]
69 #[rename(name = "InterferenceHighMagic")]
70 pub interference_high_magic: i32,
71 #[static_field]
72 #[rename(name = "InterferenceLowMagic")]
73 pub interference_low_magic: i32,
74 #[static_field]
75 #[rename(name = "Break")]
76 pub r#break: i32,
77 #[static_field]
78 #[rename(name = "Chain")]
79 pub chain: i32,
80 #[static_field]
81 #[rename(name = "MagicOnly")]
82 pub magic_only: i32,
83 #[static_field]
84 #[rename(name = "ChainAttackCount")]
85 pub chain_attack_count: i32,
86 #[static_field]
87 #[rename(name = "PierceMultiple")]
88 pub pierce_multiple: i32,
89 #[static_field]
90 #[rename(name = "InterferenceRange")]
91 pub interference_range: i32,
92 #[static_field]
93 #[rename(name = "EquipSkillMultiple")]
94 pub equip_skill_multiple: i32,
95 }
96
97 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/aithink/AIThink_EngageWaitRangeScore.md"))]
98 #[repr(C)]
99 #[derive(::core::clone::Clone, ::core::marker::Copy)]
100 pub struct AIThink_EngageWaitRangeScore {
101 pub score: u32,
102 pub x: i32,
103 pub z: i32,
104 }
105 impl ::unity::ClassIdentity for AIThink_EngageWaitRangeScore {
106 const NAME: &'static str = "AIThink.EngageWaitRangeScore";
107 const NAMESPACE: &'static str = "App";
108
109 fn class() -> ::unity::Class {
110 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
111 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
112 }
113 }
114 impl ::unity::IlType for AIThink_EngageWaitRangeScore {
115 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
116 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
117 }
118 }
119
120 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/aithink/AIThink_OverlapSkills.md"))]
121 #[repr(C)]
122 #[derive(::core::clone::Clone, ::core::marker::Copy)]
123 pub struct AIThink_OverlapSkills {
124 pub m_skills: ::unity::Array<crate::app::skilldata::SkillData>,
125 pub m_count: i32,
126 }
127 impl ::unity::ClassIdentity for AIThink_OverlapSkills {
128 const NAME: &'static str = "AIThink.OverlapSkills";
129 const NAMESPACE: &'static str = "App";
130
131 fn class() -> ::unity::Class {
132 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
133 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
134 }
135 }
136 impl ::unity::IlType for AIThink_OverlapSkills {
137 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
138 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
139 }
140 }
141
142 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/aithink/AIThink_MoveFlag.md"))]
143 #[::unity::class(namespace = "App", name = "AIThink.MoveFlag")]
144 #[parent(crate::app::bitfield32::BitField32)]
145 pub struct AIThink_MoveFlag {
146 #[static_field]
147 #[rename(name = "Through")]
148 pub through: i32,
149 #[static_field]
150 #[rename(name = "Break")]
151 pub r#break: i32,
152 #[static_field]
153 #[rename(name = "Back")]
154 pub back: i32,
155 #[static_field]
156 #[rename(name = "Slow")]
157 pub slow: i32,
158 #[static_field]
159 #[rename(name = "Door")]
160 pub door: i32,
161 #[static_field]
162 #[rename(name = "Ignore")]
163 pub ignore: i32,
164 #[static_field]
165 #[rename(name = "IgnoreIceTile")]
166 pub ignore_ice_tile: i32,
167 }
168
169 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/aithink/AIThink_EnchantThink_Kinds.md"))]
170 #[repr(C)]
171 #[derive(::core::clone::Clone, ::core::marker::Copy, ::core::fmt::Debug, ::core::cmp::PartialEq, ::core::cmp::Eq)]
172 pub struct AIThink_EnchantThink_Kinds {
173 pub value: u8,
174 }
175 impl ::unity::ClassIdentity for AIThink_EnchantThink_Kinds {
176 const NAME: &'static str = "AIThink.EnchantThink.Kinds";
177 const NAMESPACE: &'static str = "App";
178
179 fn class() -> ::unity::Class {
180 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
181 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
182 }
183 }
184 impl ::unity::IlType for AIThink_EnchantThink_Kinds {
185 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
186 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
187 }
188 }
189 impl AIThink_EnchantThink_Kinds {
190 pub fn rest() -> Self {
191 Self { value: 0 }
192 }
193
194 pub fn engage_count() -> Self {
195 Self { value: 1 }
196 }
197
198 pub fn efficacy_morph() -> Self {
199 Self { value: 2 }
200 }
201
202 pub fn sight() -> Self {
203 Self { value: 3 }
204 }
205
206 pub fn no_chain_attack() -> Self {
207 Self { value: 4 }
208 }
209
210 pub fn weight_zero() -> Self {
211 Self { value: 5 }
212 }
213
214 pub fn no_silence() -> Self {
215 Self { value: 6 }
216 }
217
218 pub fn reflect_physics() -> Self {
219 Self { value: 7 }
220 }
221
222 pub fn reflect_magic() -> Self {
223 Self { value: 8 }
224 }
225
226 pub fn no_break() -> Self {
227 Self { value: 9 }
228 }
229
230 pub fn no_freeze() -> Self {
231 Self { value: 10 }
232 }
233
234 pub fn no_damage() -> Self {
235 Self { value: 11 }
236 }
237
238 pub fn hold_out() -> Self {
239 Self { value: 12 }
240 }
241
242 pub fn weapon() -> Self {
243 Self { value: 13 }
244 }
245
246 pub fn max() -> Self {
247 Self { value: 14 }
248 }
249 }
250
251 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/aithink/AIThink_EnchantThink.md"))]
252 #[::unity::class(namespace = "App", name = "AIThink.EnchantThink")]
253 #[parent(crate::system::object::Object)]
254 pub struct AIThink_EnchantThink {
255 #[offset(16)]
256 #[rename(name = "m_Unit")]
257 pub m_unit: crate::app::unit::Unit,
258 #[offset(24)]
259 #[rename(name = "m_ItemInfos")]
260 pub m_item_infos: ::unity::Array<crate::app::aithink::AIThink_EnchantThink_ItemInfo>,
261 #[offset(32)]
262 #[rename(name = "m_ItemInfoCount")]
263 pub m_item_info_count: i32,
264 #[offset(40)]
265 #[rename(name = "m_UnitScores")]
266 pub m_unit_scores: crate::system::collections::generic::dictionary_2::Dictionary_2<i32, u8>,
267 #[offset(48)]
268 #[rename(name = "m_UnitSurroundings")]
269 pub m_unit_surroundings:
270 crate::system::collections::generic::dictionary_2::Dictionary_2<i32, crate::app::aithink::AIThink_EnchantThink_SurroundingInfo>,
271 #[static_field]
272 #[rename(name = "Descs")]
273 pub descs: ::unity::Array<crate::app::aithink::AIThink_EnchantThink_Desc>,
274 }
275
276 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/aithink/AIThink_EntrustAttackTarget.md"))]
277 #[repr(C)]
278 #[derive(::core::clone::Clone, ::core::marker::Copy)]
279 pub struct AIThink_EntrustAttackTarget {
280 pub eas_result: crate::app::aithink::AIThink_EntrustAttackScoreResult,
281 }
282 impl ::unity::ClassIdentity for AIThink_EntrustAttackTarget {
283 const NAME: &'static str = "AIThink.EntrustAttackTarget";
284 const NAMESPACE: &'static str = "App";
285
286 fn class() -> ::unity::Class {
287 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
288 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
289 }
290 }
291 impl ::unity::IlType for AIThink_EntrustAttackTarget {
292 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
293 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
294 }
295 }
296
297 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/aithink/AIThink_EnchantThink_SurroundingInfo.md"))]
298 #[repr(C)]
299 #[derive(::core::clone::Clone, ::core::marker::Copy)]
300 pub struct AIThink_EnchantThink_SurroundingInfo {
301 pub m_value: u32,
302 }
303 impl ::unity::ClassIdentity for AIThink_EnchantThink_SurroundingInfo {
304 const NAME: &'static str = "AIThink.EnchantThink.SurroundingInfo";
305 const NAMESPACE: &'static str = "App";
306
307 fn class() -> ::unity::Class {
308 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
309 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
310 }
311 }
312 impl ::unity::IlType for AIThink_EnchantThink_SurroundingInfo {
313 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
314 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
315 }
316 }
317 impl AIThink_EnchantThink_SurroundingInfo {
318 #[inline]
319 pub fn count_mask() -> u32 {
320 static OFFSET: ::std::sync::OnceLock<usize> = ::std::sync::OnceLock::new();
321 let __offset = ::unity::cached_field_offset_static::<Self>(&OFFSET, "CountMask");
322 ::unity::static_field_get_value_at_offset(<Self as ::unity::ClassIdentity>::class(), __offset)
323 }
324
325 #[inline]
326 pub fn set_count_mask(value: u32) {
327 static OFFSET: ::std::sync::OnceLock<usize> = ::std::sync::OnceLock::new();
328 let __offset = ::unity::cached_field_offset_static::<Self>(&OFFSET, "CountMask");
329 ::unity::static_field_set_value_at_offset(<Self as ::unity::ClassIdentity>::class(), __offset, value);
330 }
331
332 #[inline]
333 pub fn morph_shift() -> i32 {
334 static OFFSET: ::std::sync::OnceLock<usize> = ::std::sync::OnceLock::new();
335 let __offset = ::unity::cached_field_offset_static::<Self>(&OFFSET, "MorphShift");
336 ::unity::static_field_get_value_at_offset(<Self as ::unity::ClassIdentity>::class(), __offset)
337 }
338
339 #[inline]
340 pub fn set_morph_shift(value: i32) {
341 static OFFSET: ::std::sync::OnceLock<usize> = ::std::sync::OnceLock::new();
342 let __offset = ::unity::cached_field_offset_static::<Self>(&OFFSET, "MorphShift");
343 ::unity::static_field_set_value_at_offset(<Self as ::unity::ClassIdentity>::class(), __offset, value);
344 }
345
346 #[inline]
347 pub fn physical_attack_shift() -> i32 {
348 static OFFSET: ::std::sync::OnceLock<usize> = ::std::sync::OnceLock::new();
349 let __offset = ::unity::cached_field_offset_static::<Self>(&OFFSET, "PhysicalAttackShift");
350 ::unity::static_field_get_value_at_offset(<Self as ::unity::ClassIdentity>::class(), __offset)
351 }
352
353 #[inline]
354 pub fn set_physical_attack_shift(value: i32) {
355 static OFFSET: ::std::sync::OnceLock<usize> = ::std::sync::OnceLock::new();
356 let __offset = ::unity::cached_field_offset_static::<Self>(&OFFSET, "PhysicalAttackShift");
357 ::unity::static_field_set_value_at_offset(<Self as ::unity::ClassIdentity>::class(), __offset, value);
358 }
359
360 #[inline]
361 pub fn magic_attack_shift() -> i32 {
362 static OFFSET: ::std::sync::OnceLock<usize> = ::std::sync::OnceLock::new();
363 let __offset = ::unity::cached_field_offset_static::<Self>(&OFFSET, "MagicAttackShift");
364 ::unity::static_field_get_value_at_offset(<Self as ::unity::ClassIdentity>::class(), __offset)
365 }
366
367 #[inline]
368 pub fn set_magic_attack_shift(value: i32) {
369 static OFFSET: ::std::sync::OnceLock<usize> = ::std::sync::OnceLock::new();
370 let __offset = ::unity::cached_field_offset_static::<Self>(&OFFSET, "MagicAttackShift");
371 ::unity::static_field_set_value_at_offset(<Self as ::unity::ClassIdentity>::class(), __offset, value);
372 }
373
374 #[inline]
375 pub fn chain_attack_shift() -> i32 {
376 static OFFSET: ::std::sync::OnceLock<usize> = ::std::sync::OnceLock::new();
377 let __offset = ::unity::cached_field_offset_static::<Self>(&OFFSET, "ChainAttackShift");
378 ::unity::static_field_get_value_at_offset(<Self as ::unity::ClassIdentity>::class(), __offset)
379 }
380
381 #[inline]
382 pub fn set_chain_attack_shift(value: i32) {
383 static OFFSET: ::std::sync::OnceLock<usize> = ::std::sync::OnceLock::new();
384 let __offset = ::unity::cached_field_offset_static::<Self>(&OFFSET, "ChainAttackShift");
385 ::unity::static_field_set_value_at_offset(<Self as ::unity::ClassIdentity>::class(), __offset, value);
386 }
387
388 #[inline]
389 pub fn break_shift() -> i32 {
390 static OFFSET: ::std::sync::OnceLock<usize> = ::std::sync::OnceLock::new();
391 let __offset = ::unity::cached_field_offset_static::<Self>(&OFFSET, "BreakShift");
392 ::unity::static_field_get_value_at_offset(<Self as ::unity::ClassIdentity>::class(), __offset)
393 }
394
395 #[inline]
396 pub fn set_break_shift(value: i32) {
397 static OFFSET: ::std::sync::OnceLock<usize> = ::std::sync::OnceLock::new();
398 let __offset = ::unity::cached_field_offset_static::<Self>(&OFFSET, "BreakShift");
399 ::unity::static_field_set_value_at_offset(<Self as ::unity::ClassIdentity>::class(), __offset, value);
400 }
401
402 #[inline]
403 pub fn silence_shift() -> i32 {
404 static OFFSET: ::std::sync::OnceLock<usize> = ::std::sync::OnceLock::new();
405 let __offset = ::unity::cached_field_offset_static::<Self>(&OFFSET, "SilenceShift");
406 ::unity::static_field_get_value_at_offset(<Self as ::unity::ClassIdentity>::class(), __offset)
407 }
408
409 #[inline]
410 pub fn set_silence_shift(value: i32) {
411 static OFFSET: ::std::sync::OnceLock<usize> = ::std::sync::OnceLock::new();
412 let __offset = ::unity::cached_field_offset_static::<Self>(&OFFSET, "SilenceShift");
413 ::unity::static_field_set_value_at_offset(<Self as ::unity::ClassIdentity>::class(), __offset, value);
414 }
415
416 #[inline]
417 pub fn freeze_shift() -> i32 {
418 static OFFSET: ::std::sync::OnceLock<usize> = ::std::sync::OnceLock::new();
419 let __offset = ::unity::cached_field_offset_static::<Self>(&OFFSET, "FreezeShift");
420 ::unity::static_field_get_value_at_offset(<Self as ::unity::ClassIdentity>::class(), __offset)
421 }
422
423 #[inline]
424 pub fn set_freeze_shift(value: i32) {
425 static OFFSET: ::std::sync::OnceLock<usize> = ::std::sync::OnceLock::new();
426 let __offset = ::unity::cached_field_offset_static::<Self>(&OFFSET, "FreezeShift");
427 ::unity::static_field_set_value_at_offset(<Self as ::unity::ClassIdentity>::class(), __offset, value);
428 }
429 }
430
431 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/aithink/AIThink_EnchantThink_DMPTResult.md"))]
432 #[repr(C)]
433 #[derive(::core::clone::Clone, ::core::marker::Copy)]
434 pub struct AIThink_EnchantThink_DMPTResult {
435 pub move_x: i32,
436 pub move_z: i32,
437 pub target_index: i32,
438 pub target_x: i32,
439 pub target_z: i32,
440 }
441 impl ::unity::ClassIdentity for AIThink_EnchantThink_DMPTResult {
442 const NAME: &'static str = "AIThink.EnchantThink.DMPTResult";
443 const NAMESPACE: &'static str = "App";
444
445 fn class() -> ::unity::Class {
446 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
447 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
448 }
449 }
450 impl ::unity::IlType for AIThink_EnchantThink_DMPTResult {
451 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
452 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
453 }
454 }
455
456 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/aithink/AIThink_EntrustAttackScoreResult.md"))]
457 #[repr(C)]
458 #[derive(::core::clone::Clone, ::core::marker::Copy)]
459 pub struct AIThink_EntrustAttackScoreResult {}
460 impl ::unity::ClassIdentity for AIThink_EntrustAttackScoreResult {
461 const NAME: &'static str = "AIThink.EntrustAttackScoreResult";
462 const NAMESPACE: &'static str = "App";
463
464 fn class() -> ::unity::Class {
465 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
466 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
467 }
468 }
469 impl ::unity::IlType for AIThink_EntrustAttackScoreResult {
470 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
471 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
472 }
473 }
474
475 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/aithink/AIThink_HealRodScoreImplResult.md"))]
476 #[repr(C)]
477 #[derive(::core::clone::Clone, ::core::marker::Copy)]
478 pub struct AIThink_HealRodScoreImplResult {}
479 impl ::unity::ClassIdentity for AIThink_HealRodScoreImplResult {
480 const NAME: &'static str = "AIThink.HealRodScoreImplResult";
481 const NAMESPACE: &'static str = "App";
482
483 fn class() -> ::unity::Class {
484 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
485 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
486 }
487 }
488 impl ::unity::IlType for AIThink_HealRodScoreImplResult {
489 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
490 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
491 }
492 }
493
494 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/aithink/AIThink_InterferenceScoreResult.md"))]
495 #[repr(C)]
496 #[derive(::core::clone::Clone, ::core::marker::Copy)]
497 pub struct AIThink_InterferenceScoreResult {}
498 impl ::unity::ClassIdentity for AIThink_InterferenceScoreResult {
499 const NAME: &'static str = "AIThink.InterferenceScoreResult";
500 const NAMESPACE: &'static str = "App";
501
502 fn class() -> ::unity::Class {
503 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
504 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
505 }
506 }
507 impl ::unity::IlType for AIThink_InterferenceScoreResult {
508 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
509 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
510 }
511 }
512
513 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/aithink/AIThink_RescueRodScoreResult.md"))]
514 #[repr(C)]
515 #[derive(::core::clone::Clone, ::core::marker::Copy)]
516 pub struct AIThink_RescueRodScoreResult {}
517 impl ::unity::ClassIdentity for AIThink_RescueRodScoreResult {
518 const NAME: &'static str = "AIThink.RescueRodScoreResult";
519 const NAMESPACE: &'static str = "App";
520
521 fn class() -> ::unity::Class {
522 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
523 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
524 }
525 }
526 impl ::unity::IlType for AIThink_RescueRodScoreResult {
527 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
528 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
529 }
530 }
531
532 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/aithink/AIThink_WarpRodTarget.md"))]
533 #[repr(C)]
534 #[derive(::core::clone::Clone, ::core::marker::Copy)]
535 pub struct AIThink_WarpRodTarget {
536 pub wre_result: crate::app::aithink::AIThink_WarpRodEvaluationResult,
537 }
538 impl ::unity::ClassIdentity for AIThink_WarpRodTarget {
539 const NAME: &'static str = "AIThink.WarpRodTarget";
540 const NAMESPACE: &'static str = "App";
541
542 fn class() -> ::unity::Class {
543 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
544 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
545 }
546 }
547 impl ::unity::IlType for AIThink_WarpRodTarget {
548 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
549 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
550 }
551 }
552
553 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/aithink/AIThink_ActionFunc.md"))]
554 #[::unity::class(namespace = "App", name = "AIThink.ActionFunc")]
555 #[parent(crate::system::multicastdelegate::MulticastDelegate)]
556 pub struct AIThink_ActionFunc {}
557
558 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/aithink/AIThink_HealRodPositionResult.md"))]
559 #[repr(C)]
560 #[derive(::core::clone::Clone, ::core::marker::Copy)]
561 pub struct AIThink_HealRodPositionResult {}
562 impl ::unity::ClassIdentity for AIThink_HealRodPositionResult {
563 const NAME: &'static str = "AIThink.HealRodPositionResult";
564 const NAMESPACE: &'static str = "App";
565
566 fn class() -> ::unity::Class {
567 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
568 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
569 }
570 }
571 impl ::unity::IlType for AIThink_HealRodPositionResult {
572 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
573 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
574 }
575 }
576
577 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/aithink/AIThink_UncontrollAttackScoreResult.md"))]
578 #[repr(C)]
579 #[derive(::core::clone::Clone, ::core::marker::Copy)]
580 pub struct AIThink_UncontrollAttackScoreResult {}
581 impl ::unity::ClassIdentity for AIThink_UncontrollAttackScoreResult {
582 const NAME: &'static str = "AIThink.UncontrollAttackScoreResult";
583 const NAMESPACE: &'static str = "App";
584
585 fn class() -> ::unity::Class {
586 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
587 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
588 }
589 }
590 impl ::unity::IlType for AIThink_UncontrollAttackScoreResult {
591 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
592 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
593 }
594 }
595
596 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/aithink/AIThink_AttackPositionResult.md"))]
597 #[repr(C)]
598 #[derive(::core::clone::Clone, ::core::marker::Copy)]
599 pub struct AIThink_AttackPositionResult {}
600 impl ::unity::ClassIdentity for AIThink_AttackPositionResult {
601 const NAME: &'static str = "AIThink.AttackPositionResult";
602 const NAMESPACE: &'static str = "App";
603
604 fn class() -> ::unity::Class {
605 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
606 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
607 }
608 }
609 impl ::unity::IlType for AIThink_AttackPositionResult {
610 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
611 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
612 }
613 }
614
615 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/aithink/AIThink_Think.md"))]
616 #[repr(C)]
617 #[derive(::core::clone::Clone, ::core::marker::Copy, ::core::fmt::Debug, ::core::cmp::PartialEq, ::core::cmp::Eq)]
618 pub struct AIThink_Think {
619 pub value: i32,
620 }
621 impl ::unity::ClassIdentity for AIThink_Think {
622 const NAME: &'static str = "AIThink.Think";
623 const NAMESPACE: &'static str = "App";
624
625 fn class() -> ::unity::Class {
626 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
627 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
628 }
629 }
630 impl ::unity::IlType for AIThink_Think {
631 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
632 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
633 }
634 }
635 impl AIThink_Think {
636 pub fn none() -> Self {
637 Self { value: 0 }
638 }
639
640 pub fn cause() -> Self {
641 Self { value: 1 }
642 }
643
644 pub fn mind() -> Self {
645 Self { value: 2 }
646 }
647
648 pub fn attack() -> Self {
649 Self { value: 3 }
650 }
651
652 pub fn attack_long_range() -> Self {
653 Self { value: 4 }
654 }
655
656 pub fn attack_high() -> Self {
657 Self { value: 5 }
658 }
659
660 pub fn attack_middle() -> Self {
661 Self { value: 6 }
662 }
663
664 pub fn attack_low() -> Self {
665 Self { value: 7 }
666 }
667
668 pub fn r#move() -> Self {
669 Self { value: 8 }
670 }
671
672 pub fn entrust_heal() -> Self {
673 Self { value: 1 }
674 }
675
676 pub fn entrust_attack() -> Self {
677 Self { value: 2 }
678 }
679
680 pub fn entrust_move() -> Self {
681 Self { value: 3 }
682 }
683
684 pub fn entrust_fixed() -> Self {
685 Self { value: 4 }
686 }
687
688 pub fn uncontroll_heal() -> Self {
689 Self { value: 1 }
690 }
691
692 pub fn uncontroll_attack() -> Self {
693 Self { value: 2 }
694 }
695
696 pub fn uncontroll_move() -> Self {
697 Self { value: 3 }
698 }
699
700 pub fn uncontroll_fixed() -> Self {
701 Self { value: 4 }
702 }
703 }
704
705 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/aithink/AIThink_UpdateFlag.md"))]
706 #[::unity::class(namespace = "App", name = "AIThink.UpdateFlag")]
707 #[parent(crate::app::bitfield32::BitField32)]
708 pub struct AIThink_UpdateFlag {
709 #[static_field]
710 #[rename(name = "Active")]
711 pub active: i32,
712 #[static_field]
713 #[rename(name = "Value0")]
714 pub value0: i32,
715 #[static_field]
716 #[rename(name = "Value1")]
717 pub value1: i32,
718 #[static_field]
719 #[rename(name = "Value2")]
720 pub value2: i32,
721 #[static_field]
722 #[rename(name = "Value3")]
723 pub value3: i32,
724 #[static_field]
725 #[rename(name = "Retry")]
726 pub retry: i32,
727 #[static_field]
728 #[rename(name = "MaskUpdate")]
729 pub mask_update: i32,
730 }
731
732 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/aithink/AIThink_Result.md"))]
733 #[repr(C)]
734 #[derive(::core::clone::Clone, ::core::marker::Copy, ::core::fmt::Debug, ::core::cmp::PartialEq, ::core::cmp::Eq)]
735 pub struct AIThink_Result {
736 pub value: i32,
737 }
738 impl ::unity::ClassIdentity for AIThink_Result {
739 const NAME: &'static str = "AIThink.Result";
740 const NAMESPACE: &'static str = "App";
741
742 fn class() -> ::unity::Class {
743 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
744 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
745 }
746 }
747 impl ::unity::IlType for AIThink_Result {
748 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
749 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
750 }
751 }
752 impl AIThink_Result {
753 pub fn none() -> Self {
754 Self { value: 0 }
755 }
756
757 pub fn decide() -> Self {
758 Self { value: 1 }
759 }
760
761 pub fn reserve() -> Self {
762 Self { value: 2 }
763 }
764 }
765
766 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/aithink/AIThink_AttackTarget.md"))]
767 #[repr(C)]
768 #[derive(::core::clone::Clone, ::core::marker::Copy)]
769 pub struct AIThink_AttackTarget {
770 pub as_result: crate::app::aithink::AIThink_AttackScoreResult,
771 }
772 impl ::unity::ClassIdentity for AIThink_AttackTarget {
773 const NAME: &'static str = "AIThink.AttackTarget";
774 const NAMESPACE: &'static str = "App";
775
776 fn class() -> ::unity::Class {
777 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
778 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
779 }
780 }
781 impl ::unity::IlType for AIThink_AttackTarget {
782 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
783 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
784 }
785 }
786
787 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/aithink/AIThink_HealRodScoreResult.md"))]
788 #[repr(C)]
789 #[derive(::core::clone::Clone, ::core::marker::Copy)]
790 pub struct AIThink_HealRodScoreResult {
791 pub hrsi_result: crate::app::aithink::AIThink_HealRodScoreImplResult,
792 }
793 impl ::unity::ClassIdentity for AIThink_HealRodScoreResult {
794 const NAME: &'static str = "AIThink.HealRodScoreResult";
795 const NAMESPACE: &'static str = "App";
796
797 fn class() -> ::unity::Class {
798 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
799 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
800 }
801 }
802 impl ::unity::IlType for AIThink_HealRodScoreResult {
803 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
804 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
805 }
806 }
807
808 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/aithink/AIThink_RescueRodTarget.md"))]
809 #[repr(C)]
810 #[derive(::core::clone::Clone, ::core::marker::Copy)]
811 pub struct AIThink_RescueRodTarget {
812 pub rrs_result: crate::app::aithink::AIThink_RescueRodScoreResult,
813 }
814 impl ::unity::ClassIdentity for AIThink_RescueRodTarget {
815 const NAME: &'static str = "AIThink.RescueRodTarget";
816 const NAMESPACE: &'static str = "App";
817
818 fn class() -> ::unity::Class {
819 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
820 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
821 }
822 }
823 impl ::unity::IlType for AIThink_RescueRodTarget {
824 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
825 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
826 }
827 }
828
829 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/aithink/AIThink_RcFunc.md"))]
830 #[::unity::class(namespace = "App", name = "AIThink.RcFunc")]
831 #[parent(crate::system::multicastdelegate::MulticastDelegate)]
832 pub struct AIThink_RcFunc {}
833
834 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/aithink/AIThink_EnchantThink_CalcUnitScoreFunction.md"))]
835 #[::unity::class(namespace = "App", name = "AIThink.EnchantThink.CalcUnitScoreFunction")]
836 #[parent(crate::system::multicastdelegate::MulticastDelegate)]
837 pub struct AIThink_EnchantThink_CalcUnitScoreFunction {}
838
839 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/aithink/AIThink_EngageWaitResult.md"))]
840 #[repr(C)]
841 #[derive(::core::clone::Clone, ::core::marker::Copy)]
842 pub struct AIThink_EngageWaitResult {
843 pub score: u32,
844 pub x: i32,
845 pub z: i32,
846 pub item_index: i32,
847 pub power: i32,
848 pub unit: crate::app::unit::Unit,
849 }
850 impl ::unity::ClassIdentity for AIThink_EngageWaitResult {
851 const NAME: &'static str = "AIThink.EngageWaitResult";
852 const NAMESPACE: &'static str = "App";
853
854 fn class() -> ::unity::Class {
855 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
856 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
857 }
858 }
859 impl ::unity::IlType for AIThink_EngageWaitResult {
860 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
861 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
862 }
863 }
864
865 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/aithink/AIThink_TrimasteriesSkills.md"))]
866 #[repr(C)]
867 #[derive(::core::clone::Clone, ::core::marker::Copy)]
868 pub struct AIThink_TrimasteriesSkills {
869 pub m_skills: ::unity::Array<crate::app::skilldata::SkillData>,
870 pub m_count: i32,
871 pub m_last_engage_turn: i32,
872 }
873 impl ::unity::ClassIdentity for AIThink_TrimasteriesSkills {
874 const NAME: &'static str = "AIThink.TrimasteriesSkills";
875 const NAMESPACE: &'static str = "App";
876
877 fn class() -> ::unity::Class {
878 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
879 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
880 }
881 }
882 impl ::unity::IlType for AIThink_TrimasteriesSkills {
883 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
884 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
885 }
886 }
887
888 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/aithink/AIThink_CGBSResult.md"))]
889 #[repr(C)]
890 #[derive(::core::clone::Clone, ::core::marker::Copy, ::core::fmt::Debug, ::core::cmp::PartialEq, ::core::cmp::Eq)]
891 pub struct AIThink_CGBSResult {
892 pub value: i32,
893 }
894 impl ::unity::ClassIdentity for AIThink_CGBSResult {
895 const NAME: &'static str = "AIThink.CGBSResult";
896 const NAMESPACE: &'static str = "App";
897
898 fn class() -> ::unity::Class {
899 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
900 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
901 }
902 }
903 impl ::unity::IlType for AIThink_CGBSResult {
904 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
905 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
906 }
907 }
908 impl AIThink_CGBSResult {
909 pub fn no_give() -> Self {
910 Self { value: 0 }
911 }
912
913 pub fn cannot_give() -> Self {
914 Self { value: 1 }
915 }
916
917 pub fn can_give() -> Self {
918 Self { value: 2 }
919 }
920 }
921
922 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/aithink/AIThink_EnchantThink_ItemInfo.md"))]
923 #[repr(C)]
924 #[derive(::core::clone::Clone, ::core::marker::Copy)]
925 pub struct AIThink_EnchantThink_ItemInfo {
926 pub item_index: u8,
927 pub kind: u8,
928 }
929 impl ::unity::ClassIdentity for AIThink_EnchantThink_ItemInfo {
930 const NAME: &'static str = "AIThink.EnchantThink.ItemInfo";
931 const NAMESPACE: &'static str = "App";
932
933 fn class() -> ::unity::Class {
934 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
935 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
936 }
937 }
938 impl ::unity::IlType for AIThink_EnchantThink_ItemInfo {
939 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
940 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
941 }
942 }
943
944 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/aithink/AIThink_AttackScoreResult.md"))]
945 #[repr(C)]
946 #[derive(::core::clone::Clone, ::core::marker::Copy)]
947 pub struct AIThink_AttackScoreResult {}
948 impl ::unity::ClassIdentity for AIThink_AttackScoreResult {
949 const NAME: &'static str = "AIThink.AttackScoreResult";
950 const NAMESPACE: &'static str = "App";
951
952 fn class() -> ::unity::Class {
953 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
954 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
955 }
956 }
957 impl ::unity::IlType for AIThink_AttackScoreResult {
958 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
959 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
960 }
961 }
962
963 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/aithink/AIThink_WarpRodEvaluationResult.md"))]
964 #[repr(C)]
965 #[derive(::core::clone::Clone, ::core::marker::Copy)]
966 pub struct AIThink_WarpRodEvaluationResult {}
967 impl ::unity::ClassIdentity for AIThink_WarpRodEvaluationResult {
968 const NAME: &'static str = "AIThink.WarpRodEvaluationResult";
969 const NAMESPACE: &'static str = "App";
970
971 fn class() -> ::unity::Class {
972 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
973 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
974 }
975 }
976 impl ::unity::IlType for AIThink_WarpRodEvaluationResult {
977 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
978 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
979 }
980 }
981
982 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/aithink/AIThink_InterferenceTarget.md"))]
983 #[repr(C)]
984 #[derive(::core::clone::Clone, ::core::marker::Copy)]
985 pub struct AIThink_InterferenceTarget {
986 pub is_result: crate::app::aithink::AIThink_InterferenceScoreResult,
987 }
988 impl ::unity::ClassIdentity for AIThink_InterferenceTarget {
989 const NAME: &'static str = "AIThink.InterferenceTarget";
990 const NAMESPACE: &'static str = "App";
991
992 fn class() -> ::unity::Class {
993 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
994 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
995 }
996 }
997 impl ::unity::IlType for AIThink_InterferenceTarget {
998 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
999 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
1000 }
1001 }
1002
1003 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/aithink/AIThink_UncontrollAttackTarget.md"))]
1004 #[repr(C)]
1005 #[derive(::core::clone::Clone, ::core::marker::Copy)]
1006 pub struct AIThink_UncontrollAttackTarget {
1007 pub uas_result: crate::app::aithink::AIThink_UncontrollAttackScoreResult,
1008 }
1009 impl ::unity::ClassIdentity for AIThink_UncontrollAttackTarget {
1010 const NAME: &'static str = "AIThink.UncontrollAttackTarget";
1011 const NAMESPACE: &'static str = "App";
1012
1013 fn class() -> ::unity::Class {
1014 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
1015 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
1016 }
1017 }
1018 impl ::unity::IlType for AIThink_UncontrollAttackTarget {
1019 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
1020 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
1021 }
1022 }
1023
1024 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/aithink/AIThink.md"))]
1025 #[::unity::class(namespace = "App", name = "AIThink")]
1026 #[parent(crate::system::object::Object)]
1027 pub struct AIThink {
1028 #[static_field]
1029 #[rename(name = "BlowScoreNone")]
1030 pub blow_score_none: u32,
1031 #[static_field]
1032 #[rename(name = "BlowScoreWall")]
1033 pub blow_score_wall: u32,
1034 #[static_field]
1035 #[rename(name = "BlowScoreBlew")]
1036 pub blow_score_blew: u32,
1037 #[static_field]
1038 #[rename(name = "BlowScoreHole")]
1039 pub blow_score_hole: u32,
1040 #[static_field]
1041 #[rename(name = "BlowScoreBit")]
1042 pub blow_score_bit: i32,
1043 #[static_field]
1044 #[rename(name = "TerrainScoreBit")]
1045 pub terrain_score_bit: i32,
1046 #[static_field]
1047 #[rename(name = "IceTileMoveMax")]
1048 pub ice_tile_move_max: i32,
1049 #[static_field]
1050 #[rename(name = "EscortDistance")]
1051 pub escort_distance: i32,
1052 #[static_field]
1053 #[rename(name = "EntrustAskHealA")]
1054 pub entrust_ask_heal_a: i32,
1055 #[static_field]
1056 #[rename(name = "EntrustAskHealB")]
1057 pub entrust_ask_heal_b: i32,
1058 #[static_field]
1059 #[rename(name = "AttackTargetMax")]
1060 pub attack_target_max: u32,
1061 #[static_field]
1062 #[rename(name = "EngageHealTargetCountThreshold")]
1063 pub engage_heal_target_count_threshold: i32,
1064 #[offset(16)]
1065 #[rename(name = "m_Unit")]
1066 pub m_unit: crate::app::unit::Unit,
1067 #[offset(24)]
1068 #[rename(name = "m_Think")]
1069 pub m_think: crate::app::aithink::AIThink_Think,
1070 #[offset(28)]
1071 #[rename(name = "m_Order")]
1072 pub m_order: crate::app::aivalue::AIValue_Order,
1073 #[offset(32)]
1074 #[rename(name = "m_UpdateFlag")]
1075 pub m_update_flag: crate::app::aithink::AIThink_UpdateFlag,
1076 #[offset(40)]
1077 #[rename(name = "m_UpdateActive")]
1078 pub m_update_active: i32,
1079 #[offset(48)]
1080 #[rename(name = "m_aUpdateValue")]
1081 pub m_a_update_value: ::unity::Array<crate::app::aivalue::AIValue>,
1082 #[offset(56)]
1083 #[rename(name = "m_Caution")]
1084 pub m_caution: crate::app::mapimagecorebyte::MapImageCoreByte,
1085 #[offset(64)]
1086 #[rename(name = "m_Rerewarp")]
1087 pub m_rerewarp: crate::app::mapimagecorebyte::MapImageCoreByte,
1088 #[offset(72)]
1089 #[rename(name = "m_aAttackTargetForCandidate")]
1090 pub m_a_attack_target_for_candidate: ::unity::Array<u8>,
1091 #[offset(80)]
1092 #[rename(name = "m_aAttackTargetForMind")]
1093 pub m_a_attack_target_for_mind: ::unity::Array<u8>,
1094 #[offset(88)]
1095 #[rename(name = "m_ProhibitEngageAttack")]
1096 pub m_prohibit_engage_attack: i32,
1097 #[offset(92)]
1098 #[rename(name = "m_ProhibitRod")]
1099 pub m_prohibit_rod: i32,
1100 #[offset(96)]
1101 #[rename(name = "m_ProhibitOverlap")]
1102 pub m_prohibit_overlap: i32,
1103 #[offset(100)]
1104 #[rename(name = "m_IsEngageAttackOnceDone")]
1105 pub m_is_engage_attack_once_done: bool,
1106 #[offset(101)]
1107 #[rename(name = "m_IsMagicShieldOnceDone")]
1108 pub m_is_magic_shield_once_done: bool,
1109 #[offset(102)]
1110 #[rename(name = "m_IsEnchantWeaponDone")]
1111 pub m_is_enchant_weapon_done: bool,
1112 #[offset(104)]
1113 #[rename(name = "m_BulletPattern")]
1114 pub m_bullet_pattern: i32,
1115 #[offset(108)]
1116 #[rename(name = "m_IsChangeATAttack")]
1117 pub m_is_change_at_attack: bool,
1118 #[offset(112)]
1119 #[rename(name = "m_Cells")]
1120 pub m_cells: ::unity::Array<crate::app::mappos::MapPos>,
1121 #[offset(120)]
1122 #[rename(name = "m_OverlapSkills")]
1123 pub m_overlap_skills: crate::app::aithink::AIThink_OverlapSkills,
1124 #[offset(136)]
1125 #[rename(name = "m_TrimasteriesSkills")]
1126 pub m_trimasteries_skills: crate::app::aithink::AIThink_TrimasteriesSkills,
1127 #[offset(152)]
1128 #[rename(name = "m_BattleSimulator")]
1129 pub m_battle_simulator: crate::app::aibattlesimulator::AIBattleSimulator,
1130 #[offset(160)]
1131 #[rename(name = "m_BattleSimulatorForScore")]
1132 pub m_battle_simulator_for_score: crate::app::aibattlesimulator::AIBattleSimulator,
1133 #[offset(168)]
1134 #[rename(name = "m_InterferenceSimulator")]
1135 pub m_interference_simulator: crate::app::aiinterferencesimulator::AIInterferenceSimulator,
1136 #[offset(176)]
1137 #[rename(name = "m_NearTargetsCSO")]
1138 pub m_near_targets_cso: ::unity::Array<crate::app::unit::Unit>,
1139 #[offset(184)]
1140 #[rename(name = "m_TargetDistsCSO")]
1141 pub m_target_dists_cso: ::unity::Array<i32>,
1142 #[offset(192)]
1143 #[rename(name = "m_UnitScores")]
1144 pub m_unit_scores: crate::system::collections::generic::dictionary_2::Dictionary_2<i32, u32>,
1145 #[static_field]
1146 #[rename(name = "s_CellsGAP")]
1147 pub s_cells_gap: ::unity::Array<crate::app::mappos::MapPos>,
1148 #[static_field]
1149 #[rename(name = "s_BattleInfoGAP")]
1150 pub s_battle_info_gap: crate::app::battleinfo::BattleInfo,
1151 #[static_field]
1152 #[rename(name = "s_UnitItemGAR")]
1153 pub s_unit_item_gar: crate::app::unititem::UnitItem,
1154 #[offset(200)]
1155 #[rename(name = "m_EngageWaitAdditionalAttackImage")]
1156 pub m_engage_wait_additional_attack_image: crate::app::aithink::AIThink_EngageWaitAdditionalAttackImage,
1157 #[offset(208)]
1158 #[rename(name = "m_HolyShield")]
1159 pub m_holy_shield: crate::app::mapimagecorebyte::MapImageCoreByte,
1160 #[offset(216)]
1161 #[rename(name = "m_EnchantThink")]
1162 pub m_enchant_think: crate::app::aithink::AIThink_EnchantThink,
1163 }
1164
1165 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/aithink/AIThink_AcFunc.md"))]
1166 #[::unity::class(namespace = "App", name = "AIThink.AcFunc")]
1167 #[parent(crate::system::multicastdelegate::MulticastDelegate)]
1168 pub struct AIThink_AcFunc {}
1169
1170 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/aithink/AIThink_TrimasteriesSkills_Kinds.md"))]
1171 #[repr(C)]
1172 #[derive(::core::clone::Clone, ::core::marker::Copy, ::core::fmt::Debug, ::core::cmp::PartialEq, ::core::cmp::Eq)]
1173 pub struct AIThink_TrimasteriesSkills_Kinds {
1174 pub value: i32,
1175 }
1176 impl ::unity::ClassIdentity for AIThink_TrimasteriesSkills_Kinds {
1177 const NAME: &'static str = "AIThink.TrimasteriesSkills.Kinds";
1178 const NAMESPACE: &'static str = "App";
1179
1180 fn class() -> ::unity::Class {
1181 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
1182 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
1183 }
1184 }
1185 impl ::unity::IlType for AIThink_TrimasteriesSkills_Kinds {
1186 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
1187 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
1188 }
1189 }
1190 impl AIThink_TrimasteriesSkills_Kinds {
1191 pub fn unknown() -> Self {
1192 Self { value: -1 }
1193 }
1194
1195 pub fn mad_storm() -> Self {
1196 Self { value: 0 }
1197 }
1198
1199 pub fn miserable() -> Self {
1200 Self { value: 1 }
1201 }
1202
1203 pub fn falling_stars() -> Self {
1204 Self { value: 2 }
1205 }
1206
1207 pub fn max() -> Self {
1208 Self { value: 3 }
1209 }
1210 }
1211
1212 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/aithink/AIThink_EngageWaitAdditionalAttackImage.md"))]
1213 #[::unity::class(namespace = "App", name = "AIThink.EngageWaitAdditionalAttackImage")]
1214 #[parent(crate::app::mapimagecore_1::MapImageCore_1<u16>)]
1215 pub struct AIThink_EngageWaitAdditionalAttackImage {}
1216
1217 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/aithink/AIThink_GodSkillTypes.md"))]
1218 #[repr(C)]
1219 #[derive(::core::clone::Clone, ::core::marker::Copy, ::core::fmt::Debug, ::core::cmp::PartialEq, ::core::cmp::Eq)]
1220 pub struct AIThink_GodSkillTypes {
1221 pub value: i32,
1222 }
1223 impl ::unity::ClassIdentity for AIThink_GodSkillTypes {
1224 const NAME: &'static str = "AIThink.GodSkillTypes";
1225 const NAMESPACE: &'static str = "App";
1226
1227 fn class() -> ::unity::Class {
1228 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
1229 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
1230 }
1231 }
1232 impl ::unity::IlType for AIThink_GodSkillTypes {
1233 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
1234 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
1235 }
1236 }
1237 impl AIThink_GodSkillTypes {
1238 pub fn none() -> Self {
1239 Self { value: 0 }
1240 }
1241
1242 pub fn remagic() -> Self {
1243 Self { value: 1 }
1244 }
1245
1246 pub fn before_move() -> Self {
1247 Self { value: 2 }
1248 }
1249
1250 pub fn vision() -> Self {
1251 Self { value: 3 }
1252 }
1253
1254 pub fn overlap() -> Self {
1255 Self { value: 4 }
1256 }
1257
1258 pub fn support() -> Self {
1259 Self { value: 5 }
1260 }
1261
1262 pub fn engage_guard() -> Self {
1263 Self { value: 6 }
1264 }
1265
1266 pub fn pull_back() -> Self {
1267 Self { value: 7 }
1268 }
1269
1270 pub fn god_change() -> Self {
1271 Self { value: 8 }
1272 }
1273
1274 pub fn decoy() -> Self {
1275 Self { value: 9 }
1276 }
1277
1278 pub fn strategy() -> Self {
1279 Self { value: 10 }
1280 }
1281
1282 pub fn strategy_holy_shield() -> Self {
1283 Self { value: 11 }
1284 }
1285
1286 pub fn trimasteries() -> Self {
1287 Self { value: 12 }
1288 }
1289
1290 pub fn contract() -> Self {
1291 Self { value: 13 }
1292 }
1293
1294 pub fn gaze() -> Self {
1295 Self { value: 14 }
1296 }
1297
1298 pub fn num() -> Self {
1299 Self { value: 15 }
1300 }
1301 }
1302
1303 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/aithink/AIThink_Command.md"))]
1304 #[repr(C)]
1305 #[derive(::core::clone::Clone, ::core::marker::Copy, ::core::fmt::Debug, ::core::cmp::PartialEq, ::core::cmp::Eq)]
1306 pub struct AIThink_Command {
1307 pub value: i32,
1308 }
1309 impl ::unity::ClassIdentity for AIThink_Command {
1310 const NAME: &'static str = "AIThink.Command";
1311 const NAMESPACE: &'static str = "App";
1312
1313 fn class() -> ::unity::Class {
1314 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
1315 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
1316 }
1317 }
1318 impl ::unity::IlType for AIThink_Command {
1319 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
1320 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
1321 }
1322 }
1323 impl AIThink_Command {
1324 pub fn every_time() -> Self {
1325 Self { value: -1 }
1326 }
1327
1328 pub fn non_actiive() -> Self {
1329 Self { value: -2 }
1330 }
1331
1332 pub fn active() -> Self {
1333 Self { value: 0 }
1334 }
1335 }
1336}
1337
1338#[cfg(feature = "app-aithink-types")]
1339pub use __types::*;
1340
1341#[cfg(feature = "app-aithink")]
1342impl AIThink_EnchantThink_Desc {
1343 #[doc = "`.ctor(i32, crate::app::aithink::AIThink_EnchantThink_CalcUnitScoreFunction)` overload"]
1344 pub fn ctor(
1345 &mut self,
1346 priority: impl ::core::convert::Into<i32>,
1347 calc_unit_score: impl ::core::convert::Into<crate::app::aithink::AIThink_EnchantThink_CalcUnitScoreFunction>,
1348 ) -> () {
1349 unsafe {
1350 ::unity::il2cpp_call!((::unity::module_base()+0x1b311c0usize)as*mut u8,();
1351(*mut AIThink_EnchantThink_Desc)self as*mut AIThink_EnchantThink_Desc,(i32)::core::convert::Into::into(priority),(crate::app::aithink::AIThink_EnchantThink_CalcUnitScoreFunction)::core::convert::Into::into(calc_unit_score))
1352 }
1353 }
1354}
1355
1356#[cfg(feature = "app-aithink")]
1357impl AIThink_EnchantThink_Desc {
1358 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1359 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1360 }
1361}
1362
1363#[cfg(feature = "app-aithink")]
1364pub trait IAIThink_AttackFlagMethods: IAIThink_AttackFlag {
1365 #[doc = "`.ctor()` overload"]
1366 fn ctor(self) -> () {
1367 unsafe {
1368 let __receiver = <AIThink_AttackFlag as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1369 ::unity::il2cpp_call!((::unity::module_base()+0x28fb6e0usize)as*mut u8,();
1370(AIThink_AttackFlag)__receiver)
1371 }
1372 }
1373}
1374
1375#[cfg(feature = "app-aithink")]
1376impl<__T: IAIThink_AttackFlag> IAIThink_AttackFlagMethods for __T {}
1377
1378#[cfg(feature = "app-aithink")]
1379impl AIThink_AttackFlag {
1380 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1381 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1382 }
1383}
1384
1385#[cfg(feature = "app-aithink")]
1386impl AIThink_AttackFlag {
1387 #[doc = "`.ctor()` — no args"]
1388 pub fn new() -> Self {
1389 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1390 panic!(
1391 "{}
1392::{}
1393 failed to instantiate",
1394 ::core::stringify!(AIThink_AttackFlag),
1395 ::core::stringify!(new),
1396 )
1397 });
1398 <Self as IAIThink_AttackFlagMethods>::ctor(this);
1399 this
1400 }
1401}
1402
1403#[cfg(feature = "app-aithink")]
1404impl AIThink_EngageWaitRangeScore {
1405 #[doc = "`New(*mutcrate::app::aithink::AIThink_EngageWaitRangeScore)` overload"]
1406 pub fn new() -> crate::app::aithink::AIThink_EngageWaitRangeScore {
1407 unsafe {
1408 let mut __out_0 = ::core::mem::MaybeUninit::<crate::app::aithink::AIThink_EngageWaitRangeScore>::uninit();
1409 ::unity::il2cpp_call!((::unity::module_base()+0x2900160usize)as*mut u8,();
1410(*mut crate::app::aithink::AIThink_EngageWaitRangeScore)__out_0.as_mut_ptr());
1411 __out_0.assume_init()
1412 }
1413 }
1414}
1415
1416#[cfg(feature = "app-aithink")]
1417impl AIThink_EngageWaitRangeScore {
1418 #[doc = "`CompareAndSwap(u32, i32, i32)` overload"]
1419 pub fn compare_and_swap(
1420 &mut self,
1421 temp_score: impl ::core::convert::Into<u32>,
1422 temp_x: impl ::core::convert::Into<i32>,
1423 temp_z: impl ::core::convert::Into<i32>,
1424 ) -> () {
1425 unsafe {
1426 ::unity::il2cpp_call!((::unity::module_base()+0x28ee560usize)as*mut u8,();
1427(*mut AIThink_EngageWaitRangeScore)self as*mut AIThink_EngageWaitRangeScore,(u32)::core::convert::Into::into(temp_score),(i32)::core::convert::Into::into(temp_x),(i32)::core::convert::Into::into(temp_z))
1428 }
1429 }
1430}
1431
1432#[cfg(feature = "app-aithink")]
1433impl AIThink_EngageWaitRangeScore {
1434 pub fn compare_and_swap_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1435 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1436 }
1437
1438 pub fn new_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1439 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1440 }
1441}
1442
1443#[cfg(feature = "app-aithink")]
1444impl AIThink_OverlapSkills {
1445 #[doc = "`Prepare()` overload"]
1446 pub fn prepare(&mut self) -> () {
1447 unsafe {
1448 ::unity::il2cpp_call!((::unity::module_base()+0x2900910usize)as*mut u8,();
1449(*mut AIThink_OverlapSkills)self as*mut AIThink_OverlapSkills)
1450 }
1451 }
1452
1453 #[doc = "`Add(crate::app::skilldata::SkillData)` overload"]
1454 pub fn add(&mut self, skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>) -> () {
1455 unsafe {
1456 ::unity::il2cpp_call!((::unity::module_base()+0x29009d0usize)as*mut u8,();
1457(*mut AIThink_OverlapSkills)self as*mut AIThink_OverlapSkills,(crate::app::skilldata::SkillData)::core::convert::Into::into(skill))
1458 }
1459 }
1460
1461 #[doc = "`GetByRandom()` overload"]
1462 pub fn get_by_random(&mut self) -> crate::app::skilldata::SkillData {
1463 unsafe {
1464 ::unity::il2cpp_call!((::unity::module_base()+0x2900a80usize)as*mut u8,crate::app::skilldata::SkillData;
1465(*mut AIThink_OverlapSkills)self as*mut AIThink_OverlapSkills)
1466 }
1467 }
1468
1469 #[doc = "`get_Count()` overload"]
1470 pub fn get_count(&mut self) -> i32 {
1471 unsafe {
1472 ::unity::il2cpp_call!((::unity::module_base()+0x2900b20usize)as*mut u8,i32;
1473(*mut AIThink_OverlapSkills)self as*mut AIThink_OverlapSkills)
1474 }
1475 }
1476}
1477
1478#[cfg(feature = "app-aithink")]
1479impl AIThink_OverlapSkills {
1480 pub fn prepare_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1481 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1482 }
1483
1484 pub fn add_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1485 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1486 }
1487
1488 pub fn get_by_random_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1489 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1490 }
1491
1492 pub fn get_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1493 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
1494 }
1495}
1496
1497#[cfg(feature = "app-aithink")]
1498pub trait IAIThink_MoveFlagMethods: IAIThink_MoveFlag {
1499 #[doc = "`.ctor()` overload"]
1500 fn ctor(self) -> () {
1501 unsafe {
1502 let __receiver = <AIThink_MoveFlag as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1503 ::unity::il2cpp_call!((::unity::module_base()+0x2900900usize)as*mut u8,();
1504(AIThink_MoveFlag)__receiver)
1505 }
1506 }
1507}
1508
1509#[cfg(feature = "app-aithink")]
1510impl<__T: IAIThink_MoveFlag> IAIThink_MoveFlagMethods for __T {}
1511
1512#[cfg(feature = "app-aithink")]
1513impl AIThink_MoveFlag {
1514 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1515 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1516 }
1517}
1518
1519#[cfg(feature = "app-aithink")]
1520impl AIThink_MoveFlag {
1521 #[doc = "`.ctor()` — no args"]
1522 pub fn new() -> Self {
1523 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1524 panic!(
1525 "{}
1526::{}
1527 failed to instantiate",
1528 ::core::stringify!(AIThink_MoveFlag),
1529 ::core::stringify!(new),
1530 )
1531 });
1532 <Self as IAIThink_MoveFlagMethods>::ctor(this);
1533 this
1534 }
1535}
1536
1537#[cfg(feature = "app-aithink")]
1538impl AIThink_EnchantThink {
1539 #[doc = "`MakeUnitScoreKey(crate::app::unit::Unit, i32)` overload"]
1540 pub fn make_unit_score_key(unit: impl ::core::convert::Into<crate::app::unit::Unit>, item_info_index: impl ::core::convert::Into<i32>) -> i32 {
1541 unsafe {
1542 ::unity::il2cpp_call!((::unity::module_base()+0x28fcc70usize)as*mut u8,i32;
1543(crate::app::unit::Unit)::core::convert::Into::into(unit),(i32)::core::convert::Into::into(item_info_index))
1544 }
1545 }
1546
1547 #[doc = "`CalcUnitScoreRest(crate::app::aithink::AIThink_EnchantThink, crate::app::unit::Unit, crate::app::unit::Unit, crate::app::unititem::UnitItem)` overload"]
1548 pub fn calc_unit_score_rest(
1549 think: impl ::core::convert::Into<crate::app::aithink::AIThink_EnchantThink>,
1550 actor: impl ::core::convert::Into<crate::app::unit::Unit>,
1551 target: impl ::core::convert::Into<crate::app::unit::Unit>,
1552 unit_item: impl ::core::convert::Into<crate::app::unititem::UnitItem>,
1553 ) -> u8 {
1554 unsafe {
1555 ::unity::il2cpp_call!((::unity::module_base()+0x28fe0c0usize)as*mut u8,u8;
1556(crate::app::aithink::AIThink_EnchantThink)::core::convert::Into::into(think),(crate::app::unit::Unit)::core::convert::Into::into(actor),(crate::app::unit::Unit)::core::convert::Into::into(target),(crate::app::unititem::UnitItem)::core::convert::Into::into(unit_item))
1557 }
1558 }
1559
1560 #[doc = "`CalcUnitScoreEngageCount(crate::app::aithink::AIThink_EnchantThink, crate::app::unit::Unit, crate::app::unit::Unit, crate::app::unititem::UnitItem)` overload"]
1561 pub fn calc_unit_score_engage_count(
1562 think: impl ::core::convert::Into<crate::app::aithink::AIThink_EnchantThink>,
1563 actor: impl ::core::convert::Into<crate::app::unit::Unit>,
1564 target: impl ::core::convert::Into<crate::app::unit::Unit>,
1565 unit_item: impl ::core::convert::Into<crate::app::unititem::UnitItem>,
1566 ) -> u8 {
1567 unsafe {
1568 ::unity::il2cpp_call!((::unity::module_base()+0x28fe0f0usize)as*mut u8,u8;
1569(crate::app::aithink::AIThink_EnchantThink)::core::convert::Into::into(think),(crate::app::unit::Unit)::core::convert::Into::into(actor),(crate::app::unit::Unit)::core::convert::Into::into(target),(crate::app::unititem::UnitItem)::core::convert::Into::into(unit_item))
1570 }
1571 }
1572
1573 #[doc = "`CalcUnitScoreEfficacyMorph(crate::app::aithink::AIThink_EnchantThink, crate::app::unit::Unit, crate::app::unit::Unit, crate::app::unititem::UnitItem)` overload"]
1574 pub fn calc_unit_score_efficacy_morph(
1575 think: impl ::core::convert::Into<crate::app::aithink::AIThink_EnchantThink>,
1576 actor: impl ::core::convert::Into<crate::app::unit::Unit>,
1577 target: impl ::core::convert::Into<crate::app::unit::Unit>,
1578 unit_item: impl ::core::convert::Into<crate::app::unititem::UnitItem>,
1579 ) -> u8 {
1580 unsafe {
1581 ::unity::il2cpp_call!((::unity::module_base()+0x28fe200usize)as*mut u8,u8;
1582(crate::app::aithink::AIThink_EnchantThink)::core::convert::Into::into(think),(crate::app::unit::Unit)::core::convert::Into::into(actor),(crate::app::unit::Unit)::core::convert::Into::into(target),(crate::app::unititem::UnitItem)::core::convert::Into::into(unit_item))
1583 }
1584 }
1585
1586 #[doc = "`CalcUnitScoreSight(crate::app::aithink::AIThink_EnchantThink, crate::app::unit::Unit, crate::app::unit::Unit, crate::app::unititem::UnitItem)` overload"]
1587 pub fn calc_unit_score_sight(
1588 think: impl ::core::convert::Into<crate::app::aithink::AIThink_EnchantThink>,
1589 actor: impl ::core::convert::Into<crate::app::unit::Unit>,
1590 target: impl ::core::convert::Into<crate::app::unit::Unit>,
1591 unit_item: impl ::core::convert::Into<crate::app::unititem::UnitItem>,
1592 ) -> u8 {
1593 unsafe {
1594 ::unity::il2cpp_call!((::unity::module_base()+0x28fe2a0usize)as*mut u8,u8;
1595(crate::app::aithink::AIThink_EnchantThink)::core::convert::Into::into(think),(crate::app::unit::Unit)::core::convert::Into::into(actor),(crate::app::unit::Unit)::core::convert::Into::into(target),(crate::app::unititem::UnitItem)::core::convert::Into::into(unit_item))
1596 }
1597 }
1598
1599 #[doc = "`CalcUnitScoreNoChainAttack(crate::app::aithink::AIThink_EnchantThink, crate::app::unit::Unit, crate::app::unit::Unit, crate::app::unititem::UnitItem)` overload"]
1600 pub fn calc_unit_score_no_chain_attack(
1601 think: impl ::core::convert::Into<crate::app::aithink::AIThink_EnchantThink>,
1602 actor: impl ::core::convert::Into<crate::app::unit::Unit>,
1603 target: impl ::core::convert::Into<crate::app::unit::Unit>,
1604 unit_item: impl ::core::convert::Into<crate::app::unititem::UnitItem>,
1605 ) -> u8 {
1606 unsafe {
1607 ::unity::il2cpp_call!((::unity::module_base()+0x28fe2b0usize)as*mut u8,u8;
1608(crate::app::aithink::AIThink_EnchantThink)::core::convert::Into::into(think),(crate::app::unit::Unit)::core::convert::Into::into(actor),(crate::app::unit::Unit)::core::convert::Into::into(target),(crate::app::unititem::UnitItem)::core::convert::Into::into(unit_item))
1609 }
1610 }
1611
1612 #[doc = "`CalcUnitScoreWeightZero(crate::app::aithink::AIThink_EnchantThink, crate::app::unit::Unit, crate::app::unit::Unit, crate::app::unititem::UnitItem)` overload"]
1613 pub fn calc_unit_score_weight_zero(
1614 think: impl ::core::convert::Into<crate::app::aithink::AIThink_EnchantThink>,
1615 actor: impl ::core::convert::Into<crate::app::unit::Unit>,
1616 target: impl ::core::convert::Into<crate::app::unit::Unit>,
1617 unit_item: impl ::core::convert::Into<crate::app::unititem::UnitItem>,
1618 ) -> u8 {
1619 unsafe {
1620 ::unity::il2cpp_call!((::unity::module_base()+0x28fe350usize)as*mut u8,u8;
1621(crate::app::aithink::AIThink_EnchantThink)::core::convert::Into::into(think),(crate::app::unit::Unit)::core::convert::Into::into(actor),(crate::app::unit::Unit)::core::convert::Into::into(target),(crate::app::unititem::UnitItem)::core::convert::Into::into(unit_item))
1622 }
1623 }
1624
1625 #[doc = "`CalcUnitScoreNoSilence(crate::app::aithink::AIThink_EnchantThink, crate::app::unit::Unit, crate::app::unit::Unit, crate::app::unititem::UnitItem)` overload"]
1626 pub fn calc_unit_score_no_silence(
1627 think: impl ::core::convert::Into<crate::app::aithink::AIThink_EnchantThink>,
1628 actor: impl ::core::convert::Into<crate::app::unit::Unit>,
1629 target: impl ::core::convert::Into<crate::app::unit::Unit>,
1630 unit_item: impl ::core::convert::Into<crate::app::unititem::UnitItem>,
1631 ) -> u8 {
1632 unsafe {
1633 ::unity::il2cpp_call!((::unity::module_base()+0x28fe9f0usize)as*mut u8,u8;
1634(crate::app::aithink::AIThink_EnchantThink)::core::convert::Into::into(think),(crate::app::unit::Unit)::core::convert::Into::into(actor),(crate::app::unit::Unit)::core::convert::Into::into(target),(crate::app::unititem::UnitItem)::core::convert::Into::into(unit_item))
1635 }
1636 }
1637
1638 #[doc = "`CalcUnitScoreReflectPhysics(crate::app::aithink::AIThink_EnchantThink, crate::app::unit::Unit, crate::app::unit::Unit, crate::app::unititem::UnitItem)` overload"]
1639 pub fn calc_unit_score_reflect_physics(
1640 think: impl ::core::convert::Into<crate::app::aithink::AIThink_EnchantThink>,
1641 actor: impl ::core::convert::Into<crate::app::unit::Unit>,
1642 target: impl ::core::convert::Into<crate::app::unit::Unit>,
1643 unit_item: impl ::core::convert::Into<crate::app::unititem::UnitItem>,
1644 ) -> u8 {
1645 unsafe {
1646 ::unity::il2cpp_call!((::unity::module_base()+0x28fea90usize)as*mut u8,u8;
1647(crate::app::aithink::AIThink_EnchantThink)::core::convert::Into::into(think),(crate::app::unit::Unit)::core::convert::Into::into(actor),(crate::app::unit::Unit)::core::convert::Into::into(target),(crate::app::unititem::UnitItem)::core::convert::Into::into(unit_item))
1648 }
1649 }
1650
1651 #[doc = "`CalcUnitScoreReflectMagic(crate::app::aithink::AIThink_EnchantThink, crate::app::unit::Unit, crate::app::unit::Unit, crate::app::unititem::UnitItem)` overload"]
1652 pub fn calc_unit_score_reflect_magic(
1653 think: impl ::core::convert::Into<crate::app::aithink::AIThink_EnchantThink>,
1654 actor: impl ::core::convert::Into<crate::app::unit::Unit>,
1655 target: impl ::core::convert::Into<crate::app::unit::Unit>,
1656 unit_item: impl ::core::convert::Into<crate::app::unititem::UnitItem>,
1657 ) -> u8 {
1658 unsafe {
1659 ::unity::il2cpp_call!((::unity::module_base()+0x28feb30usize)as*mut u8,u8;
1660(crate::app::aithink::AIThink_EnchantThink)::core::convert::Into::into(think),(crate::app::unit::Unit)::core::convert::Into::into(actor),(crate::app::unit::Unit)::core::convert::Into::into(target),(crate::app::unititem::UnitItem)::core::convert::Into::into(unit_item))
1661 }
1662 }
1663
1664 #[doc = "`CalcUnitScoreNoBreak(crate::app::aithink::AIThink_EnchantThink, crate::app::unit::Unit, crate::app::unit::Unit, crate::app::unititem::UnitItem)` overload"]
1665 pub fn calc_unit_score_no_break(
1666 think: impl ::core::convert::Into<crate::app::aithink::AIThink_EnchantThink>,
1667 actor: impl ::core::convert::Into<crate::app::unit::Unit>,
1668 target: impl ::core::convert::Into<crate::app::unit::Unit>,
1669 unit_item: impl ::core::convert::Into<crate::app::unititem::UnitItem>,
1670 ) -> u8 {
1671 unsafe {
1672 ::unity::il2cpp_call!((::unity::module_base()+0x28febd0usize)as*mut u8,u8;
1673(crate::app::aithink::AIThink_EnchantThink)::core::convert::Into::into(think),(crate::app::unit::Unit)::core::convert::Into::into(actor),(crate::app::unit::Unit)::core::convert::Into::into(target),(crate::app::unititem::UnitItem)::core::convert::Into::into(unit_item))
1674 }
1675 }
1676
1677 #[doc = "`CalcUnitScoreNoFreeze(crate::app::aithink::AIThink_EnchantThink, crate::app::unit::Unit, crate::app::unit::Unit, crate::app::unititem::UnitItem)` overload"]
1678 pub fn calc_unit_score_no_freeze(
1679 think: impl ::core::convert::Into<crate::app::aithink::AIThink_EnchantThink>,
1680 actor: impl ::core::convert::Into<crate::app::unit::Unit>,
1681 target: impl ::core::convert::Into<crate::app::unit::Unit>,
1682 unit_item: impl ::core::convert::Into<crate::app::unititem::UnitItem>,
1683 ) -> u8 {
1684 unsafe {
1685 ::unity::il2cpp_call!((::unity::module_base()+0x28fec70usize)as*mut u8,u8;
1686(crate::app::aithink::AIThink_EnchantThink)::core::convert::Into::into(think),(crate::app::unit::Unit)::core::convert::Into::into(actor),(crate::app::unit::Unit)::core::convert::Into::into(target),(crate::app::unititem::UnitItem)::core::convert::Into::into(unit_item))
1687 }
1688 }
1689
1690 #[doc = "`CalcUnitScoreNoDamage(crate::app::aithink::AIThink_EnchantThink, crate::app::unit::Unit, crate::app::unit::Unit, crate::app::unititem::UnitItem)` overload"]
1691 pub fn calc_unit_score_no_damage(
1692 think: impl ::core::convert::Into<crate::app::aithink::AIThink_EnchantThink>,
1693 actor: impl ::core::convert::Into<crate::app::unit::Unit>,
1694 target: impl ::core::convert::Into<crate::app::unit::Unit>,
1695 unit_item: impl ::core::convert::Into<crate::app::unititem::UnitItem>,
1696 ) -> u8 {
1697 unsafe {
1698 ::unity::il2cpp_call!((::unity::module_base()+0x28fed10usize)as*mut u8,u8;
1699(crate::app::aithink::AIThink_EnchantThink)::core::convert::Into::into(think),(crate::app::unit::Unit)::core::convert::Into::into(actor),(crate::app::unit::Unit)::core::convert::Into::into(target),(crate::app::unititem::UnitItem)::core::convert::Into::into(unit_item))
1700 }
1701 }
1702
1703 #[doc = "`CalcUnitScoreHoldOut(crate::app::aithink::AIThink_EnchantThink, crate::app::unit::Unit, crate::app::unit::Unit, crate::app::unititem::UnitItem)` overload"]
1704 pub fn calc_unit_score_hold_out(
1705 think: impl ::core::convert::Into<crate::app::aithink::AIThink_EnchantThink>,
1706 actor: impl ::core::convert::Into<crate::app::unit::Unit>,
1707 target: impl ::core::convert::Into<crate::app::unit::Unit>,
1708 unit_item: impl ::core::convert::Into<crate::app::unititem::UnitItem>,
1709 ) -> u8 {
1710 unsafe {
1711 ::unity::il2cpp_call!((::unity::module_base()+0x28fedc0usize)as*mut u8,u8;
1712(crate::app::aithink::AIThink_EnchantThink)::core::convert::Into::into(think),(crate::app::unit::Unit)::core::convert::Into::into(actor),(crate::app::unit::Unit)::core::convert::Into::into(target),(crate::app::unititem::UnitItem)::core::convert::Into::into(unit_item))
1713 }
1714 }
1715
1716 #[doc = "`CalcUnitScoreWeapon(crate::app::aithink::AIThink_EnchantThink, crate::app::unit::Unit, crate::app::unit::Unit, crate::app::unititem::UnitItem)` overload"]
1717 pub fn calc_unit_score_weapon(
1718 think: impl ::core::convert::Into<crate::app::aithink::AIThink_EnchantThink>,
1719 actor: impl ::core::convert::Into<crate::app::unit::Unit>,
1720 target: impl ::core::convert::Into<crate::app::unit::Unit>,
1721 unit_item: impl ::core::convert::Into<crate::app::unititem::UnitItem>,
1722 ) -> u8 {
1723 unsafe {
1724 ::unity::il2cpp_call!((::unity::module_base()+0x28fef80usize)as*mut u8,u8;
1725(crate::app::aithink::AIThink_EnchantThink)::core::convert::Into::into(think),(crate::app::unit::Unit)::core::convert::Into::into(actor),(crate::app::unit::Unit)::core::convert::Into::into(target),(crate::app::unititem::UnitItem)::core::convert::Into::into(unit_item))
1726 }
1727 }
1728
1729 #[doc = "`CalcUnitScoreDummy(crate::app::aithink::AIThink_EnchantThink, crate::app::unit::Unit, crate::app::unit::Unit, crate::app::unititem::UnitItem)` overload"]
1730 pub fn calc_unit_score_dummy(
1731 think: impl ::core::convert::Into<crate::app::aithink::AIThink_EnchantThink>,
1732 actor: impl ::core::convert::Into<crate::app::unit::Unit>,
1733 target: impl ::core::convert::Into<crate::app::unit::Unit>,
1734 unit_item: impl ::core::convert::Into<crate::app::unititem::UnitItem>,
1735 ) -> u8 {
1736 unsafe {
1737 ::unity::il2cpp_call!((::unity::module_base()+0x28ff570usize)as*mut u8,u8;
1738(crate::app::aithink::AIThink_EnchantThink)::core::convert::Into::into(think),(crate::app::unit::Unit)::core::convert::Into::into(actor),(crate::app::unit::Unit)::core::convert::Into::into(target),(crate::app::unititem::UnitItem)::core::convert::Into::into(unit_item))
1739 }
1740 }
1741
1742 #[doc = "`.cctor()` overload"]
1743 pub fn cctor() -> () {
1744 unsafe {
1745 ::unity::il2cpp_call!((::unity::module_base()+0x28ff8d0usize)as*mut u8,();
1746 )
1747 }
1748 }
1749}
1750
1751#[cfg(feature = "app-aithink")]
1752pub trait IAIThink_EnchantThinkMethods: IAIThink_EnchantThink {
1753 #[doc = "`.ctor()` overload"]
1754 fn ctor(self) -> () {
1755 unsafe {
1756 let __receiver = <AIThink_EnchantThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1757 ::unity::il2cpp_call!((::unity::module_base()+0x28fbb00usize)as*mut u8,();
1758(AIThink_EnchantThink)__receiver)
1759 }
1760 }
1761 #[doc = "`Think(crate::app::unit::Unit, bool)` overload"]
1762 fn think(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>, is_entrust: impl ::core::convert::Into<bool>) -> bool {
1763 unsafe {
1764 let __receiver = <AIThink_EnchantThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1765 ::unity::il2cpp_call!((::unity::module_base()+0x28fbd20usize)as*mut u8,bool;
1766(AIThink_EnchantThink)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(unit),(bool)::core::convert::Into::into(is_entrust))
1767 }
1768 }
1769 #[doc = "`CollectItemInfos()` overload"]
1770 fn collect_item_infos(self) -> bool {
1771 unsafe {
1772 let __receiver = <AIThink_EnchantThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1773 ::unity::il2cpp_call!((::unity::module_base()+0x28fc050usize)as*mut u8,bool;
1774(AIThink_EnchantThink)__receiver)
1775 }
1776 }
1777 #[doc = "`CanUseItem(i32)` overload"]
1778 fn can_use_item(self, item_info_index: impl ::core::convert::Into<i32>) -> bool {
1779 unsafe {
1780 let __receiver = <AIThink_EnchantThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1781 ::unity::il2cpp_call!((::unity::module_base()+0x28fc8c0usize)as*mut u8,bool;
1782(AIThink_EnchantThink)__receiver,(i32)::core::convert::Into::into(item_info_index))
1783 }
1784 }
1785 #[doc = "`DecideMovePosAndTarget(i32, *mutcrate::app::aithink::AIThink_EnchantThink_DMPTResult)` overload"]
1786 fn decide_move_pos_and_target(
1787 self,
1788 item_info_index: impl ::core::convert::Into<i32>,
1789 ) -> (bool, crate::app::aithink::AIThink_EnchantThink_DMPTResult) {
1790 unsafe {
1791 let __receiver = <AIThink_EnchantThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1792 let mut __out_0 = ::core::mem::MaybeUninit::<crate::app::aithink::AIThink_EnchantThink_DMPTResult>::uninit();
1793 let __ret = {
1794 ::unity::il2cpp_call!((::unity::module_base()+0x28fca70usize)as*mut u8,bool;
1795(AIThink_EnchantThink)__receiver,(i32)::core::convert::Into::into(item_info_index),(*mut crate::app::aithink::AIThink_EnchantThink_DMPTResult)__out_0.as_mut_ptr())
1796 };
1797 (__ret, __out_0.assume_init())
1798 }
1799 }
1800 #[doc = "`Reset(crate::app::unit::Unit)` overload"]
1801 fn reset(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> () {
1802 unsafe {
1803 let __receiver = <AIThink_EnchantThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1804 ::unity::il2cpp_call!((::unity::module_base()+0x28fbc80usize)as*mut u8,();
1805(AIThink_EnchantThink)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(unit))
1806 }
1807 }
1808 #[doc = "`AddItemInfo(i32, crate::app::aithink::AIThink_EnchantThink_Kinds)` overload"]
1809 fn add_item_info(
1810 self,
1811 item_index: impl ::core::convert::Into<i32>,
1812 kind: impl ::core::convert::Into<crate::app::aithink::AIThink_EnchantThink_Kinds>,
1813 ) -> () {
1814 unsafe {
1815 let __receiver = <AIThink_EnchantThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1816 ::unity::il2cpp_call!((::unity::module_base()+0x28fcc10usize)as*mut u8,();
1817(AIThink_EnchantThink)__receiver,(i32)::core::convert::Into::into(item_index),(crate::app::aithink::AIThink_EnchantThink_Kinds)::core::convert::Into::into(kind))
1818 }
1819 }
1820 #[doc = "`CalcUnitScore(u8, crate::app::unit::Unit, crate::app::unititem::UnitItem)` overload"]
1821 fn calc_unit_score(
1822 self,
1823 kind: impl ::core::convert::Into<u8>,
1824 target: impl ::core::convert::Into<crate::app::unit::Unit>,
1825 unit_item: impl ::core::convert::Into<crate::app::unititem::UnitItem>,
1826 ) -> u8 {
1827 unsafe {
1828 let __receiver = <AIThink_EnchantThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1829 ::unity::il2cpp_call!((::unity::module_base()+0x28fcc80usize)as*mut u8,u8;
1830(AIThink_EnchantThink)__receiver,(u8)::core::convert::Into::into(kind),(crate::app::unit::Unit)::core::convert::Into::into(target),(crate::app::unititem::UnitItem)::core::convert::Into::into(unit_item))
1831 }
1832 }
1833 #[doc = "`CalcPosScore(u8, i32, i32, i32, i32, crate::app::unititem::UnitItem, *mutcrate::app::aithink::AIThink_EnchantThink_DMPTResult)` overload"]
1834 fn calc_pos_score(
1835 self,
1836 kind: impl ::core::convert::Into<u8>,
1837 move_x: impl ::core::convert::Into<i32>,
1838 move_z: impl ::core::convert::Into<i32>,
1839 r#move: impl ::core::convert::Into<i32>,
1840 item_info_index: impl ::core::convert::Into<i32>,
1841 unit_item: impl ::core::convert::Into<crate::app::unititem::UnitItem>,
1842 ) -> (u32, crate::app::aithink::AIThink_EnchantThink_DMPTResult) {
1843 unsafe {
1844 let __receiver = <AIThink_EnchantThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1845 let mut __out_0 = ::core::mem::MaybeUninit::<crate::app::aithink::AIThink_EnchantThink_DMPTResult>::uninit();
1846 let __ret = {
1847 ::unity::il2cpp_call!((::unity::module_base()+0x28fcd80usize)as*mut u8,u32;
1848(AIThink_EnchantThink)__receiver,(u8)::core::convert::Into::into(kind),(i32)::core::convert::Into::into(move_x),(i32)::core::convert::Into::into(move_z),(i32)::core::convert::Into::into(r#move),(i32)::core::convert::Into::into(item_info_index),(crate::app::unititem::UnitItem)::core::convert::Into::into(unit_item),(*mut crate::app::aithink::AIThink_EnchantThink_DMPTResult)__out_0.as_mut_ptr())
1849 };
1850 (__ret, __out_0.assume_init())
1851 }
1852 }
1853 #[doc = "`CollectSurroundingInfo(crate::app::unit::Unit)` overload"]
1854 fn collect_surrounding_info(self, target: impl ::core::convert::Into<crate::app::unit::Unit>) -> () {
1855 unsafe {
1856 let __receiver = <AIThink_EnchantThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1857 ::unity::il2cpp_call!((::unity::module_base()+0x28fd100usize)as*mut u8,();
1858(AIThink_EnchantThink)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(target))
1859 }
1860 }
1861 #[doc = "`CalcPosScoreWhole(crate::app::unit::Unit, i32, i32, i32, i32, crate::app::unititem::UnitItem, *mutcrate::app::aithink::AIThink_EnchantThink_DMPTResult)` overload"]
1862 fn calc_pos_score_whole(
1863 self,
1864 actor: impl ::core::convert::Into<crate::app::unit::Unit>,
1865 move_x: impl ::core::convert::Into<i32>,
1866 move_z: impl ::core::convert::Into<i32>,
1867 r#move: impl ::core::convert::Into<i32>,
1868 item_info_index: impl ::core::convert::Into<i32>,
1869 unit_item: impl ::core::convert::Into<crate::app::unititem::UnitItem>,
1870 ) -> (u32, crate::app::aithink::AIThink_EnchantThink_DMPTResult) {
1871 unsafe {
1872 let __receiver = <AIThink_EnchantThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1873 let mut __out_0 = ::core::mem::MaybeUninit::<crate::app::aithink::AIThink_EnchantThink_DMPTResult>::uninit();
1874 let __ret = {
1875 ::unity::il2cpp_call!((::unity::module_base()+0x28fd0a0usize)as*mut u8,u32;
1876(AIThink_EnchantThink)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(actor),(i32)::core::convert::Into::into(move_x),(i32)::core::convert::Into::into(move_z),(i32)::core::convert::Into::into(r#move),(i32)::core::convert::Into::into(item_info_index),(crate::app::unititem::UnitItem)::core::convert::Into::into(unit_item),(*mut crate::app::aithink::AIThink_EnchantThink_DMPTResult)__out_0.as_mut_ptr())
1877 };
1878 (__ret, __out_0.assume_init())
1879 }
1880 }
1881 #[doc = "`CalcPosScoreRange(crate::app::unit::Unit, i32, i32, i32, i32, crate::app::unititem::UnitItem, *mutcrate::app::aithink::AIThink_EnchantThink_DMPTResult)` overload"]
1882 fn calc_pos_score_range(
1883 self,
1884 actor: impl ::core::convert::Into<crate::app::unit::Unit>,
1885 move_x: impl ::core::convert::Into<i32>,
1886 move_z: impl ::core::convert::Into<i32>,
1887 r#move: impl ::core::convert::Into<i32>,
1888 item_info_index: impl ::core::convert::Into<i32>,
1889 unit_item: impl ::core::convert::Into<crate::app::unititem::UnitItem>,
1890 ) -> (u32, crate::app::aithink::AIThink_EnchantThink_DMPTResult) {
1891 unsafe {
1892 let __receiver = <AIThink_EnchantThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1893 let mut __out_0 = ::core::mem::MaybeUninit::<crate::app::aithink::AIThink_EnchantThink_DMPTResult>::uninit();
1894 let __ret = {
1895 ::unity::il2cpp_call!((::unity::module_base()+0x28fce20usize)as*mut u8,u32;
1896(AIThink_EnchantThink)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(actor),(i32)::core::convert::Into::into(move_x),(i32)::core::convert::Into::into(move_z),(i32)::core::convert::Into::into(r#move),(i32)::core::convert::Into::into(item_info_index),(crate::app::unititem::UnitItem)::core::convert::Into::into(unit_item),(*mut crate::app::aithink::AIThink_EnchantThink_DMPTResult)__out_0.as_mut_ptr())
1897 };
1898 (__ret, __out_0.assume_init())
1899 }
1900 }
1901 #[doc = "`CalcPosScoreRangeImpl(crate::app::unit::Unit, i32, i32, i32, i32, crate::app::unititem::UnitItem, *mutcrate::app::aithink::AIThink_EnchantThink_DMPTResult, bool)` overload"]
1902 fn calc_pos_score_range_impl(
1903 self,
1904 actor: impl ::core::convert::Into<crate::app::unit::Unit>,
1905 move_x: impl ::core::convert::Into<i32>,
1906 move_z: impl ::core::convert::Into<i32>,
1907 r#move: impl ::core::convert::Into<i32>,
1908 item_info_index: impl ::core::convert::Into<i32>,
1909 unit_item: impl ::core::convert::Into<crate::app::unititem::UnitItem>,
1910 is_whole: impl ::core::convert::Into<bool>,
1911 ) -> (u32, crate::app::aithink::AIThink_EnchantThink_DMPTResult) {
1912 unsafe {
1913 let __receiver = <AIThink_EnchantThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1914 let mut __out_0 = ::core::mem::MaybeUninit::<crate::app::aithink::AIThink_EnchantThink_DMPTResult>::uninit();
1915 let __ret = {
1916 ::unity::il2cpp_call!((::unity::module_base()+0x28ff580usize)as*mut u8,u32;
1917(AIThink_EnchantThink)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(actor),(i32)::core::convert::Into::into(move_x),(i32)::core::convert::Into::into(move_z),(i32)::core::convert::Into::into(r#move),(i32)::core::convert::Into::into(item_info_index),(crate::app::unititem::UnitItem)::core::convert::Into::into(unit_item),(*mut crate::app::aithink::AIThink_EnchantThink_DMPTResult)__out_0.as_mut_ptr(),(bool)::core::convert::Into::into(is_whole))
1918 };
1919 (__ret, __out_0.assume_init())
1920 }
1921 }
1922 #[doc = "`CalcPosScoreNeighbor(crate::app::unit::Unit, i32, i32, i32, i32, crate::app::unititem::UnitItem, *mutcrate::app::aithink::AIThink_EnchantThink_DMPTResult)` overload"]
1923 fn calc_pos_score_neighbor(
1924 self,
1925 actor: impl ::core::convert::Into<crate::app::unit::Unit>,
1926 move_x: impl ::core::convert::Into<i32>,
1927 move_z: impl ::core::convert::Into<i32>,
1928 r#move: impl ::core::convert::Into<i32>,
1929 item_info_index: impl ::core::convert::Into<i32>,
1930 unit_item: impl ::core::convert::Into<crate::app::unititem::UnitItem>,
1931 ) -> (u32, crate::app::aithink::AIThink_EnchantThink_DMPTResult) {
1932 unsafe {
1933 let __receiver = <AIThink_EnchantThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1934 let mut __out_0 = ::core::mem::MaybeUninit::<crate::app::aithink::AIThink_EnchantThink_DMPTResult>::uninit();
1935 let __ret = {
1936 ::unity::il2cpp_call!((::unity::module_base()+0x28fce40usize)as*mut u8,u32;
1937(AIThink_EnchantThink)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(actor),(i32)::core::convert::Into::into(move_x),(i32)::core::convert::Into::into(move_z),(i32)::core::convert::Into::into(r#move),(i32)::core::convert::Into::into(item_info_index),(crate::app::unititem::UnitItem)::core::convert::Into::into(unit_item),(*mut crate::app::aithink::AIThink_EnchantThink_DMPTResult)__out_0.as_mut_ptr())
1938 };
1939 (__ret, __out_0.assume_init())
1940 }
1941 }
1942 #[doc = "`CalcPosScoreDummy(crate::app::unit::Unit, i32, i32, i32, i32, crate::app::unititem::UnitItem, *mutcrate::app::aithink::AIThink_EnchantThink_DMPTResult)` overload"]
1943 fn calc_pos_score_dummy(
1944 self,
1945 actor: impl ::core::convert::Into<crate::app::unit::Unit>,
1946 move_x: impl ::core::convert::Into<i32>,
1947 move_z: impl ::core::convert::Into<i32>,
1948 r#move: impl ::core::convert::Into<i32>,
1949 item_info_index: impl ::core::convert::Into<i32>,
1950 unit_item: impl ::core::convert::Into<crate::app::unititem::UnitItem>,
1951 ) -> (u32, crate::app::aithink::AIThink_EnchantThink_DMPTResult) {
1952 unsafe {
1953 let __receiver = <AIThink_EnchantThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1954 let mut __out_0 = ::core::mem::MaybeUninit::<crate::app::aithink::AIThink_EnchantThink_DMPTResult>::uninit();
1955 let __ret = {
1956 ::unity::il2cpp_call!((::unity::module_base()+0x28fd0d0usize)as*mut u8,u32;
1957(AIThink_EnchantThink)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(actor),(i32)::core::convert::Into::into(move_x),(i32)::core::convert::Into::into(move_z),(i32)::core::convert::Into::into(r#move),(i32)::core::convert::Into::into(item_info_index),(crate::app::unititem::UnitItem)::core::convert::Into::into(unit_item),(*mut crate::app::aithink::AIThink_EnchantThink_DMPTResult)__out_0.as_mut_ptr())
1958 };
1959 (__ret, __out_0.assume_init())
1960 }
1961 }
1962}
1963
1964#[cfg(feature = "app-aithink")]
1965impl<__T: IAIThink_EnchantThink> IAIThink_EnchantThinkMethods for __T {}
1966
1967#[cfg(feature = "app-aithink")]
1968impl AIThink_EnchantThink {
1969 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1970 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1971 }
1972
1973 pub fn think_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1974 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1975 }
1976
1977 pub fn collect_item_infos_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1978 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1979 }
1980
1981 pub fn can_use_item_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1982 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
1983 }
1984
1985 pub fn decide_move_pos_and_target_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1986 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
1987 }
1988
1989 pub fn reset_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1990 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
1991 }
1992
1993 pub fn add_item_info_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1994 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
1995 }
1996
1997 pub fn make_unit_score_key_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1998 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
1999 }
2000
2001 pub fn calc_unit_score_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2002 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
2003 }
2004
2005 pub fn calc_pos_score_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2006 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
2007 }
2008
2009 pub fn collect_surrounding_info_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2010 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
2011 }
2012
2013 pub fn calc_unit_score_rest_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2014 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
2015 }
2016
2017 pub fn calc_unit_score_engage_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2018 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
2019 }
2020
2021 pub fn calc_unit_score_efficacy_morph_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2022 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
2023 }
2024
2025 pub fn calc_unit_score_sight_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2026 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[14]
2027 }
2028
2029 pub fn calc_unit_score_no_chain_attack_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2030 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[15]
2031 }
2032
2033 pub fn calc_unit_score_weight_zero_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2034 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[16]
2035 }
2036
2037 pub fn calc_unit_score_no_silence_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2038 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[17]
2039 }
2040
2041 pub fn calc_unit_score_reflect_physics_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2042 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[18]
2043 }
2044
2045 pub fn calc_unit_score_reflect_magic_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2046 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[19]
2047 }
2048
2049 pub fn calc_unit_score_no_break_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2050 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[20]
2051 }
2052
2053 pub fn calc_unit_score_no_freeze_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2054 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[21]
2055 }
2056
2057 pub fn calc_unit_score_no_damage_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2058 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[22]
2059 }
2060
2061 pub fn calc_unit_score_hold_out_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2062 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[23]
2063 }
2064
2065 pub fn calc_unit_score_weapon_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2066 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[24]
2067 }
2068
2069 pub fn calc_unit_score_dummy_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2070 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[25]
2071 }
2072
2073 pub fn calc_pos_score_whole_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2074 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[26]
2075 }
2076
2077 pub fn calc_pos_score_range_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2078 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[27]
2079 }
2080
2081 pub fn calc_pos_score_range_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2082 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[28]
2083 }
2084
2085 pub fn calc_pos_score_neighbor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2086 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[29]
2087 }
2088
2089 pub fn calc_pos_score_dummy_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2090 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[30]
2091 }
2092
2093 pub fn cctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2094 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[31]
2095 }
2096}
2097
2098#[cfg(feature = "app-aithink")]
2099impl AIThink_EnchantThink {
2100 #[doc = "`.ctor()` — no args"]
2101 pub fn new() -> Self {
2102 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2103 panic!(
2104 "{}
2105::{}
2106 failed to instantiate",
2107 ::core::stringify!(AIThink_EnchantThink),
2108 ::core::stringify!(new),
2109 )
2110 });
2111 <Self as IAIThink_EnchantThinkMethods>::ctor(this);
2112 this
2113 }
2114}
2115
2116#[cfg(feature = "app-aithink")]
2117impl AIThink_EntrustAttackTarget {
2118 #[doc = "`New(*mutcrate::app::aithink::AIThink_EntrustAttackTarget)` overload"]
2119 pub fn new() -> crate::app::aithink::AIThink_EntrustAttackTarget {
2120 unsafe {
2121 let mut __out_0 = ::core::mem::MaybeUninit::<crate::app::aithink::AIThink_EntrustAttackTarget>::uninit();
2122 ::unity::il2cpp_call!((::unity::module_base()+0x29004a0usize)as*mut u8,();
2123(*mut crate::app::aithink::AIThink_EntrustAttackTarget)__out_0.as_mut_ptr());
2124 __out_0.assume_init()
2125 }
2126 }
2127}
2128
2129#[cfg(feature = "app-aithink")]
2130impl AIThink_EntrustAttackTarget {
2131 #[doc = "`get_Unit()` overload"]
2132 pub fn get_unit(&mut self) -> crate::app::unit::Unit {
2133 unsafe {
2134 ::unity::il2cpp_call!((::unity::module_base()+0x29003a0usize)as*mut u8,crate::app::unit::Unit;
2135(*mut AIThink_EntrustAttackTarget)self as*mut AIThink_EntrustAttackTarget)
2136 }
2137 }
2138
2139 #[doc = "`set_Unit(crate::app::unit::Unit)` overload"]
2140 pub fn set_unit(&mut self, value: impl ::core::convert::Into<crate::app::unit::Unit>) -> () {
2141 unsafe {
2142 ::unity::il2cpp_call!((::unity::module_base()+0x29003b0usize)as*mut u8,();
2143(*mut AIThink_EntrustAttackTarget)self as*mut AIThink_EntrustAttackTarget,(crate::app::unit::Unit)::core::convert::Into::into(value))
2144 }
2145 }
2146
2147 #[doc = "`get_X()` overload"]
2148 pub fn get_x(&mut self) -> i32 {
2149 unsafe {
2150 ::unity::il2cpp_call!((::unity::module_base()+0x29003c0usize)as*mut u8,i32;
2151(*mut AIThink_EntrustAttackTarget)self as*mut AIThink_EntrustAttackTarget)
2152 }
2153 }
2154
2155 #[doc = "`set_X(i32)` overload"]
2156 pub fn set_x(&mut self, value: impl ::core::convert::Into<i32>) -> () {
2157 unsafe {
2158 ::unity::il2cpp_call!((::unity::module_base()+0x29003d0usize)as*mut u8,();
2159(*mut AIThink_EntrustAttackTarget)self as*mut AIThink_EntrustAttackTarget,(i32)::core::convert::Into::into(value))
2160 }
2161 }
2162
2163 #[doc = "`get_Z()` overload"]
2164 pub fn get_z(&mut self) -> i32 {
2165 unsafe {
2166 ::unity::il2cpp_call!((::unity::module_base()+0x29003e0usize)as*mut u8,i32;
2167(*mut AIThink_EntrustAttackTarget)self as*mut AIThink_EntrustAttackTarget)
2168 }
2169 }
2170
2171 #[doc = "`set_Z(i32)` overload"]
2172 pub fn set_z(&mut self, value: impl ::core::convert::Into<i32>) -> () {
2173 unsafe {
2174 ::unity::il2cpp_call!((::unity::module_base()+0x29003f0usize)as*mut u8,();
2175(*mut AIThink_EntrustAttackTarget)self as*mut AIThink_EntrustAttackTarget,(i32)::core::convert::Into::into(value))
2176 }
2177 }
2178
2179 #[doc = "`get_Score()` overload"]
2180 pub fn get_score(&mut self) -> u32 {
2181 unsafe {
2182 ::unity::il2cpp_call!((::unity::module_base()+0x28f59e0usize)as*mut u8,u32;
2183(*mut AIThink_EntrustAttackTarget)self as*mut AIThink_EntrustAttackTarget)
2184 }
2185 }
2186
2187 #[doc = "`get_MoveX()` overload"]
2188 pub fn get_move_x(&mut self) -> i32 {
2189 unsafe {
2190 ::unity::il2cpp_call!((::unity::module_base()+0x2900400usize)as*mut u8,i32;
2191(*mut AIThink_EntrustAttackTarget)self as*mut AIThink_EntrustAttackTarget)
2192 }
2193 }
2194
2195 #[doc = "`get_MoveZ()` overload"]
2196 pub fn get_move_z(&mut self) -> i32 {
2197 unsafe {
2198 ::unity::il2cpp_call!((::unity::module_base()+0x2900410usize)as*mut u8,i32;
2199(*mut AIThink_EntrustAttackTarget)self as*mut AIThink_EntrustAttackTarget)
2200 }
2201 }
2202
2203 #[doc = "`get_AttackX()` overload"]
2204 pub fn get_attack_x(&mut self) -> i32 {
2205 unsafe {
2206 ::unity::il2cpp_call!((::unity::module_base()+0x2900420usize)as*mut u8,i32;
2207(*mut AIThink_EntrustAttackTarget)self as*mut AIThink_EntrustAttackTarget)
2208 }
2209 }
2210
2211 #[doc = "`get_AttackZ()` overload"]
2212 pub fn get_attack_z(&mut self) -> i32 {
2213 unsafe {
2214 ::unity::il2cpp_call!((::unity::module_base()+0x2900430usize)as*mut u8,i32;
2215(*mut AIThink_EntrustAttackTarget)self as*mut AIThink_EntrustAttackTarget)
2216 }
2217 }
2218
2219 #[doc = "`get_KillRate()` overload"]
2220 pub fn get_kill_rate(&mut self) -> f32 {
2221 unsafe {
2222 ::unity::il2cpp_call!((::unity::module_base()+0x2900440usize)as*mut u8,f32;
2223(*mut AIThink_EntrustAttackTarget)self as*mut AIThink_EntrustAttackTarget)
2224 }
2225 }
2226
2227 #[doc = "`get_DeadRate()` overload"]
2228 pub fn get_dead_rate(&mut self) -> f32 {
2229 unsafe {
2230 ::unity::il2cpp_call!((::unity::module_base()+0x2900450usize)as*mut u8,f32;
2231(*mut AIThink_EntrustAttackTarget)self as*mut AIThink_EntrustAttackTarget)
2232 }
2233 }
2234
2235 #[doc = "`Clear()` overload"]
2236 pub fn clear(&mut self) -> () {
2237 unsafe {
2238 ::unity::il2cpp_call!((::unity::module_base()+0x2900460usize)as*mut u8,();
2239(*mut AIThink_EntrustAttackTarget)self as*mut AIThink_EntrustAttackTarget)
2240 }
2241 }
2242}
2243
2244#[cfg(feature = "app-aithink")]
2245impl AIThink_EntrustAttackTarget {
2246 pub fn get_unit_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2247 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2248 }
2249
2250 pub fn set_unit_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2251 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2252 }
2253
2254 pub fn get_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2255 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2256 }
2257
2258 pub fn set_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2259 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
2260 }
2261
2262 pub fn get_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2263 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
2264 }
2265
2266 pub fn set_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2267 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
2268 }
2269
2270 pub fn get_score_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2271 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
2272 }
2273
2274 pub fn get_move_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2275 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
2276 }
2277
2278 pub fn get_move_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2279 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
2280 }
2281
2282 pub fn get_attack_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2283 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
2284 }
2285
2286 pub fn get_attack_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2287 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
2288 }
2289
2290 pub fn get_kill_rate_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2291 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
2292 }
2293
2294 pub fn get_dead_rate_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2295 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
2296 }
2297
2298 pub fn clear_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2299 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
2300 }
2301
2302 pub fn new_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2303 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[14]
2304 }
2305}
2306
2307#[cfg(feature = "app-aithink")]
2308impl AIThink_EnchantThink_SurroundingInfo {
2309 #[doc = "`get_MorphCount()` overload"]
2310 pub fn get_morph_count(&mut self) -> i32 {
2311 unsafe {
2312 ::unity::il2cpp_call!((::unity::module_base()+0x1b31290usize)as*mut u8,i32;
2313(*mut AIThink_EnchantThink_SurroundingInfo)self as*mut AIThink_EnchantThink_SurroundingInfo)
2314 }
2315 }
2316
2317 #[doc = "`set_MorphCount(i32)` overload"]
2318 pub fn set_morph_count(&mut self, value: impl ::core::convert::Into<i32>) -> () {
2319 unsafe {
2320 ::unity::il2cpp_call!((::unity::module_base()+0x1b312a0usize)as*mut u8,();
2321(*mut AIThink_EnchantThink_SurroundingInfo)self as*mut AIThink_EnchantThink_SurroundingInfo,(i32)::core::convert::Into::into(value))
2322 }
2323 }
2324
2325 #[doc = "`get_PhysicalAttackCount()` overload"]
2326 pub fn get_physical_attack_count(&mut self) -> i32 {
2327 unsafe {
2328 ::unity::il2cpp_call!((::unity::module_base()+0x1b31330usize)as*mut u8,i32;
2329(*mut AIThink_EnchantThink_SurroundingInfo)self as*mut AIThink_EnchantThink_SurroundingInfo)
2330 }
2331 }
2332
2333 #[doc = "`set_PhysicalAttackCount(i32)` overload"]
2334 pub fn set_physical_attack_count(&mut self, value: impl ::core::convert::Into<i32>) -> () {
2335 unsafe {
2336 ::unity::il2cpp_call!((::unity::module_base()+0x1b31340usize)as*mut u8,();
2337(*mut AIThink_EnchantThink_SurroundingInfo)self as*mut AIThink_EnchantThink_SurroundingInfo,(i32)::core::convert::Into::into(value))
2338 }
2339 }
2340
2341 #[doc = "`get_MagicAttackCount()` overload"]
2342 pub fn get_magic_attack_count(&mut self) -> i32 {
2343 unsafe {
2344 ::unity::il2cpp_call!((::unity::module_base()+0x1b313d0usize)as*mut u8,i32;
2345(*mut AIThink_EnchantThink_SurroundingInfo)self as*mut AIThink_EnchantThink_SurroundingInfo)
2346 }
2347 }
2348
2349 #[doc = "`set_MagicAttackCount(i32)` overload"]
2350 pub fn set_magic_attack_count(&mut self, value: impl ::core::convert::Into<i32>) -> () {
2351 unsafe {
2352 ::unity::il2cpp_call!((::unity::module_base()+0x1b313e0usize)as*mut u8,();
2353(*mut AIThink_EnchantThink_SurroundingInfo)self as*mut AIThink_EnchantThink_SurroundingInfo,(i32)::core::convert::Into::into(value))
2354 }
2355 }
2356
2357 #[doc = "`get_AttackCount()` overload"]
2358 pub fn get_attack_count(&mut self) -> i32 {
2359 unsafe {
2360 ::unity::il2cpp_call!((::unity::module_base()+0x1b31470usize)as*mut u8,i32;
2361(*mut AIThink_EnchantThink_SurroundingInfo)self as*mut AIThink_EnchantThink_SurroundingInfo)
2362 }
2363 }
2364
2365 #[doc = "`get_ChainAttackCount()` overload"]
2366 pub fn get_chain_attack_count(&mut self) -> i32 {
2367 unsafe {
2368 ::unity::il2cpp_call!((::unity::module_base()+0x1b31490usize)as*mut u8,i32;
2369(*mut AIThink_EnchantThink_SurroundingInfo)self as*mut AIThink_EnchantThink_SurroundingInfo)
2370 }
2371 }
2372
2373 #[doc = "`set_ChainAttackCount(i32)` overload"]
2374 pub fn set_chain_attack_count(&mut self, value: impl ::core::convert::Into<i32>) -> () {
2375 unsafe {
2376 ::unity::il2cpp_call!((::unity::module_base()+0x1b314a0usize)as*mut u8,();
2377(*mut AIThink_EnchantThink_SurroundingInfo)self as*mut AIThink_EnchantThink_SurroundingInfo,(i32)::core::convert::Into::into(value))
2378 }
2379 }
2380
2381 #[doc = "`get_BreakCount()` overload"]
2382 pub fn get_break_count(&mut self) -> i32 {
2383 unsafe {
2384 ::unity::il2cpp_call!((::unity::module_base()+0x1b31530usize)as*mut u8,i32;
2385(*mut AIThink_EnchantThink_SurroundingInfo)self as*mut AIThink_EnchantThink_SurroundingInfo)
2386 }
2387 }
2388
2389 #[doc = "`set_BreakCount(i32)` overload"]
2390 pub fn set_break_count(&mut self, value: impl ::core::convert::Into<i32>) -> () {
2391 unsafe {
2392 ::unity::il2cpp_call!((::unity::module_base()+0x1b31540usize)as*mut u8,();
2393(*mut AIThink_EnchantThink_SurroundingInfo)self as*mut AIThink_EnchantThink_SurroundingInfo,(i32)::core::convert::Into::into(value))
2394 }
2395 }
2396
2397 #[doc = "`get_SilenceCount()` overload"]
2398 pub fn get_silence_count(&mut self) -> i32 {
2399 unsafe {
2400 ::unity::il2cpp_call!((::unity::module_base()+0x1b315d0usize)as*mut u8,i32;
2401(*mut AIThink_EnchantThink_SurroundingInfo)self as*mut AIThink_EnchantThink_SurroundingInfo)
2402 }
2403 }
2404
2405 #[doc = "`set_SilenceCount(i32)` overload"]
2406 pub fn set_silence_count(&mut self, value: impl ::core::convert::Into<i32>) -> () {
2407 unsafe {
2408 ::unity::il2cpp_call!((::unity::module_base()+0x1b315e0usize)as*mut u8,();
2409(*mut AIThink_EnchantThink_SurroundingInfo)self as*mut AIThink_EnchantThink_SurroundingInfo,(i32)::core::convert::Into::into(value))
2410 }
2411 }
2412
2413 #[doc = "`get_FreezeCount()` overload"]
2414 pub fn get_freeze_count(&mut self) -> i32 {
2415 unsafe {
2416 ::unity::il2cpp_call!((::unity::module_base()+0x1b31670usize)as*mut u8,i32;
2417(*mut AIThink_EnchantThink_SurroundingInfo)self as*mut AIThink_EnchantThink_SurroundingInfo)
2418 }
2419 }
2420
2421 #[doc = "`set_FreezeCount(i32)` overload"]
2422 pub fn set_freeze_count(&mut self, value: impl ::core::convert::Into<i32>) -> () {
2423 unsafe {
2424 ::unity::il2cpp_call!((::unity::module_base()+0x1b31680usize)as*mut u8,();
2425(*mut AIThink_EnchantThink_SurroundingInfo)self as*mut AIThink_EnchantThink_SurroundingInfo,(i32)::core::convert::Into::into(value))
2426 }
2427 }
2428
2429 #[doc = "`Get(u32, i32)` overload"]
2430 pub fn get(&mut self, mask: impl ::core::convert::Into<u32>, shift: impl ::core::convert::Into<i32>) -> i32 {
2431 unsafe {
2432 ::unity::il2cpp_call!((::unity::module_base()+0x1b31710usize)as*mut u8,i32;
2433(*mut AIThink_EnchantThink_SurroundingInfo)self as*mut AIThink_EnchantThink_SurroundingInfo,(u32)::core::convert::Into::into(mask),(i32)::core::convert::Into::into(shift))
2434 }
2435 }
2436
2437 #[doc = "`Set(u32, i32, i32)` overload"]
2438 pub fn set(&mut self, mask: impl ::core::convert::Into<u32>, shift: impl ::core::convert::Into<i32>, v: impl ::core::convert::Into<i32>) -> () {
2439 unsafe {
2440 ::unity::il2cpp_call!((::unity::module_base()+0x1b31720usize)as*mut u8,();
2441(*mut AIThink_EnchantThink_SurroundingInfo)self as*mut AIThink_EnchantThink_SurroundingInfo,(u32)::core::convert::Into::into(mask),(i32)::core::convert::Into::into(shift),(i32)::core::convert::Into::into(v))
2442 }
2443 }
2444}
2445
2446#[cfg(feature = "app-aithink")]
2447impl AIThink_EnchantThink_SurroundingInfo {
2448 pub fn get_morph_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2449 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2450 }
2451
2452 pub fn set_morph_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2453 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2454 }
2455
2456 pub fn get_physical_attack_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2457 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2458 }
2459
2460 pub fn set_physical_attack_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2461 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
2462 }
2463
2464 pub fn get_magic_attack_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2465 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
2466 }
2467
2468 pub fn set_magic_attack_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2469 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
2470 }
2471
2472 pub fn get_attack_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2473 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
2474 }
2475
2476 pub fn get_chain_attack_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2477 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
2478 }
2479
2480 pub fn set_chain_attack_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2481 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
2482 }
2483
2484 pub fn get_break_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2485 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
2486 }
2487
2488 pub fn set_break_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2489 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
2490 }
2491
2492 pub fn get_silence_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2493 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
2494 }
2495
2496 pub fn set_silence_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2497 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
2498 }
2499
2500 pub fn get_freeze_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2501 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
2502 }
2503
2504 pub fn set_freeze_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2505 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[14]
2506 }
2507
2508 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2509 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[15]
2510 }
2511
2512 pub fn set_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2513 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[16]
2514 }
2515}
2516
2517#[cfg(feature = "app-aithink")]
2518impl AIThink_EnchantThink_DMPTResult {
2519 #[doc = "`Clear()` overload"]
2520 pub fn clear(&mut self) -> () {
2521 unsafe {
2522 ::unity::il2cpp_call!((::unity::module_base()+0x1b311b0usize)as*mut u8,();
2523(*mut AIThink_EnchantThink_DMPTResult)self as*mut AIThink_EnchantThink_DMPTResult)
2524 }
2525 }
2526}
2527
2528#[cfg(feature = "app-aithink")]
2529impl AIThink_EnchantThink_DMPTResult {
2530 pub fn clear_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2531 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2532 }
2533}
2534
2535#[cfg(feature = "app-aithink")]
2536impl AIThink_EntrustAttackScoreResult {
2537 #[doc = "`get_Score()` overload"]
2538 pub fn get_score(&mut self) -> u32 {
2539 unsafe {
2540 ::unity::il2cpp_call!((::unity::module_base()+0x29002a0usize)as*mut u8,u32;
2541(*mut AIThink_EntrustAttackScoreResult)self as*mut AIThink_EntrustAttackScoreResult)
2542 }
2543 }
2544
2545 #[doc = "`set_Score(u32)` overload"]
2546 pub fn set_score(&mut self, value: impl ::core::convert::Into<u32>) -> () {
2547 unsafe {
2548 ::unity::il2cpp_call!((::unity::module_base()+0x29002b0usize)as*mut u8,();
2549(*mut AIThink_EntrustAttackScoreResult)self as*mut AIThink_EntrustAttackScoreResult,(u32)::core::convert::Into::into(value))
2550 }
2551 }
2552
2553 #[doc = "`get_MoveX()` overload"]
2554 pub fn get_move_x(&mut self) -> i32 {
2555 unsafe {
2556 ::unity::il2cpp_call!((::unity::module_base()+0x29002c0usize)as*mut u8,i32;
2557(*mut AIThink_EntrustAttackScoreResult)self as*mut AIThink_EntrustAttackScoreResult)
2558 }
2559 }
2560
2561 #[doc = "`set_MoveX(i32)` overload"]
2562 pub fn set_move_x(&mut self, value: impl ::core::convert::Into<i32>) -> () {
2563 unsafe {
2564 ::unity::il2cpp_call!((::unity::module_base()+0x29002d0usize)as*mut u8,();
2565(*mut AIThink_EntrustAttackScoreResult)self as*mut AIThink_EntrustAttackScoreResult,(i32)::core::convert::Into::into(value))
2566 }
2567 }
2568
2569 #[doc = "`get_MoveZ()` overload"]
2570 pub fn get_move_z(&mut self) -> i32 {
2571 unsafe {
2572 ::unity::il2cpp_call!((::unity::module_base()+0x29002e0usize)as*mut u8,i32;
2573(*mut AIThink_EntrustAttackScoreResult)self as*mut AIThink_EntrustAttackScoreResult)
2574 }
2575 }
2576
2577 #[doc = "`set_MoveZ(i32)` overload"]
2578 pub fn set_move_z(&mut self, value: impl ::core::convert::Into<i32>) -> () {
2579 unsafe {
2580 ::unity::il2cpp_call!((::unity::module_base()+0x29002f0usize)as*mut u8,();
2581(*mut AIThink_EntrustAttackScoreResult)self as*mut AIThink_EntrustAttackScoreResult,(i32)::core::convert::Into::into(value))
2582 }
2583 }
2584
2585 #[doc = "`get_AttackX()` overload"]
2586 pub fn get_attack_x(&mut self) -> i32 {
2587 unsafe {
2588 ::unity::il2cpp_call!((::unity::module_base()+0x2900300usize)as*mut u8,i32;
2589(*mut AIThink_EntrustAttackScoreResult)self as*mut AIThink_EntrustAttackScoreResult)
2590 }
2591 }
2592
2593 #[doc = "`set_AttackX(i32)` overload"]
2594 pub fn set_attack_x(&mut self, value: impl ::core::convert::Into<i32>) -> () {
2595 unsafe {
2596 ::unity::il2cpp_call!((::unity::module_base()+0x2900310usize)as*mut u8,();
2597(*mut AIThink_EntrustAttackScoreResult)self as*mut AIThink_EntrustAttackScoreResult,(i32)::core::convert::Into::into(value))
2598 }
2599 }
2600
2601 #[doc = "`get_AttackZ()` overload"]
2602 pub fn get_attack_z(&mut self) -> i32 {
2603 unsafe {
2604 ::unity::il2cpp_call!((::unity::module_base()+0x2900320usize)as*mut u8,i32;
2605(*mut AIThink_EntrustAttackScoreResult)self as*mut AIThink_EntrustAttackScoreResult)
2606 }
2607 }
2608
2609 #[doc = "`set_AttackZ(i32)` overload"]
2610 pub fn set_attack_z(&mut self, value: impl ::core::convert::Into<i32>) -> () {
2611 unsafe {
2612 ::unity::il2cpp_call!((::unity::module_base()+0x2900330usize)as*mut u8,();
2613(*mut AIThink_EntrustAttackScoreResult)self as*mut AIThink_EntrustAttackScoreResult,(i32)::core::convert::Into::into(value))
2614 }
2615 }
2616
2617 #[doc = "`get_KillRate()` overload"]
2618 pub fn get_kill_rate(&mut self) -> f32 {
2619 unsafe {
2620 ::unity::il2cpp_call!((::unity::module_base()+0x2900340usize)as*mut u8,f32;
2621(*mut AIThink_EntrustAttackScoreResult)self as*mut AIThink_EntrustAttackScoreResult)
2622 }
2623 }
2624
2625 #[doc = "`set_KillRate(f32)` overload"]
2626 pub fn set_kill_rate(&mut self, value: impl ::core::convert::Into<f32>) -> () {
2627 unsafe {
2628 ::unity::il2cpp_call!((::unity::module_base()+0x2900350usize)as*mut u8,();
2629(*mut AIThink_EntrustAttackScoreResult)self as*mut AIThink_EntrustAttackScoreResult,(f32)::core::convert::Into::into(value))
2630 }
2631 }
2632
2633 #[doc = "`get_DeadRate()` overload"]
2634 pub fn get_dead_rate(&mut self) -> f32 {
2635 unsafe {
2636 ::unity::il2cpp_call!((::unity::module_base()+0x2900360usize)as*mut u8,f32;
2637(*mut AIThink_EntrustAttackScoreResult)self as*mut AIThink_EntrustAttackScoreResult)
2638 }
2639 }
2640
2641 #[doc = "`set_DeadRate(f32)` overload"]
2642 pub fn set_dead_rate(&mut self, value: impl ::core::convert::Into<f32>) -> () {
2643 unsafe {
2644 ::unity::il2cpp_call!((::unity::module_base()+0x2900370usize)as*mut u8,();
2645(*mut AIThink_EntrustAttackScoreResult)self as*mut AIThink_EntrustAttackScoreResult,(f32)::core::convert::Into::into(value))
2646 }
2647 }
2648
2649 #[doc = "`Clear()` overload"]
2650 pub fn clear(&mut self) -> () {
2651 unsafe {
2652 ::unity::il2cpp_call!((::unity::module_base()+0x2900380usize)as*mut u8,();
2653(*mut AIThink_EntrustAttackScoreResult)self as*mut AIThink_EntrustAttackScoreResult)
2654 }
2655 }
2656}
2657
2658#[cfg(feature = "app-aithink")]
2659impl AIThink_EntrustAttackScoreResult {
2660 pub fn get_score_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2661 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2662 }
2663
2664 pub fn set_score_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2665 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2666 }
2667
2668 pub fn get_move_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2669 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2670 }
2671
2672 pub fn set_move_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2673 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
2674 }
2675
2676 pub fn get_move_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2677 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
2678 }
2679
2680 pub fn set_move_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2681 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
2682 }
2683
2684 pub fn get_attack_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2685 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
2686 }
2687
2688 pub fn set_attack_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2689 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
2690 }
2691
2692 pub fn get_attack_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2693 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
2694 }
2695
2696 pub fn set_attack_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2697 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
2698 }
2699
2700 pub fn get_kill_rate_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2701 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
2702 }
2703
2704 pub fn set_kill_rate_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2705 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
2706 }
2707
2708 pub fn get_dead_rate_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2709 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
2710 }
2711
2712 pub fn set_dead_rate_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2713 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
2714 }
2715
2716 pub fn clear_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2717 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[14]
2718 }
2719}
2720
2721#[cfg(feature = "app-aithink")]
2722impl AIThink_HealRodScoreImplResult {
2723 #[doc = "`get_MoveX()` overload"]
2724 pub fn get_move_x(&mut self) -> i32 {
2725 unsafe {
2726 ::unity::il2cpp_call!((::unity::module_base()+0x2900580usize)as*mut u8,i32;
2727(*mut AIThink_HealRodScoreImplResult)self as*mut AIThink_HealRodScoreImplResult)
2728 }
2729 }
2730
2731 #[doc = "`set_MoveX(i32)` overload"]
2732 pub fn set_move_x(&mut self, value: impl ::core::convert::Into<i32>) -> () {
2733 unsafe {
2734 ::unity::il2cpp_call!((::unity::module_base()+0x2900590usize)as*mut u8,();
2735(*mut AIThink_HealRodScoreImplResult)self as*mut AIThink_HealRodScoreImplResult,(i32)::core::convert::Into::into(value))
2736 }
2737 }
2738
2739 #[doc = "`get_MoveZ()` overload"]
2740 pub fn get_move_z(&mut self) -> i32 {
2741 unsafe {
2742 ::unity::il2cpp_call!((::unity::module_base()+0x29005a0usize)as*mut u8,i32;
2743(*mut AIThink_HealRodScoreImplResult)self as*mut AIThink_HealRodScoreImplResult)
2744 }
2745 }
2746
2747 #[doc = "`set_MoveZ(i32)` overload"]
2748 pub fn set_move_z(&mut self, value: impl ::core::convert::Into<i32>) -> () {
2749 unsafe {
2750 ::unity::il2cpp_call!((::unity::module_base()+0x29005b0usize)as*mut u8,();
2751(*mut AIThink_HealRodScoreImplResult)self as*mut AIThink_HealRodScoreImplResult,(i32)::core::convert::Into::into(value))
2752 }
2753 }
2754
2755 #[doc = "`get_AttackX()` overload"]
2756 pub fn get_attack_x(&mut self) -> i32 {
2757 unsafe {
2758 ::unity::il2cpp_call!((::unity::module_base()+0x29005c0usize)as*mut u8,i32;
2759(*mut AIThink_HealRodScoreImplResult)self as*mut AIThink_HealRodScoreImplResult)
2760 }
2761 }
2762
2763 #[doc = "`set_AttackX(i32)` overload"]
2764 pub fn set_attack_x(&mut self, value: impl ::core::convert::Into<i32>) -> () {
2765 unsafe {
2766 ::unity::il2cpp_call!((::unity::module_base()+0x29005d0usize)as*mut u8,();
2767(*mut AIThink_HealRodScoreImplResult)self as*mut AIThink_HealRodScoreImplResult,(i32)::core::convert::Into::into(value))
2768 }
2769 }
2770
2771 #[doc = "`get_AttackZ()` overload"]
2772 pub fn get_attack_z(&mut self) -> i32 {
2773 unsafe {
2774 ::unity::il2cpp_call!((::unity::module_base()+0x29005e0usize)as*mut u8,i32;
2775(*mut AIThink_HealRodScoreImplResult)self as*mut AIThink_HealRodScoreImplResult)
2776 }
2777 }
2778
2779 #[doc = "`set_AttackZ(i32)` overload"]
2780 pub fn set_attack_z(&mut self, value: impl ::core::convert::Into<i32>) -> () {
2781 unsafe {
2782 ::unity::il2cpp_call!((::unity::module_base()+0x29005f0usize)as*mut u8,();
2783(*mut AIThink_HealRodScoreImplResult)self as*mut AIThink_HealRodScoreImplResult,(i32)::core::convert::Into::into(value))
2784 }
2785 }
2786
2787 #[doc = "`get_Heal()` overload"]
2788 pub fn get_heal(&mut self) -> i32 {
2789 unsafe {
2790 ::unity::il2cpp_call!((::unity::module_base()+0x2900600usize)as*mut u8,i32;
2791(*mut AIThink_HealRodScoreImplResult)self as*mut AIThink_HealRodScoreImplResult)
2792 }
2793 }
2794
2795 #[doc = "`set_Heal(i32)` overload"]
2796 pub fn set_heal(&mut self, value: impl ::core::convert::Into<i32>) -> () {
2797 unsafe {
2798 ::unity::il2cpp_call!((::unity::module_base()+0x2900610usize)as*mut u8,();
2799(*mut AIThink_HealRodScoreImplResult)self as*mut AIThink_HealRodScoreImplResult,(i32)::core::convert::Into::into(value))
2800 }
2801 }
2802
2803 #[doc = "`get_Damage()` overload"]
2804 pub fn get_damage(&mut self) -> i32 {
2805 unsafe {
2806 ::unity::il2cpp_call!((::unity::module_base()+0x2900620usize)as*mut u8,i32;
2807(*mut AIThink_HealRodScoreImplResult)self as*mut AIThink_HealRodScoreImplResult)
2808 }
2809 }
2810
2811 #[doc = "`set_Damage(i32)` overload"]
2812 pub fn set_damage(&mut self, value: impl ::core::convert::Into<i32>) -> () {
2813 unsafe {
2814 ::unity::il2cpp_call!((::unity::module_base()+0x2900630usize)as*mut u8,();
2815(*mut AIThink_HealRodScoreImplResult)self as*mut AIThink_HealRodScoreImplResult,(i32)::core::convert::Into::into(value))
2816 }
2817 }
2818
2819 #[doc = "`Clear()` overload"]
2820 pub fn clear(&mut self) -> () {
2821 unsafe {
2822 ::unity::il2cpp_call!((::unity::module_base()+0x2900640usize)as*mut u8,();
2823(*mut AIThink_HealRodScoreImplResult)self as*mut AIThink_HealRodScoreImplResult)
2824 }
2825 }
2826}
2827
2828#[cfg(feature = "app-aithink")]
2829impl AIThink_HealRodScoreImplResult {
2830 pub fn get_move_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2831 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2832 }
2833
2834 pub fn set_move_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2835 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2836 }
2837
2838 pub fn get_move_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2839 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2840 }
2841
2842 pub fn set_move_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2843 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
2844 }
2845
2846 pub fn get_attack_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2847 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
2848 }
2849
2850 pub fn set_attack_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2851 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
2852 }
2853
2854 pub fn get_attack_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2855 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
2856 }
2857
2858 pub fn set_attack_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2859 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
2860 }
2861
2862 pub fn get_heal_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2863 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
2864 }
2865
2866 pub fn set_heal_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2867 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
2868 }
2869
2870 pub fn get_damage_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2871 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
2872 }
2873
2874 pub fn set_damage_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2875 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
2876 }
2877
2878 pub fn clear_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2879 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
2880 }
2881}
2882
2883#[cfg(feature = "app-aithink")]
2884impl AIThink_InterferenceScoreResult {
2885 #[doc = "`get_Score()` overload"]
2886 pub fn get_score(&mut self) -> u32 {
2887 unsafe {
2888 ::unity::il2cpp_call!((::unity::module_base()+0x29006d0usize)as*mut u8,u32;
2889(*mut AIThink_InterferenceScoreResult)self as*mut AIThink_InterferenceScoreResult)
2890 }
2891 }
2892
2893 #[doc = "`set_Score(u32)` overload"]
2894 pub fn set_score(&mut self, value: impl ::core::convert::Into<u32>) -> () {
2895 unsafe {
2896 ::unity::il2cpp_call!((::unity::module_base()+0x29006e0usize)as*mut u8,();
2897(*mut AIThink_InterferenceScoreResult)self as*mut AIThink_InterferenceScoreResult,(u32)::core::convert::Into::into(value))
2898 }
2899 }
2900
2901 #[doc = "`get_MoveX()` overload"]
2902 pub fn get_move_x(&mut self) -> i32 {
2903 unsafe {
2904 ::unity::il2cpp_call!((::unity::module_base()+0x29006f0usize)as*mut u8,i32;
2905(*mut AIThink_InterferenceScoreResult)self as*mut AIThink_InterferenceScoreResult)
2906 }
2907 }
2908
2909 #[doc = "`set_MoveX(i32)` overload"]
2910 pub fn set_move_x(&mut self, value: impl ::core::convert::Into<i32>) -> () {
2911 unsafe {
2912 ::unity::il2cpp_call!((::unity::module_base()+0x2900700usize)as*mut u8,();
2913(*mut AIThink_InterferenceScoreResult)self as*mut AIThink_InterferenceScoreResult,(i32)::core::convert::Into::into(value))
2914 }
2915 }
2916
2917 #[doc = "`get_MoveZ()` overload"]
2918 pub fn get_move_z(&mut self) -> i32 {
2919 unsafe {
2920 ::unity::il2cpp_call!((::unity::module_base()+0x2900710usize)as*mut u8,i32;
2921(*mut AIThink_InterferenceScoreResult)self as*mut AIThink_InterferenceScoreResult)
2922 }
2923 }
2924
2925 #[doc = "`set_MoveZ(i32)` overload"]
2926 pub fn set_move_z(&mut self, value: impl ::core::convert::Into<i32>) -> () {
2927 unsafe {
2928 ::unity::il2cpp_call!((::unity::module_base()+0x2900720usize)as*mut u8,();
2929(*mut AIThink_InterferenceScoreResult)self as*mut AIThink_InterferenceScoreResult,(i32)::core::convert::Into::into(value))
2930 }
2931 }
2932
2933 #[doc = "`get_AttackX()` overload"]
2934 pub fn get_attack_x(&mut self) -> i32 {
2935 unsafe {
2936 ::unity::il2cpp_call!((::unity::module_base()+0x2900730usize)as*mut u8,i32;
2937(*mut AIThink_InterferenceScoreResult)self as*mut AIThink_InterferenceScoreResult)
2938 }
2939 }
2940
2941 #[doc = "`set_AttackX(i32)` overload"]
2942 pub fn set_attack_x(&mut self, value: impl ::core::convert::Into<i32>) -> () {
2943 unsafe {
2944 ::unity::il2cpp_call!((::unity::module_base()+0x2900740usize)as*mut u8,();
2945(*mut AIThink_InterferenceScoreResult)self as*mut AIThink_InterferenceScoreResult,(i32)::core::convert::Into::into(value))
2946 }
2947 }
2948
2949 #[doc = "`get_AttackZ()` overload"]
2950 pub fn get_attack_z(&mut self) -> i32 {
2951 unsafe {
2952 ::unity::il2cpp_call!((::unity::module_base()+0x2900750usize)as*mut u8,i32;
2953(*mut AIThink_InterferenceScoreResult)self as*mut AIThink_InterferenceScoreResult)
2954 }
2955 }
2956
2957 #[doc = "`set_AttackZ(i32)` overload"]
2958 pub fn set_attack_z(&mut self, value: impl ::core::convert::Into<i32>) -> () {
2959 unsafe {
2960 ::unity::il2cpp_call!((::unity::module_base()+0x2900760usize)as*mut u8,();
2961(*mut AIThink_InterferenceScoreResult)self as*mut AIThink_InterferenceScoreResult,(i32)::core::convert::Into::into(value))
2962 }
2963 }
2964
2965 #[doc = "`get_ItemIndex()` overload"]
2966 pub fn get_item_index(&mut self) -> i32 {
2967 unsafe {
2968 ::unity::il2cpp_call!((::unity::module_base()+0x2900770usize)as*mut u8,i32;
2969(*mut AIThink_InterferenceScoreResult)self as*mut AIThink_InterferenceScoreResult)
2970 }
2971 }
2972
2973 #[doc = "`set_ItemIndex(i32)` overload"]
2974 pub fn set_item_index(&mut self, value: impl ::core::convert::Into<i32>) -> () {
2975 unsafe {
2976 ::unity::il2cpp_call!((::unity::module_base()+0x2900780usize)as*mut u8,();
2977(*mut AIThink_InterferenceScoreResult)self as*mut AIThink_InterferenceScoreResult,(i32)::core::convert::Into::into(value))
2978 }
2979 }
2980
2981 #[doc = "`Clear()` overload"]
2982 pub fn clear(&mut self) -> () {
2983 unsafe {
2984 ::unity::il2cpp_call!((::unity::module_base()+0x2900790usize)as*mut u8,();
2985(*mut AIThink_InterferenceScoreResult)self as*mut AIThink_InterferenceScoreResult)
2986 }
2987 }
2988}
2989
2990#[cfg(feature = "app-aithink")]
2991impl AIThink_InterferenceScoreResult {
2992 pub fn get_score_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2993 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2994 }
2995
2996 pub fn set_score_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2997 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2998 }
2999
3000 pub fn get_move_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3001 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
3002 }
3003
3004 pub fn set_move_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3005 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
3006 }
3007
3008 pub fn get_move_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3009 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
3010 }
3011
3012 pub fn set_move_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3013 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
3014 }
3015
3016 pub fn get_attack_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3017 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
3018 }
3019
3020 pub fn set_attack_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3021 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
3022 }
3023
3024 pub fn get_attack_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3025 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
3026 }
3027
3028 pub fn set_attack_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3029 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
3030 }
3031
3032 pub fn get_item_index_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3033 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
3034 }
3035
3036 pub fn set_item_index_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3037 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
3038 }
3039
3040 pub fn clear_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3041 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
3042 }
3043}
3044
3045#[cfg(feature = "app-aithink")]
3046impl AIThink_RescueRodScoreResult {
3047 #[doc = "`get_Score()` overload"]
3048 pub fn get_score(&mut self) -> u32 {
3049 unsafe {
3050 ::unity::il2cpp_call!((::unity::module_base()+0x2900e90usize)as*mut u8,u32;
3051(*mut AIThink_RescueRodScoreResult)self as*mut AIThink_RescueRodScoreResult)
3052 }
3053 }
3054
3055 #[doc = "`set_Score(u32)` overload"]
3056 pub fn set_score(&mut self, value: impl ::core::convert::Into<u32>) -> () {
3057 unsafe {
3058 ::unity::il2cpp_call!((::unity::module_base()+0x2900ea0usize)as*mut u8,();
3059(*mut AIThink_RescueRodScoreResult)self as*mut AIThink_RescueRodScoreResult,(u32)::core::convert::Into::into(value))
3060 }
3061 }
3062
3063 #[doc = "`get_MoveX()` overload"]
3064 pub fn get_move_x(&mut self) -> i32 {
3065 unsafe {
3066 ::unity::il2cpp_call!((::unity::module_base()+0x2900eb0usize)as*mut u8,i32;
3067(*mut AIThink_RescueRodScoreResult)self as*mut AIThink_RescueRodScoreResult)
3068 }
3069 }
3070
3071 #[doc = "`set_MoveX(i32)` overload"]
3072 pub fn set_move_x(&mut self, value: impl ::core::convert::Into<i32>) -> () {
3073 unsafe {
3074 ::unity::il2cpp_call!((::unity::module_base()+0x2900ec0usize)as*mut u8,();
3075(*mut AIThink_RescueRodScoreResult)self as*mut AIThink_RescueRodScoreResult,(i32)::core::convert::Into::into(value))
3076 }
3077 }
3078
3079 #[doc = "`get_MoveZ()` overload"]
3080 pub fn get_move_z(&mut self) -> i32 {
3081 unsafe {
3082 ::unity::il2cpp_call!((::unity::module_base()+0x2900ed0usize)as*mut u8,i32;
3083(*mut AIThink_RescueRodScoreResult)self as*mut AIThink_RescueRodScoreResult)
3084 }
3085 }
3086
3087 #[doc = "`set_MoveZ(i32)` overload"]
3088 pub fn set_move_z(&mut self, value: impl ::core::convert::Into<i32>) -> () {
3089 unsafe {
3090 ::unity::il2cpp_call!((::unity::module_base()+0x2900ee0usize)as*mut u8,();
3091(*mut AIThink_RescueRodScoreResult)self as*mut AIThink_RescueRodScoreResult,(i32)::core::convert::Into::into(value))
3092 }
3093 }
3094
3095 #[doc = "`get_AttackX()` overload"]
3096 pub fn get_attack_x(&mut self) -> i32 {
3097 unsafe {
3098 ::unity::il2cpp_call!((::unity::module_base()+0x2900ef0usize)as*mut u8,i32;
3099(*mut AIThink_RescueRodScoreResult)self as*mut AIThink_RescueRodScoreResult)
3100 }
3101 }
3102
3103 #[doc = "`set_AttackX(i32)` overload"]
3104 pub fn set_attack_x(&mut self, value: impl ::core::convert::Into<i32>) -> () {
3105 unsafe {
3106 ::unity::il2cpp_call!((::unity::module_base()+0x2900f00usize)as*mut u8,();
3107(*mut AIThink_RescueRodScoreResult)self as*mut AIThink_RescueRodScoreResult,(i32)::core::convert::Into::into(value))
3108 }
3109 }
3110
3111 #[doc = "`get_AttackZ()` overload"]
3112 pub fn get_attack_z(&mut self) -> i32 {
3113 unsafe {
3114 ::unity::il2cpp_call!((::unity::module_base()+0x2900f10usize)as*mut u8,i32;
3115(*mut AIThink_RescueRodScoreResult)self as*mut AIThink_RescueRodScoreResult)
3116 }
3117 }
3118
3119 #[doc = "`set_AttackZ(i32)` overload"]
3120 pub fn set_attack_z(&mut self, value: impl ::core::convert::Into<i32>) -> () {
3121 unsafe {
3122 ::unity::il2cpp_call!((::unity::module_base()+0x2900f20usize)as*mut u8,();
3123(*mut AIThink_RescueRodScoreResult)self as*mut AIThink_RescueRodScoreResult,(i32)::core::convert::Into::into(value))
3124 }
3125 }
3126
3127 #[doc = "`Clear()` overload"]
3128 pub fn clear(&mut self) -> () {
3129 unsafe {
3130 ::unity::il2cpp_call!((::unity::module_base()+0x2900f30usize)as*mut u8,();
3131(*mut AIThink_RescueRodScoreResult)self as*mut AIThink_RescueRodScoreResult)
3132 }
3133 }
3134}
3135
3136#[cfg(feature = "app-aithink")]
3137impl AIThink_RescueRodScoreResult {
3138 pub fn get_score_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3139 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
3140 }
3141
3142 pub fn set_score_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3143 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
3144 }
3145
3146 pub fn get_move_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3147 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
3148 }
3149
3150 pub fn set_move_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3151 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
3152 }
3153
3154 pub fn get_move_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3155 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
3156 }
3157
3158 pub fn set_move_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3159 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
3160 }
3161
3162 pub fn get_attack_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3163 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
3164 }
3165
3166 pub fn set_attack_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3167 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
3168 }
3169
3170 pub fn get_attack_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3171 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
3172 }
3173
3174 pub fn set_attack_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3175 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
3176 }
3177
3178 pub fn clear_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3179 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
3180 }
3181}
3182
3183#[cfg(feature = "app-aithink")]
3184impl AIThink_WarpRodTarget {
3185 #[doc = "`New(*mutcrate::app::aithink::AIThink_WarpRodTarget)` overload"]
3186 pub fn new() -> crate::app::aithink::AIThink_WarpRodTarget {
3187 unsafe {
3188 let mut __out_0 = ::core::mem::MaybeUninit::<crate::app::aithink::AIThink_WarpRodTarget>::uninit();
3189 ::unity::il2cpp_call!((::unity::module_base()+0x2901950usize)as*mut u8,();
3190(*mut crate::app::aithink::AIThink_WarpRodTarget)__out_0.as_mut_ptr());
3191 __out_0.assume_init()
3192 }
3193 }
3194}
3195
3196#[cfg(feature = "app-aithink")]
3197impl AIThink_WarpRodTarget {
3198 #[doc = "`get_Unit()` overload"]
3199 pub fn get_unit(&mut self) -> crate::app::unit::Unit {
3200 unsafe {
3201 ::unity::il2cpp_call!((::unity::module_base()+0x2901870usize)as*mut u8,crate::app::unit::Unit;
3202(*mut AIThink_WarpRodTarget)self as*mut AIThink_WarpRodTarget)
3203 }
3204 }
3205
3206 #[doc = "`set_Unit(crate::app::unit::Unit)` overload"]
3207 pub fn set_unit(&mut self, value: impl ::core::convert::Into<crate::app::unit::Unit>) -> () {
3208 unsafe {
3209 ::unity::il2cpp_call!((::unity::module_base()+0x2901880usize)as*mut u8,();
3210(*mut AIThink_WarpRodTarget)self as*mut AIThink_WarpRodTarget,(crate::app::unit::Unit)::core::convert::Into::into(value))
3211 }
3212 }
3213
3214 #[doc = "`get_Score()` overload"]
3215 pub fn get_score(&mut self) -> u32 {
3216 unsafe {
3217 ::unity::il2cpp_call!((::unity::module_base()+0x2901890usize)as*mut u8,u32;
3218(*mut AIThink_WarpRodTarget)self as*mut AIThink_WarpRodTarget)
3219 }
3220 }
3221
3222 #[doc = "`set_Score(u32)` overload"]
3223 pub fn set_score(&mut self, value: impl ::core::convert::Into<u32>) -> () {
3224 unsafe {
3225 ::unity::il2cpp_call!((::unity::module_base()+0x29018a0usize)as*mut u8,();
3226(*mut AIThink_WarpRodTarget)self as*mut AIThink_WarpRodTarget,(u32)::core::convert::Into::into(value))
3227 }
3228 }
3229
3230 #[doc = "`get_MoveX()` overload"]
3231 pub fn get_move_x(&mut self) -> i32 {
3232 unsafe {
3233 ::unity::il2cpp_call!((::unity::module_base()+0x29018b0usize)as*mut u8,i32;
3234(*mut AIThink_WarpRodTarget)self as*mut AIThink_WarpRodTarget)
3235 }
3236 }
3237
3238 #[doc = "`get_MoveZ()` overload"]
3239 pub fn get_move_z(&mut self) -> i32 {
3240 unsafe {
3241 ::unity::il2cpp_call!((::unity::module_base()+0x29018c0usize)as*mut u8,i32;
3242(*mut AIThink_WarpRodTarget)self as*mut AIThink_WarpRodTarget)
3243 }
3244 }
3245
3246 #[doc = "`get_AttackX()` overload"]
3247 pub fn get_attack_x(&mut self) -> i32 {
3248 unsafe {
3249 ::unity::il2cpp_call!((::unity::module_base()+0x29018d0usize)as*mut u8,i32;
3250(*mut AIThink_WarpRodTarget)self as*mut AIThink_WarpRodTarget)
3251 }
3252 }
3253
3254 #[doc = "`get_AttackZ()` overload"]
3255 pub fn get_attack_z(&mut self) -> i32 {
3256 unsafe {
3257 ::unity::il2cpp_call!((::unity::module_base()+0x29018e0usize)as*mut u8,i32;
3258(*mut AIThink_WarpRodTarget)self as*mut AIThink_WarpRodTarget)
3259 }
3260 }
3261
3262 #[doc = "`get_WarpX()` overload"]
3263 pub fn get_warp_x(&mut self) -> i32 {
3264 unsafe {
3265 ::unity::il2cpp_call!((::unity::module_base()+0x29018f0usize)as*mut u8,i32;
3266(*mut AIThink_WarpRodTarget)self as*mut AIThink_WarpRodTarget)
3267 }
3268 }
3269
3270 #[doc = "`get_WarpZ()` overload"]
3271 pub fn get_warp_z(&mut self) -> i32 {
3272 unsafe {
3273 ::unity::il2cpp_call!((::unity::module_base()+0x2901900usize)as*mut u8,i32;
3274(*mut AIThink_WarpRodTarget)self as*mut AIThink_WarpRodTarget)
3275 }
3276 }
3277
3278 #[doc = "`Clear()` overload"]
3279 pub fn clear(&mut self) -> () {
3280 unsafe {
3281 ::unity::il2cpp_call!((::unity::module_base()+0x2901910usize)as*mut u8,();
3282(*mut AIThink_WarpRodTarget)self as*mut AIThink_WarpRodTarget)
3283 }
3284 }
3285}
3286
3287#[cfg(feature = "app-aithink")]
3288impl AIThink_WarpRodTarget {
3289 pub fn get_unit_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3290 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
3291 }
3292
3293 pub fn set_unit_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3294 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
3295 }
3296
3297 pub fn get_score_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3298 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
3299 }
3300
3301 pub fn set_score_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3302 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
3303 }
3304
3305 pub fn get_move_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3306 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
3307 }
3308
3309 pub fn get_move_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3310 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
3311 }
3312
3313 pub fn get_attack_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3314 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
3315 }
3316
3317 pub fn get_attack_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3318 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
3319 }
3320
3321 pub fn get_warp_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3322 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
3323 }
3324
3325 pub fn get_warp_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3326 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
3327 }
3328
3329 pub fn clear_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3330 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
3331 }
3332
3333 pub fn new_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3334 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
3335 }
3336}
3337
3338#[cfg(feature = "app-aithink")]
3339pub trait IAIThink_ActionFuncMethods: IAIThink_ActionFunc {
3340 #[doc = "`.ctor(crate::system::object::Object, ::unity::IntPtr)` overload"]
3341 fn ctor(self, object: impl ::core::convert::Into<crate::system::object::Object>, method: impl ::core::convert::Into<::unity::IntPtr>) -> () {
3342 unsafe {
3343 let __receiver = <AIThink_ActionFunc as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3344 ::unity::il2cpp_call!((::unity::module_base()+0x28fb380usize)as*mut u8,();
3345(AIThink_ActionFunc)__receiver,(crate::system::object::Object)::core::convert::Into::into(object),(::unity::IntPtr)::core::convert::Into::into(method))
3346 }
3347 }
3348 #[doc = "`Invoke(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
3349 fn invoke(
3350 self,
3351 command: impl ::core::convert::Into<i32>,
3352 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
3353 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
3354 ) -> crate::app::aithink::AIThink_Result {
3355 unsafe {
3356 let __receiver = <AIThink_ActionFunc as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3357 {
3358 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3359 let __vi = *__vt.get(13usize).unwrap_or_else(|| {
3360 panic!(
3361 "unity: virtual slot {}
3362 out of range (vtable len {}
3363) on the runtime class behind {}
3364 (method `{}
3365`)",
3366 13usize,
3367 __vt.len(),
3368 <AIThink_ActionFunc as ::unity::ClassIdentity>::NAME,
3369 "Invoke",
3370 )
3371 });
3372 let __inner: extern "C" fn(
3373 AIThink_ActionFunc,
3374 i32,
3375 crate::app::aivalue::AIValue,
3376 crate::app::aivalue::AIValue,
3377 ::unity::OptionalMethod,
3378 ) -> crate::app::aithink::AIThink_Result = ::core::mem::transmute(__vi.method_ptr);
3379 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3380 __inner(
3381 __receiver,
3382 ::core::convert::Into::into(command),
3383 ::core::convert::Into::into(v0),
3384 ::core::convert::Into::into(v1),
3385 __mi,
3386 )
3387 }
3388 }
3389 }
3390}
3391
3392#[cfg(feature = "app-aithink")]
3393impl<__T: IAIThink_ActionFunc> IAIThink_ActionFuncMethods for __T {}
3394
3395#[cfg(feature = "app-aithink")]
3396impl AIThink_ActionFunc {
3397 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3398 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
3399 }
3400
3401 pub fn invoke_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3402 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
3403 }
3404}
3405
3406#[cfg(feature = "app-aithink")]
3407impl AIThink_ActionFunc {
3408 #[doc = "Direct (non-virtual) call to `AIThink_ActionFunc`'s own `Invoke`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3409 pub unsafe fn invoke(
3410 this: impl ::core::convert::Into<::unity::IlInstance>,
3411 command: i32,
3412 v0: crate::app::aivalue::AIValue,
3413 v1: crate::app::aivalue::AIValue,
3414 ) -> crate::app::aithink::AIThink_Result {
3415 let __mi = Self::invoke_method_info();
3416 let __inner: extern "C" fn(
3417 ::unity::IlInstance,
3418 i32,
3419 crate::app::aivalue::AIValue,
3420 crate::app::aivalue::AIValue,
3421 ::unity::OptionalMethod,
3422 ) -> crate::app::aithink::AIThink_Result = ::core::mem::transmute(__mi.method_ptr);
3423 __inner(this.into(), command, v0, v1, ::core::option::Option::None)
3424 }
3425}
3426
3427#[cfg(feature = "app-aithink")]
3428impl AIThink_ActionFunc {
3429 #[doc = "`.ctor(crate::system::object::Object, ::unity::IntPtr)` — overload selector"]
3430 pub fn new(object: crate::system::object::Object, method: ::unity::IntPtr) -> Self {
3431 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
3432 panic!(
3433 "{}
3434::{}
3435 failed to instantiate",
3436 ::core::stringify!(AIThink_ActionFunc),
3437 ::core::stringify!(new),
3438 )
3439 });
3440 <Self as IAIThink_ActionFuncMethods>::ctor(this, object, method);
3441 this
3442 }
3443}
3444
3445#[cfg(feature = "app-aithink")]
3446impl AIThink_HealRodPositionResult {
3447 #[doc = "`get_MoveX()` overload"]
3448 pub fn get_move_x(&mut self) -> i32 {
3449 unsafe {
3450 ::unity::il2cpp_call!((::unity::module_base()+0x29004f0usize)as*mut u8,i32;
3451(*mut AIThink_HealRodPositionResult)self as*mut AIThink_HealRodPositionResult)
3452 }
3453 }
3454
3455 #[doc = "`set_MoveX(i32)` overload"]
3456 pub fn set_move_x(&mut self, value: impl ::core::convert::Into<i32>) -> () {
3457 unsafe {
3458 ::unity::il2cpp_call!((::unity::module_base()+0x2900500usize)as*mut u8,();
3459(*mut AIThink_HealRodPositionResult)self as*mut AIThink_HealRodPositionResult,(i32)::core::convert::Into::into(value))
3460 }
3461 }
3462
3463 #[doc = "`get_MoveZ()` overload"]
3464 pub fn get_move_z(&mut self) -> i32 {
3465 unsafe {
3466 ::unity::il2cpp_call!((::unity::module_base()+0x2900510usize)as*mut u8,i32;
3467(*mut AIThink_HealRodPositionResult)self as*mut AIThink_HealRodPositionResult)
3468 }
3469 }
3470
3471 #[doc = "`set_MoveZ(i32)` overload"]
3472 pub fn set_move_z(&mut self, value: impl ::core::convert::Into<i32>) -> () {
3473 unsafe {
3474 ::unity::il2cpp_call!((::unity::module_base()+0x2900520usize)as*mut u8,();
3475(*mut AIThink_HealRodPositionResult)self as*mut AIThink_HealRodPositionResult,(i32)::core::convert::Into::into(value))
3476 }
3477 }
3478
3479 #[doc = "`get_AttackX()` overload"]
3480 pub fn get_attack_x(&mut self) -> i32 {
3481 unsafe {
3482 ::unity::il2cpp_call!((::unity::module_base()+0x2900530usize)as*mut u8,i32;
3483(*mut AIThink_HealRodPositionResult)self as*mut AIThink_HealRodPositionResult)
3484 }
3485 }
3486
3487 #[doc = "`set_AttackX(i32)` overload"]
3488 pub fn set_attack_x(&mut self, value: impl ::core::convert::Into<i32>) -> () {
3489 unsafe {
3490 ::unity::il2cpp_call!((::unity::module_base()+0x2900540usize)as*mut u8,();
3491(*mut AIThink_HealRodPositionResult)self as*mut AIThink_HealRodPositionResult,(i32)::core::convert::Into::into(value))
3492 }
3493 }
3494
3495 #[doc = "`get_AttackZ()` overload"]
3496 pub fn get_attack_z(&mut self) -> i32 {
3497 unsafe {
3498 ::unity::il2cpp_call!((::unity::module_base()+0x2900550usize)as*mut u8,i32;
3499(*mut AIThink_HealRodPositionResult)self as*mut AIThink_HealRodPositionResult)
3500 }
3501 }
3502
3503 #[doc = "`set_AttackZ(i32)` overload"]
3504 pub fn set_attack_z(&mut self, value: impl ::core::convert::Into<i32>) -> () {
3505 unsafe {
3506 ::unity::il2cpp_call!((::unity::module_base()+0x2900560usize)as*mut u8,();
3507(*mut AIThink_HealRodPositionResult)self as*mut AIThink_HealRodPositionResult,(i32)::core::convert::Into::into(value))
3508 }
3509 }
3510
3511 #[doc = "`Clear()` overload"]
3512 pub fn clear(&mut self) -> () {
3513 unsafe {
3514 ::unity::il2cpp_call!((::unity::module_base()+0x2900570usize)as*mut u8,();
3515(*mut AIThink_HealRodPositionResult)self as*mut AIThink_HealRodPositionResult)
3516 }
3517 }
3518}
3519
3520#[cfg(feature = "app-aithink")]
3521impl AIThink_HealRodPositionResult {
3522 pub fn get_move_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3523 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
3524 }
3525
3526 pub fn set_move_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3527 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
3528 }
3529
3530 pub fn get_move_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3531 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
3532 }
3533
3534 pub fn set_move_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3535 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
3536 }
3537
3538 pub fn get_attack_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3539 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
3540 }
3541
3542 pub fn set_attack_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3543 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
3544 }
3545
3546 pub fn get_attack_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3547 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
3548 }
3549
3550 pub fn set_attack_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3551 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
3552 }
3553
3554 pub fn clear_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3555 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
3556 }
3557}
3558
3559#[cfg(feature = "app-aithink")]
3560impl AIThink_UncontrollAttackScoreResult {
3561 #[doc = "`get_Score()` overload"]
3562 pub fn get_score(&mut self) -> u32 {
3563 unsafe {
3564 ::unity::il2cpp_call!((::unity::module_base()+0x2901550usize)as*mut u8,u32;
3565(*mut AIThink_UncontrollAttackScoreResult)self as*mut AIThink_UncontrollAttackScoreResult)
3566 }
3567 }
3568
3569 #[doc = "`set_Score(u32)` overload"]
3570 pub fn set_score(&mut self, value: impl ::core::convert::Into<u32>) -> () {
3571 unsafe {
3572 ::unity::il2cpp_call!((::unity::module_base()+0x2901560usize)as*mut u8,();
3573(*mut AIThink_UncontrollAttackScoreResult)self as*mut AIThink_UncontrollAttackScoreResult,(u32)::core::convert::Into::into(value))
3574 }
3575 }
3576
3577 #[doc = "`get_MoveX()` overload"]
3578 pub fn get_move_x(&mut self) -> i32 {
3579 unsafe {
3580 ::unity::il2cpp_call!((::unity::module_base()+0x2901570usize)as*mut u8,i32;
3581(*mut AIThink_UncontrollAttackScoreResult)self as*mut AIThink_UncontrollAttackScoreResult)
3582 }
3583 }
3584
3585 #[doc = "`set_MoveX(i32)` overload"]
3586 pub fn set_move_x(&mut self, value: impl ::core::convert::Into<i32>) -> () {
3587 unsafe {
3588 ::unity::il2cpp_call!((::unity::module_base()+0x2901580usize)as*mut u8,();
3589(*mut AIThink_UncontrollAttackScoreResult)self as*mut AIThink_UncontrollAttackScoreResult,(i32)::core::convert::Into::into(value))
3590 }
3591 }
3592
3593 #[doc = "`get_MoveZ()` overload"]
3594 pub fn get_move_z(&mut self) -> i32 {
3595 unsafe {
3596 ::unity::il2cpp_call!((::unity::module_base()+0x2901590usize)as*mut u8,i32;
3597(*mut AIThink_UncontrollAttackScoreResult)self as*mut AIThink_UncontrollAttackScoreResult)
3598 }
3599 }
3600
3601 #[doc = "`set_MoveZ(i32)` overload"]
3602 pub fn set_move_z(&mut self, value: impl ::core::convert::Into<i32>) -> () {
3603 unsafe {
3604 ::unity::il2cpp_call!((::unity::module_base()+0x29015a0usize)as*mut u8,();
3605(*mut AIThink_UncontrollAttackScoreResult)self as*mut AIThink_UncontrollAttackScoreResult,(i32)::core::convert::Into::into(value))
3606 }
3607 }
3608
3609 #[doc = "`get_AttackX()` overload"]
3610 pub fn get_attack_x(&mut self) -> i32 {
3611 unsafe {
3612 ::unity::il2cpp_call!((::unity::module_base()+0x29015b0usize)as*mut u8,i32;
3613(*mut AIThink_UncontrollAttackScoreResult)self as*mut AIThink_UncontrollAttackScoreResult)
3614 }
3615 }
3616
3617 #[doc = "`set_AttackX(i32)` overload"]
3618 pub fn set_attack_x(&mut self, value: impl ::core::convert::Into<i32>) -> () {
3619 unsafe {
3620 ::unity::il2cpp_call!((::unity::module_base()+0x29015c0usize)as*mut u8,();
3621(*mut AIThink_UncontrollAttackScoreResult)self as*mut AIThink_UncontrollAttackScoreResult,(i32)::core::convert::Into::into(value))
3622 }
3623 }
3624
3625 #[doc = "`get_AttackZ()` overload"]
3626 pub fn get_attack_z(&mut self) -> i32 {
3627 unsafe {
3628 ::unity::il2cpp_call!((::unity::module_base()+0x29015d0usize)as*mut u8,i32;
3629(*mut AIThink_UncontrollAttackScoreResult)self as*mut AIThink_UncontrollAttackScoreResult)
3630 }
3631 }
3632
3633 #[doc = "`set_AttackZ(i32)` overload"]
3634 pub fn set_attack_z(&mut self, value: impl ::core::convert::Into<i32>) -> () {
3635 unsafe {
3636 ::unity::il2cpp_call!((::unity::module_base()+0x29015e0usize)as*mut u8,();
3637(*mut AIThink_UncontrollAttackScoreResult)self as*mut AIThink_UncontrollAttackScoreResult,(i32)::core::convert::Into::into(value))
3638 }
3639 }
3640
3641 #[doc = "`Clear()` overload"]
3642 pub fn clear(&mut self) -> () {
3643 unsafe {
3644 ::unity::il2cpp_call!((::unity::module_base()+0x29015f0usize)as*mut u8,();
3645(*mut AIThink_UncontrollAttackScoreResult)self as*mut AIThink_UncontrollAttackScoreResult)
3646 }
3647 }
3648}
3649
3650#[cfg(feature = "app-aithink")]
3651impl AIThink_UncontrollAttackScoreResult {
3652 pub fn get_score_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3653 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
3654 }
3655
3656 pub fn set_score_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3657 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
3658 }
3659
3660 pub fn get_move_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3661 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
3662 }
3663
3664 pub fn set_move_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3665 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
3666 }
3667
3668 pub fn get_move_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3669 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
3670 }
3671
3672 pub fn set_move_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3673 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
3674 }
3675
3676 pub fn get_attack_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3677 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
3678 }
3679
3680 pub fn set_attack_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3681 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
3682 }
3683
3684 pub fn get_attack_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3685 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
3686 }
3687
3688 pub fn set_attack_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3689 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
3690 }
3691
3692 pub fn clear_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3693 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
3694 }
3695}
3696
3697#[cfg(feature = "app-aithink")]
3698impl AIThink_AttackPositionResult {
3699 #[doc = "`get_MoveX()` overload"]
3700 pub fn get_move_x(&mut self) -> i32 {
3701 unsafe {
3702 ::unity::il2cpp_call!((::unity::module_base()+0x28fb6f0usize)as*mut u8,i32;
3703(*mut AIThink_AttackPositionResult)self as*mut AIThink_AttackPositionResult)
3704 }
3705 }
3706
3707 #[doc = "`set_MoveX(i32)` overload"]
3708 pub fn set_move_x(&mut self, value: impl ::core::convert::Into<i32>) -> () {
3709 unsafe {
3710 ::unity::il2cpp_call!((::unity::module_base()+0x28fb700usize)as*mut u8,();
3711(*mut AIThink_AttackPositionResult)self as*mut AIThink_AttackPositionResult,(i32)::core::convert::Into::into(value))
3712 }
3713 }
3714
3715 #[doc = "`get_MoveZ()` overload"]
3716 pub fn get_move_z(&mut self) -> i32 {
3717 unsafe {
3718 ::unity::il2cpp_call!((::unity::module_base()+0x28fb710usize)as*mut u8,i32;
3719(*mut AIThink_AttackPositionResult)self as*mut AIThink_AttackPositionResult)
3720 }
3721 }
3722
3723 #[doc = "`set_MoveZ(i32)` overload"]
3724 pub fn set_move_z(&mut self, value: impl ::core::convert::Into<i32>) -> () {
3725 unsafe {
3726 ::unity::il2cpp_call!((::unity::module_base()+0x28fb720usize)as*mut u8,();
3727(*mut AIThink_AttackPositionResult)self as*mut AIThink_AttackPositionResult,(i32)::core::convert::Into::into(value))
3728 }
3729 }
3730
3731 #[doc = "`get_AttackX()` overload"]
3732 pub fn get_attack_x(&mut self) -> i32 {
3733 unsafe {
3734 ::unity::il2cpp_call!((::unity::module_base()+0x28fb730usize)as*mut u8,i32;
3735(*mut AIThink_AttackPositionResult)self as*mut AIThink_AttackPositionResult)
3736 }
3737 }
3738
3739 #[doc = "`set_AttackX(i32)` overload"]
3740 pub fn set_attack_x(&mut self, value: impl ::core::convert::Into<i32>) -> () {
3741 unsafe {
3742 ::unity::il2cpp_call!((::unity::module_base()+0x28fb740usize)as*mut u8,();
3743(*mut AIThink_AttackPositionResult)self as*mut AIThink_AttackPositionResult,(i32)::core::convert::Into::into(value))
3744 }
3745 }
3746
3747 #[doc = "`get_AttackZ()` overload"]
3748 pub fn get_attack_z(&mut self) -> i32 {
3749 unsafe {
3750 ::unity::il2cpp_call!((::unity::module_base()+0x28fb750usize)as*mut u8,i32;
3751(*mut AIThink_AttackPositionResult)self as*mut AIThink_AttackPositionResult)
3752 }
3753 }
3754
3755 #[doc = "`set_AttackZ(i32)` overload"]
3756 pub fn set_attack_z(&mut self, value: impl ::core::convert::Into<i32>) -> () {
3757 unsafe {
3758 ::unity::il2cpp_call!((::unity::module_base()+0x28fb760usize)as*mut u8,();
3759(*mut AIThink_AttackPositionResult)self as*mut AIThink_AttackPositionResult,(i32)::core::convert::Into::into(value))
3760 }
3761 }
3762
3763 #[doc = "`get_BlowScore()` overload"]
3764 pub fn get_blow_score(&mut self) -> u32 {
3765 unsafe {
3766 ::unity::il2cpp_call!((::unity::module_base()+0x28fb770usize)as*mut u8,u32;
3767(*mut AIThink_AttackPositionResult)self as*mut AIThink_AttackPositionResult)
3768 }
3769 }
3770
3771 #[doc = "`set_BlowScore(u32)` overload"]
3772 pub fn set_blow_score(&mut self, value: impl ::core::convert::Into<u32>) -> () {
3773 unsafe {
3774 ::unity::il2cpp_call!((::unity::module_base()+0x28fb780usize)as*mut u8,();
3775(*mut AIThink_AttackPositionResult)self as*mut AIThink_AttackPositionResult,(u32)::core::convert::Into::into(value))
3776 }
3777 }
3778
3779 #[doc = "`get_ChainAttackCount()` overload"]
3780 pub fn get_chain_attack_count(&mut self) -> i32 {
3781 unsafe {
3782 ::unity::il2cpp_call!((::unity::module_base()+0x28fb790usize)as*mut u8,i32;
3783(*mut AIThink_AttackPositionResult)self as*mut AIThink_AttackPositionResult)
3784 }
3785 }
3786
3787 #[doc = "`set_ChainAttackCount(i32)` overload"]
3788 pub fn set_chain_attack_count(&mut self, value: impl ::core::convert::Into<i32>) -> () {
3789 unsafe {
3790 ::unity::il2cpp_call!((::unity::module_base()+0x28fb7a0usize)as*mut u8,();
3791(*mut AIThink_AttackPositionResult)self as*mut AIThink_AttackPositionResult,(i32)::core::convert::Into::into(value))
3792 }
3793 }
3794
3795 #[doc = "`Clear()` overload"]
3796 pub fn clear(&mut self) -> () {
3797 unsafe {
3798 ::unity::il2cpp_call!((::unity::module_base()+0x28fb7b0usize)as*mut u8,();
3799(*mut AIThink_AttackPositionResult)self as*mut AIThink_AttackPositionResult)
3800 }
3801 }
3802}
3803
3804#[cfg(feature = "app-aithink")]
3805impl AIThink_AttackPositionResult {
3806 pub fn get_move_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3807 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
3808 }
3809
3810 pub fn set_move_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3811 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
3812 }
3813
3814 pub fn get_move_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3815 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
3816 }
3817
3818 pub fn set_move_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3819 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
3820 }
3821
3822 pub fn get_attack_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3823 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
3824 }
3825
3826 pub fn set_attack_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3827 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
3828 }
3829
3830 pub fn get_attack_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3831 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
3832 }
3833
3834 pub fn set_attack_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3835 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
3836 }
3837
3838 pub fn get_blow_score_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3839 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
3840 }
3841
3842 pub fn set_blow_score_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3843 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
3844 }
3845
3846 pub fn get_chain_attack_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3847 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
3848 }
3849
3850 pub fn set_chain_attack_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3851 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
3852 }
3853
3854 pub fn clear_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3855 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
3856 }
3857}
3858
3859#[cfg(feature = "app-aithink")]
3860pub trait IAIThink_UpdateFlagMethods: IAIThink_UpdateFlag {
3861 #[doc = "`.ctor()` overload"]
3862 fn ctor(self) -> () {
3863 unsafe {
3864 let __receiver = <AIThink_UpdateFlag as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3865 ::unity::il2cpp_call!((::unity::module_base()+0x2901740usize)as*mut u8,();
3866(AIThink_UpdateFlag)__receiver)
3867 }
3868 }
3869}
3870
3871#[cfg(feature = "app-aithink")]
3872impl<__T: IAIThink_UpdateFlag> IAIThink_UpdateFlagMethods for __T {}
3873
3874#[cfg(feature = "app-aithink")]
3875impl AIThink_UpdateFlag {
3876 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3877 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
3878 }
3879}
3880
3881#[cfg(feature = "app-aithink")]
3882impl AIThink_UpdateFlag {
3883 #[doc = "`.ctor()` — no args"]
3884 pub fn new() -> Self {
3885 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
3886 panic!(
3887 "{}
3888::{}
3889 failed to instantiate",
3890 ::core::stringify!(AIThink_UpdateFlag),
3891 ::core::stringify!(new),
3892 )
3893 });
3894 <Self as IAIThink_UpdateFlagMethods>::ctor(this);
3895 this
3896 }
3897}
3898
3899#[cfg(feature = "app-aithink")]
3900impl AIThink_AttackTarget {
3901 #[doc = "`New(*mutcrate::app::aithink::AIThink_AttackTarget)` overload"]
3902 pub fn new() -> crate::app::aithink::AIThink_AttackTarget {
3903 unsafe {
3904 let mut __out_0 = ::core::mem::MaybeUninit::<crate::app::aithink::AIThink_AttackTarget>::uninit();
3905 ::unity::il2cpp_call!((::unity::module_base()+0x28fbaa0usize)as*mut u8,();
3906(*mut crate::app::aithink::AIThink_AttackTarget)__out_0.as_mut_ptr());
3907 __out_0.assume_init()
3908 }
3909 }
3910}
3911
3912#[cfg(feature = "app-aithink")]
3913impl AIThink_AttackTarget {
3914 #[doc = "`get_Unit()` overload"]
3915 pub fn get_unit(&mut self) -> crate::app::unit::Unit {
3916 unsafe {
3917 ::unity::il2cpp_call!((::unity::module_base()+0x28fb940usize)as*mut u8,crate::app::unit::Unit;
3918(*mut AIThink_AttackTarget)self as*mut AIThink_AttackTarget)
3919 }
3920 }
3921
3922 #[doc = "`set_Unit(crate::app::unit::Unit)` overload"]
3923 pub fn set_unit(&mut self, value: impl ::core::convert::Into<crate::app::unit::Unit>) -> () {
3924 unsafe {
3925 ::unity::il2cpp_call!((::unity::module_base()+0x28fb950usize)as*mut u8,();
3926(*mut AIThink_AttackTarget)self as*mut AIThink_AttackTarget,(crate::app::unit::Unit)::core::convert::Into::into(value))
3927 }
3928 }
3929
3930 #[doc = "`get_X()` overload"]
3931 pub fn get_x(&mut self) -> i32 {
3932 unsafe {
3933 ::unity::il2cpp_call!((::unity::module_base()+0x28fb960usize)as*mut u8,i32;
3934(*mut AIThink_AttackTarget)self as*mut AIThink_AttackTarget)
3935 }
3936 }
3937
3938 #[doc = "`set_X(i32)` overload"]
3939 pub fn set_x(&mut self, value: impl ::core::convert::Into<i32>) -> () {
3940 unsafe {
3941 ::unity::il2cpp_call!((::unity::module_base()+0x28fb970usize)as*mut u8,();
3942(*mut AIThink_AttackTarget)self as*mut AIThink_AttackTarget,(i32)::core::convert::Into::into(value))
3943 }
3944 }
3945
3946 #[doc = "`get_Z()` overload"]
3947 pub fn get_z(&mut self) -> i32 {
3948 unsafe {
3949 ::unity::il2cpp_call!((::unity::module_base()+0x28fb980usize)as*mut u8,i32;
3950(*mut AIThink_AttackTarget)self as*mut AIThink_AttackTarget)
3951 }
3952 }
3953
3954 #[doc = "`set_Z(i32)` overload"]
3955 pub fn set_z(&mut self, value: impl ::core::convert::Into<i32>) -> () {
3956 unsafe {
3957 ::unity::il2cpp_call!((::unity::module_base()+0x28fb990usize)as*mut u8,();
3958(*mut AIThink_AttackTarget)self as*mut AIThink_AttackTarget,(i32)::core::convert::Into::into(value))
3959 }
3960 }
3961
3962 #[doc = "`get_Score()` overload"]
3963 pub fn get_score(&mut self) -> u32 {
3964 unsafe {
3965 ::unity::il2cpp_call!((::unity::module_base()+0x28fb9a0usize)as*mut u8,u32;
3966(*mut AIThink_AttackTarget)self as*mut AIThink_AttackTarget)
3967 }
3968 }
3969
3970 #[doc = "`get_MoveX()` overload"]
3971 pub fn get_move_x(&mut self) -> i32 {
3972 unsafe {
3973 ::unity::il2cpp_call!((::unity::module_base()+0x28fb9b0usize)as*mut u8,i32;
3974(*mut AIThink_AttackTarget)self as*mut AIThink_AttackTarget)
3975 }
3976 }
3977
3978 #[doc = "`get_MoveZ()` overload"]
3979 pub fn get_move_z(&mut self) -> i32 {
3980 unsafe {
3981 ::unity::il2cpp_call!((::unity::module_base()+0x28fb9c0usize)as*mut u8,i32;
3982(*mut AIThink_AttackTarget)self as*mut AIThink_AttackTarget)
3983 }
3984 }
3985
3986 #[doc = "`get_AttackX()` overload"]
3987 pub fn get_attack_x(&mut self) -> i32 {
3988 unsafe {
3989 ::unity::il2cpp_call!((::unity::module_base()+0x28fb9d0usize)as*mut u8,i32;
3990(*mut AIThink_AttackTarget)self as*mut AIThink_AttackTarget)
3991 }
3992 }
3993
3994 #[doc = "`get_AttackZ()` overload"]
3995 pub fn get_attack_z(&mut self) -> i32 {
3996 unsafe {
3997 ::unity::il2cpp_call!((::unity::module_base()+0x28fb9e0usize)as*mut u8,i32;
3998(*mut AIThink_AttackTarget)self as*mut AIThink_AttackTarget)
3999 }
4000 }
4001
4002 #[doc = "`get_ItemIndex()` overload"]
4003 pub fn get_item_index(&mut self) -> i32 {
4004 unsafe {
4005 ::unity::il2cpp_call!((::unity::module_base()+0x28fb9f0usize)as*mut u8,i32;
4006(*mut AIThink_AttackTarget)self as*mut AIThink_AttackTarget)
4007 }
4008 }
4009
4010 #[doc = "`get_KillRate()` overload"]
4011 pub fn get_kill_rate(&mut self) -> f32 {
4012 unsafe {
4013 ::unity::il2cpp_call!((::unity::module_base()+0x28fba00usize)as*mut u8,f32;
4014(*mut AIThink_AttackTarget)self as*mut AIThink_AttackTarget)
4015 }
4016 }
4017
4018 #[doc = "`get_DeadRate()` overload"]
4019 pub fn get_dead_rate(&mut self) -> f32 {
4020 unsafe {
4021 ::unity::il2cpp_call!((::unity::module_base()+0x28fba10usize)as*mut u8,f32;
4022(*mut AIThink_AttackTarget)self as*mut AIThink_AttackTarget)
4023 }
4024 }
4025
4026 #[doc = "`get_Expectation()` overload"]
4027 pub fn get_expectation(&mut self) -> f32 {
4028 unsafe {
4029 ::unity::il2cpp_call!((::unity::module_base()+0x28fba20usize)as*mut u8,f32;
4030(*mut AIThink_AttackTarget)self as*mut AIThink_AttackTarget)
4031 }
4032 }
4033
4034 #[doc = "`get_BlowScore()` overload"]
4035 pub fn get_blow_score(&mut self) -> u32 {
4036 unsafe {
4037 ::unity::il2cpp_call!((::unity::module_base()+0x28fba30usize)as*mut u8,u32;
4038(*mut AIThink_AttackTarget)self as*mut AIThink_AttackTarget)
4039 }
4040 }
4041
4042 #[doc = "`get_ChainAttackCount()` overload"]
4043 pub fn get_chain_attack_count(&mut self) -> i32 {
4044 unsafe {
4045 ::unity::il2cpp_call!((::unity::module_base()+0x28fba40usize)as*mut u8,i32;
4046(*mut AIThink_AttackTarget)self as*mut AIThink_AttackTarget)
4047 }
4048 }
4049
4050 #[doc = "`Clear()` overload"]
4051 pub fn clear(&mut self) -> () {
4052 unsafe {
4053 ::unity::il2cpp_call!((::unity::module_base()+0x28fba50usize)as*mut u8,();
4054(*mut AIThink_AttackTarget)self as*mut AIThink_AttackTarget)
4055 }
4056 }
4057}
4058
4059#[cfg(feature = "app-aithink")]
4060impl AIThink_AttackTarget {
4061 pub fn get_unit_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4062 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
4063 }
4064
4065 pub fn set_unit_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4066 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
4067 }
4068
4069 pub fn get_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4070 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
4071 }
4072
4073 pub fn set_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4074 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
4075 }
4076
4077 pub fn get_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4078 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
4079 }
4080
4081 pub fn set_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4082 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
4083 }
4084
4085 pub fn get_score_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4086 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
4087 }
4088
4089 pub fn get_move_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4090 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
4091 }
4092
4093 pub fn get_move_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4094 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
4095 }
4096
4097 pub fn get_attack_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4098 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
4099 }
4100
4101 pub fn get_attack_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4102 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
4103 }
4104
4105 pub fn get_item_index_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4106 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
4107 }
4108
4109 pub fn get_kill_rate_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4110 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
4111 }
4112
4113 pub fn get_dead_rate_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4114 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
4115 }
4116
4117 pub fn get_expectation_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4118 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[14]
4119 }
4120
4121 pub fn get_blow_score_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4122 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[15]
4123 }
4124
4125 pub fn get_chain_attack_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4126 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[16]
4127 }
4128
4129 pub fn clear_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4130 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[17]
4131 }
4132
4133 pub fn new_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4134 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[18]
4135 }
4136}
4137
4138#[cfg(feature = "app-aithink")]
4139impl AIThink_HealRodScoreResult {
4140 #[doc = "`get_Score()` overload"]
4141 pub fn get_score(&mut self) -> u32 {
4142 unsafe {
4143 ::unity::il2cpp_call!((::unity::module_base()+0x2900650usize)as*mut u8,u32;
4144(*mut AIThink_HealRodScoreResult)self as*mut AIThink_HealRodScoreResult)
4145 }
4146 }
4147
4148 #[doc = "`set_Score(u32)` overload"]
4149 pub fn set_score(&mut self, value: impl ::core::convert::Into<u32>) -> () {
4150 unsafe {
4151 ::unity::il2cpp_call!((::unity::module_base()+0x2900660usize)as*mut u8,();
4152(*mut AIThink_HealRodScoreResult)self as*mut AIThink_HealRodScoreResult,(u32)::core::convert::Into::into(value))
4153 }
4154 }
4155
4156 #[doc = "`get_ItemIndex()` overload"]
4157 pub fn get_item_index(&mut self) -> i32 {
4158 unsafe {
4159 ::unity::il2cpp_call!((::unity::module_base()+0x2900670usize)as*mut u8,i32;
4160(*mut AIThink_HealRodScoreResult)self as*mut AIThink_HealRodScoreResult)
4161 }
4162 }
4163
4164 #[doc = "`set_ItemIndex(i32)` overload"]
4165 pub fn set_item_index(&mut self, value: impl ::core::convert::Into<i32>) -> () {
4166 unsafe {
4167 ::unity::il2cpp_call!((::unity::module_base()+0x2900680usize)as*mut u8,();
4168(*mut AIThink_HealRodScoreResult)self as*mut AIThink_HealRodScoreResult,(i32)::core::convert::Into::into(value))
4169 }
4170 }
4171
4172 #[doc = "`get_MoveX()` overload"]
4173 pub fn get_move_x(&mut self) -> i32 {
4174 unsafe {
4175 ::unity::il2cpp_call!((::unity::module_base()+0x28f81c0usize)as*mut u8,i32;
4176(*mut AIThink_HealRodScoreResult)self as*mut AIThink_HealRodScoreResult)
4177 }
4178 }
4179
4180 #[doc = "`get_MoveZ()` overload"]
4181 pub fn get_move_z(&mut self) -> i32 {
4182 unsafe {
4183 ::unity::il2cpp_call!((::unity::module_base()+0x28f81d0usize)as*mut u8,i32;
4184(*mut AIThink_HealRodScoreResult)self as*mut AIThink_HealRodScoreResult)
4185 }
4186 }
4187
4188 #[doc = "`get_AttackX()` overload"]
4189 pub fn get_attack_x(&mut self) -> i32 {
4190 unsafe {
4191 ::unity::il2cpp_call!((::unity::module_base()+0x28f81e0usize)as*mut u8,i32;
4192(*mut AIThink_HealRodScoreResult)self as*mut AIThink_HealRodScoreResult)
4193 }
4194 }
4195
4196 #[doc = "`get_AttackZ()` overload"]
4197 pub fn get_attack_z(&mut self) -> i32 {
4198 unsafe {
4199 ::unity::il2cpp_call!((::unity::module_base()+0x28f81f0usize)as*mut u8,i32;
4200(*mut AIThink_HealRodScoreResult)self as*mut AIThink_HealRodScoreResult)
4201 }
4202 }
4203
4204 #[doc = "`get_Heal()` overload"]
4205 pub fn get_heal(&mut self) -> i32 {
4206 unsafe {
4207 ::unity::il2cpp_call!((::unity::module_base()+0x2900690usize)as*mut u8,i32;
4208(*mut AIThink_HealRodScoreResult)self as*mut AIThink_HealRodScoreResult)
4209 }
4210 }
4211
4212 #[doc = "`get_Damage()` overload"]
4213 pub fn get_damage(&mut self) -> i32 {
4214 unsafe {
4215 ::unity::il2cpp_call!((::unity::module_base()+0x29006a0usize)as*mut u8,i32;
4216(*mut AIThink_HealRodScoreResult)self as*mut AIThink_HealRodScoreResult)
4217 }
4218 }
4219
4220 #[doc = "`Clear()` overload"]
4221 pub fn clear(&mut self) -> () {
4222 unsafe {
4223 ::unity::il2cpp_call!((::unity::module_base()+0x29006b0usize)as*mut u8,();
4224(*mut AIThink_HealRodScoreResult)self as*mut AIThink_HealRodScoreResult)
4225 }
4226 }
4227}
4228
4229#[cfg(feature = "app-aithink")]
4230impl AIThink_HealRodScoreResult {
4231 pub fn get_score_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4232 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
4233 }
4234
4235 pub fn set_score_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4236 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
4237 }
4238
4239 pub fn get_item_index_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4240 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
4241 }
4242
4243 pub fn set_item_index_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4244 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
4245 }
4246
4247 pub fn get_move_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4248 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
4249 }
4250
4251 pub fn get_move_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4252 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
4253 }
4254
4255 pub fn get_attack_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4256 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
4257 }
4258
4259 pub fn get_attack_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4260 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
4261 }
4262
4263 pub fn get_heal_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4264 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
4265 }
4266
4267 pub fn get_damage_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4268 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
4269 }
4270
4271 pub fn clear_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4272 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
4273 }
4274}
4275
4276#[cfg(feature = "app-aithink")]
4277impl AIThink_RescueRodTarget {
4278 #[doc = "`New(*mutcrate::app::aithink::AIThink_RescueRodTarget)` overload"]
4279 pub fn new() -> crate::app::aithink::AIThink_RescueRodTarget {
4280 unsafe {
4281 let mut __out_0 = ::core::mem::MaybeUninit::<crate::app::aithink::AIThink_RescueRodTarget>::uninit();
4282 ::unity::il2cpp_call!((::unity::module_base()+0x2901040usize)as*mut u8,();
4283(*mut crate::app::aithink::AIThink_RescueRodTarget)__out_0.as_mut_ptr());
4284 __out_0.assume_init()
4285 }
4286 }
4287}
4288
4289#[cfg(feature = "app-aithink")]
4290impl AIThink_RescueRodTarget {
4291 #[doc = "`get_Unit()` overload"]
4292 pub fn get_unit(&mut self) -> crate::app::unit::Unit {
4293 unsafe {
4294 ::unity::il2cpp_call!((::unity::module_base()+0x2900f50usize)as*mut u8,crate::app::unit::Unit;
4295(*mut AIThink_RescueRodTarget)self as*mut AIThink_RescueRodTarget)
4296 }
4297 }
4298
4299 #[doc = "`set_Unit(crate::app::unit::Unit)` overload"]
4300 pub fn set_unit(&mut self, value: impl ::core::convert::Into<crate::app::unit::Unit>) -> () {
4301 unsafe {
4302 ::unity::il2cpp_call!((::unity::module_base()+0x2900f60usize)as*mut u8,();
4303(*mut AIThink_RescueRodTarget)self as*mut AIThink_RescueRodTarget,(crate::app::unit::Unit)::core::convert::Into::into(value))
4304 }
4305 }
4306
4307 #[doc = "`get_X()` overload"]
4308 pub fn get_x(&mut self) -> i32 {
4309 unsafe {
4310 ::unity::il2cpp_call!((::unity::module_base()+0x2900f70usize)as*mut u8,i32;
4311(*mut AIThink_RescueRodTarget)self as*mut AIThink_RescueRodTarget)
4312 }
4313 }
4314
4315 #[doc = "`set_X(i32)` overload"]
4316 pub fn set_x(&mut self, value: impl ::core::convert::Into<i32>) -> () {
4317 unsafe {
4318 ::unity::il2cpp_call!((::unity::module_base()+0x2900f80usize)as*mut u8,();
4319(*mut AIThink_RescueRodTarget)self as*mut AIThink_RescueRodTarget,(i32)::core::convert::Into::into(value))
4320 }
4321 }
4322
4323 #[doc = "`get_Z()` overload"]
4324 pub fn get_z(&mut self) -> i32 {
4325 unsafe {
4326 ::unity::il2cpp_call!((::unity::module_base()+0x2900f90usize)as*mut u8,i32;
4327(*mut AIThink_RescueRodTarget)self as*mut AIThink_RescueRodTarget)
4328 }
4329 }
4330
4331 #[doc = "`set_Z(i32)` overload"]
4332 pub fn set_z(&mut self, value: impl ::core::convert::Into<i32>) -> () {
4333 unsafe {
4334 ::unity::il2cpp_call!((::unity::module_base()+0x2900fa0usize)as*mut u8,();
4335(*mut AIThink_RescueRodTarget)self as*mut AIThink_RescueRodTarget,(i32)::core::convert::Into::into(value))
4336 }
4337 }
4338
4339 #[doc = "`get_Score()` overload"]
4340 pub fn get_score(&mut self) -> u32 {
4341 unsafe {
4342 ::unity::il2cpp_call!((::unity::module_base()+0x2900fb0usize)as*mut u8,u32;
4343(*mut AIThink_RescueRodTarget)self as*mut AIThink_RescueRodTarget)
4344 }
4345 }
4346
4347 #[doc = "`get_MoveX()` overload"]
4348 pub fn get_move_x(&mut self) -> i32 {
4349 unsafe {
4350 ::unity::il2cpp_call!((::unity::module_base()+0x2900fc0usize)as*mut u8,i32;
4351(*mut AIThink_RescueRodTarget)self as*mut AIThink_RescueRodTarget)
4352 }
4353 }
4354
4355 #[doc = "`get_MoveZ()` overload"]
4356 pub fn get_move_z(&mut self) -> i32 {
4357 unsafe {
4358 ::unity::il2cpp_call!((::unity::module_base()+0x2900fd0usize)as*mut u8,i32;
4359(*mut AIThink_RescueRodTarget)self as*mut AIThink_RescueRodTarget)
4360 }
4361 }
4362
4363 #[doc = "`get_AttackX()` overload"]
4364 pub fn get_attack_x(&mut self) -> i32 {
4365 unsafe {
4366 ::unity::il2cpp_call!((::unity::module_base()+0x2900fe0usize)as*mut u8,i32;
4367(*mut AIThink_RescueRodTarget)self as*mut AIThink_RescueRodTarget)
4368 }
4369 }
4370
4371 #[doc = "`get_AttackZ()` overload"]
4372 pub fn get_attack_z(&mut self) -> i32 {
4373 unsafe {
4374 ::unity::il2cpp_call!((::unity::module_base()+0x2900ff0usize)as*mut u8,i32;
4375(*mut AIThink_RescueRodTarget)self as*mut AIThink_RescueRodTarget)
4376 }
4377 }
4378
4379 #[doc = "`Clear()` overload"]
4380 pub fn clear(&mut self) -> () {
4381 unsafe {
4382 ::unity::il2cpp_call!((::unity::module_base()+0x2901000usize)as*mut u8,();
4383(*mut AIThink_RescueRodTarget)self as*mut AIThink_RescueRodTarget)
4384 }
4385 }
4386}
4387
4388#[cfg(feature = "app-aithink")]
4389impl AIThink_RescueRodTarget {
4390 pub fn get_unit_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4391 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
4392 }
4393
4394 pub fn set_unit_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4395 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
4396 }
4397
4398 pub fn get_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4399 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
4400 }
4401
4402 pub fn set_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4403 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
4404 }
4405
4406 pub fn get_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4407 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
4408 }
4409
4410 pub fn set_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4411 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
4412 }
4413
4414 pub fn get_score_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4415 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
4416 }
4417
4418 pub fn get_move_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4419 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
4420 }
4421
4422 pub fn get_move_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4423 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
4424 }
4425
4426 pub fn get_attack_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4427 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
4428 }
4429
4430 pub fn get_attack_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4431 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
4432 }
4433
4434 pub fn clear_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4435 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
4436 }
4437
4438 pub fn new_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4439 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
4440 }
4441}
4442
4443#[cfg(feature = "app-aithink")]
4444pub trait IAIThink_RcFuncMethods: IAIThink_RcFunc {
4445 #[doc = "`.ctor(crate::system::object::Object, ::unity::IntPtr)` overload"]
4446 fn ctor(self, object: impl ::core::convert::Into<crate::system::object::Object>, method: impl ::core::convert::Into<::unity::IntPtr>) -> () {
4447 unsafe {
4448 let __receiver = <AIThink_RcFunc as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4449 ::unity::il2cpp_call!((::unity::module_base()+0x2900b30usize)as*mut u8,();
4450(AIThink_RcFunc)__receiver,(crate::system::object::Object)::core::convert::Into::into(object),(::unity::IntPtr)::core::convert::Into::into(method))
4451 }
4452 }
4453 #[doc = "`Invoke(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
4454 fn invoke(
4455 self,
4456 command: impl ::core::convert::Into<i32>,
4457 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
4458 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
4459 ) -> bool {
4460 unsafe {
4461 let __receiver = <AIThink_RcFunc as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4462 {
4463 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4464 let __vi = *__vt.get(13usize).unwrap_or_else(|| {
4465 panic!(
4466 "unity: virtual slot {}
4467 out of range (vtable len {}
4468) on the runtime class behind {}
4469 (method `{}
4470`)",
4471 13usize,
4472 __vt.len(),
4473 <AIThink_RcFunc as ::unity::ClassIdentity>::NAME,
4474 "Invoke",
4475 )
4476 });
4477 let __inner: extern "C" fn(
4478 AIThink_RcFunc,
4479 i32,
4480 crate::app::aivalue::AIValue,
4481 crate::app::aivalue::AIValue,
4482 ::unity::OptionalMethod,
4483 ) -> bool = ::core::mem::transmute(__vi.method_ptr);
4484 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4485 __inner(
4486 __receiver,
4487 ::core::convert::Into::into(command),
4488 ::core::convert::Into::into(v0),
4489 ::core::convert::Into::into(v1),
4490 __mi,
4491 )
4492 }
4493 }
4494 }
4495}
4496
4497#[cfg(feature = "app-aithink")]
4498impl<__T: IAIThink_RcFunc> IAIThink_RcFuncMethods for __T {}
4499
4500#[cfg(feature = "app-aithink")]
4501impl AIThink_RcFunc {
4502 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4503 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
4504 }
4505
4506 pub fn invoke_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4507 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
4508 }
4509}
4510
4511#[cfg(feature = "app-aithink")]
4512impl AIThink_RcFunc {
4513 #[doc = "Direct (non-virtual) call to `AIThink_RcFunc`'s own `Invoke`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4514 pub unsafe fn invoke(
4515 this: impl ::core::convert::Into<::unity::IlInstance>,
4516 command: i32,
4517 v0: crate::app::aivalue::AIValue,
4518 v1: crate::app::aivalue::AIValue,
4519 ) -> bool {
4520 let __mi = Self::invoke_method_info();
4521 let __inner: extern "C" fn(
4522 ::unity::IlInstance,
4523 i32,
4524 crate::app::aivalue::AIValue,
4525 crate::app::aivalue::AIValue,
4526 ::unity::OptionalMethod,
4527 ) -> bool = ::core::mem::transmute(__mi.method_ptr);
4528 __inner(this.into(), command, v0, v1, ::core::option::Option::None)
4529 }
4530}
4531
4532#[cfg(feature = "app-aithink")]
4533impl AIThink_RcFunc {
4534 #[doc = "`.ctor(crate::system::object::Object, ::unity::IntPtr)` — overload selector"]
4535 pub fn new(object: crate::system::object::Object, method: ::unity::IntPtr) -> Self {
4536 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
4537 panic!(
4538 "{}
4539::{}
4540 failed to instantiate",
4541 ::core::stringify!(AIThink_RcFunc),
4542 ::core::stringify!(new),
4543 )
4544 });
4545 <Self as IAIThink_RcFuncMethods>::ctor(this, object, method);
4546 this
4547 }
4548}
4549
4550#[cfg(feature = "app-aithink")]
4551pub trait IAIThink_EnchantThink_CalcUnitScoreFunctionMethods: IAIThink_EnchantThink_CalcUnitScoreFunction {
4552 #[doc = "`.ctor(crate::system::object::Object, ::unity::IntPtr)` overload"]
4553 fn ctor(self, object: impl ::core::convert::Into<crate::system::object::Object>, method: impl ::core::convert::Into<::unity::IntPtr>) -> () {
4554 unsafe {
4555 let __receiver = <AIThink_EnchantThink_CalcUnitScoreFunction as ::unity::FromIlInstance>::from_il_instance(
4556 <Self as ::unity::SystemObject>::as_instance(self),
4557 );
4558 ::unity::il2cpp_call!((::unity::module_base()+0x1b30d60usize)as*mut u8,();
4559(AIThink_EnchantThink_CalcUnitScoreFunction)__receiver,(crate::system::object::Object)::core::convert::Into::into(object),(::unity::IntPtr)::core::convert::Into::into(method))
4560 }
4561 }
4562 #[doc = "`Invoke(crate::app::aithink::AIThink_EnchantThink, crate::app::unit::Unit, crate::app::unit::Unit, crate::app::unititem::UnitItem)` overload"]
4563 fn invoke(
4564 self,
4565 think: impl ::core::convert::Into<crate::app::aithink::AIThink_EnchantThink>,
4566 actor: impl ::core::convert::Into<crate::app::unit::Unit>,
4567 target: impl ::core::convert::Into<crate::app::unit::Unit>,
4568 unit_item: impl ::core::convert::Into<crate::app::unititem::UnitItem>,
4569 ) -> u8 {
4570 unsafe {
4571 let __receiver = <AIThink_EnchantThink_CalcUnitScoreFunction as ::unity::FromIlInstance>::from_il_instance(
4572 <Self as ::unity::SystemObject>::as_instance(self),
4573 );
4574 {
4575 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4576 let __vi = *__vt.get(13usize).unwrap_or_else(|| {
4577 panic!(
4578 "unity: virtual slot {}
4579 out of range (vtable len {}
4580) on the runtime class behind {}
4581 (method `{}
4582`)",
4583 13usize,
4584 __vt.len(),
4585 <AIThink_EnchantThink_CalcUnitScoreFunction as ::unity::ClassIdentity>::NAME,
4586 "Invoke",
4587 )
4588 });
4589 let __inner: extern "C" fn(
4590 AIThink_EnchantThink_CalcUnitScoreFunction,
4591 crate::app::aithink::AIThink_EnchantThink,
4592 crate::app::unit::Unit,
4593 crate::app::unit::Unit,
4594 crate::app::unititem::UnitItem,
4595 ::unity::OptionalMethod,
4596 ) -> u8 = ::core::mem::transmute(__vi.method_ptr);
4597 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4598 __inner(
4599 __receiver,
4600 ::core::convert::Into::into(think),
4601 ::core::convert::Into::into(actor),
4602 ::core::convert::Into::into(target),
4603 ::core::convert::Into::into(unit_item),
4604 __mi,
4605 )
4606 }
4607 }
4608 }
4609}
4610
4611#[cfg(feature = "app-aithink")]
4612impl<__T: IAIThink_EnchantThink_CalcUnitScoreFunction> IAIThink_EnchantThink_CalcUnitScoreFunctionMethods for __T {}
4613
4614#[cfg(feature = "app-aithink")]
4615impl AIThink_EnchantThink_CalcUnitScoreFunction {
4616 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4617 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
4618 }
4619
4620 pub fn invoke_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4621 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
4622 }
4623}
4624
4625#[cfg(feature = "app-aithink")]
4626impl AIThink_EnchantThink_CalcUnitScoreFunction {
4627 #[doc = "Direct (non-virtual) call to `AIThink_EnchantThink_CalcUnitScoreFunction`'s own `Invoke`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4628 pub unsafe fn invoke(
4629 this: impl ::core::convert::Into<::unity::IlInstance>,
4630 think: crate::app::aithink::AIThink_EnchantThink,
4631 actor: crate::app::unit::Unit,
4632 target: crate::app::unit::Unit,
4633 unit_item: crate::app::unititem::UnitItem,
4634 ) -> u8 {
4635 let __mi = Self::invoke_method_info();
4636 let __inner: extern "C" fn(
4637 ::unity::IlInstance,
4638 crate::app::aithink::AIThink_EnchantThink,
4639 crate::app::unit::Unit,
4640 crate::app::unit::Unit,
4641 crate::app::unititem::UnitItem,
4642 ::unity::OptionalMethod,
4643 ) -> u8 = ::core::mem::transmute(__mi.method_ptr);
4644 __inner(this.into(), think, actor, target, unit_item, ::core::option::Option::None)
4645 }
4646}
4647
4648#[cfg(feature = "app-aithink")]
4649impl AIThink_EnchantThink_CalcUnitScoreFunction {
4650 #[doc = "`.ctor(crate::system::object::Object, ::unity::IntPtr)` — overload selector"]
4651 pub fn new(object: crate::system::object::Object, method: ::unity::IntPtr) -> Self {
4652 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
4653 panic!(
4654 "{}
4655::{}
4656 failed to instantiate",
4657 ::core::stringify!(AIThink_EnchantThink_CalcUnitScoreFunction),
4658 ::core::stringify!(new),
4659 )
4660 });
4661 <Self as IAIThink_EnchantThink_CalcUnitScoreFunctionMethods>::ctor(this, object, method);
4662 this
4663 }
4664}
4665
4666#[cfg(feature = "app-aithink")]
4667impl AIThink_EngageWaitResult {
4668 #[doc = "`New(crate::app::unit::Unit, *mutcrate::app::aithink::AIThink_EngageWaitResult)` overload"]
4669 pub fn new(unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> crate::app::aithink::AIThink_EngageWaitResult {
4670 unsafe {
4671 let mut __out_0 = ::core::mem::MaybeUninit::<crate::app::aithink::AIThink_EngageWaitResult>::uninit();
4672 ::unity::il2cpp_call!((::unity::module_base()+0x2900270usize)as*mut u8,();
4673(crate::app::unit::Unit)::core::convert::Into::into(unit),(*mut crate::app::aithink::AIThink_EngageWaitResult)__out_0.as_mut_ptr());
4674 __out_0.assume_init()
4675 }
4676 }
4677}
4678
4679#[cfg(feature = "app-aithink")]
4680impl AIThink_EngageWaitResult {
4681 #[doc = "`CompareAndSwap(u32, i32, i32, i32)` overload"]
4682 pub fn compare_and_swap(
4683 &mut self,
4684 temp_score: impl ::core::convert::Into<u32>,
4685 temp_x: impl ::core::convert::Into<i32>,
4686 temp_z: impl ::core::convert::Into<i32>,
4687 temp_item_index: impl ::core::convert::Into<i32>,
4688 ) -> () {
4689 unsafe {
4690 ::unity::il2cpp_call!((::unity::module_base()+0x2900180usize)as*mut u8,();
4691(*mut AIThink_EngageWaitResult)self as*mut AIThink_EngageWaitResult,(u32)::core::convert::Into::into(temp_score),(i32)::core::convert::Into::into(temp_x),(i32)::core::convert::Into::into(temp_z),(i32)::core::convert::Into::into(temp_item_index))
4692 }
4693 }
4694}
4695
4696#[cfg(feature = "app-aithink")]
4697impl AIThink_EngageWaitResult {
4698 pub fn compare_and_swap_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4699 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
4700 }
4701
4702 pub fn new_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4703 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
4704 }
4705}
4706
4707#[cfg(feature = "app-aithink")]
4708impl AIThink_TrimasteriesSkills {
4709 #[doc = "`Prepare(crate::app::unit::Unit)` overload"]
4710 pub fn prepare(&mut self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> () {
4711 unsafe {
4712 ::unity::il2cpp_call!((::unity::module_base()+0x2901090usize)as*mut u8,();
4713(*mut AIThink_TrimasteriesSkills)self as*mut AIThink_TrimasteriesSkills,(crate::app::unit::Unit)::core::convert::Into::into(unit))
4714 }
4715 }
4716
4717 #[doc = "`Add(crate::app::skilldata::SkillData)` overload"]
4718 pub fn add(&mut self, skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>) -> () {
4719 unsafe {
4720 ::unity::il2cpp_call!((::unity::module_base()+0x29012d0usize)as*mut u8,();
4721(*mut AIThink_TrimasteriesSkills)self as*mut AIThink_TrimasteriesSkills,(crate::app::skilldata::SkillData)::core::convert::Into::into(skill))
4722 }
4723 }
4724
4725 #[doc = "`get_Count()` overload"]
4726 pub fn get_count(&mut self) -> i32 {
4727 unsafe {
4728 ::unity::il2cpp_call!((::unity::module_base()+0x29014b0usize)as*mut u8,i32;
4729(*mut AIThink_TrimasteriesSkills)self as*mut AIThink_TrimasteriesSkills)
4730 }
4731 }
4732
4733 #[doc = "`get_MadStorm()` overload"]
4734 pub fn get_mad_storm(&mut self) -> crate::app::skilldata::SkillData {
4735 unsafe {
4736 ::unity::il2cpp_call!((::unity::module_base()+0x29014c0usize)as*mut u8,crate::app::skilldata::SkillData;
4737(*mut AIThink_TrimasteriesSkills)self as*mut AIThink_TrimasteriesSkills)
4738 }
4739 }
4740
4741 #[doc = "`get_Miserable()` overload"]
4742 pub fn get_miserable(&mut self) -> crate::app::skilldata::SkillData {
4743 unsafe {
4744 ::unity::il2cpp_call!((::unity::module_base()+0x29014f0usize)as*mut u8,crate::app::skilldata::SkillData;
4745(*mut AIThink_TrimasteriesSkills)self as*mut AIThink_TrimasteriesSkills)
4746 }
4747 }
4748
4749 #[doc = "`get_FallingStars()` overload"]
4750 pub fn get_falling_stars(&mut self) -> crate::app::skilldata::SkillData {
4751 unsafe {
4752 ::unity::il2cpp_call!((::unity::module_base()+0x2901520usize)as*mut u8,crate::app::skilldata::SkillData;
4753(*mut AIThink_TrimasteriesSkills)self as*mut AIThink_TrimasteriesSkills)
4754 }
4755 }
4756
4757 #[doc = "`GetKind(crate::app::skilldata::SkillData)` overload"]
4758 pub fn get_kind(
4759 &mut self,
4760 skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>,
4761 ) -> crate::app::aithink::AIThink_TrimasteriesSkills_Kinds {
4762 unsafe {
4763 ::unity::il2cpp_call!((::unity::module_base()+0x2901430usize)as*mut u8,crate::app::aithink::AIThink_TrimasteriesSkills_Kinds;
4764(*mut AIThink_TrimasteriesSkills)self as*mut AIThink_TrimasteriesSkills,(crate::app::skilldata::SkillData)::core::convert::Into::into(skill))
4765 }
4766 }
4767}
4768
4769#[cfg(feature = "app-aithink")]
4770impl AIThink_TrimasteriesSkills {
4771 pub fn prepare_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4772 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
4773 }
4774
4775 pub fn add_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4776 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
4777 }
4778
4779 pub fn get_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4780 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
4781 }
4782
4783 pub fn get_mad_storm_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4784 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
4785 }
4786
4787 pub fn get_miserable_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4788 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
4789 }
4790
4791 pub fn get_falling_stars_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4792 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
4793 }
4794
4795 pub fn get_kind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4796 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
4797 }
4798}
4799
4800#[cfg(feature = "app-aithink")]
4801impl AIThink_EnchantThink_ItemInfo {
4802 #[doc = "`CompareTo(crate::app::aithink::AIThink_EnchantThink_ItemInfo)` overload"]
4803 pub fn compare_to(&mut self, other: impl ::core::convert::Into<crate::app::aithink::AIThink_EnchantThink_ItemInfo>) -> i32 {
4804 unsafe {
4805 ::unity::il2cpp_call!((::unity::module_base()+0x1b311d0usize)as*mut u8,i32;
4806(*mut AIThink_EnchantThink_ItemInfo)self as*mut AIThink_EnchantThink_ItemInfo,(crate::app::aithink::AIThink_EnchantThink_ItemInfo)::core::convert::Into::into(other))
4807 }
4808 }
4809}
4810
4811#[cfg(feature = "app-aithink")]
4812impl AIThink_EnchantThink_ItemInfo {
4813 pub fn compare_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4814 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
4815 }
4816}
4817
4818#[cfg(feature = "app-aithink")]
4819impl AIThink_AttackScoreResult {
4820 #[doc = "`get_Score()` overload"]
4821 pub fn get_score(&mut self) -> u32 {
4822 unsafe {
4823 ::unity::il2cpp_call!((::unity::module_base()+0x28fb7c0usize)as*mut u8,u32;
4824(*mut AIThink_AttackScoreResult)self as*mut AIThink_AttackScoreResult)
4825 }
4826 }
4827
4828 #[doc = "`set_Score(u32)` overload"]
4829 pub fn set_score(&mut self, value: impl ::core::convert::Into<u32>) -> () {
4830 unsafe {
4831 ::unity::il2cpp_call!((::unity::module_base()+0x28fb7d0usize)as*mut u8,();
4832(*mut AIThink_AttackScoreResult)self as*mut AIThink_AttackScoreResult,(u32)::core::convert::Into::into(value))
4833 }
4834 }
4835
4836 #[doc = "`get_MoveX()` overload"]
4837 pub fn get_move_x(&mut self) -> i32 {
4838 unsafe {
4839 ::unity::il2cpp_call!((::unity::module_base()+0x28fb7e0usize)as*mut u8,i32;
4840(*mut AIThink_AttackScoreResult)self as*mut AIThink_AttackScoreResult)
4841 }
4842 }
4843
4844 #[doc = "`set_MoveX(i32)` overload"]
4845 pub fn set_move_x(&mut self, value: impl ::core::convert::Into<i32>) -> () {
4846 unsafe {
4847 ::unity::il2cpp_call!((::unity::module_base()+0x28fb7f0usize)as*mut u8,();
4848(*mut AIThink_AttackScoreResult)self as*mut AIThink_AttackScoreResult,(i32)::core::convert::Into::into(value))
4849 }
4850 }
4851
4852 #[doc = "`get_MoveZ()` overload"]
4853 pub fn get_move_z(&mut self) -> i32 {
4854 unsafe {
4855 ::unity::il2cpp_call!((::unity::module_base()+0x28fb800usize)as*mut u8,i32;
4856(*mut AIThink_AttackScoreResult)self as*mut AIThink_AttackScoreResult)
4857 }
4858 }
4859
4860 #[doc = "`set_MoveZ(i32)` overload"]
4861 pub fn set_move_z(&mut self, value: impl ::core::convert::Into<i32>) -> () {
4862 unsafe {
4863 ::unity::il2cpp_call!((::unity::module_base()+0x28fb810usize)as*mut u8,();
4864(*mut AIThink_AttackScoreResult)self as*mut AIThink_AttackScoreResult,(i32)::core::convert::Into::into(value))
4865 }
4866 }
4867
4868 #[doc = "`get_AttackX()` overload"]
4869 pub fn get_attack_x(&mut self) -> i32 {
4870 unsafe {
4871 ::unity::il2cpp_call!((::unity::module_base()+0x28fb820usize)as*mut u8,i32;
4872(*mut AIThink_AttackScoreResult)self as*mut AIThink_AttackScoreResult)
4873 }
4874 }
4875
4876 #[doc = "`set_AttackX(i32)` overload"]
4877 pub fn set_attack_x(&mut self, value: impl ::core::convert::Into<i32>) -> () {
4878 unsafe {
4879 ::unity::il2cpp_call!((::unity::module_base()+0x28fb830usize)as*mut u8,();
4880(*mut AIThink_AttackScoreResult)self as*mut AIThink_AttackScoreResult,(i32)::core::convert::Into::into(value))
4881 }
4882 }
4883
4884 #[doc = "`get_AttackZ()` overload"]
4885 pub fn get_attack_z(&mut self) -> i32 {
4886 unsafe {
4887 ::unity::il2cpp_call!((::unity::module_base()+0x28fb840usize)as*mut u8,i32;
4888(*mut AIThink_AttackScoreResult)self as*mut AIThink_AttackScoreResult)
4889 }
4890 }
4891
4892 #[doc = "`set_AttackZ(i32)` overload"]
4893 pub fn set_attack_z(&mut self, value: impl ::core::convert::Into<i32>) -> () {
4894 unsafe {
4895 ::unity::il2cpp_call!((::unity::module_base()+0x28fb850usize)as*mut u8,();
4896(*mut AIThink_AttackScoreResult)self as*mut AIThink_AttackScoreResult,(i32)::core::convert::Into::into(value))
4897 }
4898 }
4899
4900 #[doc = "`get_ItemIndex()` overload"]
4901 pub fn get_item_index(&mut self) -> i32 {
4902 unsafe {
4903 ::unity::il2cpp_call!((::unity::module_base()+0x28fb860usize)as*mut u8,i32;
4904(*mut AIThink_AttackScoreResult)self as*mut AIThink_AttackScoreResult)
4905 }
4906 }
4907
4908 #[doc = "`set_ItemIndex(i32)` overload"]
4909 pub fn set_item_index(&mut self, value: impl ::core::convert::Into<i32>) -> () {
4910 unsafe {
4911 ::unity::il2cpp_call!((::unity::module_base()+0x28fb870usize)as*mut u8,();
4912(*mut AIThink_AttackScoreResult)self as*mut AIThink_AttackScoreResult,(i32)::core::convert::Into::into(value))
4913 }
4914 }
4915
4916 #[doc = "`get_KillRate()` overload"]
4917 pub fn get_kill_rate(&mut self) -> f32 {
4918 unsafe {
4919 ::unity::il2cpp_call!((::unity::module_base()+0x28fb880usize)as*mut u8,f32;
4920(*mut AIThink_AttackScoreResult)self as*mut AIThink_AttackScoreResult)
4921 }
4922 }
4923
4924 #[doc = "`set_KillRate(f32)` overload"]
4925 pub fn set_kill_rate(&mut self, value: impl ::core::convert::Into<f32>) -> () {
4926 unsafe {
4927 ::unity::il2cpp_call!((::unity::module_base()+0x28fb890usize)as*mut u8,();
4928(*mut AIThink_AttackScoreResult)self as*mut AIThink_AttackScoreResult,(f32)::core::convert::Into::into(value))
4929 }
4930 }
4931
4932 #[doc = "`get_DeadRate()` overload"]
4933 pub fn get_dead_rate(&mut self) -> f32 {
4934 unsafe {
4935 ::unity::il2cpp_call!((::unity::module_base()+0x28fb8a0usize)as*mut u8,f32;
4936(*mut AIThink_AttackScoreResult)self as*mut AIThink_AttackScoreResult)
4937 }
4938 }
4939
4940 #[doc = "`set_DeadRate(f32)` overload"]
4941 pub fn set_dead_rate(&mut self, value: impl ::core::convert::Into<f32>) -> () {
4942 unsafe {
4943 ::unity::il2cpp_call!((::unity::module_base()+0x28fb8b0usize)as*mut u8,();
4944(*mut AIThink_AttackScoreResult)self as*mut AIThink_AttackScoreResult,(f32)::core::convert::Into::into(value))
4945 }
4946 }
4947
4948 #[doc = "`get_Expectation()` overload"]
4949 pub fn get_expectation(&mut self) -> f32 {
4950 unsafe {
4951 ::unity::il2cpp_call!((::unity::module_base()+0x28fb8c0usize)as*mut u8,f32;
4952(*mut AIThink_AttackScoreResult)self as*mut AIThink_AttackScoreResult)
4953 }
4954 }
4955
4956 #[doc = "`set_Expectation(f32)` overload"]
4957 pub fn set_expectation(&mut self, value: impl ::core::convert::Into<f32>) -> () {
4958 unsafe {
4959 ::unity::il2cpp_call!((::unity::module_base()+0x28fb8d0usize)as*mut u8,();
4960(*mut AIThink_AttackScoreResult)self as*mut AIThink_AttackScoreResult,(f32)::core::convert::Into::into(value))
4961 }
4962 }
4963
4964 #[doc = "`get_BlowScore()` overload"]
4965 pub fn get_blow_score(&mut self) -> u32 {
4966 unsafe {
4967 ::unity::il2cpp_call!((::unity::module_base()+0x28fb8e0usize)as*mut u8,u32;
4968(*mut AIThink_AttackScoreResult)self as*mut AIThink_AttackScoreResult)
4969 }
4970 }
4971
4972 #[doc = "`set_BlowScore(u32)` overload"]
4973 pub fn set_blow_score(&mut self, value: impl ::core::convert::Into<u32>) -> () {
4974 unsafe {
4975 ::unity::il2cpp_call!((::unity::module_base()+0x28fb8f0usize)as*mut u8,();
4976(*mut AIThink_AttackScoreResult)self as*mut AIThink_AttackScoreResult,(u32)::core::convert::Into::into(value))
4977 }
4978 }
4979
4980 #[doc = "`get_ChainAttackCount()` overload"]
4981 pub fn get_chain_attack_count(&mut self) -> i32 {
4982 unsafe {
4983 ::unity::il2cpp_call!((::unity::module_base()+0x28fb900usize)as*mut u8,i32;
4984(*mut AIThink_AttackScoreResult)self as*mut AIThink_AttackScoreResult)
4985 }
4986 }
4987
4988 #[doc = "`set_ChainAttackCount(i32)` overload"]
4989 pub fn set_chain_attack_count(&mut self, value: impl ::core::convert::Into<i32>) -> () {
4990 unsafe {
4991 ::unity::il2cpp_call!((::unity::module_base()+0x28fb910usize)as*mut u8,();
4992(*mut AIThink_AttackScoreResult)self as*mut AIThink_AttackScoreResult,(i32)::core::convert::Into::into(value))
4993 }
4994 }
4995
4996 #[doc = "`Clear()` overload"]
4997 pub fn clear(&mut self) -> () {
4998 unsafe {
4999 ::unity::il2cpp_call!((::unity::module_base()+0x28fb920usize)as*mut u8,();
5000(*mut AIThink_AttackScoreResult)self as*mut AIThink_AttackScoreResult)
5001 }
5002 }
5003}
5004
5005#[cfg(feature = "app-aithink")]
5006impl AIThink_AttackScoreResult {
5007 pub fn get_score_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5008 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
5009 }
5010
5011 pub fn set_score_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5012 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
5013 }
5014
5015 pub fn get_move_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5016 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
5017 }
5018
5019 pub fn set_move_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5020 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
5021 }
5022
5023 pub fn get_move_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5024 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
5025 }
5026
5027 pub fn set_move_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5028 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
5029 }
5030
5031 pub fn get_attack_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5032 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
5033 }
5034
5035 pub fn set_attack_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5036 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
5037 }
5038
5039 pub fn get_attack_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5040 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
5041 }
5042
5043 pub fn set_attack_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5044 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
5045 }
5046
5047 pub fn get_item_index_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5048 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
5049 }
5050
5051 pub fn set_item_index_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5052 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
5053 }
5054
5055 pub fn get_kill_rate_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5056 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
5057 }
5058
5059 pub fn set_kill_rate_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5060 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
5061 }
5062
5063 pub fn get_dead_rate_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5064 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[14]
5065 }
5066
5067 pub fn set_dead_rate_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5068 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[15]
5069 }
5070
5071 pub fn get_expectation_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5072 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[16]
5073 }
5074
5075 pub fn set_expectation_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5076 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[17]
5077 }
5078
5079 pub fn get_blow_score_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5080 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[18]
5081 }
5082
5083 pub fn set_blow_score_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5084 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[19]
5085 }
5086
5087 pub fn get_chain_attack_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5088 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[20]
5089 }
5090
5091 pub fn set_chain_attack_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5092 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[21]
5093 }
5094
5095 pub fn clear_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5096 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[22]
5097 }
5098}
5099
5100#[cfg(feature = "app-aithink")]
5101impl AIThink_WarpRodEvaluationResult {
5102 #[doc = "`get_MoveX()` overload"]
5103 pub fn get_move_x(&mut self) -> i32 {
5104 unsafe {
5105 ::unity::il2cpp_call!((::unity::module_base()+0x2901750usize)as*mut u8,i32;
5106(*mut AIThink_WarpRodEvaluationResult)self as*mut AIThink_WarpRodEvaluationResult)
5107 }
5108 }
5109
5110 #[doc = "`set_MoveX(i32)` overload"]
5111 pub fn set_move_x(&mut self, value: impl ::core::convert::Into<i32>) -> () {
5112 unsafe {
5113 ::unity::il2cpp_call!((::unity::module_base()+0x2901760usize)as*mut u8,();
5114(*mut AIThink_WarpRodEvaluationResult)self as*mut AIThink_WarpRodEvaluationResult,(i32)::core::convert::Into::into(value))
5115 }
5116 }
5117
5118 #[doc = "`get_MoveZ()` overload"]
5119 pub fn get_move_z(&mut self) -> i32 {
5120 unsafe {
5121 ::unity::il2cpp_call!((::unity::module_base()+0x2901770usize)as*mut u8,i32;
5122(*mut AIThink_WarpRodEvaluationResult)self as*mut AIThink_WarpRodEvaluationResult)
5123 }
5124 }
5125
5126 #[doc = "`set_MoveZ(i32)` overload"]
5127 pub fn set_move_z(&mut self, value: impl ::core::convert::Into<i32>) -> () {
5128 unsafe {
5129 ::unity::il2cpp_call!((::unity::module_base()+0x2901780usize)as*mut u8,();
5130(*mut AIThink_WarpRodEvaluationResult)self as*mut AIThink_WarpRodEvaluationResult,(i32)::core::convert::Into::into(value))
5131 }
5132 }
5133
5134 #[doc = "`get_AttackX()` overload"]
5135 pub fn get_attack_x(&mut self) -> i32 {
5136 unsafe {
5137 ::unity::il2cpp_call!((::unity::module_base()+0x2901790usize)as*mut u8,i32;
5138(*mut AIThink_WarpRodEvaluationResult)self as*mut AIThink_WarpRodEvaluationResult)
5139 }
5140 }
5141
5142 #[doc = "`set_AttackX(i32)` overload"]
5143 pub fn set_attack_x(&mut self, value: impl ::core::convert::Into<i32>) -> () {
5144 unsafe {
5145 ::unity::il2cpp_call!((::unity::module_base()+0x29017a0usize)as*mut u8,();
5146(*mut AIThink_WarpRodEvaluationResult)self as*mut AIThink_WarpRodEvaluationResult,(i32)::core::convert::Into::into(value))
5147 }
5148 }
5149
5150 #[doc = "`get_AttackZ()` overload"]
5151 pub fn get_attack_z(&mut self) -> i32 {
5152 unsafe {
5153 ::unity::il2cpp_call!((::unity::module_base()+0x29017b0usize)as*mut u8,i32;
5154(*mut AIThink_WarpRodEvaluationResult)self as*mut AIThink_WarpRodEvaluationResult)
5155 }
5156 }
5157
5158 #[doc = "`set_AttackZ(i32)` overload"]
5159 pub fn set_attack_z(&mut self, value: impl ::core::convert::Into<i32>) -> () {
5160 unsafe {
5161 ::unity::il2cpp_call!((::unity::module_base()+0x29017c0usize)as*mut u8,();
5162(*mut AIThink_WarpRodEvaluationResult)self as*mut AIThink_WarpRodEvaluationResult,(i32)::core::convert::Into::into(value))
5163 }
5164 }
5165
5166 #[doc = "`get_WarpX()` overload"]
5167 pub fn get_warp_x(&mut self) -> i32 {
5168 unsafe {
5169 ::unity::il2cpp_call!((::unity::module_base()+0x29017d0usize)as*mut u8,i32;
5170(*mut AIThink_WarpRodEvaluationResult)self as*mut AIThink_WarpRodEvaluationResult)
5171 }
5172 }
5173
5174 #[doc = "`set_WarpX(i32)` overload"]
5175 pub fn set_warp_x(&mut self, value: impl ::core::convert::Into<i32>) -> () {
5176 unsafe {
5177 ::unity::il2cpp_call!((::unity::module_base()+0x29017e0usize)as*mut u8,();
5178(*mut AIThink_WarpRodEvaluationResult)self as*mut AIThink_WarpRodEvaluationResult,(i32)::core::convert::Into::into(value))
5179 }
5180 }
5181
5182 #[doc = "`get_WarpZ()` overload"]
5183 pub fn get_warp_z(&mut self) -> i32 {
5184 unsafe {
5185 ::unity::il2cpp_call!((::unity::module_base()+0x29017f0usize)as*mut u8,i32;
5186(*mut AIThink_WarpRodEvaluationResult)self as*mut AIThink_WarpRodEvaluationResult)
5187 }
5188 }
5189
5190 #[doc = "`set_WarpZ(i32)` overload"]
5191 pub fn set_warp_z(&mut self, value: impl ::core::convert::Into<i32>) -> () {
5192 unsafe {
5193 ::unity::il2cpp_call!((::unity::module_base()+0x2901800usize)as*mut u8,();
5194(*mut AIThink_WarpRodEvaluationResult)self as*mut AIThink_WarpRodEvaluationResult,(i32)::core::convert::Into::into(value))
5195 }
5196 }
5197
5198 #[doc = "`get_MoveDist()` overload"]
5199 pub fn get_move_dist(&mut self) -> i32 {
5200 unsafe {
5201 ::unity::il2cpp_call!((::unity::module_base()+0x2901810usize)as*mut u8,i32;
5202(*mut AIThink_WarpRodEvaluationResult)self as*mut AIThink_WarpRodEvaluationResult)
5203 }
5204 }
5205
5206 #[doc = "`set_MoveDist(i32)` overload"]
5207 pub fn set_move_dist(&mut self, value: impl ::core::convert::Into<i32>) -> () {
5208 unsafe {
5209 ::unity::il2cpp_call!((::unity::module_base()+0x2901820usize)as*mut u8,();
5210(*mut AIThink_WarpRodEvaluationResult)self as*mut AIThink_WarpRodEvaluationResult,(i32)::core::convert::Into::into(value))
5211 }
5212 }
5213
5214 #[doc = "`get_EnemyDist()` overload"]
5215 pub fn get_enemy_dist(&mut self) -> i32 {
5216 unsafe {
5217 ::unity::il2cpp_call!((::unity::module_base()+0x2901830usize)as*mut u8,i32;
5218(*mut AIThink_WarpRodEvaluationResult)self as*mut AIThink_WarpRodEvaluationResult)
5219 }
5220 }
5221
5222 #[doc = "`set_EnemyDist(i32)` overload"]
5223 pub fn set_enemy_dist(&mut self, value: impl ::core::convert::Into<i32>) -> () {
5224 unsafe {
5225 ::unity::il2cpp_call!((::unity::module_base()+0x2901840usize)as*mut u8,();
5226(*mut AIThink_WarpRodEvaluationResult)self as*mut AIThink_WarpRodEvaluationResult,(i32)::core::convert::Into::into(value))
5227 }
5228 }
5229
5230 #[doc = "`Clear()` overload"]
5231 pub fn clear(&mut self) -> () {
5232 unsafe {
5233 ::unity::il2cpp_call!((::unity::module_base()+0x2901850usize)as*mut u8,();
5234(*mut AIThink_WarpRodEvaluationResult)self as*mut AIThink_WarpRodEvaluationResult)
5235 }
5236 }
5237}
5238
5239#[cfg(feature = "app-aithink")]
5240impl AIThink_WarpRodEvaluationResult {
5241 pub fn get_move_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5242 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
5243 }
5244
5245 pub fn set_move_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5246 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
5247 }
5248
5249 pub fn get_move_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5250 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
5251 }
5252
5253 pub fn set_move_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5254 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
5255 }
5256
5257 pub fn get_attack_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5258 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
5259 }
5260
5261 pub fn set_attack_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5262 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
5263 }
5264
5265 pub fn get_attack_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5266 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
5267 }
5268
5269 pub fn set_attack_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5270 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
5271 }
5272
5273 pub fn get_warp_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5274 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
5275 }
5276
5277 pub fn set_warp_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5278 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
5279 }
5280
5281 pub fn get_warp_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5282 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
5283 }
5284
5285 pub fn set_warp_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5286 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
5287 }
5288
5289 pub fn get_move_dist_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5290 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
5291 }
5292
5293 pub fn set_move_dist_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5294 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
5295 }
5296
5297 pub fn get_enemy_dist_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5298 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[14]
5299 }
5300
5301 pub fn set_enemy_dist_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5302 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[15]
5303 }
5304
5305 pub fn clear_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5306 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[16]
5307 }
5308}
5309
5310#[cfg(feature = "app-aithink")]
5311impl AIThink_InterferenceTarget {
5312 #[doc = "`New(*mutcrate::app::aithink::AIThink_InterferenceTarget)` overload"]
5313 pub fn new() -> crate::app::aithink::AIThink_InterferenceTarget {
5314 unsafe {
5315 let mut __out_0 = ::core::mem::MaybeUninit::<crate::app::aithink::AIThink_InterferenceTarget>::uninit();
5316 ::unity::il2cpp_call!((::unity::module_base()+0x29008b0usize)as*mut u8,();
5317(*mut crate::app::aithink::AIThink_InterferenceTarget)__out_0.as_mut_ptr());
5318 __out_0.assume_init()
5319 }
5320 }
5321}
5322
5323#[cfg(feature = "app-aithink")]
5324impl AIThink_InterferenceTarget {
5325 #[doc = "`get_Unit()` overload"]
5326 pub fn get_unit(&mut self) -> crate::app::unit::Unit {
5327 unsafe {
5328 ::unity::il2cpp_call!((::unity::module_base()+0x29007b0usize)as*mut u8,crate::app::unit::Unit;
5329(*mut AIThink_InterferenceTarget)self as*mut AIThink_InterferenceTarget)
5330 }
5331 }
5332
5333 #[doc = "`set_Unit(crate::app::unit::Unit)` overload"]
5334 pub fn set_unit(&mut self, value: impl ::core::convert::Into<crate::app::unit::Unit>) -> () {
5335 unsafe {
5336 ::unity::il2cpp_call!((::unity::module_base()+0x29007c0usize)as*mut u8,();
5337(*mut AIThink_InterferenceTarget)self as*mut AIThink_InterferenceTarget,(crate::app::unit::Unit)::core::convert::Into::into(value))
5338 }
5339 }
5340
5341 #[doc = "`get_X()` overload"]
5342 pub fn get_x(&mut self) -> i32 {
5343 unsafe {
5344 ::unity::il2cpp_call!((::unity::module_base()+0x29007d0usize)as*mut u8,i32;
5345(*mut AIThink_InterferenceTarget)self as*mut AIThink_InterferenceTarget)
5346 }
5347 }
5348
5349 #[doc = "`set_X(i32)` overload"]
5350 pub fn set_x(&mut self, value: impl ::core::convert::Into<i32>) -> () {
5351 unsafe {
5352 ::unity::il2cpp_call!((::unity::module_base()+0x29007e0usize)as*mut u8,();
5353(*mut AIThink_InterferenceTarget)self as*mut AIThink_InterferenceTarget,(i32)::core::convert::Into::into(value))
5354 }
5355 }
5356
5357 #[doc = "`get_Z()` overload"]
5358 pub fn get_z(&mut self) -> i32 {
5359 unsafe {
5360 ::unity::il2cpp_call!((::unity::module_base()+0x29007f0usize)as*mut u8,i32;
5361(*mut AIThink_InterferenceTarget)self as*mut AIThink_InterferenceTarget)
5362 }
5363 }
5364
5365 #[doc = "`set_Z(i32)` overload"]
5366 pub fn set_z(&mut self, value: impl ::core::convert::Into<i32>) -> () {
5367 unsafe {
5368 ::unity::il2cpp_call!((::unity::module_base()+0x2900800usize)as*mut u8,();
5369(*mut AIThink_InterferenceTarget)self as*mut AIThink_InterferenceTarget,(i32)::core::convert::Into::into(value))
5370 }
5371 }
5372
5373 #[doc = "`get_Score()` overload"]
5374 pub fn get_score(&mut self) -> u32 {
5375 unsafe {
5376 ::unity::il2cpp_call!((::unity::module_base()+0x2900810usize)as*mut u8,u32;
5377(*mut AIThink_InterferenceTarget)self as*mut AIThink_InterferenceTarget)
5378 }
5379 }
5380
5381 #[doc = "`get_MoveX()` overload"]
5382 pub fn get_move_x(&mut self) -> i32 {
5383 unsafe {
5384 ::unity::il2cpp_call!((::unity::module_base()+0x2900820usize)as*mut u8,i32;
5385(*mut AIThink_InterferenceTarget)self as*mut AIThink_InterferenceTarget)
5386 }
5387 }
5388
5389 #[doc = "`get_MoveZ()` overload"]
5390 pub fn get_move_z(&mut self) -> i32 {
5391 unsafe {
5392 ::unity::il2cpp_call!((::unity::module_base()+0x2900830usize)as*mut u8,i32;
5393(*mut AIThink_InterferenceTarget)self as*mut AIThink_InterferenceTarget)
5394 }
5395 }
5396
5397 #[doc = "`get_AttackX()` overload"]
5398 pub fn get_attack_x(&mut self) -> i32 {
5399 unsafe {
5400 ::unity::il2cpp_call!((::unity::module_base()+0x2900840usize)as*mut u8,i32;
5401(*mut AIThink_InterferenceTarget)self as*mut AIThink_InterferenceTarget)
5402 }
5403 }
5404
5405 #[doc = "`get_AttackZ()` overload"]
5406 pub fn get_attack_z(&mut self) -> i32 {
5407 unsafe {
5408 ::unity::il2cpp_call!((::unity::module_base()+0x2900850usize)as*mut u8,i32;
5409(*mut AIThink_InterferenceTarget)self as*mut AIThink_InterferenceTarget)
5410 }
5411 }
5412
5413 #[doc = "`get_ItemIndex()` overload"]
5414 pub fn get_item_index(&mut self) -> i32 {
5415 unsafe {
5416 ::unity::il2cpp_call!((::unity::module_base()+0x2900860usize)as*mut u8,i32;
5417(*mut AIThink_InterferenceTarget)self as*mut AIThink_InterferenceTarget)
5418 }
5419 }
5420
5421 #[doc = "`Clear()` overload"]
5422 pub fn clear(&mut self) -> () {
5423 unsafe {
5424 ::unity::il2cpp_call!((::unity::module_base()+0x2900870usize)as*mut u8,();
5425(*mut AIThink_InterferenceTarget)self as*mut AIThink_InterferenceTarget)
5426 }
5427 }
5428}
5429
5430#[cfg(feature = "app-aithink")]
5431impl AIThink_InterferenceTarget {
5432 pub fn get_unit_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5433 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
5434 }
5435
5436 pub fn set_unit_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5437 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
5438 }
5439
5440 pub fn get_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5441 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
5442 }
5443
5444 pub fn set_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5445 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
5446 }
5447
5448 pub fn get_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5449 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
5450 }
5451
5452 pub fn set_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5453 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
5454 }
5455
5456 pub fn get_score_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5457 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
5458 }
5459
5460 pub fn get_move_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5461 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
5462 }
5463
5464 pub fn get_move_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5465 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
5466 }
5467
5468 pub fn get_attack_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5469 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
5470 }
5471
5472 pub fn get_attack_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5473 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
5474 }
5475
5476 pub fn get_item_index_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5477 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
5478 }
5479
5480 pub fn clear_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5481 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
5482 }
5483
5484 pub fn new_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5485 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
5486 }
5487}
5488
5489#[cfg(feature = "app-aithink")]
5490impl AIThink_UncontrollAttackTarget {
5491 #[doc = "`New(*mutcrate::app::aithink::AIThink_UncontrollAttackTarget)` overload"]
5492 pub fn new() -> crate::app::aithink::AIThink_UncontrollAttackTarget {
5493 unsafe {
5494 let mut __out_0 = ::core::mem::MaybeUninit::<crate::app::aithink::AIThink_UncontrollAttackTarget>::uninit();
5495 ::unity::il2cpp_call!((::unity::module_base()+0x29016f0usize)as*mut u8,();
5496(*mut crate::app::aithink::AIThink_UncontrollAttackTarget)__out_0.as_mut_ptr());
5497 __out_0.assume_init()
5498 }
5499 }
5500}
5501
5502#[cfg(feature = "app-aithink")]
5503impl AIThink_UncontrollAttackTarget {
5504 #[doc = "`get_Unit()` overload"]
5505 pub fn get_unit(&mut self) -> crate::app::unit::Unit {
5506 unsafe {
5507 ::unity::il2cpp_call!((::unity::module_base()+0x2901610usize)as*mut u8,crate::app::unit::Unit;
5508(*mut AIThink_UncontrollAttackTarget)self as*mut AIThink_UncontrollAttackTarget)
5509 }
5510 }
5511
5512 #[doc = "`set_Unit(crate::app::unit::Unit)` overload"]
5513 pub fn set_unit(&mut self, value: impl ::core::convert::Into<crate::app::unit::Unit>) -> () {
5514 unsafe {
5515 ::unity::il2cpp_call!((::unity::module_base()+0x2901620usize)as*mut u8,();
5516(*mut AIThink_UncontrollAttackTarget)self as*mut AIThink_UncontrollAttackTarget,(crate::app::unit::Unit)::core::convert::Into::into(value))
5517 }
5518 }
5519
5520 #[doc = "`get_X()` overload"]
5521 pub fn get_x(&mut self) -> i32 {
5522 unsafe {
5523 ::unity::il2cpp_call!((::unity::module_base()+0x2901630usize)as*mut u8,i32;
5524(*mut AIThink_UncontrollAttackTarget)self as*mut AIThink_UncontrollAttackTarget)
5525 }
5526 }
5527
5528 #[doc = "`set_X(i32)` overload"]
5529 pub fn set_x(&mut self, value: impl ::core::convert::Into<i32>) -> () {
5530 unsafe {
5531 ::unity::il2cpp_call!((::unity::module_base()+0x2901640usize)as*mut u8,();
5532(*mut AIThink_UncontrollAttackTarget)self as*mut AIThink_UncontrollAttackTarget,(i32)::core::convert::Into::into(value))
5533 }
5534 }
5535
5536 #[doc = "`get_Z()` overload"]
5537 pub fn get_z(&mut self) -> i32 {
5538 unsafe {
5539 ::unity::il2cpp_call!((::unity::module_base()+0x2901650usize)as*mut u8,i32;
5540(*mut AIThink_UncontrollAttackTarget)self as*mut AIThink_UncontrollAttackTarget)
5541 }
5542 }
5543
5544 #[doc = "`set_Z(i32)` overload"]
5545 pub fn set_z(&mut self, value: impl ::core::convert::Into<i32>) -> () {
5546 unsafe {
5547 ::unity::il2cpp_call!((::unity::module_base()+0x2901660usize)as*mut u8,();
5548(*mut AIThink_UncontrollAttackTarget)self as*mut AIThink_UncontrollAttackTarget,(i32)::core::convert::Into::into(value))
5549 }
5550 }
5551
5552 #[doc = "`get_Score()` overload"]
5553 pub fn get_score(&mut self) -> u32 {
5554 unsafe {
5555 ::unity::il2cpp_call!((::unity::module_base()+0x28fa180usize)as*mut u8,u32;
5556(*mut AIThink_UncontrollAttackTarget)self as*mut AIThink_UncontrollAttackTarget)
5557 }
5558 }
5559
5560 #[doc = "`get_MoveX()` overload"]
5561 pub fn get_move_x(&mut self) -> i32 {
5562 unsafe {
5563 ::unity::il2cpp_call!((::unity::module_base()+0x2901670usize)as*mut u8,i32;
5564(*mut AIThink_UncontrollAttackTarget)self as*mut AIThink_UncontrollAttackTarget)
5565 }
5566 }
5567
5568 #[doc = "`get_MoveZ()` overload"]
5569 pub fn get_move_z(&mut self) -> i32 {
5570 unsafe {
5571 ::unity::il2cpp_call!((::unity::module_base()+0x2901680usize)as*mut u8,i32;
5572(*mut AIThink_UncontrollAttackTarget)self as*mut AIThink_UncontrollAttackTarget)
5573 }
5574 }
5575
5576 #[doc = "`get_AttackX()` overload"]
5577 pub fn get_attack_x(&mut self) -> i32 {
5578 unsafe {
5579 ::unity::il2cpp_call!((::unity::module_base()+0x2901690usize)as*mut u8,i32;
5580(*mut AIThink_UncontrollAttackTarget)self as*mut AIThink_UncontrollAttackTarget)
5581 }
5582 }
5583
5584 #[doc = "`get_AttackZ()` overload"]
5585 pub fn get_attack_z(&mut self) -> i32 {
5586 unsafe {
5587 ::unity::il2cpp_call!((::unity::module_base()+0x29016a0usize)as*mut u8,i32;
5588(*mut AIThink_UncontrollAttackTarget)self as*mut AIThink_UncontrollAttackTarget)
5589 }
5590 }
5591
5592 #[doc = "`Clear()` overload"]
5593 pub fn clear(&mut self) -> () {
5594 unsafe {
5595 ::unity::il2cpp_call!((::unity::module_base()+0x29016b0usize)as*mut u8,();
5596(*mut AIThink_UncontrollAttackTarget)self as*mut AIThink_UncontrollAttackTarget)
5597 }
5598 }
5599}
5600
5601#[cfg(feature = "app-aithink")]
5602impl AIThink_UncontrollAttackTarget {
5603 pub fn get_unit_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5604 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
5605 }
5606
5607 pub fn set_unit_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5608 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
5609 }
5610
5611 pub fn get_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5612 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
5613 }
5614
5615 pub fn set_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5616 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
5617 }
5618
5619 pub fn get_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5620 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
5621 }
5622
5623 pub fn set_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5624 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
5625 }
5626
5627 pub fn get_score_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5628 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
5629 }
5630
5631 pub fn get_move_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5632 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
5633 }
5634
5635 pub fn get_move_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5636 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
5637 }
5638
5639 pub fn get_attack_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5640 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
5641 }
5642
5643 pub fn get_attack_z_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5644 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
5645 }
5646
5647 pub fn clear_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5648 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
5649 }
5650
5651 pub fn new_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5652 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
5653 }
5654}
5655
5656#[cfg(feature = "app-aithink")]
5657impl AIThink {
5658 #[doc = "`IsActiveCommand(crate::app::unit::Unit, crate::app::aidata::AIData)` overload"]
5659 pub fn is_active_command(
5660 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
5661 command: impl ::core::convert::Into<crate::app::aidata::AIData>,
5662 ) -> bool {
5663 unsafe {
5664 ::unity::il2cpp_call!((::unity::module_base()+0x193c7a0usize)as*mut u8,bool;
5665(crate::app::unit::Unit)::core::convert::Into::into(unit),(crate::app::aidata::AIData)::core::convert::Into::into(command))
5666 }
5667 }
5668
5669 #[doc = "`IsAttackPermission(crate::app::unit::Unit, crate::app::unit::Unit)` overload"]
5670 pub fn is_attack_permission(
5671 actor: impl ::core::convert::Into<crate::app::unit::Unit>,
5672 target: impl ::core::convert::Into<crate::app::unit::Unit>,
5673 ) -> bool {
5674 unsafe {
5675 ::unity::il2cpp_call!((::unity::module_base()+0x192ed50usize)as*mut u8,bool;
5676(crate::app::unit::Unit)::core::convert::Into::into(actor),(crate::app::unit::Unit)::core::convert::Into::into(target))
5677 }
5678 }
5679
5680 #[doc = "`Warning(bool, ::unity::Il2CppString)` overload"]
5681 pub fn warning(condition: impl ::core::convert::Into<bool>, messge: impl ::core::convert::Into<::unity::Il2CppString>) -> () {
5682 unsafe {
5683 ::unity::il2cpp_call!((::unity::module_base()+0x193c820usize)as*mut u8,();
5684(bool)::core::convert::Into::into(condition),(::unity::Il2CppString)::core::convert::Into::into(messge))
5685 }
5686 }
5687
5688 #[doc = "`IsAttackPermissionOnlyCommand(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue, crate::app::unit::Unit)` overload"]
5689 pub fn is_attack_permission_only_command(
5690 command: impl ::core::convert::Into<i32>,
5691 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
5692 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
5693 target: impl ::core::convert::Into<crate::app::unit::Unit>,
5694 ) -> bool {
5695 unsafe {
5696 ::unity::il2cpp_call!((::unity::module_base()+0x193c830usize)as*mut u8,bool;
5697(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1),(crate::app::unit::Unit)::core::convert::Into::into(target))
5698 }
5699 }
5700
5701 #[doc = "`GetAttackPosition(crate::app::unit::Unit, crate::app::unit::Unit, i32, i32, *mutcrate::app::aithink::AIThink_AttackPositionResult)` overload"]
5702 pub fn get_attack_position(
5703 actor: impl ::core::convert::Into<crate::app::unit::Unit>,
5704 target: impl ::core::convert::Into<crate::app::unit::Unit>,
5705 item_index: impl ::core::convert::Into<i32>,
5706 flag: impl ::core::convert::Into<i32>,
5707 ) -> (bool, crate::app::aithink::AIThink_AttackPositionResult) {
5708 unsafe {
5709 let mut __out_0 = ::core::mem::MaybeUninit::<crate::app::aithink::AIThink_AttackPositionResult>::uninit();
5710 let __ret = {
5711 ::unity::il2cpp_call!((::unity::module_base()+0x192d250usize)as*mut u8,bool;
5712(crate::app::unit::Unit)::core::convert::Into::into(actor),(crate::app::unit::Unit)::core::convert::Into::into(target),(i32)::core::convert::Into::into(item_index),(i32)::core::convert::Into::into(flag),(*mut crate::app::aithink::AIThink_AttackPositionResult)__out_0.as_mut_ptr())
5713 };
5714 (__ret, __out_0.assume_init())
5715 }
5716 }
5717
5718 #[doc = "`GetAttackPosition(crate::app::unit::Unit, crate::app::unit::Unit, i32, i32, i32, i32, *mutcrate::app::aithink::AIThink_AttackPositionResult)` overload"]
5719 pub fn get_attack_position_2(
5720 actor: impl ::core::convert::Into<crate::app::unit::Unit>,
5721 target: impl ::core::convert::Into<crate::app::unit::Unit>,
5722 item_index: impl ::core::convert::Into<i32>,
5723 target_x: impl ::core::convert::Into<i32>,
5724 target_z: impl ::core::convert::Into<i32>,
5725 flag: impl ::core::convert::Into<i32>,
5726 ) -> (bool, crate::app::aithink::AIThink_AttackPositionResult) {
5727 unsafe {
5728 let mut __out_0 = ::core::mem::MaybeUninit::<crate::app::aithink::AIThink_AttackPositionResult>::uninit();
5729 let __ret = {
5730 ::unity::il2cpp_call!((::unity::module_base()+0x193ca10usize)as*mut u8,bool;
5731(crate::app::unit::Unit)::core::convert::Into::into(actor),(crate::app::unit::Unit)::core::convert::Into::into(target),(i32)::core::convert::Into::into(item_index),(i32)::core::convert::Into::into(target_x),(i32)::core::convert::Into::into(target_z),(i32)::core::convert::Into::into(flag),(*mut crate::app::aithink::AIThink_AttackPositionResult)__out_0.as_mut_ptr())
5732 };
5733 (__ret, __out_0.assume_init())
5734 }
5735 }
5736
5737 #[doc = "`GetAttackPosition(crate::app::unit::Unit, crate::app::unit::Unit, crate::app::unit::Unit, i32, crate::app::skilldata::SkillData, i32, i32, i32, *mutcrate::app::aithink::AIThink_AttackPositionResult)` overload"]
5738 pub fn get_attack_position_3(
5739 actor: impl ::core::convert::Into<crate::app::unit::Unit>,
5740 chained: impl ::core::convert::Into<crate::app::unit::Unit>,
5741 target: impl ::core::convert::Into<crate::app::unit::Unit>,
5742 item_index: impl ::core::convert::Into<i32>,
5743 skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>,
5744 target_x: impl ::core::convert::Into<i32>,
5745 target_z: impl ::core::convert::Into<i32>,
5746 flag: impl ::core::convert::Into<i32>,
5747 ) -> (bool, crate::app::aithink::AIThink_AttackPositionResult) {
5748 unsafe {
5749 let mut __out_0 = ::core::mem::MaybeUninit::<crate::app::aithink::AIThink_AttackPositionResult>::uninit();
5750 let __ret = {
5751 ::unity::il2cpp_call!((::unity::module_base()+0x19325d0usize)as*mut u8,bool;
5752(crate::app::unit::Unit)::core::convert::Into::into(actor),(crate::app::unit::Unit)::core::convert::Into::into(chained),(crate::app::unit::Unit)::core::convert::Into::into(target),(i32)::core::convert::Into::into(item_index),(crate::app::skilldata::SkillData)::core::convert::Into::into(skill),(i32)::core::convert::Into::into(target_x),(i32)::core::convert::Into::into(target_z),(i32)::core::convert::Into::into(flag),(*mut crate::app::aithink::AIThink_AttackPositionResult)__out_0.as_mut_ptr())
5753 };
5754 (__ret, __out_0.assume_init())
5755 }
5756 }
5757
5758 #[doc = "`GetAttackPosition(crate::app::unit::Unit, crate::app::unit::Unit, crate::app::unit::Unit, i32, crate::app::skilldata::SkillData, i32, i32, i32, i32, *mutcrate::app::aithink::AIThink_AttackPositionResult)` overload"]
5759 pub fn get_attack_position_4(
5760 actor: impl ::core::convert::Into<crate::app::unit::Unit>,
5761 chained: impl ::core::convert::Into<crate::app::unit::Unit>,
5762 target: impl ::core::convert::Into<crate::app::unit::Unit>,
5763 item_index: impl ::core::convert::Into<i32>,
5764 skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>,
5765 req_target_count_in_range: impl ::core::convert::Into<i32>,
5766 target_x: impl ::core::convert::Into<i32>,
5767 target_z: impl ::core::convert::Into<i32>,
5768 flag: impl ::core::convert::Into<i32>,
5769 ) -> (bool, crate::app::aithink::AIThink_AttackPositionResult) {
5770 unsafe {
5771 let mut __out_0 = ::core::mem::MaybeUninit::<crate::app::aithink::AIThink_AttackPositionResult>::uninit();
5772 let __ret = {
5773 ::unity::il2cpp_call!((::unity::module_base()+0x193cb30usize)as*mut u8,bool;
5774(crate::app::unit::Unit)::core::convert::Into::into(actor),(crate::app::unit::Unit)::core::convert::Into::into(chained),(crate::app::unit::Unit)::core::convert::Into::into(target),(i32)::core::convert::Into::into(item_index),(crate::app::skilldata::SkillData)::core::convert::Into::into(skill),(i32)::core::convert::Into::into(req_target_count_in_range),(i32)::core::convert::Into::into(target_x),(i32)::core::convert::Into::into(target_z),(i32)::core::convert::Into::into(flag),(*mut crate::app::aithink::AIThink_AttackPositionResult)__out_0.as_mut_ptr())
5775 };
5776 (__ret, __out_0.assume_init())
5777 }
5778 }
5779
5780 #[doc = "`GetMovePosition(crate::app::unit::Unit, i32, i32, bool, *muti32, *muti32, *muti32)` overload"]
5781 pub fn get_move_position(
5782 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
5783 attack_x: impl ::core::convert::Into<i32>,
5784 attack_z: impl ::core::convert::Into<i32>,
5785 is_ahead_ignore: impl ::core::convert::Into<bool>,
5786 ) -> (bool, i32, i32, i32) {
5787 unsafe {
5788 let mut __out_0 = ::core::mem::MaybeUninit::<i32>::uninit();
5789 let mut __out_1 = ::core::mem::MaybeUninit::<i32>::uninit();
5790 let mut __out_2 = ::core::mem::MaybeUninit::<i32>::uninit();
5791 let __ret = {
5792 ::unity::il2cpp_call!((::unity::module_base()+0x193f170usize)as*mut u8,bool;
5793(crate::app::unit::Unit)::core::convert::Into::into(unit),(i32)::core::convert::Into::into(attack_x),(i32)::core::convert::Into::into(attack_z),(bool)::core::convert::Into::into(is_ahead_ignore),(*mut i32)__out_0.as_mut_ptr(),(*mut i32)__out_1.as_mut_ptr(),(*mut i32)__out_2.as_mut_ptr())
5794 };
5795 (__ret, __out_0.assume_init(), __out_1.assume_init(), __out_2.assume_init())
5796 }
5797 }
5798
5799 #[doc = "`GetMovePosition(crate::app::unit::Unit, i32, i32, bool, bool, crate::app::unit::Unit, i32, i32, crate::app::skilldata::SkillData, *muti32, *muti32, *muti32, *muti32, *muti32)` overload"]
5800 pub fn get_move_position_2(
5801 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
5802 final_attack_x: impl ::core::convert::Into<i32>,
5803 final_attack_z: impl ::core::convert::Into<i32>,
5804 is_ahead_ignore: impl ::core::convert::Into<bool>,
5805 is_pierce_multiple: impl ::core::convert::Into<bool>,
5806 target: impl ::core::convert::Into<crate::app::unit::Unit>,
5807 target_x: impl ::core::convert::Into<i32>,
5808 target_z: impl ::core::convert::Into<i32>,
5809 command_skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>,
5810 ) -> (bool, i32, i32, i32, i32, i32) {
5811 unsafe {
5812 let mut __out_0 = ::core::mem::MaybeUninit::<i32>::uninit();
5813 let mut __out_1 = ::core::mem::MaybeUninit::<i32>::uninit();
5814 let mut __out_2 = ::core::mem::MaybeUninit::<i32>::uninit();
5815 let mut __out_3 = ::core::mem::MaybeUninit::<i32>::uninit();
5816 let mut __out_4 = ::core::mem::MaybeUninit::<i32>::uninit();
5817 let __ret = {
5818 ::unity::il2cpp_call!((::unity::module_base()+0x193f2a0usize)as*mut u8,bool;
5819(crate::app::unit::Unit)::core::convert::Into::into(unit),(i32)::core::convert::Into::into(final_attack_x),(i32)::core::convert::Into::into(final_attack_z),(bool)::core::convert::Into::into(is_ahead_ignore),(bool)::core::convert::Into::into(is_pierce_multiple),(crate::app::unit::Unit)::core::convert::Into::into(target),(i32)::core::convert::Into::into(target_x),(i32)::core::convert::Into::into(target_z),(crate::app::skilldata::SkillData)::core::convert::Into::into(command_skill),(*mut i32)__out_0.as_mut_ptr(),(*mut i32)__out_1.as_mut_ptr(),(*mut i32)__out_2.as_mut_ptr(),(*mut i32)__out_3.as_mut_ptr(),(*mut i32)__out_4.as_mut_ptr())
5820 };
5821 (
5822 __ret,
5823 __out_0.assume_init(),
5824 __out_1.assume_init(),
5825 __out_2.assume_init(),
5826 __out_3.assume_init(),
5827 __out_4.assume_init(),
5828 )
5829 }
5830 }
5831
5832 #[doc = "`GetMovePosition(crate::app::unit::Unit, i32, i32, bool, bool, i32, crate::app::unit::Unit, i32, i32, crate::app::skilldata::SkillData, crate::app::skillarray::SkillArray, *muti32, *muti32, *muti32, *muti32, *muti32)` overload"]
5833 pub fn get_move_position_3(
5834 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
5835 final_attack_x: impl ::core::convert::Into<i32>,
5836 final_attack_z: impl ::core::convert::Into<i32>,
5837 is_ahead_ignore: impl ::core::convert::Into<bool>,
5838 is_pierce_multiple: impl ::core::convert::Into<bool>,
5839 req_target_count_in_range: impl ::core::convert::Into<i32>,
5840 target: impl ::core::convert::Into<crate::app::unit::Unit>,
5841 target_x: impl ::core::convert::Into<i32>,
5842 target_z: impl ::core::convert::Into<i32>,
5843 command_skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>,
5844 equip_skills_of_item: impl ::core::convert::Into<crate::app::skillarray::SkillArray>,
5845 ) -> (bool, i32, i32, i32, i32, i32) {
5846 unsafe {
5847 let mut __out_0 = ::core::mem::MaybeUninit::<i32>::uninit();
5848 let mut __out_1 = ::core::mem::MaybeUninit::<i32>::uninit();
5849 let mut __out_2 = ::core::mem::MaybeUninit::<i32>::uninit();
5850 let mut __out_3 = ::core::mem::MaybeUninit::<i32>::uninit();
5851 let mut __out_4 = ::core::mem::MaybeUninit::<i32>::uninit();
5852 let __ret = {
5853 ::unity::il2cpp_call!((::unity::module_base()+0x193f3c0usize)as*mut u8,bool;
5854(crate::app::unit::Unit)::core::convert::Into::into(unit),(i32)::core::convert::Into::into(final_attack_x),(i32)::core::convert::Into::into(final_attack_z),(bool)::core::convert::Into::into(is_ahead_ignore),(bool)::core::convert::Into::into(is_pierce_multiple),(i32)::core::convert::Into::into(req_target_count_in_range),(crate::app::unit::Unit)::core::convert::Into::into(target),(i32)::core::convert::Into::into(target_x),(i32)::core::convert::Into::into(target_z),(crate::app::skilldata::SkillData)::core::convert::Into::into(command_skill),(crate::app::skillarray::SkillArray)::core::convert::Into::into(equip_skills_of_item),(*mut i32)__out_0.as_mut_ptr(),(*mut i32)__out_1.as_mut_ptr(),(*mut i32)__out_2.as_mut_ptr(),(*mut i32)__out_3.as_mut_ptr(),(*mut i32)__out_4.as_mut_ptr())
5855 };
5856 (
5857 __ret,
5858 __out_0.assume_init(),
5859 __out_1.assume_init(),
5860 __out_2.assume_init(),
5861 __out_3.assume_init(),
5862 __out_4.assume_init(),
5863 )
5864 }
5865 }
5866
5867 #[doc = "`CountPierceTargets(crate::app::unit::Unit, i32, i32, crate::app::skilldata::SkillData, crate::app::unit::Unit)` overload"]
5868 pub fn count_pierce_targets(
5869 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
5870 move_x: impl ::core::convert::Into<i32>,
5871 move_z: impl ::core::convert::Into<i32>,
5872 skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>,
5873 target: impl ::core::convert::Into<crate::app::unit::Unit>,
5874 ) -> i32 {
5875 unsafe {
5876 ::unity::il2cpp_call!((::unity::module_base()+0x19407d0usize)as*mut u8,i32;
5877(crate::app::unit::Unit)::core::convert::Into::into(unit),(i32)::core::convert::Into::into(move_x),(i32)::core::convert::Into::into(move_z),(crate::app::skilldata::SkillData)::core::convert::Into::into(skill),(crate::app::unit::Unit)::core::convert::Into::into(target))
5878 }
5879 }
5880
5881 #[doc = "`CountTargetsInRange(crate::app::unit::Unit, i32, i32, crate::app::skilldata::SkillData, crate::app::unit::Unit)` overload"]
5882 pub fn count_targets_in_range(
5883 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
5884 move_x: impl ::core::convert::Into<i32>,
5885 move_z: impl ::core::convert::Into<i32>,
5886 skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>,
5887 target: impl ::core::convert::Into<crate::app::unit::Unit>,
5888 ) -> i32 {
5889 unsafe {
5890 ::unity::il2cpp_call!((::unity::module_base()+0x1940920usize)as*mut u8,i32;
5891(crate::app::unit::Unit)::core::convert::Into::into(unit),(i32)::core::convert::Into::into(move_x),(i32)::core::convert::Into::into(move_z),(crate::app::skilldata::SkillData)::core::convert::Into::into(skill),(crate::app::unit::Unit)::core::convert::Into::into(target))
5892 }
5893 }
5894
5895 #[doc = "`CountTargetsInRangeForEquipSkillsOfItem(crate::app::unit::Unit, i32, i32, crate::app::skillarray::SkillArray, crate::app::unit::Unit)` overload"]
5896 pub fn count_targets_in_range_for_equip_skills_of_item(
5897 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
5898 move_x: impl ::core::convert::Into<i32>,
5899 move_z: impl ::core::convert::Into<i32>,
5900 skills: impl ::core::convert::Into<crate::app::skillarray::SkillArray>,
5901 target: impl ::core::convert::Into<crate::app::unit::Unit>,
5902 ) -> i32 {
5903 unsafe {
5904 ::unity::il2cpp_call!((::unity::module_base()+0x1941050usize)as*mut u8,i32;
5905(crate::app::unit::Unit)::core::convert::Into::into(unit),(i32)::core::convert::Into::into(move_x),(i32)::core::convert::Into::into(move_z),(crate::app::skillarray::SkillArray)::core::convert::Into::into(skills),(crate::app::unit::Unit)::core::convert::Into::into(target))
5906 }
5907 }
5908
5909 #[doc = "`GetEventPosition(crate::app::mapinspector::MapInspector_Kind, *muti32, *muti32, *mutu32, bool, bool, u32)` overload"]
5910 pub fn get_event_position(
5911 kind: impl ::core::convert::Into<crate::app::mapinspector::MapInspector_Kind>,
5912 is_in: impl ::core::convert::Into<bool>,
5913 is_arrival: impl ::core::convert::Into<bool>,
5914 priority: impl ::core::convert::Into<u32>,
5915 ) -> (bool, i32, i32, u32) {
5916 unsafe {
5917 let mut __out_0 = ::core::mem::MaybeUninit::<i32>::uninit();
5918 let mut __out_1 = ::core::mem::MaybeUninit::<i32>::uninit();
5919 let mut __out_2 = ::core::mem::MaybeUninit::<u32>::uninit();
5920 let __ret = {
5921 ::unity::il2cpp_call!((::unity::module_base()+0x1941290usize)as*mut u8,bool;
5922(crate::app::mapinspector::MapInspector_Kind)::core::convert::Into::into(kind),(*mut i32)__out_0.as_mut_ptr(),(*mut i32)__out_1.as_mut_ptr(),(*mut u32)__out_2.as_mut_ptr(),(bool)::core::convert::Into::into(is_in),(bool)::core::convert::Into::into(is_arrival),(u32)::core::convert::Into::into(priority))
5923 };
5924 (__ret, __out_0.assume_init(), __out_1.assume_init(), __out_2.assume_init())
5925 }
5926 }
5927
5928 #[doc = "`GetEventPosition(crate::app::mapinspector::MapInspector_Kind, *muti32, *muti32, *muti32, *muti32, *mutu32, bool, bool, u32)` overload"]
5929 pub fn get_event_position_2(
5930 kind: impl ::core::convert::Into<crate::app::mapinspector::MapInspector_Kind>,
5931 is_in: impl ::core::convert::Into<bool>,
5932 is_arrival: impl ::core::convert::Into<bool>,
5933 priority: impl ::core::convert::Into<u32>,
5934 ) -> (bool, i32, i32, i32, i32, u32) {
5935 unsafe {
5936 let mut __out_0 = ::core::mem::MaybeUninit::<i32>::uninit();
5937 let mut __out_1 = ::core::mem::MaybeUninit::<i32>::uninit();
5938 let mut __out_2 = ::core::mem::MaybeUninit::<i32>::uninit();
5939 let mut __out_3 = ::core::mem::MaybeUninit::<i32>::uninit();
5940 let mut __out_4 = ::core::mem::MaybeUninit::<u32>::uninit();
5941 let __ret = {
5942 ::unity::il2cpp_call!((::unity::module_base()+0x1941360usize)as*mut u8,bool;
5943(crate::app::mapinspector::MapInspector_Kind)::core::convert::Into::into(kind),(*mut i32)__out_0.as_mut_ptr(),(*mut i32)__out_1.as_mut_ptr(),(*mut i32)__out_2.as_mut_ptr(),(*mut i32)__out_3.as_mut_ptr(),(*mut u32)__out_4.as_mut_ptr(),(bool)::core::convert::Into::into(is_in),(bool)::core::convert::Into::into(is_arrival),(u32)::core::convert::Into::into(priority))
5944 };
5945 (
5946 __ret,
5947 __out_0.assume_init(),
5948 __out_1.assume_init(),
5949 __out_2.assume_init(),
5950 __out_3.assume_init(),
5951 __out_4.assume_init(),
5952 )
5953 }
5954 }
5955
5956 #[doc = "`LimitMoveImage(crate::app::unit::Unit, i32, i32, i32)` overload"]
5957 pub fn limit_move_image(
5958 actor: impl ::core::convert::Into<crate::app::unit::Unit>,
5959 limit_x: impl ::core::convert::Into<i32>,
5960 limit_z: impl ::core::convert::Into<i32>,
5961 limit_distance: impl ::core::convert::Into<i32>,
5962 ) -> () {
5963 unsafe {
5964 ::unity::il2cpp_call!((::unity::module_base()+0x192c6d0usize)as*mut u8,();
5965(crate::app::unit::Unit)::core::convert::Into::into(actor),(i32)::core::convert::Into::into(limit_x),(i32)::core::convert::Into::into(limit_z),(i32)::core::convert::Into::into(limit_distance))
5966 }
5967 }
5968
5969 #[doc = "`IsClever()` overload"]
5970 pub fn is_clever() -> bool {
5971 unsafe {
5972 ::unity::il2cpp_call!((::unity::module_base()+0x192a000usize)as*mut u8,bool;
5973 )
5974 }
5975 }
5976
5977 #[doc = "`GetDeployFreeMoveFlag(crate::app::unit::Unit)` overload"]
5978 pub fn get_deploy_free_move_flag(
5979 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
5980 ) -> crate::app::mapdeploytemplate_1::MapDeployTemplate_1_Flag<crate::app::aideploy::AIDeploy> {
5981 unsafe {
5982 ::unity::il2cpp_call!((::unity::module_base()+0x1935890usize)as*mut u8,crate::app::mapdeploytemplate_1::MapDeployTemplate_1_Flag<crate::app::aideploy::AIDeploy> ;
5983(crate::app::unit::Unit)::core::convert::Into::into(unit))
5984 }
5985 }
5986
5987 #[doc = "`IsMoveOver()` overload"]
5988 pub fn is_move_over() -> bool {
5989 unsafe {
5990 ::unity::il2cpp_call!((::unity::module_base()+0x193aeb0usize)as*mut u8,bool;
5991 )
5992 }
5993 }
5994
5995 #[doc = "`IsMoveOver(crate::app::unit::Unit, i32, i32)` overload"]
5996 pub fn is_move_over_2(
5997 actor: impl ::core::convert::Into<crate::app::unit::Unit>,
5998 x: impl ::core::convert::Into<i32>,
5999 z: impl ::core::convert::Into<i32>,
6000 ) -> bool {
6001 unsafe {
6002 ::unity::il2cpp_call!((::unity::module_base()+0x1940710usize)as*mut u8,bool;
6003(crate::app::unit::Unit)::core::convert::Into::into(actor),(i32)::core::convert::Into::into(x),(i32)::core::convert::Into::into(z))
6004 }
6005 }
6006
6007 #[doc = "`IsAllowIdleMutation()` overload"]
6008 pub fn is_allow_idle_mutation() -> bool {
6009 unsafe {
6010 ::unity::il2cpp_call!((::unity::module_base()+0x19414f0usize)as*mut u8,bool;
6011 )
6012 }
6013 }
6014
6015 #[doc = "`UpdateHealCondition(crate::app::unit::Unit, i32)` overload"]
6016 pub fn update_heal_condition(unit: impl ::core::convert::Into<crate::app::unit::Unit>, heal_power: impl ::core::convert::Into<i32>) -> () {
6017 unsafe {
6018 ::unity::il2cpp_call!((::unity::module_base()+0x1941570usize)as*mut u8,();
6019(crate::app::unit::Unit)::core::convert::Into::into(unit),(i32)::core::convert::Into::into(heal_power))
6020 }
6021 }
6022
6023 #[doc = "`IsHealConditionForEntrust(crate::app::unit::Unit)` overload"]
6024 pub fn is_heal_condition_for_entrust(unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> bool {
6025 unsafe {
6026 ::unity::il2cpp_call!((::unity::module_base()+0x1941a10usize)as*mut u8,bool;
6027(crate::app::unit::Unit)::core::convert::Into::into(unit))
6028 }
6029 }
6030
6031 #[doc = "`GetItemIndexHeal(crate::app::unit::Unit)` overload"]
6032 pub fn get_item_index_heal(unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> i32 {
6033 unsafe {
6034 ::unity::il2cpp_call!((::unity::module_base()+0x1941bf0usize)as*mut u8,i32;
6035(crate::app::unit::Unit)::core::convert::Into::into(unit))
6036 }
6037 }
6038
6039 #[doc = "`GetTerrainScore(crate::app::unit::Unit, i32, i32)` overload"]
6040 pub fn get_terrain_score(
6041 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
6042 x: impl ::core::convert::Into<i32>,
6043 z: impl ::core::convert::Into<i32>,
6044 ) -> u32 {
6045 unsafe {
6046 ::unity::il2cpp_call!((::unity::module_base()+0x19422b0usize)as*mut u8,u32;
6047(crate::app::unit::Unit)::core::convert::Into::into(unit),(i32)::core::convert::Into::into(x),(i32)::core::convert::Into::into(z))
6048 }
6049 }
6050
6051 #[doc = "`GetTerrainHeal(crate::app::unit::Unit, crate::app::terraindata_2::TerrainData_2)` overload"]
6052 pub fn get_terrain_heal(
6053 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
6054 terrain: impl ::core::convert::Into<crate::app::terraindata_2::TerrainData_2>,
6055 ) -> i32 {
6056 unsafe {
6057 ::unity::il2cpp_call!((::unity::module_base()+0x1942630usize)as*mut u8,i32;
6058(crate::app::unit::Unit)::core::convert::Into::into(unit),(crate::app::terraindata_2::TerrainData_2)::core::convert::Into::into(terrain))
6059 }
6060 }
6061
6062 #[doc = "`GetBoundaryIceTileMove(crate::app::unit::Unit, i32, i32, i32, i32)` overload"]
6063 pub fn get_boundary_ice_tile_move(
6064 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
6065 x: impl ::core::convert::Into<i32>,
6066 z: impl ::core::convert::Into<i32>,
6067 r#move: impl ::core::convert::Into<i32>,
6068 flag: impl ::core::convert::Into<i32>,
6069 ) -> i32 {
6070 unsafe {
6071 ::unity::il2cpp_call!((::unity::module_base()+0x1942740usize)as*mut u8,i32;
6072(crate::app::unit::Unit)::core::convert::Into::into(unit),(i32)::core::convert::Into::into(x),(i32)::core::convert::Into::into(z),(i32)::core::convert::Into::into(r#move),(i32)::core::convert::Into::into(flag))
6073 }
6074 }
6075
6076 #[doc = "`GetBoundaryIceTileMove(crate::app::unit::Unit, i32, i32, i32, i32, i32, i32)` overload"]
6077 pub fn get_boundary_ice_tile_move_2(
6078 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
6079 x: impl ::core::convert::Into<i32>,
6080 z: impl ::core::convert::Into<i32>,
6081 r#move: impl ::core::convert::Into<i32>,
6082 goal_x: impl ::core::convert::Into<i32>,
6083 goal_z: impl ::core::convert::Into<i32>,
6084 flag: impl ::core::convert::Into<i32>,
6085 ) -> i32 {
6086 unsafe {
6087 ::unity::il2cpp_call!((::unity::module_base()+0x1942b80usize)as*mut u8,i32;
6088(crate::app::unit::Unit)::core::convert::Into::into(unit),(i32)::core::convert::Into::into(x),(i32)::core::convert::Into::into(z),(i32)::core::convert::Into::into(r#move),(i32)::core::convert::Into::into(goal_x),(i32)::core::convert::Into::into(goal_z),(i32)::core::convert::Into::into(flag))
6089 }
6090 }
6091
6092 #[doc = "`GetActiveAttackCommand(crate::app::unit::Unit, crate::app::unit::Unit, *muti32, *mutcrate::app::aivalue::AIValue, *mutcrate::app::aivalue::AIValue)` overload"]
6093 pub fn get_active_attack_command(
6094 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
6095 target: impl ::core::convert::Into<crate::app::unit::Unit>,
6096 ) -> (bool, i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue) {
6097 unsafe {
6098 let mut __out_0 = ::core::mem::MaybeUninit::<i32>::uninit();
6099 let mut __out_1 = ::core::mem::MaybeUninit::<crate::app::aivalue::AIValue>::uninit();
6100 let mut __out_2 = ::core::mem::MaybeUninit::<crate::app::aivalue::AIValue>::uninit();
6101 let __ret = {
6102 ::unity::il2cpp_call!((::unity::module_base()+0x1942c60usize)as*mut u8,bool;
6103(crate::app::unit::Unit)::core::convert::Into::into(unit),(crate::app::unit::Unit)::core::convert::Into::into(target),(*mut i32)__out_0.as_mut_ptr(),(*mut crate::app::aivalue::AIValue)__out_1.as_mut_ptr(),(*mut crate::app::aivalue::AIValue)__out_2.as_mut_ptr())
6104 };
6105 (__ret, __out_0.assume_init(), __out_1.assume_init(), __out_2.assume_init())
6106 }
6107 }
6108
6109 #[doc = "`HasActiveAttackCommandForCrossfire(crate::app::unit::Unit, crate::app::unit::Unit)` overload"]
6110 pub fn has_active_attack_command_for_crossfire(
6111 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
6112 target: impl ::core::convert::Into<crate::app::unit::Unit>,
6113 ) -> bool {
6114 unsafe {
6115 ::unity::il2cpp_call!((::unity::module_base()+0x192f7d0usize)as*mut u8,bool;
6116(crate::app::unit::Unit)::core::convert::Into::into(unit),(crate::app::unit::Unit)::core::convert::Into::into(target))
6117 }
6118 }
6119
6120 #[doc = "`HasActiveAttackCommandForInterruptAttack(crate::app::unit::Unit, crate::app::unit::Unit)` overload"]
6121 pub fn has_active_attack_command_for_interrupt_attack(
6122 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
6123 target: impl ::core::convert::Into<crate::app::unit::Unit>,
6124 ) -> bool {
6125 unsafe {
6126 ::unity::il2cpp_call!((::unity::module_base()+0x1942f80usize)as*mut u8,bool;
6127(crate::app::unit::Unit)::core::convert::Into::into(unit),(crate::app::unit::Unit)::core::convert::Into::into(target))
6128 }
6129 }
6130
6131 #[doc = "`HasActiveCommand(crate::app::aivalue::AIValue_Order, crate::app::unit::Unit)` overload"]
6132 pub fn has_active_command(
6133 order: impl ::core::convert::Into<crate::app::aivalue::AIValue_Order>,
6134 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
6135 ) -> bool {
6136 unsafe {
6137 ::unity::il2cpp_call!((::unity::module_base()+0x192dc20usize)as*mut u8,bool;
6138(crate::app::aivalue::AIValue_Order)::core::convert::Into::into(order),(crate::app::unit::Unit)::core::convert::Into::into(unit))
6139 }
6140 }
6141
6142 #[doc = "`GetEngageAttackCommand(crate::app::unit::Unit, *muti32, *mutcrate::app::aivalue::AIValue, *mutcrate::app::aivalue::AIValue)` overload"]
6143 pub fn get_engage_attack_command(
6144 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
6145 ) -> (bool, i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue) {
6146 unsafe {
6147 let mut __out_0 = ::core::mem::MaybeUninit::<i32>::uninit();
6148 let mut __out_1 = ::core::mem::MaybeUninit::<crate::app::aivalue::AIValue>::uninit();
6149 let mut __out_2 = ::core::mem::MaybeUninit::<crate::app::aivalue::AIValue>::uninit();
6150 let __ret = {
6151 ::unity::il2cpp_call!((::unity::module_base()+0x1943060usize)as*mut u8,bool;
6152(crate::app::unit::Unit)::core::convert::Into::into(unit),(*mut i32)__out_0.as_mut_ptr(),(*mut crate::app::aivalue::AIValue)__out_1.as_mut_ptr(),(*mut crate::app::aivalue::AIValue)__out_2.as_mut_ptr())
6153 };
6154 (__ret, __out_0.assume_init(), __out_1.assume_init(), __out_2.assume_init())
6155 }
6156 }
6157
6158 #[doc = "`IsThinkBreak(crate::app::unit::Unit)` overload"]
6159 pub fn is_think_break(unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> bool {
6160 unsafe {
6161 ::unity::il2cpp_call!((::unity::module_base()+0x1929e70usize)as*mut u8,bool;
6162(crate::app::unit::Unit)::core::convert::Into::into(unit))
6163 }
6164 }
6165
6166 #[doc = "`IsThinkChain(crate::app::unit::Unit)` overload"]
6167 pub fn is_think_chain(unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> bool {
6168 unsafe {
6169 ::unity::il2cpp_call!((::unity::module_base()+0x1929c50usize)as*mut u8,bool;
6170(crate::app::unit::Unit)::core::convert::Into::into(unit))
6171 }
6172 }
6173
6174 #[doc = "`GetRerewarpPosition(*muti32, *muti32, crate::app::unit::Unit, crate::app::mapimagecorebyte::MapImageCoreByte, bool)` overload"]
6175 pub fn get_rerewarp_position(
6176 actor: impl ::core::convert::Into<crate::app::unit::Unit>,
6177 working_image: impl ::core::convert::Into<crate::app::mapimagecorebyte::MapImageCoreByte>,
6178 is_rough: impl ::core::convert::Into<bool>,
6179 ) -> (bool, i32, i32) {
6180 unsafe {
6181 let mut __out_0 = ::core::mem::MaybeUninit::<i32>::uninit();
6182 let mut __out_1 = ::core::mem::MaybeUninit::<i32>::uninit();
6183 let __ret = {
6184 ::unity::il2cpp_call!((::unity::module_base()+0x1953b90usize)as*mut u8,bool;
6185(*mut i32)__out_0.as_mut_ptr(),(*mut i32)__out_1.as_mut_ptr(),(crate::app::unit::Unit)::core::convert::Into::into(actor),(crate::app::mapimagecorebyte::MapImageCoreByte)::core::convert::Into::into(working_image),(bool)::core::convert::Into::into(is_rough))
6186 };
6187 (__ret, __out_0.assume_init(), __out_1.assume_init())
6188 }
6189 }
6190
6191 #[doc = "`CompareAttackPriorityWithDecoy(crate::app::unit::Unit, crate::app::unit::Unit)` overload"]
6192 pub fn compare_attack_priority_with_decoy(
6193 unit0: impl ::core::convert::Into<crate::app::unit::Unit>,
6194 unit1: impl ::core::convert::Into<crate::app::unit::Unit>,
6195 ) -> i32 {
6196 unsafe {
6197 ::unity::il2cpp_call!((::unity::module_base()+0x1955360usize)as*mut u8,i32;
6198(crate::app::unit::Unit)::core::convert::Into::into(unit0),(crate::app::unit::Unit)::core::convert::Into::into(unit1))
6199 }
6200 }
6201
6202 #[doc = "`GetAttackRange(crate::app::unit::Unit, i32, crate::app::skilldata::SkillData, i32, *mutu64, bool)` overload"]
6203 pub fn get_attack_range(
6204 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
6205 item_index: impl ::core::convert::Into<i32>,
6206 skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>,
6207 flag: impl ::core::convert::Into<i32>,
6208 is_enemy: impl ::core::convert::Into<bool>,
6209 ) -> (i32, u64) {
6210 unsafe {
6211 let mut __out_0 = ::core::mem::MaybeUninit::<u64>::uninit();
6212 let __ret = {
6213 ::unity::il2cpp_call!((::unity::module_base()+0x193e700usize)as*mut u8,i32;
6214(crate::app::unit::Unit)::core::convert::Into::into(unit),(i32)::core::convert::Into::into(item_index),(crate::app::skilldata::SkillData)::core::convert::Into::into(skill),(i32)::core::convert::Into::into(flag),(*mut u64)__out_0.as_mut_ptr(),(bool)::core::convert::Into::into(is_enemy))
6215 };
6216 (__ret, __out_0.assume_init())
6217 }
6218 }
6219
6220 #[doc = "`IsWeaponProhibit(crate::app::unit::Unit, i32, crate::app::skilldata::SkillData)` overload"]
6221 pub fn is_weapon_prohibit(
6222 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
6223 item_index: impl ::core::convert::Into<i32>,
6224 skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>,
6225 ) -> bool {
6226 unsafe {
6227 ::unity::il2cpp_call!((::unity::module_base()+0x19568d0usize)as*mut u8,bool;
6228(crate::app::unit::Unit)::core::convert::Into::into(unit),(i32)::core::convert::Into::into(item_index),(crate::app::skilldata::SkillData)::core::convert::Into::into(skill))
6229 }
6230 }
6231
6232 #[doc = "`GetCommandSkill(crate::app::unit::Unit)` overload"]
6233 pub fn get_command_skill(unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> crate::app::skilldata::SkillData {
6234 unsafe {
6235 ::unity::il2cpp_call!((::unity::module_base()+0x1953460usize)as*mut u8,crate::app::skilldata::SkillData;
6236(crate::app::unit::Unit)::core::convert::Into::into(unit))
6237 }
6238 }
6239
6240 #[doc = "`GetGiveBadStatesForBullet(crate::app::itemdata::ItemData)` overload"]
6241 pub fn get_give_bad_states_for_bullet(
6242 item: impl ::core::convert::Into<crate::app::itemdata::ItemData>,
6243 ) -> crate::app::skilldata::SkillData_States {
6244 unsafe {
6245 ::unity::il2cpp_call!((::unity::module_base()+0x1957690usize)as*mut u8,crate::app::skilldata::SkillData_States;
6246(crate::app::itemdata::ItemData)::core::convert::Into::into(item))
6247 }
6248 }
6249
6250 #[doc = "`DbgCheckGetGiveBadStatesForBullet()` overload"]
6251 pub fn dbg_check_get_give_bad_states_for_bullet() -> () {
6252 unsafe {
6253 ::unity::il2cpp_call!((::unity::module_base()+0x1957930usize)as*mut u8,();
6254 )
6255 }
6256 }
6257
6258 #[doc = "`GetHealRodRange(crate::app::unit::Unit, i32, *mutu32, crate::app::skilldata::SkillData)` overload"]
6259 pub fn get_heal_rod_range(
6260 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
6261 item_index: impl ::core::convert::Into<i32>,
6262 skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>,
6263 ) -> (i32, u32) {
6264 unsafe {
6265 let mut __out_0 = ::core::mem::MaybeUninit::<u32>::uninit();
6266 let __ret = {
6267 ::unity::il2cpp_call!((::unity::module_base()+0x1959fa0usize)as*mut u8,i32;
6268(crate::app::unit::Unit)::core::convert::Into::into(unit),(i32)::core::convert::Into::into(item_index),(*mut u32)__out_0.as_mut_ptr(),(crate::app::skilldata::SkillData)::core::convert::Into::into(skill))
6269 };
6270 (__ret, __out_0.assume_init())
6271 }
6272 }
6273
6274 #[doc = "`HasHealRod(crate::app::unit::Unit, bool)` overload"]
6275 pub fn has_heal_rod(unit: impl ::core::convert::Into<crate::app::unit::Unit>, exclude_infinity: impl ::core::convert::Into<bool>) -> bool {
6276 unsafe {
6277 ::unity::il2cpp_call!((::unity::module_base()+0x1944d00usize)as*mut u8,bool;
6278(crate::app::unit::Unit)::core::convert::Into::into(unit),(bool)::core::convert::Into::into(exclude_infinity))
6279 }
6280 }
6281
6282 #[doc = "`GetTerrainHeal(i32, i32)` overload"]
6283 pub fn get_terrain_heal_2(x: impl ::core::convert::Into<i32>, z: impl ::core::convert::Into<i32>) -> i32 {
6284 unsafe {
6285 ::unity::il2cpp_call!((::unity::module_base()+0x195b110usize)as*mut u8,i32;
6286(i32)::core::convert::Into::into(x),(i32)::core::convert::Into::into(z))
6287 }
6288 }
6289
6290 #[doc = "`GetEngageProhibitMinMax(crate::app::aivalue::AIValue, crate::app::aivalue::AIValue, *muti32, *muti32)` overload"]
6291 pub fn get_engage_prohibit_min_max(
6292 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6293 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6294 ) -> (i32, i32) {
6295 unsafe {
6296 let mut __out_0 = ::core::mem::MaybeUninit::<i32>::uninit();
6297 let mut __out_1 = ::core::mem::MaybeUninit::<i32>::uninit();
6298 ::unity::il2cpp_call!((::unity::module_base()+0x195b5a0usize)as*mut u8,();
6299(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1),(*mut i32)__out_0.as_mut_ptr(),(*mut i32)__out_1.as_mut_ptr());
6300 (__out_0.assume_init(), __out_1.assume_init())
6301 }
6302 }
6303
6304 #[doc = "`IsEngagePermission(crate::app::unit::Unit, i32, i32)` overload"]
6305 pub fn is_engage_permission_2(
6306 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
6307 prohibit_min: impl ::core::convert::Into<i32>,
6308 prohibit_max: impl ::core::convert::Into<i32>,
6309 ) -> bool {
6310 unsafe {
6311 ::unity::il2cpp_call!((::unity::module_base()+0x195e230usize)as*mut u8,bool;
6312(crate::app::unit::Unit)::core::convert::Into::into(unit),(i32)::core::convert::Into::into(prohibit_min),(i32)::core::convert::Into::into(prohibit_max))
6313 }
6314 }
6315
6316 #[doc = "`CanUseEngageAttack(crate::app::unit::Unit)` overload"]
6317 pub fn can_use_engage_attack(unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> bool {
6318 unsafe {
6319 ::unity::il2cpp_call!((::unity::module_base()+0x1954250usize)as*mut u8,bool;
6320(crate::app::unit::Unit)::core::convert::Into::into(unit))
6321 }
6322 }
6323
6324 #[doc = "`IsEngageRewarp(crate::app::skilldata::SkillData)` overload"]
6325 pub fn is_engage_rewarp(engage_attack: impl ::core::convert::Into<crate::app::skilldata::SkillData>) -> bool {
6326 unsafe {
6327 ::unity::il2cpp_call!((::unity::module_base()+0x1954560usize)as*mut u8,bool;
6328(crate::app::skilldata::SkillData)::core::convert::Into::into(engage_attack))
6329 }
6330 }
6331
6332 #[doc = "`EngageCheckAndEquipItem(crate::app::unit::Unit)` overload"]
6333 pub fn engage_check_and_equip_item(actor: impl ::core::convert::Into<crate::app::unit::Unit>) -> bool {
6334 unsafe {
6335 ::unity::il2cpp_call!((::unity::module_base()+0x195c9a0usize)as*mut u8,bool;
6336(crate::app::unit::Unit)::core::convert::Into::into(actor))
6337 }
6338 }
6339
6340 #[doc = "`GetRealEngageAttack(crate::app::unit::Unit, i32, i32)` overload"]
6341 pub fn get_real_engage_attack(
6342 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
6343 move_x: impl ::core::convert::Into<i32>,
6344 move_z: impl ::core::convert::Into<i32>,
6345 ) -> crate::app::skilldata::SkillData {
6346 unsafe {
6347 ::unity::il2cpp_call!((::unity::module_base()+0x195bc90usize)as*mut u8,crate::app::skilldata::SkillData;
6348(crate::app::unit::Unit)::core::convert::Into::into(unit),(i32)::core::convert::Into::into(move_x),(i32)::core::convert::Into::into(move_z))
6349 }
6350 }
6351
6352 #[doc = "`GetBlowScore(i32, i32, crate::app::unit::Unit, i32, i32)` overload"]
6353 pub fn get_blow_score(
6354 actor_x: impl ::core::convert::Into<i32>,
6355 actor_z: impl ::core::convert::Into<i32>,
6356 target: impl ::core::convert::Into<crate::app::unit::Unit>,
6357 target_x: impl ::core::convert::Into<i32>,
6358 target_z: impl ::core::convert::Into<i32>,
6359 ) -> u32 {
6360 unsafe {
6361 ::unity::il2cpp_call!((::unity::module_base()+0x195ff70usize)as*mut u8,u32;
6362(i32)::core::convert::Into::into(actor_x),(i32)::core::convert::Into::into(actor_z),(crate::app::unit::Unit)::core::convert::Into::into(target),(i32)::core::convert::Into::into(target_x),(i32)::core::convert::Into::into(target_z))
6363 }
6364 }
6365
6366 #[doc = "`GetProhibitedTurnMinMax(crate::app::aivalue::AIValue, crate::app::aivalue::AIValue, *muti32, *muti32)` overload"]
6367 pub fn get_prohibited_turn_min_max(
6368 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6369 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6370 ) -> (i32, i32) {
6371 unsafe {
6372 let mut __out_0 = ::core::mem::MaybeUninit::<i32>::uninit();
6373 let mut __out_1 = ::core::mem::MaybeUninit::<i32>::uninit();
6374 ::unity::il2cpp_call!((::unity::module_base()+0x1957a00usize)as*mut u8,();
6375(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1),(*mut i32)__out_0.as_mut_ptr(),(*mut i32)__out_1.as_mut_ptr());
6376 (__out_0.assume_init(), __out_1.assume_init())
6377 }
6378 }
6379
6380 #[doc = "`IsProhibitedTurn(i32, i32, i32)` overload"]
6381 pub fn is_prohibited_turn(
6382 prohibit_min: impl ::core::convert::Into<i32>,
6383 prohibit_max: impl ::core::convert::Into<i32>,
6384 current_prohibit: impl ::core::convert::Into<i32>,
6385 ) -> bool {
6386 unsafe {
6387 ::unity::il2cpp_call!((::unity::module_base()+0x1957b40usize)as*mut u8,bool;
6388(i32)::core::convert::Into::into(prohibit_min),(i32)::core::convert::Into::into(prohibit_max),(i32)::core::convert::Into::into(current_prohibit))
6389 }
6390 }
6391
6392 #[doc = "`DbgPatchVersionCheckLog(::unity::Il2CppString)` overload"]
6393 pub fn dbg_patch_version_check_log(s: impl ::core::convert::Into<::unity::Il2CppString>) -> () {
6394 unsafe {
6395 ::unity::il2cpp_call!((::unity::module_base()+0x19612b0usize)as*mut u8,();
6396(::unity::Il2CppString)::core::convert::Into::into(s))
6397 }
6398 }
6399
6400 #[doc = "`EngageWaitCheckRange(i32, i32, i32)` overload"]
6401 pub fn engage_wait_check_range(
6402 range: impl ::core::convert::Into<i32>,
6403 min_range: impl ::core::convert::Into<i32>,
6404 max_range: impl ::core::convert::Into<i32>,
6405 ) -> bool {
6406 unsafe {
6407 ::unity::il2cpp_call!((::unity::module_base()+0x1963080usize)as*mut u8,bool;
6408(i32)::core::convert::Into::into(range),(i32)::core::convert::Into::into(min_range),(i32)::core::convert::Into::into(max_range))
6409 }
6410 }
6411
6412 #[doc = "`GetBulletPattern(crate::app::unit::Unit)` overload"]
6413 pub fn get_bullet_pattern(unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> i32 {
6414 unsafe {
6415 ::unity::il2cpp_call!((::unity::module_base()+0x1954810usize)as*mut u8,i32;
6416(crate::app::unit::Unit)::core::convert::Into::into(unit))
6417 }
6418 }
6419
6420 #[doc = "`GetNextBulletPattern(i32)` overload"]
6421 pub fn get_next_bullet_pattern(pattern: impl ::core::convert::Into<i32>) -> i32 {
6422 unsafe {
6423 ::unity::il2cpp_call!((::unity::module_base()+0x1932ba0usize)as*mut u8,i32;
6424(i32)::core::convert::Into::into(pattern))
6425 }
6426 }
6427
6428 #[doc = "`IsBulletPatternMatched(i32, crate::app::itemdata::ItemData)` overload"]
6429 pub fn is_bullet_pattern_matched(
6430 pattern: impl ::core::convert::Into<i32>,
6431 item: impl ::core::convert::Into<crate::app::itemdata::ItemData>,
6432 ) -> bool {
6433 unsafe {
6434 ::unity::il2cpp_call!((::unity::module_base()+0x19324b0usize)as*mut u8,bool;
6435(i32)::core::convert::Into::into(pattern),(crate::app::itemdata::ItemData)::core::convert::Into::into(item))
6436 }
6437 }
6438
6439 #[doc = "`IsBulletPatternA(crate::app::itemdata::ItemData)` overload"]
6440 pub fn is_bullet_pattern_a(item: impl ::core::convert::Into<crate::app::itemdata::ItemData>) -> bool {
6441 unsafe {
6442 ::unity::il2cpp_call!((::unity::module_base()+0x196ae40usize)as*mut u8,bool;
6443(crate::app::itemdata::ItemData)::core::convert::Into::into(item))
6444 }
6445 }
6446
6447 #[doc = "`IsBulletPatternB(crate::app::itemdata::ItemData)` overload"]
6448 pub fn is_bullet_pattern_b(item: impl ::core::convert::Into<crate::app::itemdata::ItemData>) -> bool {
6449 unsafe {
6450 ::unity::il2cpp_call!((::unity::module_base()+0x196af40usize)as*mut u8,bool;
6451(crate::app::itemdata::ItemData)::core::convert::Into::into(item))
6452 }
6453 }
6454
6455 #[doc = "`EnchantDeploy(crate::app::unit::Unit, bool, bool)` overload"]
6456 pub fn enchant_deploy(
6457 actor: impl ::core::convert::Into<crate::app::unit::Unit>,
6458 is_entrust: impl ::core::convert::Into<bool>,
6459 with_attack: impl ::core::convert::Into<bool>,
6460 ) -> () {
6461 unsafe {
6462 ::unity::il2cpp_call!((::unity::module_base()+0x196df90usize)as*mut u8,();
6463(crate::app::unit::Unit)::core::convert::Into::into(actor),(bool)::core::convert::Into::into(is_entrust),(bool)::core::convert::Into::into(with_attack))
6464 }
6465 }
6466
6467 #[doc = "`GetEntrustHero(crate::app::unit::Unit)` overload"]
6468 pub fn get_entrust_hero_2(unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> crate::app::unit::Unit {
6469 unsafe {
6470 ::unity::il2cpp_call!((::unity::module_base()+0x1970440usize)as*mut u8,crate::app::unit::Unit;
6471(crate::app::unit::Unit)::core::convert::Into::into(unit))
6472 }
6473 }
6474
6475 #[doc = "`GetEntrustHeroExcluding(crate::app::unit::Unit)` overload"]
6476 pub fn get_entrust_hero_excluding(excluded_unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> crate::app::unit::Unit {
6477 unsafe {
6478 ::unity::il2cpp_call!((::unity::module_base()+0x1970450usize)as*mut u8,crate::app::unit::Unit;
6479(crate::app::unit::Unit)::core::convert::Into::into(excluded_unit))
6480 }
6481 }
6482
6483 #[doc = "`EntrustGetDeployFreeMoveFlag(crate::app::unit::Unit)` overload"]
6484 pub fn entrust_get_deploy_free_move_flag(
6485 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
6486 ) -> crate::app::mapdeploytemplate_1::MapDeployTemplate_1_Flag<crate::app::aideploy::AIDeploy> {
6487 unsafe {
6488 ::unity::il2cpp_call!((::unity::module_base()+0x19704d0usize)as*mut u8,crate::app::mapdeploytemplate_1::MapDeployTemplate_1_Flag<crate::app::aideploy::AIDeploy> ;
6489(crate::app::unit::Unit)::core::convert::Into::into(unit))
6490 }
6491 }
6492
6493 #[doc = "`EntrustGetEscortAreaIfNeeded(crate::app::unit::Unit, *muti32, *muti32, *muti32)` overload"]
6494 pub fn entrust_get_escort_area_if_needed(actor: impl ::core::convert::Into<crate::app::unit::Unit>) -> (i32, i32, i32) {
6495 unsafe {
6496 let mut __out_0 = ::core::mem::MaybeUninit::<i32>::uninit();
6497 let mut __out_1 = ::core::mem::MaybeUninit::<i32>::uninit();
6498 let mut __out_2 = ::core::mem::MaybeUninit::<i32>::uninit();
6499 ::unity::il2cpp_call!((::unity::module_base()+0x192c5b0usize)as*mut u8,();
6500(crate::app::unit::Unit)::core::convert::Into::into(actor),(*mut i32)__out_0.as_mut_ptr(),(*mut i32)__out_1.as_mut_ptr(),(*mut i32)__out_2.as_mut_ptr());
6501 (__out_0.assume_init(), __out_1.assume_init(), __out_2.assume_init())
6502 }
6503 }
6504
6505 #[doc = "`CanVsEngageAttack(crate::app::unit::Unit)` overload"]
6506 pub fn can_vs_engage_attack_2(unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> bool {
6507 unsafe {
6508 ::unity::il2cpp_call!((::unity::module_base()+0x195e2e0usize)as*mut u8,bool;
6509(crate::app::unit::Unit)::core::convert::Into::into(unit))
6510 }
6511 }
6512
6513 #[doc = "`.cctor()` overload"]
6514 pub fn cctor() -> () {
6515 unsafe {
6516 ::unity::il2cpp_call!((::unity::module_base()+0x1976af0usize)as*mut u8,();
6517 )
6518 }
6519 }
6520}
6521
6522#[cfg(feature = "app-aithink")]
6523pub trait IAIThinkMethods: IAIThink {
6524 #[doc = "`.ctor()` overload"]
6525 fn ctor(self) -> () {
6526 unsafe {
6527 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6528 ::unity::il2cpp_call!((::unity::module_base()+0x1922e50usize)as*mut u8,();
6529(AIThink)__receiver)
6530 }
6531 }
6532 #[doc = "`SetUnit(crate::app::unit::Unit)` overload"]
6533 fn set_unit(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> () {
6534 unsafe {
6535 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6536 ::unity::il2cpp_call!((::unity::module_base()+0x193aa30usize)as*mut u8,();
6537(AIThink)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(unit))
6538 }
6539 }
6540 #[doc = "`SetThink(crate::app::aithink::AIThink_Think)` overload"]
6541 fn set_think(self, think: impl ::core::convert::Into<crate::app::aithink::AIThink_Think>) -> () {
6542 unsafe {
6543 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6544 ::unity::il2cpp_call!((::unity::module_base()+0x193aa40usize)as*mut u8,();
6545(AIThink)__receiver,(crate::app::aithink::AIThink_Think)::core::convert::Into::into(think))
6546 }
6547 }
6548 #[doc = "`GetAttackTargetForCandidateCount(i32)` overload"]
6549 fn get_attack_target_for_candidate_count(self, idx: impl ::core::convert::Into<i32>) -> i32 {
6550 unsafe {
6551 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6552 ::unity::il2cpp_call!((::unity::module_base()+0x193aa50usize)as*mut u8,i32;
6553(AIThink)__receiver,(i32)::core::convert::Into::into(idx))
6554 }
6555 }
6556 #[doc = "`GetAttackTargetForMind(i32)` overload"]
6557 fn get_attack_target_for_mind(self, idx: impl ::core::convert::Into<i32>) -> i32 {
6558 unsafe {
6559 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6560 ::unity::il2cpp_call!((::unity::module_base()+0x193aa90usize)as*mut u8,i32;
6561(AIThink)__receiver,(i32)::core::convert::Into::into(idx))
6562 }
6563 }
6564 #[doc = "`AddAttackTargetForMind(i32, u8)` overload"]
6565 fn add_attack_target_for_mind(self, idx: impl ::core::convert::Into<i32>, value: impl ::core::convert::Into<u8>) -> () {
6566 unsafe {
6567 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6568 ::unity::il2cpp_call!((::unity::module_base()+0x192d3f0usize)as*mut u8,();
6569(AIThink)__receiver,(i32)::core::convert::Into::into(idx),(u8)::core::convert::Into::into(value))
6570 }
6571 }
6572 #[doc = "`Processing()` overload"]
6573 fn processing(self) -> () {
6574 unsafe {
6575 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6576 ::unity::il2cpp_call!((::unity::module_base()+0x1925420usize)as*mut u8,();
6577(AIThink)__receiver)
6578 }
6579 }
6580 #[doc = "`ProcessingRemove()` overload"]
6581 fn processing_remove(self) -> () {
6582 unsafe {
6583 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6584 ::unity::il2cpp_call!((::unity::module_base()+0x1926080usize)as*mut u8,();
6585(AIThink)__receiver)
6586 }
6587 }
6588 #[doc = "`ProcessingRemagic()` overload"]
6589 fn processing_remagic(self) -> () {
6590 unsafe {
6591 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6592 ::unity::il2cpp_call!((::unity::module_base()+0x1926240usize)as*mut u8,();
6593(AIThink)__receiver)
6594 }
6595 }
6596 #[doc = "`ProcessingRerewarp()` overload"]
6597 fn processing_rerewarp(self) -> () {
6598 unsafe {
6599 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6600 ::unity::il2cpp_call!((::unity::module_base()+0x1926310usize)as*mut u8,();
6601(AIThink)__receiver)
6602 }
6603 }
6604 #[doc = "`UpdateTarget()` overload"]
6605 fn update_target(self) -> () {
6606 unsafe {
6607 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6608 ::unity::il2cpp_call!((::unity::module_base()+0x1924e30usize)as*mut u8,();
6609(AIThink)__receiver)
6610 }
6611 }
6612 #[doc = "`ProcessingActive(crate::app::aivalue::AIValue_Order)` overload"]
6613 fn processing_active(self, order: impl ::core::convert::Into<crate::app::aivalue::AIValue_Order>) -> crate::app::aithink::AIThink_Result {
6614 unsafe {
6615 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6616 ::unity::il2cpp_call!((::unity::module_base()+0x193aad0usize)as*mut u8,crate::app::aithink::AIThink_Result;
6617(AIThink)__receiver,(crate::app::aivalue::AIValue_Order)::core::convert::Into::into(order))
6618 }
6619 }
6620 #[doc = "`ProcessingResult(crate::app::aivalue::AIValue_Order)` overload"]
6621 fn processing_result(self, order: impl ::core::convert::Into<crate::app::aivalue::AIValue_Order>) -> () {
6622 unsafe {
6623 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6624 ::unity::il2cpp_call!((::unity::module_base()+0x193b650usize)as*mut u8,();
6625(AIThink)__receiver,(crate::app::aivalue::AIValue_Order)::core::convert::Into::into(order))
6626 }
6627 }
6628 #[doc = "`ProcessingMutation()` overload"]
6629 fn processing_mutation(self) -> crate::app::aithink::AIThink_Result {
6630 unsafe {
6631 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6632 ::unity::il2cpp_call!((::unity::module_base()+0x193b030usize)as*mut u8,crate::app::aithink::AIThink_Result;
6633(AIThink)__receiver)
6634 }
6635 }
6636 #[doc = "`ActiveCause(crate::app::aidata::AIData, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
6637 fn active_cause(
6638 self,
6639 command: impl ::core::convert::Into<crate::app::aidata::AIData>,
6640 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6641 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6642 ) -> () {
6643 unsafe {
6644 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6645 ::unity::il2cpp_call!((::unity::module_base()+0x19432c0usize)as*mut u8,();
6646(AIThink)__receiver,(crate::app::aidata::AIData)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
6647 }
6648 }
6649 #[doc = "`ResultCause(crate::app::aidata::AIData, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
6650 fn result_cause(
6651 self,
6652 command: impl ::core::convert::Into<crate::app::aidata::AIData>,
6653 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6654 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6655 ) -> () {
6656 unsafe {
6657 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6658 ::unity::il2cpp_call!((::unity::module_base()+0x1943d30usize)as*mut u8,();
6659(AIThink)__receiver,(crate::app::aidata::AIData)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
6660 }
6661 }
6662 #[doc = "`Action(crate::app::aidata::AIData, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
6663 fn action(
6664 self,
6665 command: impl ::core::convert::Into<crate::app::aidata::AIData>,
6666 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6667 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6668 ) -> crate::app::aithink::AIThink_Result {
6669 unsafe {
6670 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6671 ::unity::il2cpp_call!((::unity::module_base()+0x1943480usize)as*mut u8,crate::app::aithink::AIThink_Result;
6672(AIThink)__receiver,(crate::app::aidata::AIData)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
6673 }
6674 }
6675 #[doc = "`Update(crate::app::aivalue::AIValue_Order)` overload"]
6676 fn update(self, order: impl ::core::convert::Into<crate::app::aivalue::AIValue_Order>) -> () {
6677 unsafe {
6678 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6679 ::unity::il2cpp_call!((::unity::module_base()+0x193b4b0usize)as*mut u8,();
6680(AIThink)__receiver,(crate::app::aivalue::AIValue_Order)::core::convert::Into::into(order))
6681 }
6682 }
6683 #[doc = "`ChangeSeq(crate::app::aivalue::AIValue_Order, crate::app::aidata::AIData, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
6684 fn change_seq(
6685 self,
6686 order: impl ::core::convert::Into<crate::app::aivalue::AIValue_Order>,
6687 command: impl ::core::convert::Into<crate::app::aidata::AIData>,
6688 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6689 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6690 ) -> () {
6691 unsafe {
6692 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6693 ::unity::il2cpp_call!((::unity::module_base()+0x1943be0usize)as*mut u8,();
6694(AIThink)__receiver,(crate::app::aivalue::AIValue_Order)::core::convert::Into::into(order),(crate::app::aidata::AIData)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
6695 }
6696 }
6697 #[doc = "`ChangeValue(crate::app::aivalue::AIValue_Order, crate::app::aidata::AIData, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
6698 fn change_value(
6699 self,
6700 order: impl ::core::convert::Into<crate::app::aivalue::AIValue_Order>,
6701 command: impl ::core::convert::Into<crate::app::aidata::AIData>,
6702 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6703 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6704 ) -> () {
6705 unsafe {
6706 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6707 ::unity::il2cpp_call!((::unity::module_base()+0x1943c40usize)as*mut u8,();
6708(AIThink)__receiver,(crate::app::aivalue::AIValue_Order)::core::convert::Into::into(order),(crate::app::aidata::AIData)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
6709 }
6710 }
6711 #[doc = "`ActiveCauseEverytime(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
6712 fn active_cause_everytime(
6713 self,
6714 command: impl ::core::convert::Into<i32>,
6715 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6716 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6717 ) -> bool {
6718 unsafe {
6719 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6720 ::unity::il2cpp_call!((::unity::module_base()+0x1943e40usize)as*mut u8,bool;
6721(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
6722 }
6723 }
6724 #[doc = "`ActiveCauseAttackRange(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
6725 fn active_cause_attack_range(
6726 self,
6727 command: impl ::core::convert::Into<i32>,
6728 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6729 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6730 ) -> bool {
6731 unsafe {
6732 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6733 ::unity::il2cpp_call!((::unity::module_base()+0x1943e50usize)as*mut u8,bool;
6734(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
6735 }
6736 }
6737 #[doc = "`ActiveCauseBandRange(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
6738 fn active_cause_band_range(
6739 self,
6740 command: impl ::core::convert::Into<i32>,
6741 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6742 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6743 ) -> bool {
6744 unsafe {
6745 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6746 ::unity::il2cpp_call!((::unity::module_base()+0x1944720usize)as*mut u8,bool;
6747(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
6748 }
6749 }
6750 #[doc = "`ActiveCauseHealRange(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
6751 fn active_cause_heal_range(
6752 self,
6753 command: impl ::core::convert::Into<i32>,
6754 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6755 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6756 ) -> bool {
6757 unsafe {
6758 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6759 ::unity::il2cpp_call!((::unity::module_base()+0x1944a30usize)as*mut u8,bool;
6760(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
6761 }
6762 }
6763 #[doc = "`ActiveCauseAreaEnemy(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
6764 fn active_cause_area_enemy(
6765 self,
6766 command: impl ::core::convert::Into<i32>,
6767 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6768 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6769 ) -> bool {
6770 unsafe {
6771 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6772 ::unity::il2cpp_call!((::unity::module_base()+0x1945390usize)as*mut u8,bool;
6773(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
6774 }
6775 }
6776 #[doc = "`ActiveCauseTurn(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
6777 fn active_cause_turn(
6778 self,
6779 command: impl ::core::convert::Into<i32>,
6780 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6781 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6782 ) -> bool {
6783 unsafe {
6784 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6785 ::unity::il2cpp_call!((::unity::module_base()+0x1945540usize)as*mut u8,bool;
6786(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
6787 }
6788 }
6789 #[doc = "`ActiveCauseFlagTrue(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
6790 fn active_cause_flag_true(
6791 self,
6792 command: impl ::core::convert::Into<i32>,
6793 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6794 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6795 ) -> bool {
6796 unsafe {
6797 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6798 ::unity::il2cpp_call!((::unity::module_base()+0x19455e0usize)as*mut u8,bool;
6799(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
6800 }
6801 }
6802 #[doc = "`ActiveCauseFlagFalse(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
6803 fn active_cause_flag_false(
6804 self,
6805 command: impl ::core::convert::Into<i32>,
6806 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6807 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6808 ) -> bool {
6809 unsafe {
6810 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6811 ::unity::il2cpp_call!((::unity::module_base()+0x1945630usize)as*mut u8,bool;
6812(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
6813 }
6814 }
6815 #[doc = "`ActiveCauseDoneHeal(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
6816 fn active_cause_done_heal(
6817 self,
6818 command: impl ::core::convert::Into<i32>,
6819 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6820 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6821 ) -> bool {
6822 unsafe {
6823 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6824 ::unity::il2cpp_call!((::unity::module_base()+0x1945680usize)as*mut u8,bool;
6825(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
6826 }
6827 }
6828 #[doc = "`ActiveCauseInterferenceRange(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
6829 fn active_cause_interference_range(
6830 self,
6831 command: impl ::core::convert::Into<i32>,
6832 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6833 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6834 ) -> bool {
6835 unsafe {
6836 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6837 ::unity::il2cpp_call!((::unity::module_base()+0x19456a0usize)as*mut u8,bool;
6838(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
6839 }
6840 }
6841 #[doc = "`ResultCauseAttack(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
6842 fn result_cause_attack(
6843 self,
6844 command: impl ::core::convert::Into<i32>,
6845 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6846 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6847 ) -> bool {
6848 unsafe {
6849 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6850 ::unity::il2cpp_call!((::unity::module_base()+0x19459f0usize)as*mut u8,bool;
6851(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
6852 }
6853 }
6854 #[doc = "`ResultCauseTalk(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
6855 fn result_cause_talk(
6856 self,
6857 command: impl ::core::convert::Into<i32>,
6858 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6859 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6860 ) -> bool {
6861 unsafe {
6862 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6863 ::unity::il2cpp_call!((::unity::module_base()+0x1945a70usize)as*mut u8,bool;
6864(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
6865 }
6866 }
6867 #[doc = "`ResultCauseArrive(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
6868 fn result_cause_arrive(
6869 self,
6870 command: impl ::core::convert::Into<i32>,
6871 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6872 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6873 ) -> bool {
6874 unsafe {
6875 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6876 ::unity::il2cpp_call!((::unity::module_base()+0x1945b80usize)as*mut u8,bool;
6877(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
6878 }
6879 }
6880 #[doc = "`ActionAttackDefault(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
6881 fn action_attack_default(
6882 self,
6883 command: impl ::core::convert::Into<i32>,
6884 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6885 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6886 ) -> crate::app::aithink::AIThink_Result {
6887 unsafe {
6888 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6889 ::unity::il2cpp_call!((::unity::module_base()+0x1945da0usize)as*mut u8,crate::app::aithink::AIThink_Result;
6890(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
6891 }
6892 }
6893 #[doc = "`ActionAttackMiddleLow(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
6894 fn action_attack_middle_low(
6895 self,
6896 command: impl ::core::convert::Into<i32>,
6897 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6898 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6899 ) -> crate::app::aithink::AIThink_Result {
6900 unsafe {
6901 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6902 ::unity::il2cpp_call!((::unity::module_base()+0x19469b0usize)as*mut u8,crate::app::aithink::AIThink_Result;
6903(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
6904 }
6905 }
6906 #[doc = "`ActionAttackLow(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
6907 fn action_attack_low(
6908 self,
6909 command: impl ::core::convert::Into<i32>,
6910 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6911 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6912 ) -> crate::app::aithink::AIThink_Result {
6913 unsafe {
6914 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6915 ::unity::il2cpp_call!((::unity::module_base()+0x19469d0usize)as*mut u8,crate::app::aithink::AIThink_Result;
6916(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
6917 }
6918 }
6919 #[doc = "`ActionRodHeal(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
6920 fn action_rod_heal(
6921 self,
6922 command: impl ::core::convert::Into<i32>,
6923 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6924 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6925 ) -> crate::app::aithink::AIThink_Result {
6926 unsafe {
6927 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6928 ::unity::il2cpp_call!((::unity::module_base()+0x19469f0usize)as*mut u8,crate::app::aithink::AIThink_Result;
6929(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
6930 }
6931 }
6932 #[doc = "`ActionRodWarp(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
6933 fn action_rod_warp(
6934 self,
6935 command: impl ::core::convert::Into<i32>,
6936 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6937 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6938 ) -> crate::app::aithink::AIThink_Result {
6939 unsafe {
6940 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6941 ::unity::il2cpp_call!((::unity::module_base()+0x1946e30usize)as*mut u8,crate::app::aithink::AIThink_Result;
6942(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
6943 }
6944 }
6945 #[doc = "`ActionRodRescue(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
6946 fn action_rod_rescue(
6947 self,
6948 command: impl ::core::convert::Into<i32>,
6949 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6950 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6951 ) -> crate::app::aithink::AIThink_Result {
6952 unsafe {
6953 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6954 ::unity::il2cpp_call!((::unity::module_base()+0x19478e0usize)as*mut u8,crate::app::aithink::AIThink_Result;
6955(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
6956 }
6957 }
6958 #[doc = "`ActionRodInterference(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
6959 fn action_rod_interference(
6960 self,
6961 command: impl ::core::convert::Into<i32>,
6962 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6963 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6964 ) -> crate::app::aithink::AIThink_Result {
6965 unsafe {
6966 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6967 ::unity::il2cpp_call!((::unity::module_base()+0x1948350usize)as*mut u8,crate::app::aithink::AIThink_Result;
6968(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
6969 }
6970 }
6971 #[doc = "`ActionHealDefault(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
6972 fn action_heal_default(
6973 self,
6974 command: impl ::core::convert::Into<i32>,
6975 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6976 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6977 ) -> crate::app::aithink::AIThink_Result {
6978 unsafe {
6979 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6980 ::unity::il2cpp_call!((::unity::module_base()+0x1948960usize)as*mut u8,crate::app::aithink::AIThink_Result;
6981(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
6982 }
6983 }
6984 #[doc = "`ActionHealMiddleLow(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
6985 fn action_heal_middle_low(
6986 self,
6987 command: impl ::core::convert::Into<i32>,
6988 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6989 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
6990 ) -> crate::app::aithink::AIThink_Result {
6991 unsafe {
6992 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6993 ::unity::il2cpp_call!((::unity::module_base()+0x1948a60usize)as*mut u8,crate::app::aithink::AIThink_Result;
6994(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
6995 }
6996 }
6997 #[doc = "`ActionHealNearingHero(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
6998 fn action_heal_nearing_hero(
6999 self,
7000 command: impl ::core::convert::Into<i32>,
7001 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7002 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7003 ) -> crate::app::aithink::AIThink_Result {
7004 unsafe {
7005 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7006 ::unity::il2cpp_call!((::unity::module_base()+0x1948b00usize)as*mut u8,crate::app::aithink::AIThink_Result;
7007(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
7008 }
7009 }
7010 #[doc = "`ActionEngageAttack(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
7011 fn action_engage_attack(
7012 self,
7013 command: impl ::core::convert::Into<i32>,
7014 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7015 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7016 ) -> crate::app::aithink::AIThink_Result {
7017 unsafe {
7018 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7019 ::unity::il2cpp_call!((::unity::module_base()+0x1949620usize)as*mut u8,crate::app::aithink::AIThink_Result;
7020(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
7021 }
7022 }
7023 #[doc = "`ActionEngageDance(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
7024 fn action_engage_dance(
7025 self,
7026 command: impl ::core::convert::Into<i32>,
7027 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7028 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7029 ) -> crate::app::aithink::AIThink_Result {
7030 unsafe {
7031 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7032 ::unity::il2cpp_call!((::unity::module_base()+0x1949dd0usize)as*mut u8,crate::app::aithink::AIThink_Result;
7033(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
7034 }
7035 }
7036 #[doc = "`ActionEngageVision(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
7037 fn action_engage_vision(
7038 self,
7039 command: impl ::core::convert::Into<i32>,
7040 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7041 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7042 ) -> crate::app::aithink::AIThink_Result {
7043 unsafe {
7044 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7045 ::unity::il2cpp_call!((::unity::module_base()+0x194a140usize)as*mut u8,crate::app::aithink::AIThink_Result;
7046(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
7047 }
7048 }
7049 #[doc = "`ActionEngagePierce(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
7050 fn action_engage_pierce(
7051 self,
7052 command: impl ::core::convert::Into<i32>,
7053 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7054 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7055 ) -> crate::app::aithink::AIThink_Result {
7056 unsafe {
7057 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7058 ::unity::il2cpp_call!((::unity::module_base()+0x194a560usize)as*mut u8,crate::app::aithink::AIThink_Result;
7059(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
7060 }
7061 }
7062 #[doc = "`ActionMindTalk(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
7063 fn action_mind_talk(
7064 self,
7065 command: impl ::core::convert::Into<i32>,
7066 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7067 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7068 ) -> crate::app::aithink::AIThink_Result {
7069 unsafe {
7070 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7071 ::unity::il2cpp_call!((::unity::module_base()+0x194a990usize)as*mut u8,crate::app::aithink::AIThink_Result;
7072(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
7073 }
7074 }
7075 #[doc = "`ActionMindTreasure(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
7076 fn action_mind_treasure(
7077 self,
7078 command: impl ::core::convert::Into<i32>,
7079 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7080 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7081 ) -> crate::app::aithink::AIThink_Result {
7082 unsafe {
7083 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7084 ::unity::il2cpp_call!((::unity::module_base()+0x194ac70usize)as*mut u8,crate::app::aithink::AIThink_Result;
7085(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
7086 }
7087 }
7088 #[doc = "`ActionMindVillage(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
7089 fn action_mind_village(
7090 self,
7091 command: impl ::core::convert::Into<i32>,
7092 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7093 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7094 ) -> crate::app::aithink::AIThink_Result {
7095 unsafe {
7096 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7097 ::unity::il2cpp_call!((::unity::module_base()+0x194b040usize)as*mut u8,crate::app::aithink::AIThink_Result;
7098(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
7099 }
7100 }
7101 #[doc = "`ActionMindEscape(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
7102 fn action_mind_escape(
7103 self,
7104 command: impl ::core::convert::Into<i32>,
7105 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7106 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7107 ) -> crate::app::aithink::AIThink_Result {
7108 unsafe {
7109 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7110 ::unity::il2cpp_call!((::unity::module_base()+0x194b390usize)as*mut u8,crate::app::aithink::AIThink_Result;
7111(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
7112 }
7113 }
7114 #[doc = "`ActionMindBreakDown(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
7115 fn action_mind_break_down(
7116 self,
7117 command: impl ::core::convert::Into<i32>,
7118 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7119 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7120 ) -> crate::app::aithink::AIThink_Result {
7121 unsafe {
7122 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7123 ::unity::il2cpp_call!((::unity::module_base()+0x194c290usize)as*mut u8,crate::app::aithink::AIThink_Result;
7124(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
7125 }
7126 }
7127 #[doc = "`ActionMindDance(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
7128 fn action_mind_dance(
7129 self,
7130 command: impl ::core::convert::Into<i32>,
7131 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7132 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7133 ) -> crate::app::aithink::AIThink_Result {
7134 unsafe {
7135 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7136 ::unity::il2cpp_call!((::unity::module_base()+0x194c4b0usize)as*mut u8,crate::app::aithink::AIThink_Result;
7137(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
7138 }
7139 }
7140 #[doc = "`ActionMindTerrainDestroy(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
7141 fn action_mind_terrain_destroy(
7142 self,
7143 command: impl ::core::convert::Into<i32>,
7144 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7145 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7146 ) -> crate::app::aithink::AIThink_Result {
7147 unsafe {
7148 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7149 ::unity::il2cpp_call!((::unity::module_base()+0x194c800usize)as*mut u8,crate::app::aithink::AIThink_Result;
7150(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
7151 }
7152 }
7153 #[doc = "`ActionMindTorch(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
7154 fn action_mind_torch(
7155 self,
7156 command: impl ::core::convert::Into<i32>,
7157 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7158 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7159 ) -> crate::app::aithink::AIThink_Result {
7160 unsafe {
7161 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7162 ::unity::il2cpp_call!((::unity::module_base()+0x194caf0usize)as*mut u8,crate::app::aithink::AIThink_Result;
7163(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
7164 }
7165 }
7166 #[doc = "`ActionMindGuard(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
7167 fn action_mind_guard(
7168 self,
7169 command: impl ::core::convert::Into<i32>,
7170 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7171 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7172 ) -> crate::app::aithink::AIThink_Result {
7173 unsafe {
7174 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7175 ::unity::il2cpp_call!((::unity::module_base()+0x194cf50usize)as*mut u8,crate::app::aithink::AIThink_Result;
7176(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
7177 }
7178 }
7179 #[doc = "`ActionMoveIdle(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
7180 fn action_move_idle(
7181 self,
7182 command: impl ::core::convert::Into<i32>,
7183 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7184 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7185 ) -> crate::app::aithink::AIThink_Result {
7186 unsafe {
7187 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7188 ::unity::il2cpp_call!((::unity::module_base()+0x194d890usize)as*mut u8,crate::app::aithink::AIThink_Result;
7189(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
7190 }
7191 }
7192 #[doc = "`ActionMoveNearestEnemy(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
7193 fn action_move_nearest_enemy(
7194 self,
7195 command: impl ::core::convert::Into<i32>,
7196 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7197 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7198 ) -> crate::app::aithink::AIThink_Result {
7199 unsafe {
7200 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7201 ::unity::il2cpp_call!((::unity::module_base()+0x194db00usize)as*mut u8,crate::app::aithink::AIThink_Result;
7202(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
7203 }
7204 }
7205 #[doc = "`ActionMoveNearestFriend(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
7206 fn action_move_nearest_friend(
7207 self,
7208 command: impl ::core::convert::Into<i32>,
7209 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7210 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7211 ) -> crate::app::aithink::AIThink_Result {
7212 unsafe {
7213 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7214 ::unity::il2cpp_call!((::unity::module_base()+0x194ddf0usize)as*mut u8,crate::app::aithink::AIThink_Result;
7215(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
7216 }
7217 }
7218 #[doc = "`ActionMoveAttackRange(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
7219 fn action_move_attack_range(
7220 self,
7221 command: impl ::core::convert::Into<i32>,
7222 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7223 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7224 ) -> crate::app::aithink::AIThink_Result {
7225 unsafe {
7226 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7227 ::unity::il2cpp_call!((::unity::module_base()+0x194e0d0usize)as*mut u8,crate::app::aithink::AIThink_Result;
7228(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
7229 }
7230 }
7231 #[doc = "`ActionMoveAttackRangeImpl(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue, bool)` overload"]
7232 fn action_move_attack_range_impl(
7233 self,
7234 command: impl ::core::convert::Into<i32>,
7235 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7236 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7237 retry: impl ::core::convert::Into<bool>,
7238 ) -> crate::app::aithink::AIThink_Result {
7239 unsafe {
7240 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7241 ::unity::il2cpp_call!((::unity::module_base()+0x194e160usize)as*mut u8,crate::app::aithink::AIThink_Result;
7242(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1),(bool)::core::convert::Into::into(retry))
7243 }
7244 }
7245 #[doc = "`ActionMoveHealRange(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
7246 fn action_move_heal_range(
7247 self,
7248 command: impl ::core::convert::Into<i32>,
7249 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7250 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7251 ) -> crate::app::aithink::AIThink_Result {
7252 unsafe {
7253 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7254 ::unity::il2cpp_call!((::unity::module_base()+0x194e9b0usize)as*mut u8,crate::app::aithink::AIThink_Result;
7255(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
7256 }
7257 }
7258 #[doc = "`ActionMoveHero(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
7259 fn action_move_hero(
7260 self,
7261 command: impl ::core::convert::Into<i32>,
7262 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7263 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7264 ) -> crate::app::aithink::AIThink_Result {
7265 unsafe {
7266 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7267 ::unity::il2cpp_call!((::unity::module_base()+0x194f0a0usize)as*mut u8,crate::app::aithink::AIThink_Result;
7268(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
7269 }
7270 }
7271 #[doc = "`ActionMovePerson(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
7272 fn action_move_person(
7273 self,
7274 command: impl ::core::convert::Into<i32>,
7275 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7276 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7277 ) -> crate::app::aithink::AIThink_Result {
7278 unsafe {
7279 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7280 ::unity::il2cpp_call!((::unity::module_base()+0x194f2e0usize)as*mut u8,crate::app::aithink::AIThink_Result;
7281(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
7282 }
7283 }
7284 #[doc = "`ActionMovePosition(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
7285 fn action_move_position(
7286 self,
7287 command: impl ::core::convert::Into<i32>,
7288 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7289 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7290 ) -> crate::app::aithink::AIThink_Result {
7291 unsafe {
7292 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7293 ::unity::il2cpp_call!((::unity::module_base()+0x194f5a0usize)as*mut u8,crate::app::aithink::AIThink_Result;
7294(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
7295 }
7296 }
7297 #[doc = "`ActionMoveTerrain(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
7298 fn action_move_terrain(
7299 self,
7300 command: impl ::core::convert::Into<i32>,
7301 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7302 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7303 ) -> crate::app::aithink::AIThink_Result {
7304 unsafe {
7305 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7306 ::unity::il2cpp_call!((::unity::module_base()+0x194f7d0usize)as*mut u8,crate::app::aithink::AIThink_Result;
7307(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
7308 }
7309 }
7310 #[doc = "`ActionMoveForce(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
7311 fn action_move_force(
7312 self,
7313 command: impl ::core::convert::Into<i32>,
7314 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7315 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7316 ) -> crate::app::aithink::AIThink_Result {
7317 unsafe {
7318 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7319 ::unity::il2cpp_call!((::unity::module_base()+0x194fa10usize)as*mut u8,crate::app::aithink::AIThink_Result;
7320(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
7321 }
7322 }
7323 #[doc = "`ActionMoveReturn(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
7324 fn action_move_return(
7325 self,
7326 command: impl ::core::convert::Into<i32>,
7327 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7328 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7329 ) -> crate::app::aithink::AIThink_Result {
7330 unsafe {
7331 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7332 ::unity::il2cpp_call!((::unity::module_base()+0x193af40usize)as*mut u8,crate::app::aithink::AIThink_Result;
7333(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
7334 }
7335 }
7336 #[doc = "`ActionMoveTreasure(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
7337 fn action_move_treasure(
7338 self,
7339 command: impl ::core::convert::Into<i32>,
7340 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7341 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7342 ) -> crate::app::aithink::AIThink_Result {
7343 unsafe {
7344 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7345 ::unity::il2cpp_call!((::unity::module_base()+0x194fd10usize)as*mut u8,crate::app::aithink::AIThink_Result;
7346(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
7347 }
7348 }
7349 #[doc = "`ActionMoveVillage(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
7350 fn action_move_village(
7351 self,
7352 command: impl ::core::convert::Into<i32>,
7353 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7354 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7355 ) -> crate::app::aithink::AIThink_Result {
7356 unsafe {
7357 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7358 ::unity::il2cpp_call!((::unity::module_base()+0x19504b0usize)as*mut u8,crate::app::aithink::AIThink_Result;
7359(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
7360 }
7361 }
7362 #[doc = "`ActionMoveEscape(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
7363 fn action_move_escape(
7364 self,
7365 command: impl ::core::convert::Into<i32>,
7366 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7367 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7368 ) -> crate::app::aithink::AIThink_Result {
7369 unsafe {
7370 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7371 ::unity::il2cpp_call!((::unity::module_base()+0x1950c40usize)as*mut u8,crate::app::aithink::AIThink_Result;
7372(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
7373 }
7374 }
7375 #[doc = "`ActionMoveTerrainDestroy(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
7376 fn action_move_terrain_destroy(
7377 self,
7378 command: impl ::core::convert::Into<i32>,
7379 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7380 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7381 ) -> crate::app::aithink::AIThink_Result {
7382 unsafe {
7383 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7384 ::unity::il2cpp_call!((::unity::module_base()+0x19513e0usize)as*mut u8,crate::app::aithink::AIThink_Result;
7385(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
7386 }
7387 }
7388 #[doc = "`ActionMoveRetreat(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
7389 fn action_move_retreat(
7390 self,
7391 command: impl ::core::convert::Into<i32>,
7392 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7393 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7394 ) -> crate::app::aithink::AIThink_Result {
7395 unsafe {
7396 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7397 ::unity::il2cpp_call!((::unity::module_base()+0x1951630usize)as*mut u8,crate::app::aithink::AIThink_Result;
7398(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
7399 }
7400 }
7401 #[doc = "`ActionMoveBreakDown(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
7402 fn action_move_break_down(
7403 self,
7404 command: impl ::core::convert::Into<i32>,
7405 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7406 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7407 ) -> crate::app::aithink::AIThink_Result {
7408 unsafe {
7409 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7410 ::unity::il2cpp_call!((::unity::module_base()+0x1951e20usize)as*mut u8,crate::app::aithink::AIThink_Result;
7411(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
7412 }
7413 }
7414 #[doc = "`ActionMoveRewarp(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
7415 fn action_move_rewarp(
7416 self,
7417 command: impl ::core::convert::Into<i32>,
7418 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7419 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7420 ) -> crate::app::aithink::AIThink_Result {
7421 unsafe {
7422 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7423 ::unity::il2cpp_call!((::unity::module_base()+0x1952050usize)as*mut u8,crate::app::aithink::AIThink_Result;
7424(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
7425 }
7426 }
7427 #[doc = "`GetRewarpItemIndex(crate::app::unit::Unit)` overload"]
7428 fn get_rewarp_item_index(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> i32 {
7429 unsafe {
7430 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7431 ::unity::il2cpp_call!((::unity::module_base()+0x1952970usize)as*mut u8,i32;
7432(AIThink)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(unit))
7433 }
7434 }
7435 #[doc = "`GetRewarpPosition(crate::app::unit::Unit, crate::app::unititem::UnitItem, i32, i32, *muti32, *muti32, bool)` overload"]
7436 fn get_rewarp_position(
7437 self,
7438 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
7439 unit_item: impl ::core::convert::Into<crate::app::unititem::UnitItem>,
7440 target_x: impl ::core::convert::Into<i32>,
7441 target_z: impl ::core::convert::Into<i32>,
7442 use_move_image_b: impl ::core::convert::Into<bool>,
7443 ) -> (bool, i32, i32) {
7444 unsafe {
7445 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7446 let mut __out_0 = ::core::mem::MaybeUninit::<i32>::uninit();
7447 let mut __out_1 = ::core::mem::MaybeUninit::<i32>::uninit();
7448 let __ret = {
7449 ::unity::il2cpp_call!((::unity::module_base()+0x1952fa0usize)as*mut u8,bool;
7450(AIThink)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(unit),(crate::app::unititem::UnitItem)::core::convert::Into::into(unit_item),(i32)::core::convert::Into::into(target_x),(i32)::core::convert::Into::into(target_z),(*mut i32)__out_0.as_mut_ptr(),(*mut i32)__out_1.as_mut_ptr(),(bool)::core::convert::Into::into(use_move_image_b))
7451 };
7452 (__ret, __out_0.assume_init(), __out_1.assume_init())
7453 }
7454 }
7455 #[doc = "`ActionCommandSkillBattle(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
7456 fn action_command_skill_battle(
7457 self,
7458 command: impl ::core::convert::Into<i32>,
7459 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7460 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7461 ) -> crate::app::aithink::AIThink_Result {
7462 unsafe {
7463 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7464 ::unity::il2cpp_call!((::unity::module_base()+0x19533a0usize)as*mut u8,crate::app::aithink::AIThink_Result;
7465(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
7466 }
7467 }
7468 #[doc = "`ActionCommandSkillOverlap(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
7469 fn action_command_skill_overlap(
7470 self,
7471 command: impl ::core::convert::Into<i32>,
7472 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7473 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7474 ) -> crate::app::aithink::AIThink_Result {
7475 unsafe {
7476 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7477 ::unity::il2cpp_call!((::unity::module_base()+0x19536b0usize)as*mut u8,crate::app::aithink::AIThink_Result;
7478(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
7479 }
7480 }
7481 #[doc = "`ActionRemove()` overload"]
7482 fn action_remove(self) -> crate::app::aithink::AIThink_Result {
7483 unsafe {
7484 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7485 ::unity::il2cpp_call!((::unity::module_base()+0x193b990usize)as*mut u8,crate::app::aithink::AIThink_Result;
7486(AIThink)__receiver)
7487 }
7488 }
7489 #[doc = "`ActionRemagic()` overload"]
7490 fn action_remagic(self) -> crate::app::aithink::AIThink_Result {
7491 unsafe {
7492 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7493 ::unity::il2cpp_call!((::unity::module_base()+0x193c170usize)as*mut u8,crate::app::aithink::AIThink_Result;
7494(AIThink)__receiver)
7495 }
7496 }
7497 #[doc = "`ActionRerewarp()` overload"]
7498 fn action_rerewarp(self) -> crate::app::aithink::AIThink_Result {
7499 unsafe {
7500 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7501 ::unity::il2cpp_call!((::unity::module_base()+0x193c3d0usize)as*mut u8,crate::app::aithink::AIThink_Result;
7502(AIThink)__receiver)
7503 }
7504 }
7505 #[doc = "`IsEnemyInsideAttackAreaForAC(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue, crate::app::unit::Unit, i32, i32, i32, i32, bool)` overload"]
7506 fn is_enemy_inside_attack_area_for_ac(
7507 self,
7508 command: impl ::core::convert::Into<i32>,
7509 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7510 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7511 actor: impl ::core::convert::Into<crate::app::unit::Unit>,
7512 x: impl ::core::convert::Into<i32>,
7513 z: impl ::core::convert::Into<i32>,
7514 move_power: impl ::core::convert::Into<i32>,
7515 band_threshold: impl ::core::convert::Into<i32>,
7516 is_exclude_self: impl ::core::convert::Into<bool>,
7517 ) -> bool {
7518 unsafe {
7519 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7520 ::unity::il2cpp_call!((::unity::module_base()+0x1944330usize)as*mut u8,bool;
7521(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1),(crate::app::unit::Unit)::core::convert::Into::into(actor),(i32)::core::convert::Into::into(x),(i32)::core::convert::Into::into(z),(i32)::core::convert::Into::into(move_power),(i32)::core::convert::Into::into(band_threshold),(bool)::core::convert::Into::into(is_exclude_self))
7522 }
7523 }
7524 #[doc = "`IsAttackableEnemy(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue, crate::app::unit::Unit)` overload"]
7525 fn is_attackable_enemy(
7526 self,
7527 command: impl ::core::convert::Into<i32>,
7528 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7529 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7530 actor: impl ::core::convert::Into<crate::app::unit::Unit>,
7531 ) -> bool {
7532 unsafe {
7533 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7534 ::unity::il2cpp_call!((::unity::module_base()+0x194cd10usize)as*mut u8,bool;
7535(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1),(crate::app::unit::Unit)::core::convert::Into::into(actor))
7536 }
7537 }
7538 #[doc = "`IsAttackableEnemyForEntrust(crate::app::unit::Unit)` overload"]
7539 fn is_attackable_enemy_for_entrust(self, actor: impl ::core::convert::Into<crate::app::unit::Unit>) -> bool {
7540 unsafe {
7541 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7542 ::unity::il2cpp_call!((::unity::module_base()+0x19545f0usize)as*mut u8,bool;
7543(AIThink)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(actor))
7544 }
7545 }
7546 #[doc = "`AttackTo(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue, crate::app::skilldata::SkillData)` overload"]
7547 fn attack_to(
7548 self,
7549 command: impl ::core::convert::Into<i32>,
7550 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7551 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7552 command_skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>,
7553 ) -> crate::app::aithink::AIThink_Result {
7554 unsafe {
7555 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7556 ::unity::il2cpp_call!((::unity::module_base()+0x1945db0usize)as*mut u8,crate::app::aithink::AIThink_Result;
7557(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1),(crate::app::skilldata::SkillData)::core::convert::Into::into(command_skill))
7558 }
7559 }
7560 #[doc = "`SetAttackTargetToMind(*mutcrate::app::aithink::AIThink_AttackTarget, crate::app::skilldata::SkillData)` overload"]
7561 fn set_attack_target_to_mind(
7562 self,
7563 command_skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>,
7564 ) -> crate::app::aithink::AIThink_AttackTarget {
7565 unsafe {
7566 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7567 let mut __out_0 = ::core::mem::MaybeUninit::<crate::app::aithink::AIThink_AttackTarget>::uninit();
7568 ::unity::il2cpp_call!((::unity::module_base()+0x1953960usize)as*mut u8,();
7569(AIThink)__receiver,(*mut crate::app::aithink::AIThink_AttackTarget)__out_0.as_mut_ptr(),(crate::app::skilldata::SkillData)::core::convert::Into::into(command_skill));
7570 __out_0.assume_init()
7571 }
7572 }
7573 #[doc = "`IsAttackPermission(crate::app::unit::Unit)` overload"]
7574 fn is_attack_permission_2(self, target: impl ::core::convert::Into<crate::app::unit::Unit>) -> bool {
7575 unsafe {
7576 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7577 ::unity::il2cpp_call!((::unity::module_base()+0x1954f40usize)as*mut u8,bool;
7578(AIThink)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(target))
7579 }
7580 }
7581 #[doc = "`IsAttackPermissionWithCommand(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue, crate::app::unit::Unit)` overload"]
7582 fn is_attack_permission_with_command(
7583 self,
7584 command: impl ::core::convert::Into<i32>,
7585 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7586 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7587 target: impl ::core::convert::Into<crate::app::unit::Unit>,
7588 ) -> bool {
7589 unsafe {
7590 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7591 ::unity::il2cpp_call!((::unity::module_base()+0x1954fc0usize)as*mut u8,bool;
7592(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1),(crate::app::unit::Unit)::core::convert::Into::into(target))
7593 }
7594 }
7595 #[doc = "`IsAttackPermissionWithCommand(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue, crate::app::unit::Unit, crate::app::unit::Unit)` overload"]
7596 fn is_attack_permission_with_command_2(
7597 self,
7598 command: impl ::core::convert::Into<i32>,
7599 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7600 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7601 actor: impl ::core::convert::Into<crate::app::unit::Unit>,
7602 target: impl ::core::convert::Into<crate::app::unit::Unit>,
7603 ) -> bool {
7604 unsafe {
7605 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7606 ::unity::il2cpp_call!((::unity::module_base()+0x19550d0usize)as*mut u8,bool;
7607(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1),(crate::app::unit::Unit)::core::convert::Into::into(actor),(crate::app::unit::Unit)::core::convert::Into::into(target))
7608 }
7609 }
7610 #[doc = "`CompareAttackPriorityWithCommand(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue, crate::app::unit::Unit, crate::app::unit::Unit)` overload"]
7611 fn compare_attack_priority_with_command(
7612 self,
7613 command: impl ::core::convert::Into<i32>,
7614 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7615 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7616 unit0: impl ::core::convert::Into<crate::app::unit::Unit>,
7617 unit1: impl ::core::convert::Into<crate::app::unit::Unit>,
7618 ) -> i32 {
7619 unsafe {
7620 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7621 ::unity::il2cpp_call!((::unity::module_base()+0x19551c0usize)as*mut u8,i32;
7622(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1),(crate::app::unit::Unit)::core::convert::Into::into(unit0),(crate::app::unit::Unit)::core::convert::Into::into(unit1))
7623 }
7624 }
7625 #[doc = "`CompareAttackPriorityWithBlow(u32, f32, u32, f32)` overload"]
7626 fn compare_attack_priority_with_blow(
7627 self,
7628 blow_score0: impl ::core::convert::Into<u32>,
7629 kill_rate0: impl ::core::convert::Into<f32>,
7630 blow_score1: impl ::core::convert::Into<u32>,
7631 kill_rate1: impl ::core::convert::Into<f32>,
7632 ) -> i32 {
7633 unsafe {
7634 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7635 ::unity::il2cpp_call!((::unity::module_base()+0x19552d0usize)as*mut u8,i32;
7636(AIThink)__receiver,(u32)::core::convert::Into::into(blow_score0),(f32)::core::convert::Into::into(kill_rate0),(u32)::core::convert::Into::into(blow_score1),(f32)::core::convert::Into::into(kill_rate1))
7637 }
7638 }
7639 #[doc = "`CompareAttackPriorityWithChainAttackCount(i32, i32)` overload"]
7640 fn compare_attack_priority_with_chain_attack_count(
7641 self,
7642 chain_attack_count0: impl ::core::convert::Into<i32>,
7643 chain_attack_count1: impl ::core::convert::Into<i32>,
7644 ) -> i32 {
7645 unsafe {
7646 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7647 ::unity::il2cpp_call!((::unity::module_base()+0x1955340usize)as*mut u8,i32;
7648(AIThink)__receiver,(i32)::core::convert::Into::into(chain_attack_count0),(i32)::core::convert::Into::into(chain_attack_count1))
7649 }
7650 }
7651 #[doc = "`CompareAttackPriorityWithBullet(crate::app::unit::Unit, i32, crate::app::unit::Unit, i32, crate::app::unit::Unit)` overload"]
7652 fn compare_attack_priority_with_bullet(
7653 self,
7654 actor: impl ::core::convert::Into<crate::app::unit::Unit>,
7655 item_index0: impl ::core::convert::Into<i32>,
7656 target0: impl ::core::convert::Into<crate::app::unit::Unit>,
7657 item_index1: impl ::core::convert::Into<i32>,
7658 target1: impl ::core::convert::Into<crate::app::unit::Unit>,
7659 ) -> i32 {
7660 unsafe {
7661 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7662 ::unity::il2cpp_call!((::unity::module_base()+0x19553a0usize)as*mut u8,i32;
7663(AIThink)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(actor),(i32)::core::convert::Into::into(item_index0),(crate::app::unit::Unit)::core::convert::Into::into(target0),(i32)::core::convert::Into::into(item_index1),(crate::app::unit::Unit)::core::convert::Into::into(target1))
7664 }
7665 }
7666 #[doc = "`CheckAttackPriority(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue, crate::app::unit::Unit, *mutcrate::app::aithink::AIThink_AttackScoreResult, *mutcrate::app::aithink::AIThink_AttackTarget)` overload"]
7667 fn check_attack_priority(
7668 self,
7669 command: impl ::core::convert::Into<i32>,
7670 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7671 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7672 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
7673 ) -> (
7674 bool,
7675 crate::app::aithink::AIThink_AttackScoreResult,
7676 crate::app::aithink::AIThink_AttackTarget,
7677 ) {
7678 unsafe {
7679 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7680 let mut __out_0 = ::core::mem::MaybeUninit::<crate::app::aithink::AIThink_AttackScoreResult>::uninit();
7681 let mut __out_1 = ::core::mem::MaybeUninit::<crate::app::aithink::AIThink_AttackTarget>::uninit();
7682 let __ret = {
7683 ::unity::il2cpp_call!((::unity::module_base()+0x1955e90usize)as*mut u8,bool;
7684(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1),(crate::app::unit::Unit)::core::convert::Into::into(unit),(*mut crate::app::aithink::AIThink_AttackScoreResult)__out_0.as_mut_ptr(),(*mut crate::app::aithink::AIThink_AttackTarget)__out_1.as_mut_ptr())
7685 };
7686 (__ret, __out_0.assume_init(), __out_1.assume_init())
7687 }
7688 }
7689 #[doc = "`CheckAttackPriority(crate::app::unit::Unit, *mutcrate::app::aithink::AIThink_AttackScoreResult, *mutcrate::app::aithink::AIThink_AttackTarget)` overload"]
7690 fn check_attack_priority_2(
7691 self,
7692 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
7693 ) -> (
7694 bool,
7695 crate::app::aithink::AIThink_AttackScoreResult,
7696 crate::app::aithink::AIThink_AttackTarget,
7697 ) {
7698 unsafe {
7699 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7700 let mut __out_0 = ::core::mem::MaybeUninit::<crate::app::aithink::AIThink_AttackScoreResult>::uninit();
7701 let mut __out_1 = ::core::mem::MaybeUninit::<crate::app::aithink::AIThink_AttackTarget>::uninit();
7702 let __ret = {
7703 ::unity::il2cpp_call!((::unity::module_base()+0x1956120usize)as*mut u8,bool;
7704(AIThink)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(unit),(*mut crate::app::aithink::AIThink_AttackScoreResult)__out_0.as_mut_ptr(),(*mut crate::app::aithink::AIThink_AttackTarget)__out_1.as_mut_ptr())
7705 };
7706 (__ret, __out_0.assume_init(), __out_1.assume_init())
7707 }
7708 }
7709 #[doc = "`CheckAttackPriority(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue, crate::app::unit::Unit, crate::app::unit::Unit, *mutcrate::app::aithink::AIThink_AttackScoreResult, *mutcrate::app::aithink::AIThink_AttackTarget)` overload"]
7710 fn check_attack_priority_3(
7711 self,
7712 command: impl ::core::convert::Into<i32>,
7713 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7714 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7715 actor: impl ::core::convert::Into<crate::app::unit::Unit>,
7716 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
7717 ) -> (
7718 bool,
7719 crate::app::aithink::AIThink_AttackScoreResult,
7720 crate::app::aithink::AIThink_AttackTarget,
7721 ) {
7722 unsafe {
7723 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7724 let mut __out_0 = ::core::mem::MaybeUninit::<crate::app::aithink::AIThink_AttackScoreResult>::uninit();
7725 let mut __out_1 = ::core::mem::MaybeUninit::<crate::app::aithink::AIThink_AttackTarget>::uninit();
7726 let __ret = {
7727 ::unity::il2cpp_call!((::unity::module_base()+0x1956160usize)as*mut u8,bool;
7728(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1),(crate::app::unit::Unit)::core::convert::Into::into(actor),(crate::app::unit::Unit)::core::convert::Into::into(unit),(*mut crate::app::aithink::AIThink_AttackScoreResult)__out_0.as_mut_ptr(),(*mut crate::app::aithink::AIThink_AttackTarget)__out_1.as_mut_ptr())
7729 };
7730 (__ret, __out_0.assume_init(), __out_1.assume_init())
7731 }
7732 }
7733 #[doc = "`CheckAttackPriorityImpl(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue, crate::app::unit::Unit, crate::app::unit::Unit, *mutcrate::app::aithink::AIThink_AttackScoreResult, *mutcrate::app::aithink::AIThink_AttackTarget, bool)` overload"]
7734 fn check_attack_priority_impl(
7735 self,
7736 command: impl ::core::convert::Into<i32>,
7737 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7738 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7739 actor: impl ::core::convert::Into<crate::app::unit::Unit>,
7740 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
7741 is_ignore_command: impl ::core::convert::Into<bool>,
7742 ) -> (
7743 bool,
7744 crate::app::aithink::AIThink_AttackScoreResult,
7745 crate::app::aithink::AIThink_AttackTarget,
7746 ) {
7747 unsafe {
7748 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7749 let mut __out_0 = ::core::mem::MaybeUninit::<crate::app::aithink::AIThink_AttackScoreResult>::uninit();
7750 let mut __out_1 = ::core::mem::MaybeUninit::<crate::app::aithink::AIThink_AttackTarget>::uninit();
7751 let __ret = {
7752 ::unity::il2cpp_call!((::unity::module_base()+0x1955ed0usize)as*mut u8,bool;
7753(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1),(crate::app::unit::Unit)::core::convert::Into::into(actor),(crate::app::unit::Unit)::core::convert::Into::into(unit),(*mut crate::app::aithink::AIThink_AttackScoreResult)__out_0.as_mut_ptr(),(*mut crate::app::aithink::AIThink_AttackTarget)__out_1.as_mut_ptr(),(bool)::core::convert::Into::into(is_ignore_command))
7754 };
7755 (__ret, __out_0.assume_init(), __out_1.assume_init())
7756 }
7757 }
7758 #[doc = "`GetAttackScore(crate::app::unit::Unit, i32, *mutcrate::app::aithink::AIThink_AttackScoreResult)` overload"]
7759 fn get_attack_score(
7760 self,
7761 target: impl ::core::convert::Into<crate::app::unit::Unit>,
7762 flag: impl ::core::convert::Into<i32>,
7763 ) -> (bool, crate::app::aithink::AIThink_AttackScoreResult) {
7764 unsafe {
7765 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7766 let mut __out_0 = ::core::mem::MaybeUninit::<crate::app::aithink::AIThink_AttackScoreResult>::uninit();
7767 let __ret = {
7768 ::unity::il2cpp_call!((::unity::module_base()+0x1956190usize)as*mut u8,bool;
7769(AIThink)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(target),(i32)::core::convert::Into::into(flag),(*mut crate::app::aithink::AIThink_AttackScoreResult)__out_0.as_mut_ptr())
7770 };
7771 (__ret, __out_0.assume_init())
7772 }
7773 }
7774 #[doc = "`GetAttackScore(crate::app::unit::Unit, i32, i32, i32, *mutcrate::app::aithink::AIThink_AttackScoreResult)` overload"]
7775 fn get_attack_score_2(
7776 self,
7777 target: impl ::core::convert::Into<crate::app::unit::Unit>,
7778 target_x: impl ::core::convert::Into<i32>,
7779 target_z: impl ::core::convert::Into<i32>,
7780 flag: impl ::core::convert::Into<i32>,
7781 ) -> (bool, crate::app::aithink::AIThink_AttackScoreResult) {
7782 unsafe {
7783 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7784 let mut __out_0 = ::core::mem::MaybeUninit::<crate::app::aithink::AIThink_AttackScoreResult>::uninit();
7785 let __ret = {
7786 ::unity::il2cpp_call!((::unity::module_base()+0x1956830usize)as*mut u8,bool;
7787(AIThink)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(target),(i32)::core::convert::Into::into(target_x),(i32)::core::convert::Into::into(target_z),(i32)::core::convert::Into::into(flag),(*mut crate::app::aithink::AIThink_AttackScoreResult)__out_0.as_mut_ptr())
7788 };
7789 (__ret, __out_0.assume_init())
7790 }
7791 }
7792 #[doc = "`GetAttackScore(crate::app::unit::Unit, i32, i32, i32, i32, crate::app::skilldata::SkillData, i32, *mutcrate::app::aithink::AIThink_AttackScoreResult)` overload"]
7793 fn get_attack_score_3(
7794 self,
7795 target: impl ::core::convert::Into<crate::app::unit::Unit>,
7796 target_x: impl ::core::convert::Into<i32>,
7797 target_z: impl ::core::convert::Into<i32>,
7798 flag: impl ::core::convert::Into<i32>,
7799 prior_item_index: impl ::core::convert::Into<i32>,
7800 skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>,
7801 bullet_pattern: impl ::core::convert::Into<i32>,
7802 ) -> (bool, crate::app::aithink::AIThink_AttackScoreResult) {
7803 unsafe {
7804 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7805 let mut __out_0 = ::core::mem::MaybeUninit::<crate::app::aithink::AIThink_AttackScoreResult>::uninit();
7806 let __ret = {
7807 ::unity::il2cpp_call!((::unity::module_base()+0x1956880usize)as*mut u8,bool;
7808(AIThink)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(target),(i32)::core::convert::Into::into(target_x),(i32)::core::convert::Into::into(target_z),(i32)::core::convert::Into::into(flag),(i32)::core::convert::Into::into(prior_item_index),(crate::app::skilldata::SkillData)::core::convert::Into::into(skill),(i32)::core::convert::Into::into(bullet_pattern),(*mut crate::app::aithink::AIThink_AttackScoreResult)__out_0.as_mut_ptr())
7809 };
7810 (__ret, __out_0.assume_init())
7811 }
7812 }
7813 #[doc = "`GetAttackScore(crate::app::unit::Unit, crate::app::unit::Unit, i32, i32, i32, i32, crate::app::skilldata::SkillData, i32, *mutcrate::app::aithink::AIThink_AttackScoreResult)` overload"]
7814 fn get_attack_score_4(
7815 self,
7816 current: impl ::core::convert::Into<crate::app::unit::Unit>,
7817 target: impl ::core::convert::Into<crate::app::unit::Unit>,
7818 target_x: impl ::core::convert::Into<i32>,
7819 target_z: impl ::core::convert::Into<i32>,
7820 flag: impl ::core::convert::Into<i32>,
7821 prior_item_index: impl ::core::convert::Into<i32>,
7822 skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>,
7823 bullet_pattern: impl ::core::convert::Into<i32>,
7824 ) -> (bool, crate::app::aithink::AIThink_AttackScoreResult) {
7825 unsafe {
7826 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7827 let mut __out_0 = ::core::mem::MaybeUninit::<crate::app::aithink::AIThink_AttackScoreResult>::uninit();
7828 let __ret = {
7829 ::unity::il2cpp_call!((::unity::module_base()+0x19561e0usize)as*mut u8,bool;
7830(AIThink)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(current),(crate::app::unit::Unit)::core::convert::Into::into(target),(i32)::core::convert::Into::into(target_x),(i32)::core::convert::Into::into(target_z),(i32)::core::convert::Into::into(flag),(i32)::core::convert::Into::into(prior_item_index),(crate::app::skilldata::SkillData)::core::convert::Into::into(skill),(i32)::core::convert::Into::into(bullet_pattern),(*mut crate::app::aithink::AIThink_AttackScoreResult)__out_0.as_mut_ptr())
7831 };
7832 (__ret, __out_0.assume_init())
7833 }
7834 }
7835 #[doc = "`GetEntrustAttackScore(crate::app::unit::Unit, i32, i32, i32, *mutcrate::app::aithink::AIThink_EntrustAttackScoreResult)` overload"]
7836 fn get_entrust_attack_score(
7837 self,
7838 target: impl ::core::convert::Into<crate::app::unit::Unit>,
7839 item_index: impl ::core::convert::Into<i32>,
7840 target_x: impl ::core::convert::Into<i32>,
7841 target_z: impl ::core::convert::Into<i32>,
7842 ) -> (bool, crate::app::aithink::AIThink_EntrustAttackScoreResult) {
7843 unsafe {
7844 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7845 let mut __out_0 = ::core::mem::MaybeUninit::<crate::app::aithink::AIThink_EntrustAttackScoreResult>::uninit();
7846 let __ret = {
7847 ::unity::il2cpp_call!((::unity::module_base()+0x19569a0usize)as*mut u8,bool;
7848(AIThink)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(target),(i32)::core::convert::Into::into(item_index),(i32)::core::convert::Into::into(target_x),(i32)::core::convert::Into::into(target_z),(*mut crate::app::aithink::AIThink_EntrustAttackScoreResult)__out_0.as_mut_ptr())
7849 };
7850 (__ret, __out_0.assume_init())
7851 }
7852 }
7853 #[doc = "`GetEntrustAttackScore(crate::app::unit::Unit, i32, i32, i32, i32, crate::app::skilldata::SkillData, *mutcrate::app::aithink::AIThink_EntrustAttackScoreResult)` overload"]
7854 fn get_entrust_attack_score_2(
7855 self,
7856 target: impl ::core::convert::Into<crate::app::unit::Unit>,
7857 item_index: impl ::core::convert::Into<i32>,
7858 target_x: impl ::core::convert::Into<i32>,
7859 target_z: impl ::core::convert::Into<i32>,
7860 flag: impl ::core::convert::Into<i32>,
7861 skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>,
7862 ) -> (bool, crate::app::aithink::AIThink_EntrustAttackScoreResult) {
7863 unsafe {
7864 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7865 let mut __out_0 = ::core::mem::MaybeUninit::<crate::app::aithink::AIThink_EntrustAttackScoreResult>::uninit();
7866 let __ret = {
7867 ::unity::il2cpp_call!((::unity::module_base()+0x1956c90usize)as*mut u8,bool;
7868(AIThink)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(target),(i32)::core::convert::Into::into(item_index),(i32)::core::convert::Into::into(target_x),(i32)::core::convert::Into::into(target_z),(i32)::core::convert::Into::into(flag),(crate::app::skilldata::SkillData)::core::convert::Into::into(skill),(*mut crate::app::aithink::AIThink_EntrustAttackScoreResult)__out_0.as_mut_ptr())
7869 };
7870 (__ret, __out_0.assume_init())
7871 }
7872 }
7873 #[doc = "`GetEntrustAttackScore(crate::app::unit::Unit, crate::app::unit::Unit, i32, i32, i32, i32, crate::app::skilldata::SkillData, *mutcrate::app::aithink::AIThink_EntrustAttackScoreResult)` overload"]
7874 fn get_entrust_attack_score_3(
7875 self,
7876 current: impl ::core::convert::Into<crate::app::unit::Unit>,
7877 target: impl ::core::convert::Into<crate::app::unit::Unit>,
7878 item_index: impl ::core::convert::Into<i32>,
7879 target_x: impl ::core::convert::Into<i32>,
7880 target_z: impl ::core::convert::Into<i32>,
7881 flag: impl ::core::convert::Into<i32>,
7882 skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>,
7883 ) -> (bool, crate::app::aithink::AIThink_EntrustAttackScoreResult) {
7884 unsafe {
7885 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7886 let mut __out_0 = ::core::mem::MaybeUninit::<crate::app::aithink::AIThink_EntrustAttackScoreResult>::uninit();
7887 let __ret = {
7888 ::unity::il2cpp_call!((::unity::module_base()+0x19569f0usize)as*mut u8,bool;
7889(AIThink)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(current),(crate::app::unit::Unit)::core::convert::Into::into(target),(i32)::core::convert::Into::into(item_index),(i32)::core::convert::Into::into(target_x),(i32)::core::convert::Into::into(target_z),(i32)::core::convert::Into::into(flag),(crate::app::skilldata::SkillData)::core::convert::Into::into(skill),(*mut crate::app::aithink::AIThink_EntrustAttackScoreResult)__out_0.as_mut_ptr())
7890 };
7891 (__ret, __out_0.assume_init())
7892 }
7893 }
7894 #[doc = "`GetGodSkill(crate::app::unit::Unit, *mutcrate::app::skilldata::SkillData, i32)` overload"]
7895 fn get_god_skill(
7896 self,
7897 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
7898 kind: impl ::core::convert::Into<i32>,
7899 ) -> (crate::app::aithink::AIThink_GodSkillTypes, crate::app::skilldata::SkillData) {
7900 unsafe {
7901 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7902 let mut __out_0 = ::core::mem::MaybeUninit::<crate::app::skilldata::SkillData>::uninit();
7903 let __ret = {
7904 ::unity::il2cpp_call!((::unity::module_base()+0x1956ce0usize)as*mut u8,crate::app::aithink::AIThink_GodSkillTypes;
7905(AIThink)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(unit),(*mut crate::app::skilldata::SkillData)__out_0.as_mut_ptr(),(i32)::core::convert::Into::into(kind))
7906 };
7907 (__ret, __out_0.assume_init())
7908 }
7909 }
7910 #[doc = "`GetGodSkillImpl(crate::app::unit::Unit, *mutcrate::app::skilldata::SkillData, i32)` overload"]
7911 fn get_god_skill_impl(
7912 self,
7913 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
7914 kind: impl ::core::convert::Into<i32>,
7915 ) -> (crate::app::aithink::AIThink_GodSkillTypes, crate::app::skilldata::SkillData) {
7916 unsafe {
7917 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7918 let mut __out_0 = ::core::mem::MaybeUninit::<crate::app::skilldata::SkillData>::uninit();
7919 let __ret = {
7920 ::unity::il2cpp_call!((::unity::module_base()+0x1956d30usize)as*mut u8,crate::app::aithink::AIThink_GodSkillTypes;
7921(AIThink)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(unit),(*mut crate::app::skilldata::SkillData)__out_0.as_mut_ptr(),(i32)::core::convert::Into::into(kind))
7922 };
7923 (__ret, __out_0.assume_init())
7924 }
7925 }
7926 #[doc = "`IsGodSkillDecoy(crate::app::skillarray::SkillArray_Entity)` overload"]
7927 fn is_god_skill_decoy(self, entity: impl ::core::convert::Into<crate::app::skillarray::SkillArray_Entity>) -> bool {
7928 unsafe {
7929 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7930 ::unity::il2cpp_call!((::unity::module_base()+0x19574a0usize)as*mut u8,bool;
7931(AIThink)__receiver,(crate::app::skillarray::SkillArray_Entity)::core::convert::Into::into(entity))
7932 }
7933 }
7934 #[doc = "`IsGodSkillTrimasteries(crate::app::skillarray::SkillArray_Entity)` overload"]
7935 fn is_god_skill_trimasteries(self, entity: impl ::core::convert::Into<crate::app::skillarray::SkillArray_Entity>) -> bool {
7936 unsafe {
7937 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7938 ::unity::il2cpp_call!((::unity::module_base()+0x19571b0usize)as*mut u8,bool;
7939(AIThink)__receiver,(crate::app::skillarray::SkillArray_Entity)::core::convert::Into::into(entity))
7940 }
7941 }
7942 #[doc = "`IsGodSkillStrategyHolyShield(crate::app::skillarray::SkillArray_Entity)` overload"]
7943 fn is_god_skill_strategy_holy_shield(self, entity: impl ::core::convert::Into<crate::app::skillarray::SkillArray_Entity>) -> bool {
7944 unsafe {
7945 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7946 ::unity::il2cpp_call!((::unity::module_base()+0x19572a0usize)as*mut u8,bool;
7947(AIThink)__receiver,(crate::app::skillarray::SkillArray_Entity)::core::convert::Into::into(entity))
7948 }
7949 }
7950 #[doc = "`IsGodSkillGaze(crate::app::skillarray::SkillArray_Entity)` overload"]
7951 fn is_god_skill_gaze(self, entity: impl ::core::convert::Into<crate::app::skillarray::SkillArray_Entity>) -> bool {
7952 unsafe {
7953 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7954 ::unity::il2cpp_call!((::unity::module_base()+0x19573a0usize)as*mut u8,bool;
7955(AIThink)__receiver,(crate::app::skillarray::SkillArray_Entity)::core::convert::Into::into(entity))
7956 }
7957 }
7958 #[doc = "`CanGiveBadStatesForBullet(crate::app::itemdata::ItemData, crate::app::unit::Unit)` overload"]
7959 fn can_give_bad_states_for_bullet(
7960 self,
7961 item: impl ::core::convert::Into<crate::app::itemdata::ItemData>,
7962 target: impl ::core::convert::Into<crate::app::unit::Unit>,
7963 ) -> crate::app::aithink::AIThink_CGBSResult {
7964 unsafe {
7965 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7966 ::unity::il2cpp_call!((::unity::module_base()+0x1955470usize)as*mut u8,crate::app::aithink::AIThink_CGBSResult;
7967(AIThink)__receiver,(crate::app::itemdata::ItemData)::core::convert::Into::into(item),(crate::app::unit::Unit)::core::convert::Into::into(target))
7968 }
7969 }
7970 #[doc = "`GetRodProhibitMinMax(crate::app::aivalue::AIValue, crate::app::aivalue::AIValue, *muti32, *muti32)` overload"]
7971 fn get_rod_prohibit_min_max(
7972 self,
7973 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7974 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
7975 ) -> (i32, i32) {
7976 unsafe {
7977 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7978 let mut __out_0 = ::core::mem::MaybeUninit::<i32>::uninit();
7979 let mut __out_1 = ::core::mem::MaybeUninit::<i32>::uninit();
7980 ::unity::il2cpp_call!((::unity::module_base()+0x1957940usize)as*mut u8,();
7981(AIThink)__receiver,(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1),(*mut i32)__out_0.as_mut_ptr(),(*mut i32)__out_1.as_mut_ptr());
7982 (__out_0.assume_init(), __out_1.assume_init())
7983 }
7984 }
7985 #[doc = "`IsRodPermission(i32, i32)` overload"]
7986 fn is_rod_permission(self, prohibit_min: impl ::core::convert::Into<i32>, prohibit_max: impl ::core::convert::Into<i32>) -> bool {
7987 unsafe {
7988 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7989 ::unity::il2cpp_call!((::unity::module_base()+0x1957aa0usize)as*mut u8,bool;
7990(AIThink)__receiver,(i32)::core::convert::Into::into(prohibit_min),(i32)::core::convert::Into::into(prohibit_max))
7991 }
7992 }
7993 #[doc = "`DecideToProhibitRod(i32, i32)` overload"]
7994 fn decide_to_prohibit_rod(self, min: impl ::core::convert::Into<i32>, max: impl ::core::convert::Into<i32>) -> () {
7995 unsafe {
7996 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7997 ::unity::il2cpp_call!((::unity::module_base()+0x1957b70usize)as*mut u8,();
7998(AIThink)__receiver,(i32)::core::convert::Into::into(min),(i32)::core::convert::Into::into(max))
7999 }
8000 }
8001 #[doc = "`RodWarpTo(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
8002 fn rod_warp_to(
8003 self,
8004 command: impl ::core::convert::Into<i32>,
8005 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
8006 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
8007 ) -> crate::app::aithink::AIThink_Result {
8008 unsafe {
8009 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8010 ::unity::il2cpp_call!((::unity::module_base()+0x1946e40usize)as*mut u8,crate::app::aithink::AIThink_Result;
8011(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
8012 }
8013 }
8014 #[doc = "`GetWarpRodEvalution(crate::app::unit::Unit, crate::app::itemdata::ItemData, i32, i32, *mutcrate::app::aithink::AIThink_WarpRodEvaluationResult)` overload"]
8015 fn get_warp_rod_evalution(
8016 self,
8017 target: impl ::core::convert::Into<crate::app::unit::Unit>,
8018 warp_rod_item: impl ::core::convert::Into<crate::app::itemdata::ItemData>,
8019 warp_rod_item_index: impl ::core::convert::Into<i32>,
8020 attack_flag: impl ::core::convert::Into<i32>,
8021 ) -> (bool, crate::app::aithink::AIThink_WarpRodEvaluationResult) {
8022 unsafe {
8023 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8024 let mut __out_0 = ::core::mem::MaybeUninit::<crate::app::aithink::AIThink_WarpRodEvaluationResult>::uninit();
8025 let __ret = {
8026 ::unity::il2cpp_call!((::unity::module_base()+0x1957c30usize)as*mut u8,bool;
8027(AIThink)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(target),(crate::app::itemdata::ItemData)::core::convert::Into::into(warp_rod_item),(i32)::core::convert::Into::into(warp_rod_item_index),(i32)::core::convert::Into::into(attack_flag),(*mut crate::app::aithink::AIThink_WarpRodEvaluationResult)__out_0.as_mut_ptr())
8028 };
8029 (__ret, __out_0.assume_init())
8030 }
8031 }
8032 #[doc = "`GetWarpRodFarZEvalution(crate::app::unit::Unit, crate::app::itemdata::ItemData, i32, i32, *mutcrate::app::aithink::AIThink_WarpRodEvaluationResult)` overload"]
8033 fn get_warp_rod_far_z_evalution(
8034 self,
8035 target: impl ::core::convert::Into<crate::app::unit::Unit>,
8036 warp_rod_item: impl ::core::convert::Into<crate::app::itemdata::ItemData>,
8037 warp_rod_item_index: impl ::core::convert::Into<i32>,
8038 attack_flag: impl ::core::convert::Into<i32>,
8039 ) -> (bool, crate::app::aithink::AIThink_WarpRodEvaluationResult) {
8040 unsafe {
8041 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8042 let mut __out_0 = ::core::mem::MaybeUninit::<crate::app::aithink::AIThink_WarpRodEvaluationResult>::uninit();
8043 let __ret = {
8044 ::unity::il2cpp_call!((::unity::module_base()+0x1958390usize)as*mut u8,bool;
8045(AIThink)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(target),(crate::app::itemdata::ItemData)::core::convert::Into::into(warp_rod_item),(i32)::core::convert::Into::into(warp_rod_item_index),(i32)::core::convert::Into::into(attack_flag),(*mut crate::app::aithink::AIThink_WarpRodEvaluationResult)__out_0.as_mut_ptr())
8046 };
8047 (__ret, __out_0.assume_init())
8048 }
8049 }
8050 #[doc = "`RodRescueTo(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
8051 fn rod_rescue_to(
8052 self,
8053 command: impl ::core::convert::Into<i32>,
8054 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
8055 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
8056 ) -> crate::app::aithink::AIThink_Result {
8057 unsafe {
8058 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8059 ::unity::il2cpp_call!((::unity::module_base()+0x19478f0usize)as*mut u8,crate::app::aithink::AIThink_Result;
8060(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
8061 }
8062 }
8063 #[doc = "`GetRescueRodScore(crate::app::unit::Unit, i32, i32, crate::app::itemdata::ItemData, i32, i32, *mutcrate::app::aithink::AIThink_RescueRodScoreResult)` overload"]
8064 fn get_rescue_rod_score(
8065 self,
8066 target: impl ::core::convert::Into<crate::app::unit::Unit>,
8067 target_x: impl ::core::convert::Into<i32>,
8068 target_z: impl ::core::convert::Into<i32>,
8069 rescue_rod_item: impl ::core::convert::Into<crate::app::itemdata::ItemData>,
8070 rescue_rod_item_index: impl ::core::convert::Into<i32>,
8071 attack_flag: impl ::core::convert::Into<i32>,
8072 ) -> (bool, crate::app::aithink::AIThink_RescueRodScoreResult) {
8073 unsafe {
8074 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8075 let mut __out_0 = ::core::mem::MaybeUninit::<crate::app::aithink::AIThink_RescueRodScoreResult>::uninit();
8076 let __ret = {
8077 ::unity::il2cpp_call!((::unity::module_base()+0x1958790usize)as*mut u8,bool;
8078(AIThink)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(target),(i32)::core::convert::Into::into(target_x),(i32)::core::convert::Into::into(target_z),(crate::app::itemdata::ItemData)::core::convert::Into::into(rescue_rod_item),(i32)::core::convert::Into::into(rescue_rod_item_index),(i32)::core::convert::Into::into(attack_flag),(*mut crate::app::aithink::AIThink_RescueRodScoreResult)__out_0.as_mut_ptr())
8079 };
8080 (__ret, __out_0.assume_init())
8081 }
8082 }
8083 #[doc = "`IsEnemyInsideInterferenceArea(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue, crate::app::unit::Unit, i32, i32, i32, i32)` overload"]
8084 fn is_enemy_inside_interference_area(
8085 self,
8086 command: impl ::core::convert::Into<i32>,
8087 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
8088 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
8089 actor: impl ::core::convert::Into<crate::app::unit::Unit>,
8090 x: impl ::core::convert::Into<i32>,
8091 z: impl ::core::convert::Into<i32>,
8092 move_power: impl ::core::convert::Into<i32>,
8093 band_threshold: impl ::core::convert::Into<i32>,
8094 ) -> bool {
8095 unsafe {
8096 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8097 ::unity::il2cpp_call!((::unity::module_base()+0x19457c0usize)as*mut u8,bool;
8098(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1),(crate::app::unit::Unit)::core::convert::Into::into(actor),(i32)::core::convert::Into::into(x),(i32)::core::convert::Into::into(z),(i32)::core::convert::Into::into(move_power),(i32)::core::convert::Into::into(band_threshold))
8099 }
8100 }
8101 #[doc = "`InterferenceTo(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
8102 fn interference_to(
8103 self,
8104 command: impl ::core::convert::Into<i32>,
8105 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
8106 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
8107 ) -> crate::app::aithink::AIThink_Result {
8108 unsafe {
8109 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8110 ::unity::il2cpp_call!((::unity::module_base()+0x1948360usize)as*mut u8,crate::app::aithink::AIThink_Result;
8111(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
8112 }
8113 }
8114 #[doc = "`GetInterferenceScore(crate::app::unit::Unit, i32, i32, i32, *mutcrate::app::aithink::AIThink_InterferenceScoreResult)` overload"]
8115 fn get_interference_score(
8116 self,
8117 target: impl ::core::convert::Into<crate::app::unit::Unit>,
8118 target_x: impl ::core::convert::Into<i32>,
8119 target_z: impl ::core::convert::Into<i32>,
8120 flag: impl ::core::convert::Into<i32>,
8121 ) -> (bool, crate::app::aithink::AIThink_InterferenceScoreResult) {
8122 unsafe {
8123 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8124 let mut __out_0 = ::core::mem::MaybeUninit::<crate::app::aithink::AIThink_InterferenceScoreResult>::uninit();
8125 let __ret = {
8126 ::unity::il2cpp_call!((::unity::module_base()+0x1958850usize)as*mut u8,bool;
8127(AIThink)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(target),(i32)::core::convert::Into::into(target_x),(i32)::core::convert::Into::into(target_z),(i32)::core::convert::Into::into(flag),(*mut crate::app::aithink::AIThink_InterferenceScoreResult)__out_0.as_mut_ptr())
8128 };
8129 (__ret, __out_0.assume_init())
8130 }
8131 }
8132 #[doc = "`RodHealTo(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
8133 fn rod_heal_to(
8134 self,
8135 command: impl ::core::convert::Into<i32>,
8136 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
8137 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
8138 ) -> crate::app::aithink::AIThink_Result {
8139 unsafe {
8140 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8141 ::unity::il2cpp_call!((::unity::module_base()+0x1946a00usize)as*mut u8,crate::app::aithink::AIThink_Result;
8142(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
8143 }
8144 }
8145 #[doc = "`IsHealRodPermission(crate::app::unit::Unit)` overload"]
8146 fn is_heal_rod_permission(self, target: impl ::core::convert::Into<crate::app::unit::Unit>) -> bool {
8147 unsafe {
8148 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8149 ::unity::il2cpp_call!((::unity::module_base()+0x19594e0usize)as*mut u8,bool;
8150(AIThink)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(target))
8151 }
8152 }
8153 #[doc = "`CalcHealRodScore(i32, i32, i32, i32, i32)` overload"]
8154 fn calc_heal_rod_score(
8155 self,
8156 heal: impl ::core::convert::Into<i32>,
8157 damage: impl ::core::convert::Into<i32>,
8158 x: impl ::core::convert::Into<i32>,
8159 z: impl ::core::convert::Into<i32>,
8160 item_index: impl ::core::convert::Into<i32>,
8161 ) -> u32 {
8162 unsafe {
8163 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8164 ::unity::il2cpp_call!((::unity::module_base()+0x19598b0usize)as*mut u8,u32;
8165(AIThink)__receiver,(i32)::core::convert::Into::into(heal),(i32)::core::convert::Into::into(damage),(i32)::core::convert::Into::into(x),(i32)::core::convert::Into::into(z),(i32)::core::convert::Into::into(item_index))
8166 }
8167 }
8168 #[doc = "`GetHealRodScoreImpl(crate::app::unit::Unit, i32, i32, i32, *mutcrate::app::aithink::AIThink_HealRodScoreImplResult)` overload"]
8169 fn get_heal_rod_score_impl(
8170 self,
8171 target: impl ::core::convert::Into<crate::app::unit::Unit>,
8172 target_x: impl ::core::convert::Into<i32>,
8173 target_z: impl ::core::convert::Into<i32>,
8174 item_index: impl ::core::convert::Into<i32>,
8175 ) -> (bool, crate::app::aithink::AIThink_HealRodScoreImplResult) {
8176 unsafe {
8177 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8178 let mut __out_0 = ::core::mem::MaybeUninit::<crate::app::aithink::AIThink_HealRodScoreImplResult>::uninit();
8179 let __ret = {
8180 ::unity::il2cpp_call!((::unity::module_base()+0x19599f0usize)as*mut u8,bool;
8181(AIThink)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(target),(i32)::core::convert::Into::into(target_x),(i32)::core::convert::Into::into(target_z),(i32)::core::convert::Into::into(item_index),(*mut crate::app::aithink::AIThink_HealRodScoreImplResult)__out_0.as_mut_ptr())
8182 };
8183 (__ret, __out_0.assume_init())
8184 }
8185 }
8186 #[doc = "`GetHealRodScore(crate::app::unit::Unit, i32, i32, *mutcrate::app::aithink::AIThink_HealRodScoreResult)` overload"]
8187 fn get_heal_rod_score(
8188 self,
8189 target: impl ::core::convert::Into<crate::app::unit::Unit>,
8190 target_x: impl ::core::convert::Into<i32>,
8191 target_z: impl ::core::convert::Into<i32>,
8192 ) -> (bool, crate::app::aithink::AIThink_HealRodScoreResult) {
8193 unsafe {
8194 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8195 let mut __out_0 = ::core::mem::MaybeUninit::<crate::app::aithink::AIThink_HealRodScoreResult>::uninit();
8196 let __ret = {
8197 ::unity::il2cpp_call!((::unity::module_base()+0x1959e80usize)as*mut u8,bool;
8198(AIThink)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(target),(i32)::core::convert::Into::into(target_x),(i32)::core::convert::Into::into(target_z),(*mut crate::app::aithink::AIThink_HealRodScoreResult)__out_0.as_mut_ptr())
8199 };
8200 (__ret, __out_0.assume_init())
8201 }
8202 }
8203 #[doc = "`GetRangeHealRodScore(*mutu32, *muti32)` overload"]
8204 fn get_range_heal_rod_score(self) -> (bool, u32, i32) {
8205 unsafe {
8206 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8207 let mut __out_0 = ::core::mem::MaybeUninit::<u32>::uninit();
8208 let mut __out_1 = ::core::mem::MaybeUninit::<i32>::uninit();
8209 let __ret = {
8210 ::unity::il2cpp_call!((::unity::module_base()+0x1958b60usize)as*mut u8,bool;
8211(AIThink)__receiver,(*mut u32)__out_0.as_mut_ptr(),(*mut i32)__out_1.as_mut_ptr())
8212 };
8213 (__ret, __out_0.assume_init(), __out_1.assume_init())
8214 }
8215 }
8216 #[doc = "`GetHealRodPosition(crate::app::unit::Unit, crate::app::unit::Unit, i32, i32, i32, i32, *mutcrate::app::aithink::AIThink_HealRodPositionResult, crate::app::skilldata::SkillData)` overload"]
8217 fn get_heal_rod_position(
8218 self,
8219 actor: impl ::core::convert::Into<crate::app::unit::Unit>,
8220 target: impl ::core::convert::Into<crate::app::unit::Unit>,
8221 item_index: impl ::core::convert::Into<i32>,
8222 target_x: impl ::core::convert::Into<i32>,
8223 target_z: impl ::core::convert::Into<i32>,
8224 flag: impl ::core::convert::Into<i32>,
8225 skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>,
8226 ) -> (bool, crate::app::aithink::AIThink_HealRodPositionResult) {
8227 unsafe {
8228 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8229 let mut __out_0 = ::core::mem::MaybeUninit::<crate::app::aithink::AIThink_HealRodPositionResult>::uninit();
8230 let __ret = {
8231 ::unity::il2cpp_call!((::unity::module_base()+0x1958120usize)as*mut u8,bool;
8232(AIThink)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(actor),(crate::app::unit::Unit)::core::convert::Into::into(target),(i32)::core::convert::Into::into(item_index),(i32)::core::convert::Into::into(target_x),(i32)::core::convert::Into::into(target_z),(i32)::core::convert::Into::into(flag),(*mut crate::app::aithink::AIThink_HealRodPositionResult)__out_0.as_mut_ptr(),(crate::app::skilldata::SkillData)::core::convert::Into::into(skill))
8233 };
8234 (__ret, __out_0.assume_init())
8235 }
8236 }
8237 #[doc = "`UpdateHealConditionByRod(crate::app::unit::Unit, crate::app::unititem::UnitItem, i32, i32)` overload"]
8238 fn update_heal_condition_by_rod(
8239 self,
8240 actor: impl ::core::convert::Into<crate::app::unit::Unit>,
8241 rod: impl ::core::convert::Into<crate::app::unititem::UnitItem>,
8242 move_x: impl ::core::convert::Into<i32>,
8243 move_z: impl ::core::convert::Into<i32>,
8244 ) -> () {
8245 unsafe {
8246 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8247 ::unity::il2cpp_call!((::unity::module_base()+0x1958ed0usize)as*mut u8,();
8248(AIThink)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(actor),(crate::app::unititem::UnitItem)::core::convert::Into::into(rod),(i32)::core::convert::Into::into(move_x),(i32)::core::convert::Into::into(move_z))
8249 }
8250 }
8251 #[doc = "`UpdateHealConditionByRod(crate::app::unit::Unit, crate::app::unititem::UnitItem, crate::app::unit::Unit)` overload"]
8252 fn update_heal_condition_by_rod_2(
8253 self,
8254 actor: impl ::core::convert::Into<crate::app::unit::Unit>,
8255 rod: impl ::core::convert::Into<crate::app::unititem::UnitItem>,
8256 target: impl ::core::convert::Into<crate::app::unit::Unit>,
8257 ) -> () {
8258 unsafe {
8259 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8260 ::unity::il2cpp_call!((::unity::module_base()+0x1959170usize)as*mut u8,();
8261(AIThink)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(actor),(crate::app::unititem::UnitItem)::core::convert::Into::into(rod),(crate::app::unit::Unit)::core::convert::Into::into(target))
8262 }
8263 }
8264 #[doc = "`HealMindTo()` overload"]
8265 fn heal_mind_to(self) -> crate::app::aithink::AIThink_Result {
8266 unsafe {
8267 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8268 ::unity::il2cpp_call!((::unity::module_base()+0x19489e0usize)as*mut u8,crate::app::aithink::AIThink_Result;
8269(AIThink)__receiver)
8270 }
8271 }
8272 #[doc = "`HealMindToVulnerary()` overload"]
8273 fn heal_mind_to_vulnerary(self) -> crate::app::aithink::AIThink_Result {
8274 unsafe {
8275 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8276 ::unity::il2cpp_call!((::unity::module_base()+0x195a8d0usize)as*mut u8,crate::app::aithink::AIThink_Result;
8277(AIThink)__receiver)
8278 }
8279 }
8280 #[doc = "`HealMindToTerrain()` overload"]
8281 fn heal_mind_to_terrain(self) -> crate::app::aithink::AIThink_Result {
8282 unsafe {
8283 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8284 ::unity::il2cpp_call!((::unity::module_base()+0x195aa90usize)as*mut u8,crate::app::aithink::AIThink_Result;
8285(AIThink)__receiver)
8286 }
8287 }
8288 #[doc = "`GetTerrainHealPosition(*muti32, *muti32)` overload"]
8289 fn get_terrain_heal_position(self) -> (bool, i32, i32) {
8290 unsafe {
8291 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8292 let mut __out_0 = ::core::mem::MaybeUninit::<i32>::uninit();
8293 let mut __out_1 = ::core::mem::MaybeUninit::<i32>::uninit();
8294 let __ret = {
8295 ::unity::il2cpp_call!((::unity::module_base()+0x195aba0usize)as*mut u8,bool;
8296(AIThink)__receiver,(*mut i32)__out_0.as_mut_ptr(),(*mut i32)__out_1.as_mut_ptr())
8297 };
8298 (__ret, __out_0.assume_init(), __out_1.assume_init())
8299 }
8300 }
8301 #[doc = "`DanceTo(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
8302 fn dance_to(
8303 self,
8304 command: impl ::core::convert::Into<i32>,
8305 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
8306 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
8307 ) -> crate::app::aithink::AIThink_Result {
8308 unsafe {
8309 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8310 ::unity::il2cpp_call!((::unity::module_base()+0x194c4c0usize)as*mut u8,crate::app::aithink::AIThink_Result;
8311(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
8312 }
8313 }
8314 #[doc = "`GuardTo(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue, crate::app::skilldata::SkillData)` overload"]
8315 fn guard_to(
8316 self,
8317 command: impl ::core::convert::Into<i32>,
8318 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
8319 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
8320 skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>,
8321 ) -> crate::app::aithink::AIThink_Result {
8322 unsafe {
8323 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8324 ::unity::il2cpp_call!((::unity::module_base()+0x194cf60usize)as*mut u8,crate::app::aithink::AIThink_Result;
8325(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1),(crate::app::skilldata::SkillData)::core::convert::Into::into(skill))
8326 }
8327 }
8328 #[doc = "`TerrainDestroyTo(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
8329 fn terrain_destroy_to(
8330 self,
8331 command: impl ::core::convert::Into<i32>,
8332 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
8333 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
8334 ) -> crate::app::aithink::AIThink_Result {
8335 unsafe {
8336 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8337 ::unity::il2cpp_call!((::unity::module_base()+0x194c810usize)as*mut u8,crate::app::aithink::AIThink_Result;
8338(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
8339 }
8340 }
8341 #[doc = "`IsDestroyTarget(i32, i32)` overload"]
8342 fn is_destroy_target(self, target_x: impl ::core::convert::Into<i32>, target_z: impl ::core::convert::Into<i32>) -> bool {
8343 unsafe {
8344 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8345 ::unity::il2cpp_call!((::unity::module_base()+0x195b270usize)as*mut u8,bool;
8346(AIThink)__receiver,(i32)::core::convert::Into::into(target_x),(i32)::core::convert::Into::into(target_z))
8347 }
8348 }
8349 #[doc = "`EngageAttackTo(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
8350 fn engage_attack_to(
8351 self,
8352 command: impl ::core::convert::Into<i32>,
8353 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
8354 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
8355 ) -> crate::app::aithink::AIThink_Result {
8356 unsafe {
8357 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8358 ::unity::il2cpp_call!((::unity::module_base()+0x1949630usize)as*mut u8,crate::app::aithink::AIThink_Result;
8359(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
8360 }
8361 }
8362 #[doc = "`DeployForEngageAttackTo(crate::app::skilldata::SkillData, bool, crate::app::mapdeploytemplate_1::MapDeployTemplate_1_Flag<crate::app::aideploy::AIDeploy>, crate::app::mapdeploytemplate_1::MapDeployTemplate_1_Flag<crate::app::aideploy::AIDeploy>, i32, i32, i32)` overload"]
8363 fn deploy_for_engage_attack_to(
8364 self,
8365 engage_attack: impl ::core::convert::Into<crate::app::skilldata::SkillData>,
8366 is_rewarp: impl ::core::convert::Into<bool>,
8367 move_flag: impl ::core::convert::Into<crate::app::mapdeploytemplate_1::MapDeployTemplate_1_Flag<crate::app::aideploy::AIDeploy>>,
8368 weapon_flag: impl ::core::convert::Into<crate::app::mapdeploytemplate_1::MapDeployTemplate_1_Flag<crate::app::aideploy::AIDeploy>>,
8369 limit_x: impl ::core::convert::Into<i32>,
8370 limit_z: impl ::core::convert::Into<i32>,
8371 limit_distance: impl ::core::convert::Into<i32>,
8372 ) -> () {
8373 unsafe {
8374 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8375 ::unity::il2cpp_call!((::unity::module_base()+0x195b760usize)as*mut u8,();
8376(AIThink)__receiver,(crate::app::skilldata::SkillData)::core::convert::Into::into(engage_attack),(bool)::core::convert::Into::into(is_rewarp),(crate::app::mapdeploytemplate_1::MapDeployTemplate_1_Flag<crate::app::aideploy::AIDeploy>)::core::convert::Into::into(move_flag),(crate::app::mapdeploytemplate_1::MapDeployTemplate_1_Flag<crate::app::aideploy::AIDeploy>)::core::convert::Into::into(weapon_flag),(i32)::core::convert::Into::into(limit_x),(i32)::core::convert::Into::into(limit_z),(i32)::core::convert::Into::into(limit_distance))
8377 }
8378 }
8379 #[doc = "`GetEngageRewarpPos(crate::app::skilldata::SkillData, i32, i32, *muti32, *muti32, *muti32, *muti32)` overload"]
8380 fn get_engage_rewarp_pos(
8381 self,
8382 engage_attack: impl ::core::convert::Into<crate::app::skilldata::SkillData>,
8383 orig_move_x: impl ::core::convert::Into<i32>,
8384 orig_move_z: impl ::core::convert::Into<i32>,
8385 ) -> (i32, i32, i32, i32) {
8386 unsafe {
8387 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8388 let mut __out_0 = ::core::mem::MaybeUninit::<i32>::uninit();
8389 let mut __out_1 = ::core::mem::MaybeUninit::<i32>::uninit();
8390 let mut __out_2 = ::core::mem::MaybeUninit::<i32>::uninit();
8391 let mut __out_3 = ::core::mem::MaybeUninit::<i32>::uninit();
8392 ::unity::il2cpp_call!((::unity::module_base()+0x195ba30usize)as*mut u8,();
8393(AIThink)__receiver,(crate::app::skilldata::SkillData)::core::convert::Into::into(engage_attack),(i32)::core::convert::Into::into(orig_move_x),(i32)::core::convert::Into::into(orig_move_z),(*mut i32)__out_0.as_mut_ptr(),(*mut i32)__out_1.as_mut_ptr(),(*mut i32)__out_2.as_mut_ptr(),(*mut i32)__out_3.as_mut_ptr());
8394 (__out_0.assume_init(), __out_1.assume_init(), __out_2.assume_init(), __out_3.assume_init())
8395 }
8396 }
8397 #[doc = "`EngageDanceTo(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
8398 fn engage_dance_to(
8399 self,
8400 command: impl ::core::convert::Into<i32>,
8401 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
8402 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
8403 ) -> crate::app::aithink::AIThink_Result {
8404 unsafe {
8405 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8406 ::unity::il2cpp_call!((::unity::module_base()+0x1949de0usize)as*mut u8,crate::app::aithink::AIThink_Result;
8407(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
8408 }
8409 }
8410 #[doc = "`EngageDanceToCommon(*muti32, *muti32, i32, i32, i32)` overload"]
8411 fn engage_dance_to_common(
8412 self,
8413 limit_x: impl ::core::convert::Into<i32>,
8414 limit_z: impl ::core::convert::Into<i32>,
8415 limit_distance: impl ::core::convert::Into<i32>,
8416 ) -> (crate::app::aithink::AIThink_Result, i32, i32) {
8417 unsafe {
8418 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8419 let mut __out_0 = ::core::mem::MaybeUninit::<i32>::uninit();
8420 let mut __out_1 = ::core::mem::MaybeUninit::<i32>::uninit();
8421 let __ret = {
8422 ::unity::il2cpp_call!((::unity::module_base()+0x195bd70usize)as*mut u8,crate::app::aithink::AIThink_Result;
8423(AIThink)__receiver,(*mut i32)__out_0.as_mut_ptr(),(*mut i32)__out_1.as_mut_ptr(),(i32)::core::convert::Into::into(limit_x),(i32)::core::convert::Into::into(limit_z),(i32)::core::convert::Into::into(limit_distance))
8424 };
8425 (__ret, __out_0.assume_init(), __out_1.assume_init())
8426 }
8427 }
8428 #[doc = "`EngagePierceTo(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
8429 fn engage_pierce_to(
8430 self,
8431 command: impl ::core::convert::Into<i32>,
8432 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
8433 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
8434 ) -> crate::app::aithink::AIThink_Result {
8435 unsafe {
8436 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8437 ::unity::il2cpp_call!((::unity::module_base()+0x194a570usize)as*mut u8,crate::app::aithink::AIThink_Result;
8438(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
8439 }
8440 }
8441 #[doc = "`EngageChargeTo(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
8442 fn engage_charge_to(
8443 self,
8444 command: impl ::core::convert::Into<i32>,
8445 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
8446 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
8447 ) -> crate::app::aithink::AIThink_Result {
8448 unsafe {
8449 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8450 ::unity::il2cpp_call!((::unity::module_base()+0x195c1b0usize)as*mut u8,crate::app::aithink::AIThink_Result;
8451(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
8452 }
8453 }
8454 #[doc = "`EngageChargeToCommon(*muti32, *muti32, i32, i32, i32)` overload"]
8455 fn engage_charge_to_common(
8456 self,
8457 limit_x: impl ::core::convert::Into<i32>,
8458 limit_z: impl ::core::convert::Into<i32>,
8459 limit_distance: impl ::core::convert::Into<i32>,
8460 ) -> (crate::app::aithink::AIThink_Result, i32, i32) {
8461 unsafe {
8462 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8463 let mut __out_0 = ::core::mem::MaybeUninit::<i32>::uninit();
8464 let mut __out_1 = ::core::mem::MaybeUninit::<i32>::uninit();
8465 let __ret = {
8466 ::unity::il2cpp_call!((::unity::module_base()+0x195c570usize)as*mut u8,crate::app::aithink::AIThink_Result;
8467(AIThink)__receiver,(*mut i32)__out_0.as_mut_ptr(),(*mut i32)__out_1.as_mut_ptr(),(i32)::core::convert::Into::into(limit_x),(i32)::core::convert::Into::into(limit_z),(i32)::core::convert::Into::into(limit_distance))
8468 };
8469 (__ret, __out_0.assume_init(), __out_1.assume_init())
8470 }
8471 }
8472 #[doc = "`EngageHealTo(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
8473 fn engage_heal_to(
8474 self,
8475 command: impl ::core::convert::Into<i32>,
8476 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
8477 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
8478 ) -> crate::app::aithink::AIThink_Result {
8479 unsafe {
8480 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8481 ::unity::il2cpp_call!((::unity::module_base()+0x195cbb0usize)as*mut u8,crate::app::aithink::AIThink_Result;
8482(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
8483 }
8484 }
8485 #[doc = "`EngageHealToCommon(*muti32, *muti32, i32, i32, i32)` overload"]
8486 fn engage_heal_to_common(
8487 self,
8488 limit_x: impl ::core::convert::Into<i32>,
8489 limit_z: impl ::core::convert::Into<i32>,
8490 limit_distance: impl ::core::convert::Into<i32>,
8491 ) -> (crate::app::aithink::AIThink_Result, i32, i32) {
8492 unsafe {
8493 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8494 let mut __out_0 = ::core::mem::MaybeUninit::<i32>::uninit();
8495 let mut __out_1 = ::core::mem::MaybeUninit::<i32>::uninit();
8496 let __ret = {
8497 ::unity::il2cpp_call!((::unity::module_base()+0x195cf50usize)as*mut u8,crate::app::aithink::AIThink_Result;
8498(AIThink)__receiver,(*mut i32)__out_0.as_mut_ptr(),(*mut i32)__out_1.as_mut_ptr(),(i32)::core::convert::Into::into(limit_x),(i32)::core::convert::Into::into(limit_z),(i32)::core::convert::Into::into(limit_distance))
8499 };
8500 (__ret, __out_0.assume_init(), __out_1.assume_init())
8501 }
8502 }
8503 #[doc = "`EngageHealToCountTarget(crate::app::unit::Unit, crate::app::skilldata::SkillData)` overload"]
8504 fn engage_heal_to_count_target(
8505 self,
8506 actor: impl ::core::convert::Into<crate::app::unit::Unit>,
8507 engage_attack: impl ::core::convert::Into<crate::app::skilldata::SkillData>,
8508 ) -> i32 {
8509 unsafe {
8510 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8511 ::unity::il2cpp_call!((::unity::module_base()+0x195d2e0usize)as*mut u8,i32;
8512(AIThink)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(actor),(crate::app::skilldata::SkillData)::core::convert::Into::into(engage_attack))
8513 }
8514 }
8515 #[doc = "`EngageVisionTo(bool)` overload"]
8516 fn engage_vision_to(self, is_entrust: impl ::core::convert::Into<bool>) -> crate::app::aithink::AIThink_Result {
8517 unsafe {
8518 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8519 ::unity::il2cpp_call!((::unity::module_base()+0x194a160usize)as*mut u8,crate::app::aithink::AIThink_Result;
8520(AIThink)__receiver,(bool)::core::convert::Into::into(is_entrust))
8521 }
8522 }
8523 #[doc = "`EngageSupportTo(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue, crate::app::skilldata::SkillData)` overload"]
8524 fn engage_support_to(
8525 self,
8526 command: impl ::core::convert::Into<i32>,
8527 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
8528 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
8529 command_skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>,
8530 ) -> crate::app::aithink::AIThink_Result {
8531 unsafe {
8532 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8533 ::unity::il2cpp_call!((::unity::module_base()+0x195d4d0usize)as*mut u8,crate::app::aithink::AIThink_Result;
8534(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1),(crate::app::skilldata::SkillData)::core::convert::Into::into(command_skill))
8535 }
8536 }
8537 #[doc = "`EngageSupportToCommon(crate::app::skilldata::SkillData)` overload"]
8538 fn engage_support_to_common(
8539 self,
8540 command_skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>,
8541 ) -> crate::app::aithink::AIThink_Result {
8542 unsafe {
8543 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8544 ::unity::il2cpp_call!((::unity::module_base()+0x195d520usize)as*mut u8,crate::app::aithink::AIThink_Result;
8545(AIThink)__receiver,(crate::app::skilldata::SkillData)::core::convert::Into::into(command_skill))
8546 }
8547 }
8548 #[doc = "`EngagePullBackTo(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue, crate::app::skilldata::SkillData)` overload"]
8549 fn engage_pull_back_to(
8550 self,
8551 command: impl ::core::convert::Into<i32>,
8552 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
8553 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
8554 command_skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>,
8555 ) -> crate::app::aithink::AIThink_Result {
8556 unsafe {
8557 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8558 ::unity::il2cpp_call!((::unity::module_base()+0x195d840usize)as*mut u8,crate::app::aithink::AIThink_Result;
8559(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1),(crate::app::skilldata::SkillData)::core::convert::Into::into(command_skill))
8560 }
8561 }
8562 #[doc = "`EngagePullBackToCommon(crate::app::skilldata::SkillData)` overload"]
8563 fn engage_pull_back_to_common(
8564 self,
8565 command_skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>,
8566 ) -> crate::app::aithink::AIThink_Result {
8567 unsafe {
8568 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8569 ::unity::il2cpp_call!((::unity::module_base()+0x195d850usize)as*mut u8,crate::app::aithink::AIThink_Result;
8570(AIThink)__receiver,(crate::app::skilldata::SkillData)::core::convert::Into::into(command_skill))
8571 }
8572 }
8573 #[doc = "`EngageTo(bool)` overload"]
8574 fn engage_to(self, is_entrust: impl ::core::convert::Into<bool>) -> crate::app::aithink::AIThink_Result {
8575 unsafe {
8576 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8577 ::unity::il2cpp_call!((::unity::module_base()+0x195db80usize)as*mut u8,crate::app::aithink::AIThink_Result;
8578(AIThink)__receiver,(bool)::core::convert::Into::into(is_entrust))
8579 }
8580 }
8581 #[doc = "`GodChangeTo()` overload"]
8582 fn god_change_to(self) -> crate::app::aithink::AIThink_Result {
8583 unsafe {
8584 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8585 ::unity::il2cpp_call!((::unity::module_base()+0x195dee0usize)as*mut u8,crate::app::aithink::AIThink_Result;
8586(AIThink)__receiver)
8587 }
8588 }
8589 #[doc = "`IsEngagePermission(i32, i32)` overload"]
8590 fn is_engage_permission(self, prohibit_min: impl ::core::convert::Into<i32>, prohibit_max: impl ::core::convert::Into<i32>) -> bool {
8591 unsafe {
8592 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8593 ::unity::il2cpp_call!((::unity::module_base()+0x195b660usize)as*mut u8,bool;
8594(AIThink)__receiver,(i32)::core::convert::Into::into(prohibit_min),(i32)::core::convert::Into::into(prohibit_max))
8595 }
8596 }
8597 #[doc = "`DecideToProhibitEngage(i32, i32)` overload"]
8598 fn decide_to_prohibit_engage(self, min: impl ::core::convert::Into<i32>, max: impl ::core::convert::Into<i32>) -> () {
8599 unsafe {
8600 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8601 ::unity::il2cpp_call!((::unity::module_base()+0x195bd10usize)as*mut u8,();
8602(AIThink)__receiver,(i32)::core::convert::Into::into(min),(i32)::core::convert::Into::into(max))
8603 }
8604 }
8605 #[doc = "`MoveTo(i32, i32, i32)` overload"]
8606 fn move_to(
8607 self,
8608 xx: impl ::core::convert::Into<i32>,
8609 zz: impl ::core::convert::Into<i32>,
8610 flag: impl ::core::convert::Into<i32>,
8611 ) -> crate::app::aithink::AIThink_Result {
8612 unsafe {
8613 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8614 ::unity::il2cpp_call!((::unity::module_base()+0x1948e20usize)as*mut u8,crate::app::aithink::AIThink_Result;
8615(AIThink)__receiver,(i32)::core::convert::Into::into(xx),(i32)::core::convert::Into::into(zz),(i32)::core::convert::Into::into(flag))
8616 }
8617 }
8618 #[doc = "`ToBreak(i32, i32)` overload"]
8619 fn to_break(self, x: impl ::core::convert::Into<i32>, z: impl ::core::convert::Into<i32>) -> bool {
8620 unsafe {
8621 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8622 ::unity::il2cpp_call!((::unity::module_base()+0x195e880usize)as*mut u8,bool;
8623(AIThink)__receiver,(i32)::core::convert::Into::into(x),(i32)::core::convert::Into::into(z))
8624 }
8625 }
8626 #[doc = "`ToDoor(i32, i32)` overload"]
8627 fn to_door(self, x: impl ::core::convert::Into<i32>, z: impl ::core::convert::Into<i32>) -> bool {
8628 unsafe {
8629 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8630 ::unity::il2cpp_call!((::unity::module_base()+0x195ec40usize)as*mut u8,bool;
8631(AIThink)__receiver,(i32)::core::convert::Into::into(x),(i32)::core::convert::Into::into(z))
8632 }
8633 }
8634 #[doc = "`ToBlock(i32, i32, bool)` overload"]
8635 fn to_block(self, x: impl ::core::convert::Into<i32>, z: impl ::core::convert::Into<i32>, is_entrust: impl ::core::convert::Into<bool>) -> bool {
8636 unsafe {
8637 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8638 ::unity::il2cpp_call!((::unity::module_base()+0x195e560usize)as*mut u8,bool;
8639(AIThink)__receiver,(i32)::core::convert::Into::into(x),(i32)::core::convert::Into::into(z),(bool)::core::convert::Into::into(is_entrust))
8640 }
8641 }
8642 #[doc = "`EachBlock(crate::app::unit::Unit, crate::app::mapfor::MapFor_DestroyFunction)` overload"]
8643 fn each_block(
8644 self,
8645 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
8646 func: impl ::core::convert::Into<crate::app::mapfor::MapFor_DestroyFunction>,
8647 ) -> () {
8648 unsafe {
8649 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8650 ::unity::il2cpp_call!((::unity::module_base()+0x195f160usize)as*mut u8,();
8651(AIThink)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(unit),(crate::app::mapfor::MapFor_DestroyFunction)::core::convert::Into::into(func))
8652 }
8653 }
8654 #[doc = "`EachBlockForEntrust(crate::app::unit::Unit, crate::app::mapfor::MapFor_DestroyFunction)` overload"]
8655 fn each_block_for_entrust(
8656 self,
8657 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
8658 func: impl ::core::convert::Into<crate::app::mapfor::MapFor_DestroyFunction>,
8659 ) -> () {
8660 unsafe {
8661 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8662 ::unity::il2cpp_call!((::unity::module_base()+0x195ef00usize)as*mut u8,();
8663(AIThink)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(unit),(crate::app::mapfor::MapFor_DestroyFunction)::core::convert::Into::into(func))
8664 }
8665 }
8666 #[doc = "`IsMoveNear(i32, i32)` overload"]
8667 fn is_move_near(self, xx: impl ::core::convert::Into<i32>, zz: impl ::core::convert::Into<i32>) -> bool {
8668 unsafe {
8669 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8670 ::unity::il2cpp_call!((::unity::module_base()+0x195e350usize)as*mut u8,bool;
8671(AIThink)__receiver,(i32)::core::convert::Into::into(xx),(i32)::core::convert::Into::into(zz))
8672 }
8673 }
8674 #[doc = "`CheckMoveTargetWithAttack(crate::app::unit::Unit)` overload"]
8675 fn check_move_target_with_attack(self, target: impl ::core::convert::Into<crate::app::unit::Unit>) -> bool {
8676 unsafe {
8677 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8678 ::unity::il2cpp_call!((::unity::module_base()+0x195fa90usize)as*mut u8,bool;
8679(AIThink)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(target))
8680 }
8681 }
8682 #[doc = "`GetSidePosition(i32, i32, *muti32, *muti32)` overload"]
8683 fn get_side_position(self, target_x: impl ::core::convert::Into<i32>, target_z: impl ::core::convert::Into<i32>) -> (bool, i32, i32) {
8684 unsafe {
8685 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8686 let mut __out_0 = ::core::mem::MaybeUninit::<i32>::uninit();
8687 let mut __out_1 = ::core::mem::MaybeUninit::<i32>::uninit();
8688 let __ret = {
8689 ::unity::il2cpp_call!((::unity::module_base()+0x195fc80usize)as*mut u8,bool;
8690(AIThink)__receiver,(i32)::core::convert::Into::into(target_x),(i32)::core::convert::Into::into(target_z),(*mut i32)__out_0.as_mut_ptr(),(*mut i32)__out_1.as_mut_ptr())
8691 };
8692 (__ret, __out_0.assume_init(), __out_1.assume_init())
8693 }
8694 }
8695 #[doc = "`IsEscapePosition(i32, i32)` overload"]
8696 fn is_escape_position(self, x: impl ::core::convert::Into<i32>, z: impl ::core::convert::Into<i32>) -> bool {
8697 unsafe {
8698 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8699 ::unity::il2cpp_call!((::unity::module_base()+0x195fdf0usize)as*mut u8,bool;
8700(AIThink)__receiver,(i32)::core::convert::Into::into(x),(i32)::core::convert::Into::into(z))
8701 }
8702 }
8703 #[doc = "`GetMovePowerSlow()` overload"]
8704 fn get_move_power_slow(self) -> i32 {
8705 unsafe {
8706 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8707 ::unity::il2cpp_call!((::unity::module_base()+0x194b710usize)as*mut u8,i32;
8708(AIThink)__receiver)
8709 }
8710 }
8711 #[doc = "`GetMovePower(crate::app::unit::Unit, i32)` overload"]
8712 fn get_move_power(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>, factor: impl ::core::convert::Into<i32>) -> i32 {
8713 unsafe {
8714 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8715 ::unity::il2cpp_call!((::unity::module_base()+0x1943f70usize)as*mut u8,i32;
8716(AIThink)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(unit),(i32)::core::convert::Into::into(factor))
8717 }
8718 }
8719 #[doc = "`IsNotMove()` overload"]
8720 fn is_not_move(self) -> bool {
8721 unsafe {
8722 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8723 ::unity::il2cpp_call!((::unity::module_base()+0x193b8b0usize)as*mut u8,bool;
8724(AIThink)__receiver)
8725 }
8726 }
8727 #[doc = "`CommandSkillOverlapTo(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue, crate::app::skilldata::SkillData)` overload"]
8728 fn command_skill_overlap_to(
8729 self,
8730 command: impl ::core::convert::Into<i32>,
8731 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
8732 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
8733 command_skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>,
8734 ) -> crate::app::aithink::AIThink_Result {
8735 unsafe {
8736 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8737 ::unity::il2cpp_call!((::unity::module_base()+0x19537b0usize)as*mut u8,crate::app::aithink::AIThink_Result;
8738(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1),(crate::app::skilldata::SkillData)::core::convert::Into::into(command_skill))
8739 }
8740 }
8741 #[doc = "`CommandSkillOverlapToCommon(crate::app::skilldata::SkillData)` overload"]
8742 fn command_skill_overlap_to_common(
8743 self,
8744 command_skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>,
8745 ) -> crate::app::aithink::AIThink_Result {
8746 unsafe {
8747 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8748 ::unity::il2cpp_call!((::unity::module_base()+0x1960190usize)as*mut u8,crate::app::aithink::AIThink_Result;
8749(AIThink)__receiver,(crate::app::skilldata::SkillData)::core::convert::Into::into(command_skill))
8750 }
8751 }
8752 #[doc = "`CheckDirForOverlap(i32, i32, i32, i32, ::unity::Array<crate::app::unit::Unit>)` overload"]
8753 fn check_dir_for_overlap(
8754 self,
8755 x0: impl ::core::convert::Into<i32>,
8756 z0: impl ::core::convert::Into<i32>,
8757 x1: impl ::core::convert::Into<i32>,
8758 z1: impl ::core::convert::Into<i32>,
8759 units: impl ::core::convert::Into<::unity::Array<crate::app::unit::Unit>>,
8760 ) -> bool {
8761 unsafe {
8762 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8763 ::unity::il2cpp_call!((::unity::module_base()+0x1960a70usize)as*mut u8,bool;
8764(AIThink)__receiver,(i32)::core::convert::Into::into(x0),(i32)::core::convert::Into::into(z0),(i32)::core::convert::Into::into(x1),(i32)::core::convert::Into::into(z1),(::unity::Array<crate::app::unit::Unit>)::core::convert::Into::into(units))
8765 }
8766 }
8767 #[doc = "`IsPositiveOverlap(crate::app::skilldata::SkillData)` overload"]
8768 fn is_positive_overlap(self, skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>) -> bool {
8769 unsafe {
8770 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8771 ::unity::il2cpp_call!((::unity::module_base()+0x19608a0usize)as*mut u8,bool;
8772(AIThink)__receiver,(crate::app::skilldata::SkillData)::core::convert::Into::into(skill))
8773 }
8774 }
8775 #[doc = "`IsHealOverlap(crate::app::skilldata::SkillData)` overload"]
8776 fn is_heal_overlap(self, skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>) -> bool {
8777 unsafe {
8778 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8779 ::unity::il2cpp_call!((::unity::module_base()+0x19609c0usize)as*mut u8,bool;
8780(AIThink)__receiver,(crate::app::skilldata::SkillData)::core::convert::Into::into(skill))
8781 }
8782 }
8783 #[doc = "`UpdateTargetOne(crate::app::unit::Unit)` overload"]
8784 fn update_target_one(self, actor: impl ::core::convert::Into<crate::app::unit::Unit>) -> () {
8785 unsafe {
8786 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8787 ::unity::il2cpp_call!((::unity::module_base()+0x1960af0usize)as*mut u8,();
8788(AIThink)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(actor))
8789 }
8790 }
8791 #[doc = "`Caution(bool, bool, bool, bool)` overload"]
8792 fn caution(
8793 self,
8794 is_more_caution: impl ::core::convert::Into<bool>,
8795 is_remove: impl ::core::convert::Into<bool>,
8796 is_chain_guard: impl ::core::convert::Into<bool>,
8797 is_ignore_engage_attack: impl ::core::convert::Into<bool>,
8798 ) -> () {
8799 unsafe {
8800 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8801 ::unity::il2cpp_call!((::unity::module_base()+0x1951c30usize)as*mut u8,();
8802(AIThink)__receiver,(bool)::core::convert::Into::into(is_more_caution),(bool)::core::convert::Into::into(is_remove),(bool)::core::convert::Into::into(is_chain_guard),(bool)::core::convert::Into::into(is_ignore_engage_attack))
8803 }
8804 }
8805 #[doc = "`GetCautionInfo(crate::app::unit::Unit, i32, crate::app::unititem::UnitItem, crate::app::skilldata::SkillData, crate::app::aibattlesimulator::AIBattleSimulator, bool, *muti32, *muti32, *muti32, *muti32)` overload"]
8806 fn get_caution_info(
8807 self,
8808 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
8809 item_index: impl ::core::convert::Into<i32>,
8810 unit_item: impl ::core::convert::Into<crate::app::unititem::UnitItem>,
8811 skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>,
8812 simulator: impl ::core::convert::Into<crate::app::aibattlesimulator::AIBattleSimulator>,
8813 is_remove: impl ::core::convert::Into<bool>,
8814 ) -> (i32, i32, i32, i32) {
8815 unsafe {
8816 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8817 let mut __out_0 = ::core::mem::MaybeUninit::<i32>::uninit();
8818 let mut __out_1 = ::core::mem::MaybeUninit::<i32>::uninit();
8819 let mut __out_2 = ::core::mem::MaybeUninit::<i32>::uninit();
8820 let mut __out_3 = ::core::mem::MaybeUninit::<i32>::uninit();
8821 ::unity::il2cpp_call!((::unity::module_base()+0x1961000usize)as*mut u8,();
8822(AIThink)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(unit),(i32)::core::convert::Into::into(item_index),(crate::app::unititem::UnitItem)::core::convert::Into::into(unit_item),(crate::app::skilldata::SkillData)::core::convert::Into::into(skill),(crate::app::aibattlesimulator::AIBattleSimulator)::core::convert::Into::into(simulator),(bool)::core::convert::Into::into(is_remove),(*mut i32)__out_0.as_mut_ptr(),(*mut i32)__out_1.as_mut_ptr(),(*mut i32)__out_2.as_mut_ptr(),(*mut i32)__out_3.as_mut_ptr());
8823 (__out_0.assume_init(), __out_1.assume_init(), __out_2.assume_init(), __out_3.assume_init())
8824 }
8825 }
8826 #[doc = "`DecideToProhibitedTurn(i32, i32, *muti32)` overload"]
8827 fn decide_to_prohibited_turn(self, min: impl ::core::convert::Into<i32>, max: impl ::core::convert::Into<i32>) -> i32 {
8828 unsafe {
8829 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8830 let mut __out_0 = ::core::mem::MaybeUninit::<i32>::uninit();
8831 ::unity::il2cpp_call!((::unity::module_base()+0x1957bd0usize)as*mut u8,();
8832(AIThink)__receiver,(i32)::core::convert::Into::into(min),(i32)::core::convert::Into::into(max),(*mut i32)__out_0.as_mut_ptr());
8833 __out_0.assume_init()
8834 }
8835 }
8836 #[doc = "`DbgPatchVersionCheck()` overload"]
8837 fn dbg_patch_version_check(self) -> () {
8838 unsafe {
8839 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8840 ::unity::il2cpp_call!((::unity::module_base()+0x19612a0usize)as*mut u8,();
8841(AIThink)__receiver)
8842 }
8843 }
8844 #[doc = "`ActionEngageBless(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
8845 fn action_engage_bless(
8846 self,
8847 command: impl ::core::convert::Into<i32>,
8848 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
8849 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
8850 ) -> crate::app::aithink::AIThink_Result {
8851 unsafe {
8852 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8853 ::unity::il2cpp_call!((::unity::module_base()+0x19612c0usize)as*mut u8,crate::app::aithink::AIThink_Result;
8854(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
8855 }
8856 }
8857 #[doc = "`EngageBlessTo(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
8858 fn engage_bless_to(
8859 self,
8860 command: impl ::core::convert::Into<i32>,
8861 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
8862 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
8863 ) -> crate::app::aithink::AIThink_Result {
8864 unsafe {
8865 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8866 ::unity::il2cpp_call!((::unity::module_base()+0x19612d0usize)as*mut u8,crate::app::aithink::AIThink_Result;
8867(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
8868 }
8869 }
8870 #[doc = "`EngageBlessToCommon(i32, i32, i32, crate::app::persondata::PersonData)` overload"]
8871 fn engage_bless_to_common(
8872 self,
8873 limit_x: impl ::core::convert::Into<i32>,
8874 limit_z: impl ::core::convert::Into<i32>,
8875 limit_distance: impl ::core::convert::Into<i32>,
8876 person: impl ::core::convert::Into<crate::app::persondata::PersonData>,
8877 ) -> crate::app::aithink::AIThink_Result {
8878 unsafe {
8879 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8880 ::unity::il2cpp_call!((::unity::module_base()+0x19615d0usize)as*mut u8,crate::app::aithink::AIThink_Result;
8881(AIThink)__receiver,(i32)::core::convert::Into::into(limit_x),(i32)::core::convert::Into::into(limit_z),(i32)::core::convert::Into::into(limit_distance),(crate::app::persondata::PersonData)::core::convert::Into::into(person))
8882 }
8883 }
8884 #[doc = "`EngageBlessGetScore(i32, i32, crate::app::itemdata::ItemData, crate::app::unit::Unit, *mutbool)` overload"]
8885 fn engage_bless_get_score(
8886 self,
8887 move_x: impl ::core::convert::Into<i32>,
8888 move_z: impl ::core::convert::Into<i32>,
8889 engage_item: impl ::core::convert::Into<crate::app::itemdata::ItemData>,
8890 target: impl ::core::convert::Into<crate::app::unit::Unit>,
8891 ) -> (u32, bool) {
8892 unsafe {
8893 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8894 let mut __out_0 = ::core::mem::MaybeUninit::<bool>::uninit();
8895 let __ret = {
8896 ::unity::il2cpp_call!((::unity::module_base()+0x1961be0usize)as*mut u8,u32;
8897(AIThink)__receiver,(i32)::core::convert::Into::into(move_x),(i32)::core::convert::Into::into(move_z),(crate::app::itemdata::ItemData)::core::convert::Into::into(engage_item),(crate::app::unit::Unit)::core::convert::Into::into(target),(*mut bool)__out_0.as_mut_ptr())
8898 };
8899 (__ret, __out_0.assume_init())
8900 }
8901 }
8902 #[doc = "`ActionEngageWait(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
8903 fn action_engage_wait(
8904 self,
8905 command: impl ::core::convert::Into<i32>,
8906 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
8907 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
8908 ) -> crate::app::aithink::AIThink_Result {
8909 unsafe {
8910 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8911 ::unity::il2cpp_call!((::unity::module_base()+0x1961d40usize)as*mut u8,crate::app::aithink::AIThink_Result;
8912(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
8913 }
8914 }
8915 #[doc = "`EngageWaitTo(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
8916 fn engage_wait_to(
8917 self,
8918 command: impl ::core::convert::Into<i32>,
8919 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
8920 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
8921 ) -> crate::app::aithink::AIThink_Result {
8922 unsafe {
8923 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8924 ::unity::il2cpp_call!((::unity::module_base()+0x1961d50usize)as*mut u8,crate::app::aithink::AIThink_Result;
8925(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
8926 }
8927 }
8928 #[doc = "`EngageWaitToCommon(*muti32, *muti32, *muti32, i32, i32, i32)` overload"]
8929 fn engage_wait_to_common(
8930 self,
8931 limit_x: impl ::core::convert::Into<i32>,
8932 limit_z: impl ::core::convert::Into<i32>,
8933 limit_distance: impl ::core::convert::Into<i32>,
8934 ) -> (crate::app::aithink::AIThink_Result, i32, i32, i32) {
8935 unsafe {
8936 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8937 let mut __out_0 = ::core::mem::MaybeUninit::<i32>::uninit();
8938 let mut __out_1 = ::core::mem::MaybeUninit::<i32>::uninit();
8939 let mut __out_2 = ::core::mem::MaybeUninit::<i32>::uninit();
8940 let __ret = {
8941 ::unity::il2cpp_call!((::unity::module_base()+0x19621c0usize)as*mut u8,crate::app::aithink::AIThink_Result;
8942(AIThink)__receiver,(*mut i32)__out_0.as_mut_ptr(),(*mut i32)__out_1.as_mut_ptr(),(*mut i32)__out_2.as_mut_ptr(),(i32)::core::convert::Into::into(limit_x),(i32)::core::convert::Into::into(limit_z),(i32)::core::convert::Into::into(limit_distance))
8943 };
8944 (__ret, __out_0.assume_init(), __out_1.assume_init(), __out_2.assume_init())
8945 }
8946 }
8947 #[doc = "`EngageWaitCalcAdditionalAttackImage()` overload"]
8948 fn engage_wait_calc_additional_attack_image(self) -> () {
8949 unsafe {
8950 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8951 ::unity::il2cpp_call!((::unity::module_base()+0x1962e80usize)as*mut u8,();
8952(AIThink)__receiver)
8953 }
8954 }
8955 #[doc = "`EngageWaitGetScore(i32, i32, i32, bool)` overload"]
8956 fn engage_wait_get_score(
8957 self,
8958 x: impl ::core::convert::Into<i32>,
8959 z: impl ::core::convert::Into<i32>,
8960 hp: impl ::core::convert::Into<i32>,
8961 is_range1: impl ::core::convert::Into<bool>,
8962 ) -> u32 {
8963 unsafe {
8964 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8965 ::unity::il2cpp_call!((::unity::module_base()+0x19630a0usize)as*mut u8,u32;
8966(AIThink)__receiver,(i32)::core::convert::Into::into(x),(i32)::core::convert::Into::into(z),(i32)::core::convert::Into::into(hp),(bool)::core::convert::Into::into(is_range1))
8967 }
8968 }
8969 #[doc = "`ActionEngageSummon(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
8970 fn action_engage_summon(
8971 self,
8972 command: impl ::core::convert::Into<i32>,
8973 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
8974 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
8975 ) -> crate::app::aithink::AIThink_Result {
8976 unsafe {
8977 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8978 ::unity::il2cpp_call!((::unity::module_base()+0x19631d0usize)as*mut u8,crate::app::aithink::AIThink_Result;
8979(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
8980 }
8981 }
8982 #[doc = "`EngageSummonTo(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
8983 fn engage_summon_to(
8984 self,
8985 command: impl ::core::convert::Into<i32>,
8986 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
8987 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
8988 ) -> crate::app::aithink::AIThink_Result {
8989 unsafe {
8990 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8991 ::unity::il2cpp_call!((::unity::module_base()+0x19631e0usize)as*mut u8,crate::app::aithink::AIThink_Result;
8992(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
8993 }
8994 }
8995 #[doc = "`EngageSummonToCommon(*muti32, *muti32, *mutcrate::app::persondata::PersonData_Colors, i32, i32, i32)` overload"]
8996 fn engage_summon_to_common(
8997 self,
8998 limit_x: impl ::core::convert::Into<i32>,
8999 limit_z: impl ::core::convert::Into<i32>,
9000 limit_distance: impl ::core::convert::Into<i32>,
9001 ) -> (crate::app::aithink::AIThink_Result, i32, i32, crate::app::persondata::PersonData_Colors) {
9002 unsafe {
9003 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9004 let mut __out_0 = ::core::mem::MaybeUninit::<i32>::uninit();
9005 let mut __out_1 = ::core::mem::MaybeUninit::<i32>::uninit();
9006 let mut __out_2 = ::core::mem::MaybeUninit::<crate::app::persondata::PersonData_Colors>::uninit();
9007 let __ret = {
9008 ::unity::il2cpp_call!((::unity::module_base()+0x1963550usize)as*mut u8,crate::app::aithink::AIThink_Result;
9009(AIThink)__receiver,(*mut i32)__out_0.as_mut_ptr(),(*mut i32)__out_1.as_mut_ptr(),(*mut crate::app::persondata::PersonData_Colors)__out_2.as_mut_ptr(),(i32)::core::convert::Into::into(limit_x),(i32)::core::convert::Into::into(limit_z),(i32)::core::convert::Into::into(limit_distance))
9010 };
9011 (__ret, __out_0.assume_init(), __out_1.assume_init(), __out_2.assume_init())
9012 }
9013 }
9014 #[doc = "`EngageSummonDecideColor()` overload"]
9015 fn engage_summon_decide_color(self) -> crate::app::persondata::PersonData_Colors {
9016 unsafe {
9017 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9018 ::unity::il2cpp_call!((::unity::module_base()+0x1963950usize)as*mut u8,crate::app::persondata::PersonData_Colors;
9019(AIThink)__receiver)
9020 }
9021 }
9022 #[doc = "`EngageSummonWeapon2Color(crate::app::unit::Unit, i32, *mutcrate::app::persondata::PersonData_Colors)` overload"]
9023 fn engage_summon_weapon2_color(
9024 self,
9025 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
9026 item_index: impl ::core::convert::Into<i32>,
9027 ) -> (bool, crate::app::persondata::PersonData_Colors) {
9028 unsafe {
9029 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9030 let mut __out_0 = ::core::mem::MaybeUninit::<crate::app::persondata::PersonData_Colors>::uninit();
9031 let __ret = {
9032 ::unity::il2cpp_call!((::unity::module_base()+0x1963ad0usize)as*mut u8,bool;
9033(AIThink)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(unit),(i32)::core::convert::Into::into(item_index),(*mut crate::app::persondata::PersonData_Colors)__out_0.as_mut_ptr())
9034 };
9035 (__ret, __out_0.assume_init())
9036 }
9037 }
9038 #[doc = "`ActionEngageOverlap(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
9039 fn action_engage_overlap(
9040 self,
9041 command: impl ::core::convert::Into<i32>,
9042 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
9043 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
9044 ) -> crate::app::aithink::AIThink_Result {
9045 unsafe {
9046 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9047 ::unity::il2cpp_call!((::unity::module_base()+0x1964090usize)as*mut u8,crate::app::aithink::AIThink_Result;
9048(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
9049 }
9050 }
9051 #[doc = "`EngageOverlapTo(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
9052 fn engage_overlap_to(
9053 self,
9054 command: impl ::core::convert::Into<i32>,
9055 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
9056 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
9057 ) -> crate::app::aithink::AIThink_Result {
9058 unsafe {
9059 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9060 ::unity::il2cpp_call!((::unity::module_base()+0x19640a0usize)as*mut u8,crate::app::aithink::AIThink_Result;
9061(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
9062 }
9063 }
9064 #[doc = "`EngageOverlapToCommon(*muti32, *muti32, i32, i32, i32)` overload"]
9065 fn engage_overlap_to_common(
9066 self,
9067 limit_x: impl ::core::convert::Into<i32>,
9068 limit_z: impl ::core::convert::Into<i32>,
9069 limit_distance: impl ::core::convert::Into<i32>,
9070 ) -> (crate::app::aithink::AIThink_Result, i32, i32) {
9071 unsafe {
9072 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9073 let mut __out_0 = ::core::mem::MaybeUninit::<i32>::uninit();
9074 let mut __out_1 = ::core::mem::MaybeUninit::<i32>::uninit();
9075 let __ret = {
9076 ::unity::il2cpp_call!((::unity::module_base()+0x1964510usize)as*mut u8,crate::app::aithink::AIThink_Result;
9077(AIThink)__receiver,(*mut i32)__out_0.as_mut_ptr(),(*mut i32)__out_1.as_mut_ptr(),(i32)::core::convert::Into::into(limit_x),(i32)::core::convert::Into::into(limit_z),(i32)::core::convert::Into::into(limit_distance))
9078 };
9079 (__ret, __out_0.assume_init(), __out_1.assume_init())
9080 }
9081 }
9082 #[doc = "`ActionAttackBreath(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
9083 fn action_attack_breath(
9084 self,
9085 command: impl ::core::convert::Into<i32>,
9086 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
9087 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
9088 ) -> crate::app::aithink::AIThink_Result {
9089 unsafe {
9090 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9091 ::unity::il2cpp_call!((::unity::module_base()+0x1964930usize)as*mut u8,crate::app::aithink::AIThink_Result;
9092(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
9093 }
9094 }
9095 #[doc = "`ActionAttackBreathMiddleLow(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
9096 fn action_attack_breath_middle_low(
9097 self,
9098 command: impl ::core::convert::Into<i32>,
9099 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
9100 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
9101 ) -> crate::app::aithink::AIThink_Result {
9102 unsafe {
9103 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9104 ::unity::il2cpp_call!((::unity::module_base()+0x1964ba0usize)as*mut u8,crate::app::aithink::AIThink_Result;
9105(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
9106 }
9107 }
9108 #[doc = "`AttackBreathTo(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
9109 fn attack_breath_to(
9110 self,
9111 command: impl ::core::convert::Into<i32>,
9112 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
9113 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
9114 ) -> crate::app::aithink::AIThink_Result {
9115 unsafe {
9116 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9117 ::unity::il2cpp_call!((::unity::module_base()+0x1964950usize)as*mut u8,crate::app::aithink::AIThink_Result;
9118(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
9119 }
9120 }
9121 #[doc = "`ActionRodMagicShield(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
9122 fn action_rod_magic_shield(
9123 self,
9124 command: impl ::core::convert::Into<i32>,
9125 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
9126 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
9127 ) -> crate::app::aithink::AIThink_Result {
9128 unsafe {
9129 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9130 ::unity::il2cpp_call!((::unity::module_base()+0x1964bc0usize)as*mut u8,crate::app::aithink::AIThink_Result;
9131(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
9132 }
9133 }
9134 #[doc = "`MagicShieldFindIndex()` overload"]
9135 fn magic_shield_find_index(self) -> i32 {
9136 unsafe {
9137 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9138 ::unity::il2cpp_call!((::unity::module_base()+0x1964f60usize)as*mut u8,i32;
9139(AIThink)__receiver)
9140 }
9141 }
9142 #[doc = "`MagicShieldCalcUnitScore()` overload"]
9143 fn magic_shield_calc_unit_score(self) -> () {
9144 unsafe {
9145 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9146 ::unity::il2cpp_call!((::unity::module_base()+0x1965540usize)as*mut u8,();
9147(AIThink)__receiver)
9148 }
9149 }
9150 #[doc = "`MagicShieldCalcUnitScore(crate::app::unit::Unit)` overload"]
9151 fn magic_shield_calc_unit_score_2(self, target: impl ::core::convert::Into<crate::app::unit::Unit>) -> () {
9152 unsafe {
9153 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9154 ::unity::il2cpp_call!((::unity::module_base()+0x19656d0usize)as*mut u8,();
9155(AIThink)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(target))
9156 }
9157 }
9158 #[doc = "`ActionCommandSkillDecoy(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
9159 fn action_command_skill_decoy(
9160 self,
9161 command: impl ::core::convert::Into<i32>,
9162 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
9163 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
9164 ) -> crate::app::aithink::AIThink_Result {
9165 unsafe {
9166 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9167 ::unity::il2cpp_call!((::unity::module_base()+0x1966570usize)as*mut u8,crate::app::aithink::AIThink_Result;
9168(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
9169 }
9170 }
9171 #[doc = "`CommandSkillDecoyTo(crate::app::skilldata::SkillData, bool)` overload"]
9172 fn command_skill_decoy_to(
9173 self,
9174 command_skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>,
9175 is_entrust: impl ::core::convert::Into<bool>,
9176 ) -> crate::app::aithink::AIThink_Result {
9177 unsafe {
9178 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9179 ::unity::il2cpp_call!((::unity::module_base()+0x1966580usize)as*mut u8,crate::app::aithink::AIThink_Result;
9180(AIThink)__receiver,(crate::app::skilldata::SkillData)::core::convert::Into::into(command_skill),(bool)::core::convert::Into::into(is_entrust))
9181 }
9182 }
9183 #[doc = "`DecoyGetScore(crate::app::unit::Unit, bool)` overload"]
9184 fn decoy_get_score(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>, is_entrust: impl ::core::convert::Into<bool>) -> u32 {
9185 unsafe {
9186 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9187 ::unity::il2cpp_call!((::unity::module_base()+0x1966c80usize)as*mut u8,u32;
9188(AIThink)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(unit),(bool)::core::convert::Into::into(is_entrust))
9189 }
9190 }
9191 #[doc = "`ActionCommandSkillStrategy(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
9192 fn action_command_skill_strategy(
9193 self,
9194 command: impl ::core::convert::Into<i32>,
9195 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
9196 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
9197 ) -> crate::app::aithink::AIThink_Result {
9198 unsafe {
9199 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9200 ::unity::il2cpp_call!((::unity::module_base()+0x1967a20usize)as*mut u8,crate::app::aithink::AIThink_Result;
9201(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
9202 }
9203 }
9204 #[doc = "`CommandSkillStrategyHolyShield(crate::app::skilldata::SkillData, bool)` overload"]
9205 fn command_skill_strategy_holy_shield(
9206 self,
9207 command_skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>,
9208 is_entrust: impl ::core::convert::Into<bool>,
9209 ) -> crate::app::aithink::AIThink_Result {
9210 unsafe {
9211 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9212 ::unity::il2cpp_call!((::unity::module_base()+0x1967ca0usize)as*mut u8,crate::app::aithink::AIThink_Result;
9213(AIThink)__receiver,(crate::app::skilldata::SkillData)::core::convert::Into::into(command_skill),(bool)::core::convert::Into::into(is_entrust))
9214 }
9215 }
9216 #[doc = "`ActionCommandSkillTrimasteries(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
9217 fn action_command_skill_trimasteries(
9218 self,
9219 command: impl ::core::convert::Into<i32>,
9220 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
9221 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
9222 ) -> crate::app::aithink::AIThink_Result {
9223 unsafe {
9224 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9225 ::unity::il2cpp_call!((::unity::module_base()+0x1968950usize)as*mut u8,crate::app::aithink::AIThink_Result;
9226(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
9227 }
9228 }
9229 #[doc = "`CommandSkillTrimasteries(bool)` overload"]
9230 fn command_skill_trimasteries(self, is_entrust: impl ::core::convert::Into<bool>) -> crate::app::aithink::AIThink_Result {
9231 unsafe {
9232 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9233 ::unity::il2cpp_call!((::unity::module_base()+0x1968b30usize)as*mut u8,crate::app::aithink::AIThink_Result;
9234(AIThink)__receiver,(bool)::core::convert::Into::into(is_entrust))
9235 }
9236 }
9237 #[doc = "`TrimasteriesCanKill(f32, f32)` overload"]
9238 fn trimasteries_can_kill(self, kill_rate: impl ::core::convert::Into<f32>, dead_rate: impl ::core::convert::Into<f32>) -> bool {
9239 unsafe {
9240 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9241 ::unity::il2cpp_call!((::unity::module_base()+0x1969510usize)as*mut u8,bool;
9242(AIThink)__receiver,(f32)::core::convert::Into::into(kill_rate),(f32)::core::convert::Into::into(dead_rate))
9243 }
9244 }
9245 #[doc = "`TrimasteriesCountKillEnemies()` overload"]
9246 fn trimasteries_count_kill_enemies(self) -> i32 {
9247 unsafe {
9248 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9249 ::unity::il2cpp_call!((::unity::module_base()+0x1968d90usize)as*mut u8,i32;
9250(AIThink)__receiver)
9251 }
9252 }
9253 #[doc = "`TrimasteriesThink(crate::app::skilldata::SkillData)` overload"]
9254 fn trimasteries_think(self, command_skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>) -> crate::app::aithink::AIThink_Result {
9255 unsafe {
9256 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9257 ::unity::il2cpp_call!((::unity::module_base()+0x19690f0usize)as*mut u8,crate::app::aithink::AIThink_Result;
9258(AIThink)__receiver,(crate::app::skilldata::SkillData)::core::convert::Into::into(command_skill))
9259 }
9260 }
9261 #[doc = "`EntrustTrimasteriesCountKillEnemies()` overload"]
9262 fn entrust_trimasteries_count_kill_enemies(self) -> i32 {
9263 unsafe {
9264 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9265 ::unity::il2cpp_call!((::unity::module_base()+0x1968f70usize)as*mut u8,i32;
9266(AIThink)__receiver)
9267 }
9268 }
9269 #[doc = "`EntrustTrimasteriesThink(crate::app::skilldata::SkillData)` overload"]
9270 fn entrust_trimasteries_think(
9271 self,
9272 command_skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>,
9273 ) -> crate::app::aithink::AIThink_Result {
9274 unsafe {
9275 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9276 ::unity::il2cpp_call!((::unity::module_base()+0x1969350usize)as*mut u8,crate::app::aithink::AIThink_Result;
9277(AIThink)__receiver,(crate::app::skilldata::SkillData)::core::convert::Into::into(command_skill))
9278 }
9279 }
9280 #[doc = "`EntrustTrimasteriesDeploy(crate::app::skilldata::SkillData)` overload"]
9281 fn entrust_trimasteries_deploy(self, command_skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>) -> () {
9282 unsafe {
9283 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9284 ::unity::il2cpp_call!((::unity::module_base()+0x1969540usize)as*mut u8,();
9285(AIThink)__receiver,(crate::app::skilldata::SkillData)::core::convert::Into::into(command_skill))
9286 }
9287 }
9288 #[doc = "`ActionCommandSkillContract(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
9289 fn action_command_skill_contract(
9290 self,
9291 command: impl ::core::convert::Into<i32>,
9292 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
9293 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
9294 ) -> crate::app::aithink::AIThink_Result {
9295 unsafe {
9296 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9297 ::unity::il2cpp_call!((::unity::module_base()+0x1969920usize)as*mut u8,crate::app::aithink::AIThink_Result;
9298(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
9299 }
9300 }
9301 #[doc = "`CommandSkillContractTo(crate::app::skilldata::SkillData, bool)` overload"]
9302 fn command_skill_contract_to(
9303 self,
9304 command_skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>,
9305 is_entrust: impl ::core::convert::Into<bool>,
9306 ) -> crate::app::aithink::AIThink_Result {
9307 unsafe {
9308 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9309 ::unity::il2cpp_call!((::unity::module_base()+0x1969a90usize)as*mut u8,crate::app::aithink::AIThink_Result;
9310(AIThink)__receiver,(crate::app::skilldata::SkillData)::core::convert::Into::into(command_skill),(bool)::core::convert::Into::into(is_entrust))
9311 }
9312 }
9313 #[doc = "`ContractGetBattleScore(crate::app::unit::Unit)` overload"]
9314 fn contract_get_battle_score(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> u32 {
9315 unsafe {
9316 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9317 ::unity::il2cpp_call!((::unity::module_base()+0x1969dc0usize)as*mut u8,u32;
9318(AIThink)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(unit))
9319 }
9320 }
9321 #[doc = "`ContractGetEntrustBattleScore(crate::app::unit::Unit)` overload"]
9322 fn contract_get_entrust_battle_score(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> u32 {
9323 unsafe {
9324 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9325 ::unity::il2cpp_call!((::unity::module_base()+0x196a180usize)as*mut u8,u32;
9326(AIThink)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(unit))
9327 }
9328 }
9329 #[doc = "`ActionCommandSkillYell(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
9330 fn action_command_skill_yell(
9331 self,
9332 command: impl ::core::convert::Into<i32>,
9333 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
9334 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
9335 ) -> crate::app::aithink::AIThink_Result {
9336 unsafe {
9337 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9338 ::unity::il2cpp_call!((::unity::module_base()+0x196a530usize)as*mut u8,crate::app::aithink::AIThink_Result;
9339(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
9340 }
9341 }
9342 #[doc = "`ActionCommandSkillGaze(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
9343 fn action_command_skill_gaze(
9344 self,
9345 command: impl ::core::convert::Into<i32>,
9346 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
9347 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
9348 ) -> crate::app::aithink::AIThink_Result {
9349 unsafe {
9350 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9351 ::unity::il2cpp_call!((::unity::module_base()+0x196a760usize)as*mut u8,crate::app::aithink::AIThink_Result;
9352(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
9353 }
9354 }
9355 #[doc = "`ActionCommandSkillFullBullet(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
9356 fn action_command_skill_full_bullet(
9357 self,
9358 command: impl ::core::convert::Into<i32>,
9359 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
9360 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
9361 ) -> crate::app::aithink::AIThink_Result {
9362 unsafe {
9363 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9364 ::unity::il2cpp_call!((::unity::module_base()+0x196afd0usize)as*mut u8,crate::app::aithink::AIThink_Result;
9365(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
9366 }
9367 }
9368 #[doc = "`CommandSkillFullBulletTo(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
9369 fn command_skill_full_bullet_to(
9370 self,
9371 command: impl ::core::convert::Into<i32>,
9372 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
9373 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
9374 ) -> crate::app::aithink::AIThink_Result {
9375 unsafe {
9376 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9377 ::unity::il2cpp_call!((::unity::module_base()+0x196bf30usize)as*mut u8,crate::app::aithink::AIThink_Result;
9378(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
9379 }
9380 }
9381 #[doc = "`FullBulletCanUse(crate::app::unit::Unit, crate::app::unititem::UnitItem, bool)` overload"]
9382 fn full_bullet_can_use(
9383 self,
9384 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
9385 unit_item: impl ::core::convert::Into<crate::app::unititem::UnitItem>,
9386 is_exclude_freeze: impl ::core::convert::Into<bool>,
9387 ) -> bool {
9388 unsafe {
9389 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9390 ::unity::il2cpp_call!((::unity::module_base()+0x196c9a0usize)as*mut u8,bool;
9391(AIThink)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(unit),(crate::app::unititem::UnitItem)::core::convert::Into::into(unit_item),(bool)::core::convert::Into::into(is_exclude_freeze))
9392 }
9393 }
9394 #[doc = "`FullBulletGetRangeBit(i32, bool, *mutu32, *mutu32)` overload"]
9395 fn full_bullet_get_range_bit(
9396 self,
9397 prior_item_index: impl ::core::convert::Into<i32>,
9398 is_exclude_freeze: impl ::core::convert::Into<bool>,
9399 ) -> (i32, u32, u32) {
9400 unsafe {
9401 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9402 let mut __out_0 = ::core::mem::MaybeUninit::<u32>::uninit();
9403 let mut __out_1 = ::core::mem::MaybeUninit::<u32>::uninit();
9404 let __ret = {
9405 ::unity::il2cpp_call!((::unity::module_base()+0x196b470usize)as*mut u8,i32;
9406(AIThink)__receiver,(i32)::core::convert::Into::into(prior_item_index),(bool)::core::convert::Into::into(is_exclude_freeze),(*mut u32)__out_0.as_mut_ptr(),(*mut u32)__out_1.as_mut_ptr())
9407 };
9408 (__ret, __out_0.assume_init(), __out_1.assume_init())
9409 }
9410 }
9411 #[doc = "`FullBulletGetItemRangeBit(i32, bool, *mutu32)` overload"]
9412 fn full_bullet_get_item_range_bit(
9413 self,
9414 item_index: impl ::core::convert::Into<i32>,
9415 is_exclude_freeze: impl ::core::convert::Into<bool>,
9416 ) -> (i32, u32) {
9417 unsafe {
9418 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9419 let mut __out_0 = ::core::mem::MaybeUninit::<u32>::uninit();
9420 let __ret = {
9421 ::unity::il2cpp_call!((::unity::module_base()+0x196cfa0usize)as*mut u8,i32;
9422(AIThink)__receiver,(i32)::core::convert::Into::into(item_index),(bool)::core::convert::Into::into(is_exclude_freeze),(*mut u32)__out_0.as_mut_ptr())
9423 };
9424 (__ret, __out_0.assume_init())
9425 }
9426 }
9427 #[doc = "`FullBulletDeploy(u32)` overload"]
9428 fn full_bullet_deploy(self, item_bit: impl ::core::convert::Into<u32>) -> () {
9429 unsafe {
9430 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9431 ::unity::il2cpp_call!((::unity::module_base()+0x196b890usize)as*mut u8,();
9432(AIThink)__receiver,(u32)::core::convert::Into::into(item_bit))
9433 }
9434 }
9435 #[doc = "`FullBulletGetMovePos(i32, i32, u32, u32, i32, bool, *muti32, *muti32, *muti32)` overload"]
9436 fn full_bullet_get_move_pos(
9437 self,
9438 target_x: impl ::core::convert::Into<i32>,
9439 target_z: impl ::core::convert::Into<i32>,
9440 item_bit: impl ::core::convert::Into<u32>,
9441 range_bit: impl ::core::convert::Into<u32>,
9442 max_range: impl ::core::convert::Into<i32>,
9443 is_exclude_freeze: impl ::core::convert::Into<bool>,
9444 ) -> (u32, i32, i32, i32) {
9445 unsafe {
9446 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9447 let mut __out_0 = ::core::mem::MaybeUninit::<i32>::uninit();
9448 let mut __out_1 = ::core::mem::MaybeUninit::<i32>::uninit();
9449 let mut __out_2 = ::core::mem::MaybeUninit::<i32>::uninit();
9450 let __ret = {
9451 ::unity::il2cpp_call!((::unity::module_base()+0x196bd90usize)as*mut u8,u32;
9452(AIThink)__receiver,(i32)::core::convert::Into::into(target_x),(i32)::core::convert::Into::into(target_z),(u32)::core::convert::Into::into(item_bit),(u32)::core::convert::Into::into(range_bit),(i32)::core::convert::Into::into(max_range),(bool)::core::convert::Into::into(is_exclude_freeze),(*mut i32)__out_0.as_mut_ptr(),(*mut i32)__out_1.as_mut_ptr(),(*mut i32)__out_2.as_mut_ptr())
9453 };
9454 (__ret, __out_0.assume_init(), __out_1.assume_init(), __out_2.assume_init())
9455 }
9456 }
9457 #[doc = "`FullBulletGetMovePosVersus(i32, i32, i32, u32, i32, bool, *muti32, *muti32)` overload"]
9458 fn full_bullet_get_move_pos_versus(
9459 self,
9460 target_x: impl ::core::convert::Into<i32>,
9461 target_z: impl ::core::convert::Into<i32>,
9462 item_index: impl ::core::convert::Into<i32>,
9463 range_bit: impl ::core::convert::Into<u32>,
9464 max_range: impl ::core::convert::Into<i32>,
9465 is_exclude_freeze: impl ::core::convert::Into<bool>,
9466 ) -> (u32, i32, i32) {
9467 unsafe {
9468 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9469 let mut __out_0 = ::core::mem::MaybeUninit::<i32>::uninit();
9470 let mut __out_1 = ::core::mem::MaybeUninit::<i32>::uninit();
9471 let __ret = {
9472 ::unity::il2cpp_call!((::unity::module_base()+0x196d150usize)as*mut u8,u32;
9473(AIThink)__receiver,(i32)::core::convert::Into::into(target_x),(i32)::core::convert::Into::into(target_z),(i32)::core::convert::Into::into(item_index),(u32)::core::convert::Into::into(range_bit),(i32)::core::convert::Into::into(max_range),(bool)::core::convert::Into::into(is_exclude_freeze),(*mut i32)__out_0.as_mut_ptr(),(*mut i32)__out_1.as_mut_ptr())
9474 };
9475 (__ret, __out_0.assume_init(), __out_1.assume_init())
9476 }
9477 }
9478 #[doc = "`FullBulletCanBeTarget(crate::app::unit::Unit)` overload"]
9479 fn full_bullet_can_be_target(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> bool {
9480 unsafe {
9481 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9482 ::unity::il2cpp_call!((::unity::module_base()+0x196d300usize)as*mut u8,bool;
9483(AIThink)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(unit))
9484 }
9485 }
9486 #[doc = "`ActionCommandSkillEnchant(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
9487 fn action_command_skill_enchant(
9488 self,
9489 command: impl ::core::convert::Into<i32>,
9490 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
9491 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
9492 ) -> crate::app::aithink::AIThink_Result {
9493 unsafe {
9494 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9495 ::unity::il2cpp_call!((::unity::module_base()+0x196d5a0usize)as*mut u8,crate::app::aithink::AIThink_Result;
9496(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
9497 }
9498 }
9499 #[doc = "`ActionCommandSkillEnchantHeal(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
9500 fn action_command_skill_enchant_heal(
9501 self,
9502 command: impl ::core::convert::Into<i32>,
9503 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
9504 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
9505 ) -> crate::app::aithink::AIThink_Result {
9506 unsafe {
9507 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9508 ::unity::il2cpp_call!((::unity::module_base()+0x196d6e0usize)as*mut u8,crate::app::aithink::AIThink_Result;
9509(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
9510 }
9511 }
9512 #[doc = "`CommandSkillEnchantTo(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
9513 fn command_skill_enchant_to(
9514 self,
9515 command: impl ::core::convert::Into<i32>,
9516 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
9517 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
9518 ) -> crate::app::aithink::AIThink_Result {
9519 unsafe {
9520 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9521 ::unity::il2cpp_call!((::unity::module_base()+0x196d640usize)as*mut u8,crate::app::aithink::AIThink_Result;
9522(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
9523 }
9524 }
9525 #[doc = "`CommandSkillEnchantHealTo(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
9526 fn command_skill_enchant_heal_to(
9527 self,
9528 command: impl ::core::convert::Into<i32>,
9529 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
9530 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
9531 ) -> crate::app::aithink::AIThink_Result {
9532 unsafe {
9533 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9534 ::unity::il2cpp_call!((::unity::module_base()+0x196d740usize)as*mut u8,crate::app::aithink::AIThink_Result;
9535(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
9536 }
9537 }
9538 #[doc = "`EntrustEnchant()` overload"]
9539 fn entrust_enchant(self) -> crate::app::aithink::AIThink_Result {
9540 unsafe {
9541 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9542 ::unity::il2cpp_call!((::unity::module_base()+0x196da80usize)as*mut u8,crate::app::aithink::AIThink_Result;
9543(AIThink)__receiver)
9544 }
9545 }
9546 #[doc = "`EntrustEnchantHeal()` overload"]
9547 fn entrust_enchant_heal(self) -> crate::app::aithink::AIThink_Result {
9548 unsafe {
9549 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9550 ::unity::il2cpp_call!((::unity::module_base()+0x196dc20usize)as*mut u8,crate::app::aithink::AIThink_Result;
9551(AIThink)__receiver)
9552 }
9553 }
9554 #[doc = "`CommandSkillEnchantToCommon(bool)` overload"]
9555 fn command_skill_enchant_to_common(self, is_entrust: impl ::core::convert::Into<bool>) -> crate::app::aithink::AIThink_Result {
9556 unsafe {
9557 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9558 ::unity::il2cpp_call!((::unity::module_base()+0x196d7a0usize)as*mut u8,crate::app::aithink::AIThink_Result;
9559(AIThink)__receiver,(bool)::core::convert::Into::into(is_entrust))
9560 }
9561 }
9562 #[doc = "`CommandSkillEnchantHealToCommon(bool)` overload"]
9563 fn command_skill_enchant_heal_to_common(self, is_entrust: impl ::core::convert::Into<bool>) -> crate::app::aithink::AIThink_Result {
9564 unsafe {
9565 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9566 ::unity::il2cpp_call!((::unity::module_base()+0x196d840usize)as*mut u8,crate::app::aithink::AIThink_Result;
9567(AIThink)__receiver,(bool)::core::convert::Into::into(is_entrust))
9568 }
9569 }
9570 #[doc = "`EnchantHealGetItemBit()` overload"]
9571 fn enchant_heal_get_item_bit(self) -> u32 {
9572 unsafe {
9573 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9574 ::unity::il2cpp_call!((::unity::module_base()+0x196dd50usize)as*mut u8,u32;
9575(AIThink)__receiver)
9576 }
9577 }
9578 #[doc = "`EnchantHealGetScore(i32, i32, i32, u32, *muti32)` overload"]
9579 fn enchant_heal_get_score(
9580 self,
9581 move_x: impl ::core::convert::Into<i32>,
9582 move_z: impl ::core::convert::Into<i32>,
9583 r#move: impl ::core::convert::Into<i32>,
9584 item_bit: impl ::core::convert::Into<u32>,
9585 ) -> (u32, i32) {
9586 unsafe {
9587 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9588 let mut __out_0 = ::core::mem::MaybeUninit::<i32>::uninit();
9589 let __ret = {
9590 ::unity::il2cpp_call!((::unity::module_base()+0x196e330usize)as*mut u8,u32;
9591(AIThink)__receiver,(i32)::core::convert::Into::into(move_x),(i32)::core::convert::Into::into(move_z),(i32)::core::convert::Into::into(r#move),(u32)::core::convert::Into::into(item_bit),(*mut i32)__out_0.as_mut_ptr())
9592 };
9593 (__ret, __out_0.assume_init())
9594 }
9595 }
9596 #[doc = "`EnchantHealUpdateHealCondition(i32, i32, i32)` overload"]
9597 fn enchant_heal_update_heal_condition(
9598 self,
9599 move_x: impl ::core::convert::Into<i32>,
9600 move_z: impl ::core::convert::Into<i32>,
9601 item_index: impl ::core::convert::Into<i32>,
9602 ) -> () {
9603 unsafe {
9604 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9605 ::unity::il2cpp_call!((::unity::module_base()+0x196e160usize)as*mut u8,();
9606(AIThink)__receiver,(i32)::core::convert::Into::into(move_x),(i32)::core::convert::Into::into(move_z),(i32)::core::convert::Into::into(item_index))
9607 }
9608 }
9609 #[doc = "`ProcessingEntrust()` overload"]
9610 fn processing_entrust(self) -> () {
9611 unsafe {
9612 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9613 ::unity::il2cpp_call!((::unity::module_base()+0x1924f00usize)as*mut u8,();
9614(AIThink)__receiver)
9615 }
9616 }
9617 #[doc = "`ProcessingEntrustRemove()` overload"]
9618 fn processing_entrust_remove(self) -> () {
9619 unsafe {
9620 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9621 ::unity::il2cpp_call!((::unity::module_base()+0x1925fb0usize)as*mut u8,();
9622(AIThink)__receiver)
9623 }
9624 }
9625 #[doc = "`ProcessingEntrustRemagic()` overload"]
9626 fn processing_entrust_remagic(self) -> () {
9627 unsafe {
9628 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9629 ::unity::il2cpp_call!((::unity::module_base()+0x1926150usize)as*mut u8,();
9630(AIThink)__receiver)
9631 }
9632 }
9633 #[doc = "`GetEntrustHero()` overload"]
9634 fn get_entrust_hero(self) -> crate::app::unit::Unit {
9635 unsafe {
9636 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9637 ::unity::il2cpp_call!((::unity::module_base()+0x19703d0usize)as*mut u8,crate::app::unit::Unit;
9638(AIThink)__receiver)
9639 }
9640 }
9641 #[doc = "`EntrustHeal()` overload"]
9642 fn entrust_heal(self) -> crate::app::aithink::AIThink_Result {
9643 unsafe {
9644 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9645 ::unity::il2cpp_call!((::unity::module_base()+0x196e790usize)as*mut u8,crate::app::aithink::AIThink_Result;
9646(AIThink)__receiver)
9647 }
9648 }
9649 #[doc = "`EntrustHealMindTo()` overload"]
9650 fn entrust_heal_mind_to(self) -> crate::app::aithink::AIThink_Result {
9651 unsafe {
9652 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9653 ::unity::il2cpp_call!((::unity::module_base()+0x19704e0usize)as*mut u8,crate::app::aithink::AIThink_Result;
9654(AIThink)__receiver)
9655 }
9656 }
9657 #[doc = "`EntrustHealMindToTerrain()` overload"]
9658 fn entrust_heal_mind_to_terrain(self) -> crate::app::aithink::AIThink_Result {
9659 unsafe {
9660 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9661 ::unity::il2cpp_call!((::unity::module_base()+0x1970ae0usize)as*mut u8,crate::app::aithink::AIThink_Result;
9662(AIThink)__receiver)
9663 }
9664 }
9665 #[doc = "`EntrustHealRod()` overload"]
9666 fn entrust_heal_rod(self) -> crate::app::aithink::AIThink_Result {
9667 unsafe {
9668 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9669 ::unity::il2cpp_call!((::unity::module_base()+0x1970680usize)as*mut u8,crate::app::aithink::AIThink_Result;
9670(AIThink)__receiver)
9671 }
9672 }
9673 #[doc = "`EntrustEngage()` overload"]
9674 fn entrust_engage(self) -> crate::app::aithink::AIThink_Result {
9675 unsafe {
9676 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9677 ::unity::il2cpp_call!((::unity::module_base()+0x196e810usize)as*mut u8,crate::app::aithink::AIThink_Result;
9678(AIThink)__receiver)
9679 }
9680 }
9681 #[doc = "`EntrustEngageAttack()` overload"]
9682 fn entrust_engage_attack(self) -> crate::app::aithink::AIThink_Result {
9683 unsafe {
9684 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9685 ::unity::il2cpp_call!((::unity::module_base()+0x196e870usize)as*mut u8,crate::app::aithink::AIThink_Result;
9686(AIThink)__receiver)
9687 }
9688 }
9689 #[doc = "`EntrustEngageHeal()` overload"]
9690 fn entrust_engage_heal(self) -> crate::app::aithink::AIThink_Result {
9691 unsafe {
9692 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9693 ::unity::il2cpp_call!((::unity::module_base()+0x196e6a0usize)as*mut u8,crate::app::aithink::AIThink_Result;
9694(AIThink)__receiver)
9695 }
9696 }
9697 #[doc = "`EntrustEngageAttackCheck()` overload"]
9698 fn entrust_engage_attack_check(self) -> bool {
9699 unsafe {
9700 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9701 ::unity::il2cpp_call!((::unity::module_base()+0x19710b0usize)as*mut u8,bool;
9702(AIThink)__receiver)
9703 }
9704 }
9705 #[doc = "`EntrustEngageAttackTo()` overload"]
9706 fn entrust_engage_attack_to(self) -> crate::app::aithink::AIThink_Result {
9707 unsafe {
9708 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9709 ::unity::il2cpp_call!((::unity::module_base()+0x19711c0usize)as*mut u8,crate::app::aithink::AIThink_Result;
9710(AIThink)__receiver)
9711 }
9712 }
9713 #[doc = "`EntrustEngagePierceTo()` overload"]
9714 fn entrust_engage_pierce_to(self) -> crate::app::aithink::AIThink_Result {
9715 unsafe {
9716 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9717 ::unity::il2cpp_call!((::unity::module_base()+0x1971630usize)as*mut u8,crate::app::aithink::AIThink_Result;
9718(AIThink)__receiver)
9719 }
9720 }
9721 #[doc = "`EntrustEngageChargeTo()` overload"]
9722 fn entrust_engage_charge_to(self) -> crate::app::aithink::AIThink_Result {
9723 unsafe {
9724 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9725 ::unity::il2cpp_call!((::unity::module_base()+0x19719d0usize)as*mut u8,crate::app::aithink::AIThink_Result;
9726(AIThink)__receiver)
9727 }
9728 }
9729 #[doc = "`EntrustEngageDanceTo()` overload"]
9730 fn entrust_engage_dance_to(self) -> crate::app::aithink::AIThink_Result {
9731 unsafe {
9732 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9733 ::unity::il2cpp_call!((::unity::module_base()+0x1971b40usize)as*mut u8,crate::app::aithink::AIThink_Result;
9734(AIThink)__receiver)
9735 }
9736 }
9737 #[doc = "`EntrustEngageHealTo()` overload"]
9738 fn entrust_engage_heal_to(self) -> crate::app::aithink::AIThink_Result {
9739 unsafe {
9740 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9741 ::unity::il2cpp_call!((::unity::module_base()+0x19722a0usize)as*mut u8,crate::app::aithink::AIThink_Result;
9742(AIThink)__receiver)
9743 }
9744 }
9745 #[doc = "`EntrustEngageBlessTo()` overload"]
9746 fn entrust_engage_bless_to(self) -> crate::app::aithink::AIThink_Result {
9747 unsafe {
9748 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9749 ::unity::il2cpp_call!((::unity::module_base()+0x1971c90usize)as*mut u8,crate::app::aithink::AIThink_Result;
9750(AIThink)__receiver)
9751 }
9752 }
9753 #[doc = "`EntrustEngageWaitTo()` overload"]
9754 fn entrust_engage_wait_to(self) -> crate::app::aithink::AIThink_Result {
9755 unsafe {
9756 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9757 ::unity::il2cpp_call!((::unity::module_base()+0x1971d30usize)as*mut u8,crate::app::aithink::AIThink_Result;
9758(AIThink)__receiver)
9759 }
9760 }
9761 #[doc = "`EntrustEngageSummonTo()` overload"]
9762 fn entrust_engage_summon_to(self) -> crate::app::aithink::AIThink_Result {
9763 unsafe {
9764 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9765 ::unity::il2cpp_call!((::unity::module_base()+0x1972140usize)as*mut u8,crate::app::aithink::AIThink_Result;
9766(AIThink)__receiver)
9767 }
9768 }
9769 #[doc = "`EntrustEngageOverlapTo()` overload"]
9770 fn entrust_engage_overlap_to(self) -> crate::app::aithink::AIThink_Result {
9771 unsafe {
9772 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9773 ::unity::il2cpp_call!((::unity::module_base()+0x1971f30usize)as*mut u8,crate::app::aithink::AIThink_Result;
9774(AIThink)__receiver)
9775 }
9776 }
9777 #[doc = "`EntrustGodSkill(i32)` overload"]
9778 fn entrust_god_skill(self, kind: impl ::core::convert::Into<i32>) -> crate::app::aithink::AIThink_Result {
9779 unsafe {
9780 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9781 ::unity::il2cpp_call!((::unity::module_base()+0x196eaa0usize)as*mut u8,crate::app::aithink::AIThink_Result;
9782(AIThink)__receiver,(i32)::core::convert::Into::into(kind))
9783 }
9784 }
9785 #[doc = "`EntrustCommandSkillOverlapTo(crate::app::skilldata::SkillData)` overload"]
9786 fn entrust_command_skill_overlap_to(
9787 self,
9788 command_skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>,
9789 ) -> crate::app::aithink::AIThink_Result {
9790 unsafe {
9791 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9792 ::unity::il2cpp_call!((::unity::module_base()+0x1972a90usize)as*mut u8,crate::app::aithink::AIThink_Result;
9793(AIThink)__receiver,(crate::app::skilldata::SkillData)::core::convert::Into::into(command_skill))
9794 }
9795 }
9796 #[doc = "`EntrustEngageSupportTo(crate::app::skilldata::SkillData)` overload"]
9797 fn entrust_engage_support_to(
9798 self,
9799 command_skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>,
9800 ) -> crate::app::aithink::AIThink_Result {
9801 unsafe {
9802 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9803 ::unity::il2cpp_call!((::unity::module_base()+0x1972ae0usize)as*mut u8,crate::app::aithink::AIThink_Result;
9804(AIThink)__receiver,(crate::app::skilldata::SkillData)::core::convert::Into::into(command_skill))
9805 }
9806 }
9807 #[doc = "`EntrustEngagePullBackTo(crate::app::skilldata::SkillData)` overload"]
9808 fn entrust_engage_pull_back_to(
9809 self,
9810 command_skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>,
9811 ) -> crate::app::aithink::AIThink_Result {
9812 unsafe {
9813 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9814 ::unity::il2cpp_call!((::unity::module_base()+0x1973050usize)as*mut u8,crate::app::aithink::AIThink_Result;
9815(AIThink)__receiver,(crate::app::skilldata::SkillData)::core::convert::Into::into(command_skill))
9816 }
9817 }
9818 #[doc = "`EntrustAttack()` overload"]
9819 fn entrust_attack(self) -> crate::app::aithink::AIThink_Result {
9820 unsafe {
9821 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9822 ::unity::il2cpp_call!((::unity::module_base()+0x196ecc0usize)as*mut u8,crate::app::aithink::AIThink_Result;
9823(AIThink)__receiver)
9824 }
9825 }
9826 #[doc = "`EntrustAttackTo(crate::app::skilldata::SkillData)` overload"]
9827 fn entrust_attack_to(self, command_skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>) -> crate::app::aithink::AIThink_Result {
9828 unsafe {
9829 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9830 ::unity::il2cpp_call!((::unity::module_base()+0x1972430usize)as*mut u8,crate::app::aithink::AIThink_Result;
9831(AIThink)__receiver,(crate::app::skilldata::SkillData)::core::convert::Into::into(command_skill))
9832 }
9833 }
9834 #[doc = "`EntrustSetAttackTargetToMind(*mutcrate::app::aithink::AIThink_EntrustAttackTarget, i32, crate::app::skilldata::SkillData)` overload"]
9835 fn entrust_set_attack_target_to_mind(
9836 self,
9837 item_index: impl ::core::convert::Into<i32>,
9838 command_skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>,
9839 ) -> crate::app::aithink::AIThink_EntrustAttackTarget {
9840 unsafe {
9841 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9842 let mut __out_0 = ::core::mem::MaybeUninit::<crate::app::aithink::AIThink_EntrustAttackTarget>::uninit();
9843 ::unity::il2cpp_call!((::unity::module_base()+0x1969740usize)as*mut u8,();
9844(AIThink)__receiver,(*mut crate::app::aithink::AIThink_EntrustAttackTarget)__out_0.as_mut_ptr(),(i32)::core::convert::Into::into(item_index),(crate::app::skilldata::SkillData)::core::convert::Into::into(command_skill));
9845 __out_0.assume_init()
9846 }
9847 }
9848 #[doc = "`EntrustMindFireCannon()` overload"]
9849 fn entrust_mind_fire_cannon(self) -> crate::app::aithink::AIThink_Result {
9850 unsafe {
9851 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9852 ::unity::il2cpp_call!((::unity::module_base()+0x196ed20usize)as*mut u8,crate::app::aithink::AIThink_Result;
9853(AIThink)__receiver)
9854 }
9855 }
9856 #[doc = "`EntrustMindDestination()` overload"]
9857 fn entrust_mind_destination(self) -> crate::app::aithink::AIThink_Result {
9858 unsafe {
9859 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9860 ::unity::il2cpp_call!((::unity::module_base()+0x196f360usize)as*mut u8,crate::app::aithink::AIThink_Result;
9861(AIThink)__receiver)
9862 }
9863 }
9864 #[doc = "`EntrustMindTreasure()` overload"]
9865 fn entrust_mind_treasure(self) -> crate::app::aithink::AIThink_Result {
9866 unsafe {
9867 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9868 ::unity::il2cpp_call!((::unity::module_base()+0x196f880usize)as*mut u8,crate::app::aithink::AIThink_Result;
9869(AIThink)__receiver)
9870 }
9871 }
9872 #[doc = "`EntrustMindDoorAndDestroy()` overload"]
9873 fn entrust_mind_door_and_destroy(self) -> crate::app::aithink::AIThink_Result {
9874 unsafe {
9875 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9876 ::unity::il2cpp_call!((::unity::module_base()+0x196ee30usize)as*mut u8,crate::app::aithink::AIThink_Result;
9877(AIThink)__receiver)
9878 }
9879 }
9880 #[doc = "`EntrustMindGuard()` overload"]
9881 fn entrust_mind_guard(self) -> crate::app::aithink::AIThink_Result {
9882 unsafe {
9883 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9884 ::unity::il2cpp_call!((::unity::module_base()+0x196ede0usize)as*mut u8,crate::app::aithink::AIThink_Result;
9885(AIThink)__receiver)
9886 }
9887 }
9888 #[doc = "`EntrustGuardTo(crate::app::skilldata::SkillData)` overload"]
9889 fn entrust_guard_to(self, skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>) -> crate::app::aithink::AIThink_Result {
9890 unsafe {
9891 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9892 ::unity::il2cpp_call!((::unity::module_base()+0x1972b30usize)as*mut u8,crate::app::aithink::AIThink_Result;
9893(AIThink)__receiver,(crate::app::skilldata::SkillData)::core::convert::Into::into(skill))
9894 }
9895 }
9896 #[doc = "`EntrustMove()` overload"]
9897 fn entrust_move(self) -> crate::app::aithink::AIThink_Result {
9898 unsafe {
9899 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9900 ::unity::il2cpp_call!((::unity::module_base()+0x196f2d0usize)as*mut u8,crate::app::aithink::AIThink_Result;
9901(AIThink)__receiver)
9902 }
9903 }
9904 #[doc = "`EntrustRemove()` overload"]
9905 fn entrust_remove(self) -> crate::app::aithink::AIThink_Result {
9906 unsafe {
9907 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9908 ::unity::il2cpp_call!((::unity::module_base()+0x19702d0usize)as*mut u8,crate::app::aithink::AIThink_Result;
9909(AIThink)__receiver)
9910 }
9911 }
9912 #[doc = "`EntrustMoveRush()` overload"]
9913 fn entrust_move_rush(self) -> crate::app::aithink::AIThink_Result {
9914 unsafe {
9915 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9916 ::unity::il2cpp_call!((::unity::module_base()+0x1973060usize)as*mut u8,crate::app::aithink::AIThink_Result;
9917(AIThink)__receiver)
9918 }
9919 }
9920 #[doc = "`EntrustMoveEscort()` overload"]
9921 fn entrust_move_escort(self) -> crate::app::aithink::AIThink_Result {
9922 unsafe {
9923 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9924 ::unity::il2cpp_call!((::unity::module_base()+0x19731b0usize)as*mut u8,crate::app::aithink::AIThink_Result;
9925(AIThink)__receiver)
9926 }
9927 }
9928 #[doc = "`EntrustMoveTracking()` overload"]
9929 fn entrust_move_tracking(self) -> crate::app::aithink::AIThink_Result {
9930 unsafe {
9931 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9932 ::unity::il2cpp_call!((::unity::module_base()+0x1973340usize)as*mut u8,crate::app::aithink::AIThink_Result;
9933(AIThink)__receiver)
9934 }
9935 }
9936 #[doc = "`EntrustMoveRetreat()` overload"]
9937 fn entrust_move_retreat(self) -> crate::app::aithink::AIThink_Result {
9938 unsafe {
9939 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9940 ::unity::il2cpp_call!((::unity::module_base()+0x1973490usize)as*mut u8,crate::app::aithink::AIThink_Result;
9941(AIThink)__receiver)
9942 }
9943 }
9944 #[doc = "`EntrustMoveEnemy(bool)` overload"]
9945 fn entrust_move_enemy(self, is_in: impl ::core::convert::Into<bool>) -> crate::app::aithink::AIThink_Result {
9946 unsafe {
9947 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9948 ::unity::il2cpp_call!((::unity::module_base()+0x1974030usize)as*mut u8,crate::app::aithink::AIThink_Result;
9949(AIThink)__receiver,(bool)::core::convert::Into::into(is_in))
9950 }
9951 }
9952 #[doc = "`EntrustMoveDestination(bool)` overload"]
9953 fn entrust_move_destination(self, is_in: impl ::core::convert::Into<bool>) -> crate::app::aithink::AIThink_Result {
9954 unsafe {
9955 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9956 ::unity::il2cpp_call!((::unity::module_base()+0x196f5c0usize)as*mut u8,crate::app::aithink::AIThink_Result;
9957(AIThink)__receiver,(bool)::core::convert::Into::into(is_in))
9958 }
9959 }
9960 #[doc = "`EntrustMoveTreasure(bool)` overload"]
9961 fn entrust_move_treasure(self, is_in: impl ::core::convert::Into<bool>) -> crate::app::aithink::AIThink_Result {
9962 unsafe {
9963 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9964 ::unity::il2cpp_call!((::unity::module_base()+0x196fa80usize)as*mut u8,crate::app::aithink::AIThink_Result;
9965(AIThink)__receiver,(bool)::core::convert::Into::into(is_in))
9966 }
9967 }
9968 #[doc = "`EntrustMoveDoorAndDestroy(bool)` overload"]
9969 fn entrust_move_door_and_destroy(self, is_in: impl ::core::convert::Into<bool>) -> crate::app::aithink::AIThink_Result {
9970 unsafe {
9971 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9972 ::unity::il2cpp_call!((::unity::module_base()+0x196fc80usize)as*mut u8,crate::app::aithink::AIThink_Result;
9973(AIThink)__receiver,(bool)::core::convert::Into::into(is_in))
9974 }
9975 }
9976 #[doc = "`EntrustMoveEngageCount(bool)` overload"]
9977 fn entrust_move_engage_count(self, is_in: impl ::core::convert::Into<bool>) -> crate::app::aithink::AIThink_Result {
9978 unsafe {
9979 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9980 ::unity::il2cpp_call!((::unity::module_base()+0x1973ab0usize)as*mut u8,crate::app::aithink::AIThink_Result;
9981(AIThink)__receiver,(bool)::core::convert::Into::into(is_in))
9982 }
9983 }
9984 #[doc = "`EntrustMoveHero(bool)` overload"]
9985 fn entrust_move_hero(self, is_caution: impl ::core::convert::Into<bool>) -> crate::app::aithink::AIThink_Result {
9986 unsafe {
9987 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9988 ::unity::il2cpp_call!((::unity::module_base()+0x196ff70usize)as*mut u8,crate::app::aithink::AIThink_Result;
9989(AIThink)__receiver,(bool)::core::convert::Into::into(is_caution))
9990 }
9991 }
9992 #[doc = "`EntrustMoveSelfForce(bool)` overload"]
9993 fn entrust_move_self_force(self, is_caution: impl ::core::convert::Into<bool>) -> crate::app::aithink::AIThink_Result {
9994 unsafe {
9995 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9996 ::unity::il2cpp_call!((::unity::module_base()+0x1970020usize)as*mut u8,crate::app::aithink::AIThink_Result;
9997(AIThink)__receiver,(bool)::core::convert::Into::into(is_caution))
9998 }
9999 }
10000 #[doc = "`EntrustMoveTo(i32, i32, bool)` overload"]
10001 fn entrust_move_to(
10002 self,
10003 xx: impl ::core::convert::Into<i32>,
10004 zz: impl ::core::convert::Into<i32>,
10005 is_caution: impl ::core::convert::Into<bool>,
10006 ) -> crate::app::aithink::AIThink_Result {
10007 unsafe {
10008 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
10009 ::unity::il2cpp_call!((::unity::module_base()+0x1970bd0usize)as*mut u8,crate::app::aithink::AIThink_Result;
10010(AIThink)__receiver,(i32)::core::convert::Into::into(xx),(i32)::core::convert::Into::into(zz),(bool)::core::convert::Into::into(is_caution))
10011 }
10012 }
10013 #[doc = "`EntrustGetRangeDistance(i32, i32, i32)` overload"]
10014 fn entrust_get_range_distance(
10015 self,
10016 x: impl ::core::convert::Into<i32>,
10017 z: impl ::core::convert::Into<i32>,
10018 range_i: impl ::core::convert::Into<i32>,
10019 ) -> i32 {
10020 unsafe {
10021 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
10022 ::unity::il2cpp_call!((::unity::module_base()+0x1974a90usize)as*mut u8,i32;
10023(AIThink)__receiver,(i32)::core::convert::Into::into(x),(i32)::core::convert::Into::into(z),(i32)::core::convert::Into::into(range_i))
10024 }
10025 }
10026 #[doc = "`EntrustGetRangeDistance(i32, i32, *muti32, *muti32, i32)` overload"]
10027 fn entrust_get_range_distance_2(
10028 self,
10029 x: impl ::core::convert::Into<i32>,
10030 z: impl ::core::convert::Into<i32>,
10031 range_i: impl ::core::convert::Into<i32>,
10032 ) -> (i32, i32, i32) {
10033 unsafe {
10034 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
10035 let mut __out_0 = ::core::mem::MaybeUninit::<i32>::uninit();
10036 let mut __out_1 = ::core::mem::MaybeUninit::<i32>::uninit();
10037 let __ret = {
10038 ::unity::il2cpp_call!((::unity::module_base()+0x1974390usize)as*mut u8,i32;
10039(AIThink)__receiver,(i32)::core::convert::Into::into(x),(i32)::core::convert::Into::into(z),(*mut i32)__out_0.as_mut_ptr(),(*mut i32)__out_1.as_mut_ptr(),(i32)::core::convert::Into::into(range_i))
10040 };
10041 (__ret, __out_0.assume_init(), __out_1.assume_init())
10042 }
10043 }
10044 #[doc = "`EntrustFixed()` overload"]
10045 fn entrust_fixed(self) -> crate::app::aithink::AIThink_Result {
10046 unsafe {
10047 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
10048 ::unity::il2cpp_call!((::unity::module_base()+0x1970210usize)as*mut u8,crate::app::aithink::AIThink_Result;
10049(AIThink)__receiver)
10050 }
10051 }
10052 #[doc = "`ProcessingUncontroll()` overload"]
10053 fn processing_uncontroll(self) -> () {
10054 unsafe {
10055 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
10056 ::unity::il2cpp_call!((::unity::module_base()+0x1925c50usize)as*mut u8,();
10057(AIThink)__receiver)
10058 }
10059 }
10060 #[doc = "`UncontrollHeal()` overload"]
10061 fn uncontroll_heal(self) -> crate::app::aithink::AIThink_Result {
10062 unsafe {
10063 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
10064 ::unity::il2cpp_call!((::unity::module_base()+0x1974ad0usize)as*mut u8,crate::app::aithink::AIThink_Result;
10065(AIThink)__receiver)
10066 }
10067 }
10068 #[doc = "`UncontrollAttack()` overload"]
10069 fn uncontroll_attack(self) -> crate::app::aithink::AIThink_Result {
10070 unsafe {
10071 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
10072 ::unity::il2cpp_call!((::unity::module_base()+0x1974b10usize)as*mut u8,crate::app::aithink::AIThink_Result;
10073(AIThink)__receiver)
10074 }
10075 }
10076 #[doc = "`UncontrollMove()` overload"]
10077 fn uncontroll_move(self) -> crate::app::aithink::AIThink_Result {
10078 unsafe {
10079 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
10080 ::unity::il2cpp_call!((::unity::module_base()+0x1974b80usize)as*mut u8,crate::app::aithink::AIThink_Result;
10081(AIThink)__receiver)
10082 }
10083 }
10084 #[doc = "`UncontrollFixed()` overload"]
10085 fn uncontroll_fixed(self) -> crate::app::aithink::AIThink_Result {
10086 unsafe {
10087 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
10088 ::unity::il2cpp_call!((::unity::module_base()+0x1974bf0usize)as*mut u8,crate::app::aithink::AIThink_Result;
10089(AIThink)__receiver)
10090 }
10091 }
10092 #[doc = "`CharmHeal()` overload"]
10093 fn charm_heal(self) -> crate::app::aithink::AIThink_Result {
10094 unsafe {
10095 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
10096 ::unity::il2cpp_call!((::unity::module_base()+0x1974cb0usize)as*mut u8,crate::app::aithink::AIThink_Result;
10097(AIThink)__receiver)
10098 }
10099 }
10100 #[doc = "`ConfusionAttack()` overload"]
10101 fn confusion_attack(self) -> crate::app::aithink::AIThink_Result {
10102 unsafe {
10103 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
10104 ::unity::il2cpp_call!((::unity::module_base()+0x1974fe0usize)as*mut u8,crate::app::aithink::AIThink_Result;
10105(AIThink)__receiver)
10106 }
10107 }
10108 #[doc = "`CharmAttack()` overload"]
10109 fn charm_attack(self) -> crate::app::aithink::AIThink_Result {
10110 unsafe {
10111 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
10112 ::unity::il2cpp_call!((::unity::module_base()+0x1975350usize)as*mut u8,crate::app::aithink::AIThink_Result;
10113(AIThink)__receiver)
10114 }
10115 }
10116 #[doc = "`ConfusionMove()` overload"]
10117 fn confusion_move(self) -> crate::app::aithink::AIThink_Result {
10118 unsafe {
10119 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
10120 ::unity::il2cpp_call!((::unity::module_base()+0x1975720usize)as*mut u8,crate::app::aithink::AIThink_Result;
10121(AIThink)__receiver)
10122 }
10123 }
10124 #[doc = "`CharmMove()` overload"]
10125 fn charm_move(self) -> crate::app::aithink::AIThink_Result {
10126 unsafe {
10127 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
10128 ::unity::il2cpp_call!((::unity::module_base()+0x1975920usize)as*mut u8,crate::app::aithink::AIThink_Result;
10129(AIThink)__receiver)
10130 }
10131 }
10132 #[doc = "`GetUncontrollAttackScore(crate::app::unit::Unit, i32, i32, i32, *mutcrate::app::aithink::AIThink_UncontrollAttackScoreResult)` overload"]
10133 fn get_uncontroll_attack_score(
10134 self,
10135 target: impl ::core::convert::Into<crate::app::unit::Unit>,
10136 target_x: impl ::core::convert::Into<i32>,
10137 target_z: impl ::core::convert::Into<i32>,
10138 item_index: impl ::core::convert::Into<i32>,
10139 ) -> (bool, crate::app::aithink::AIThink_UncontrollAttackScoreResult) {
10140 unsafe {
10141 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
10142 let mut __out_0 = ::core::mem::MaybeUninit::<crate::app::aithink::AIThink_UncontrollAttackScoreResult>::uninit();
10143 let __ret = {
10144 ::unity::il2cpp_call!((::unity::module_base()+0x1975b70usize)as*mut u8,bool;
10145(AIThink)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(target),(i32)::core::convert::Into::into(target_x),(i32)::core::convert::Into::into(target_z),(i32)::core::convert::Into::into(item_index),(*mut crate::app::aithink::AIThink_UncontrollAttackScoreResult)__out_0.as_mut_ptr())
10146 };
10147 (__ret, __out_0.assume_init())
10148 }
10149 }
10150 #[doc = "`GetUncontrollMoveScore(i32, i32, *mutu32)` overload"]
10151 fn get_uncontroll_move_score(self, target_x: impl ::core::convert::Into<i32>, target_z: impl ::core::convert::Into<i32>) -> (bool, u32) {
10152 unsafe {
10153 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
10154 let mut __out_0 = ::core::mem::MaybeUninit::<u32>::uninit();
10155 let __ret = {
10156 ::unity::il2cpp_call!((::unity::module_base()+0x1975e50usize)as*mut u8,bool;
10157(AIThink)__receiver,(i32)::core::convert::Into::into(target_x),(i32)::core::convert::Into::into(target_z),(*mut u32)__out_0.as_mut_ptr())
10158 };
10159 (__ret, __out_0.assume_init())
10160 }
10161 }
10162 #[doc = "`ActionVsPlan(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
10163 fn action_vs_plan(
10164 self,
10165 command: impl ::core::convert::Into<i32>,
10166 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
10167 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
10168 ) -> crate::app::aithink::AIThink_Result {
10169 unsafe {
10170 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
10171 ::unity::il2cpp_call!((::unity::module_base()+0x1976050usize)as*mut u8,crate::app::aithink::AIThink_Result;
10172(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
10173 }
10174 }
10175 #[doc = "`ActionVsEngage(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
10176 fn action_vs_engage(
10177 self,
10178 command: impl ::core::convert::Into<i32>,
10179 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
10180 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
10181 ) -> crate::app::aithink::AIThink_Result {
10182 unsafe {
10183 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
10184 ::unity::il2cpp_call!((::unity::module_base()+0x19761c0usize)as*mut u8,crate::app::aithink::AIThink_Result;
10185(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
10186 }
10187 }
10188 #[doc = "`ActionVsEngageAttack(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
10189 fn action_vs_engage_attack(
10190 self,
10191 command: impl ::core::convert::Into<i32>,
10192 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
10193 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
10194 ) -> crate::app::aithink::AIThink_Result {
10195 unsafe {
10196 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
10197 ::unity::il2cpp_call!((::unity::module_base()+0x19761d0usize)as*mut u8,crate::app::aithink::AIThink_Result;
10198(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
10199 }
10200 }
10201 #[doc = "`ActionVsAttackMiddleLow(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
10202 fn action_vs_attack_middle_low(
10203 self,
10204 command: impl ::core::convert::Into<i32>,
10205 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
10206 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
10207 ) -> crate::app::aithink::AIThink_Result {
10208 unsafe {
10209 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
10210 ::unity::il2cpp_call!((::unity::module_base()+0x1976430usize)as*mut u8,crate::app::aithink::AIThink_Result;
10211(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
10212 }
10213 }
10214 #[doc = "`ActionVsGodSkill(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
10215 fn action_vs_god_skill(
10216 self,
10217 command: impl ::core::convert::Into<i32>,
10218 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
10219 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
10220 ) -> crate::app::aithink::AIThink_Result {
10221 unsafe {
10222 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
10223 ::unity::il2cpp_call!((::unity::module_base()+0x19764a0usize)as*mut u8,crate::app::aithink::AIThink_Result;
10224(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
10225 }
10226 }
10227 #[doc = "`ActionVsMindDance(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
10228 fn action_vs_mind_dance(
10229 self,
10230 command: impl ::core::convert::Into<i32>,
10231 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
10232 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
10233 ) -> crate::app::aithink::AIThink_Result {
10234 unsafe {
10235 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
10236 ::unity::il2cpp_call!((::unity::module_base()+0x1976660usize)as*mut u8,crate::app::aithink::AIThink_Result;
10237(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
10238 }
10239 }
10240 #[doc = "`ActionVsMindGuard(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
10241 fn action_vs_mind_guard(
10242 self,
10243 command: impl ::core::convert::Into<i32>,
10244 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
10245 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
10246 ) -> crate::app::aithink::AIThink_Result {
10247 unsafe {
10248 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
10249 ::unity::il2cpp_call!((::unity::module_base()+0x1976690usize)as*mut u8,crate::app::aithink::AIThink_Result;
10250(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
10251 }
10252 }
10253 #[doc = "`ActionVsMindFireCannon(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
10254 fn action_vs_mind_fire_cannon(
10255 self,
10256 command: impl ::core::convert::Into<i32>,
10257 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
10258 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
10259 ) -> crate::app::aithink::AIThink_Result {
10260 unsafe {
10261 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
10262 ::unity::il2cpp_call!((::unity::module_base()+0x19766c0usize)as*mut u8,crate::app::aithink::AIThink_Result;
10263(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
10264 }
10265 }
10266 #[doc = "`ActionVsMindTerrainDestroy(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
10267 fn action_vs_mind_terrain_destroy(
10268 self,
10269 command: impl ::core::convert::Into<i32>,
10270 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
10271 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
10272 ) -> crate::app::aithink::AIThink_Result {
10273 unsafe {
10274 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
10275 ::unity::il2cpp_call!((::unity::module_base()+0x1976780usize)as*mut u8,crate::app::aithink::AIThink_Result;
10276(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
10277 }
10278 }
10279 #[doc = "`ActionVsCommandSkillEnchant(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
10280 fn action_vs_command_skill_enchant(
10281 self,
10282 command: impl ::core::convert::Into<i32>,
10283 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
10284 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
10285 ) -> crate::app::aithink::AIThink_Result {
10286 unsafe {
10287 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
10288 ::unity::il2cpp_call!((::unity::module_base()+0x19767c0usize)as*mut u8,crate::app::aithink::AIThink_Result;
10289(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
10290 }
10291 }
10292 #[doc = "`ActionVsCommandSkillEnchantHeal(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
10293 fn action_vs_command_skill_enchant_heal(
10294 self,
10295 command: impl ::core::convert::Into<i32>,
10296 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
10297 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
10298 ) -> crate::app::aithink::AIThink_Result {
10299 unsafe {
10300 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
10301 ::unity::il2cpp_call!((::unity::module_base()+0x1976960usize)as*mut u8,crate::app::aithink::AIThink_Result;
10302(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
10303 }
10304 }
10305 #[doc = "`ActionVsCommandSkillFullBullet(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
10306 fn action_vs_command_skill_full_bullet(
10307 self,
10308 command: impl ::core::convert::Into<i32>,
10309 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
10310 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
10311 ) -> crate::app::aithink::AIThink_Result {
10312 unsafe {
10313 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
10314 ::unity::il2cpp_call!((::unity::module_base()+0x1976ac0usize)as*mut u8,crate::app::aithink::AIThink_Result;
10315(AIThink)__receiver,(i32)::core::convert::Into::into(command),(crate::app::aivalue::AIValue)::core::convert::Into::into(v0),(crate::app::aivalue::AIValue)::core::convert::Into::into(v1))
10316 }
10317 }
10318 #[doc = "`CanVsEngageAttack()` overload"]
10319 fn can_vs_engage_attack(self) -> bool {
10320 unsafe {
10321 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
10322 ::unity::il2cpp_call!((::unity::module_base()+0x195b4b0usize)as*mut u8,bool;
10323(AIThink)__receiver)
10324 }
10325 }
10326 #[doc = "`IsVsThinkTiming()` overload"]
10327 fn is_vs_think_timing(self) -> bool {
10328 unsafe {
10329 let __receiver = <AIThink as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
10330 ::unity::il2cpp_call!((::unity::module_base()+0x1976470usize)as*mut u8,bool;
10331(AIThink)__receiver)
10332 }
10333 }
10334}
10335
10336#[cfg(feature = "app-aithink")]
10337impl<__T: IAIThink> IAIThinkMethods for __T {}
10338
10339#[cfg(feature = "app-aithink")]
10340impl AIThink {
10341 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10342 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
10343 }
10344
10345 pub fn set_unit_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10346 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
10347 }
10348
10349 pub fn set_think_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10350 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
10351 }
10352
10353 pub fn get_attack_target_for_candidate_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10354 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
10355 }
10356
10357 pub fn get_attack_target_for_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10358 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
10359 }
10360
10361 pub fn add_attack_target_for_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10362 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
10363 }
10364
10365 pub fn processing_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10366 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
10367 }
10368
10369 pub fn processing_remove_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10370 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
10371 }
10372
10373 pub fn processing_remagic_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10374 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
10375 }
10376
10377 pub fn processing_rerewarp_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10378 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
10379 }
10380
10381 pub fn update_target_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10382 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
10383 }
10384
10385 pub fn is_active_command_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10386 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
10387 }
10388
10389 pub fn is_attack_permission_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10390 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
10391 }
10392
10393 pub fn warning_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10394 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
10395 }
10396
10397 pub fn is_attack_permission_only_command_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10398 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[14]
10399 }
10400
10401 pub fn get_attack_position_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10402 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[15]
10403 }
10404
10405 pub fn get_attack_position_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10406 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[16]
10407 }
10408
10409 pub fn get_attack_position_3_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10410 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[17]
10411 }
10412
10413 pub fn get_attack_position_4_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10414 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[18]
10415 }
10416
10417 pub fn get_move_position_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10418 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[19]
10419 }
10420
10421 pub fn get_move_position_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10422 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[20]
10423 }
10424
10425 pub fn get_move_position_3_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10426 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[21]
10427 }
10428
10429 pub fn count_pierce_targets_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10430 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[22]
10431 }
10432
10433 pub fn count_targets_in_range_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10434 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[23]
10435 }
10436
10437 pub fn count_targets_in_range_for_equip_skills_of_item_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10438 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[24]
10439 }
10440
10441 pub fn get_event_position_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10442 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[25]
10443 }
10444
10445 pub fn get_event_position_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10446 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[26]
10447 }
10448
10449 pub fn limit_move_image_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10450 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[27]
10451 }
10452
10453 pub fn is_clever_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10454 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[28]
10455 }
10456
10457 pub fn get_deploy_free_move_flag_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10458 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[29]
10459 }
10460
10461 pub fn is_move_over_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10462 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[30]
10463 }
10464
10465 pub fn is_move_over_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10466 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[31]
10467 }
10468
10469 pub fn is_allow_idle_mutation_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10470 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[32]
10471 }
10472
10473 pub fn update_heal_condition_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10474 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[33]
10475 }
10476
10477 pub fn is_heal_condition_for_entrust_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10478 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[34]
10479 }
10480
10481 pub fn get_item_index_heal_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10482 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[35]
10483 }
10484
10485 pub fn get_terrain_score_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10486 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[36]
10487 }
10488
10489 pub fn get_terrain_heal_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10490 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[37]
10491 }
10492
10493 pub fn get_boundary_ice_tile_move_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10494 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[38]
10495 }
10496
10497 pub fn get_boundary_ice_tile_move_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10498 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[39]
10499 }
10500
10501 pub fn get_active_attack_command_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10502 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[40]
10503 }
10504
10505 pub fn has_active_attack_command_for_crossfire_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10506 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[41]
10507 }
10508
10509 pub fn has_active_attack_command_for_interrupt_attack_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10510 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[42]
10511 }
10512
10513 pub fn has_active_command_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10514 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[43]
10515 }
10516
10517 pub fn get_engage_attack_command_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10518 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[44]
10519 }
10520
10521 pub fn is_think_break_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10522 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[45]
10523 }
10524
10525 pub fn is_think_chain_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10526 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[46]
10527 }
10528
10529 pub fn processing_active_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10530 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[47]
10531 }
10532
10533 pub fn processing_result_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10534 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[48]
10535 }
10536
10537 pub fn processing_mutation_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10538 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[49]
10539 }
10540
10541 pub fn active_cause_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10542 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[50]
10543 }
10544
10545 pub fn result_cause_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10546 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[51]
10547 }
10548
10549 pub fn action_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10550 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[52]
10551 }
10552
10553 pub fn update_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10554 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[53]
10555 }
10556
10557 pub fn change_seq_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10558 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[54]
10559 }
10560
10561 pub fn change_value_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10562 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[55]
10563 }
10564
10565 pub fn active_cause_everytime_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10566 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[56]
10567 }
10568
10569 pub fn active_cause_attack_range_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10570 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[57]
10571 }
10572
10573 pub fn active_cause_band_range_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10574 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[58]
10575 }
10576
10577 pub fn active_cause_heal_range_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10578 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[59]
10579 }
10580
10581 pub fn active_cause_area_enemy_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10582 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[60]
10583 }
10584
10585 pub fn active_cause_turn_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10586 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[61]
10587 }
10588
10589 pub fn active_cause_flag_true_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10590 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[62]
10591 }
10592
10593 pub fn active_cause_flag_false_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10594 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[63]
10595 }
10596
10597 pub fn active_cause_done_heal_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10598 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[64]
10599 }
10600
10601 pub fn active_cause_interference_range_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10602 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[65]
10603 }
10604
10605 pub fn result_cause_attack_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10606 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[66]
10607 }
10608
10609 pub fn result_cause_talk_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10610 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[67]
10611 }
10612
10613 pub fn result_cause_arrive_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10614 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[68]
10615 }
10616
10617 pub fn action_attack_default_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10618 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[69]
10619 }
10620
10621 pub fn action_attack_middle_low_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10622 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[70]
10623 }
10624
10625 pub fn action_attack_low_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10626 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[71]
10627 }
10628
10629 pub fn action_rod_heal_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10630 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[72]
10631 }
10632
10633 pub fn action_rod_warp_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10634 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[73]
10635 }
10636
10637 pub fn action_rod_rescue_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10638 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[74]
10639 }
10640
10641 pub fn action_rod_interference_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10642 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[75]
10643 }
10644
10645 pub fn action_heal_default_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10646 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[76]
10647 }
10648
10649 pub fn action_heal_middle_low_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10650 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[77]
10651 }
10652
10653 pub fn action_heal_nearing_hero_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10654 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[78]
10655 }
10656
10657 pub fn action_engage_attack_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10658 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[79]
10659 }
10660
10661 pub fn action_engage_dance_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10662 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[80]
10663 }
10664
10665 pub fn action_engage_vision_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10666 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[81]
10667 }
10668
10669 pub fn action_engage_pierce_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10670 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[82]
10671 }
10672
10673 pub fn action_mind_talk_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10674 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[83]
10675 }
10676
10677 pub fn action_mind_treasure_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10678 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[84]
10679 }
10680
10681 pub fn action_mind_village_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10682 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[85]
10683 }
10684
10685 pub fn action_mind_escape_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10686 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[86]
10687 }
10688
10689 pub fn action_mind_break_down_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10690 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[87]
10691 }
10692
10693 pub fn action_mind_dance_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10694 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[88]
10695 }
10696
10697 pub fn action_mind_terrain_destroy_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10698 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[89]
10699 }
10700
10701 pub fn action_mind_torch_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10702 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[90]
10703 }
10704
10705 pub fn action_mind_guard_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10706 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[91]
10707 }
10708
10709 pub fn action_move_idle_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10710 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[92]
10711 }
10712
10713 pub fn action_move_nearest_enemy_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10714 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[93]
10715 }
10716
10717 pub fn action_move_nearest_friend_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10718 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[94]
10719 }
10720
10721 pub fn action_move_attack_range_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10722 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[95]
10723 }
10724
10725 pub fn action_move_attack_range_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10726 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[96]
10727 }
10728
10729 pub fn action_move_heal_range_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10730 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[97]
10731 }
10732
10733 pub fn action_move_hero_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10734 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[98]
10735 }
10736
10737 pub fn action_move_person_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10738 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[99]
10739 }
10740
10741 pub fn action_move_position_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10742 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[100]
10743 }
10744
10745 pub fn action_move_terrain_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10746 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[101]
10747 }
10748
10749 pub fn action_move_force_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10750 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[102]
10751 }
10752
10753 pub fn action_move_return_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10754 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[103]
10755 }
10756
10757 pub fn action_move_treasure_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10758 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[104]
10759 }
10760
10761 pub fn action_move_village_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10762 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[105]
10763 }
10764
10765 pub fn action_move_escape_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10766 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[106]
10767 }
10768
10769 pub fn action_move_terrain_destroy_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10770 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[107]
10771 }
10772
10773 pub fn action_move_retreat_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10774 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[108]
10775 }
10776
10777 pub fn action_move_break_down_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10778 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[109]
10779 }
10780
10781 pub fn action_move_rewarp_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10782 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[110]
10783 }
10784
10785 pub fn get_rewarp_item_index_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10786 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[111]
10787 }
10788
10789 pub fn get_rewarp_position_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10790 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[112]
10791 }
10792
10793 pub fn action_command_skill_battle_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10794 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[113]
10795 }
10796
10797 pub fn action_command_skill_overlap_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10798 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[114]
10799 }
10800
10801 pub fn action_remove_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10802 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[115]
10803 }
10804
10805 pub fn action_remagic_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10806 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[116]
10807 }
10808
10809 pub fn action_rerewarp_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10810 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[117]
10811 }
10812
10813 pub fn get_rerewarp_position_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10814 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[118]
10815 }
10816
10817 pub fn is_enemy_inside_attack_area_for_ac_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10818 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[119]
10819 }
10820
10821 pub fn is_attackable_enemy_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10822 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[120]
10823 }
10824
10825 pub fn is_attackable_enemy_for_entrust_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10826 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[121]
10827 }
10828
10829 pub fn attack_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10830 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[122]
10831 }
10832
10833 pub fn set_attack_target_to_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10834 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[123]
10835 }
10836
10837 pub fn is_attack_permission_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10838 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[124]
10839 }
10840
10841 pub fn is_attack_permission_with_command_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10842 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[125]
10843 }
10844
10845 pub fn is_attack_permission_with_command_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10846 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[126]
10847 }
10848
10849 pub fn compare_attack_priority_with_command_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10850 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[127]
10851 }
10852
10853 pub fn compare_attack_priority_with_blow_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10854 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[128]
10855 }
10856
10857 pub fn compare_attack_priority_with_chain_attack_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10858 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[129]
10859 }
10860
10861 pub fn compare_attack_priority_with_decoy_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10862 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[130]
10863 }
10864
10865 pub fn compare_attack_priority_with_bullet_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10866 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[131]
10867 }
10868
10869 pub fn check_attack_priority_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10870 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[132]
10871 }
10872
10873 pub fn check_attack_priority_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10874 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[133]
10875 }
10876
10877 pub fn check_attack_priority_3_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10878 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[134]
10879 }
10880
10881 pub fn check_attack_priority_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10882 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[135]
10883 }
10884
10885 pub fn get_attack_score_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10886 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[136]
10887 }
10888
10889 pub fn get_attack_score_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10890 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[137]
10891 }
10892
10893 pub fn get_attack_score_3_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10894 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[138]
10895 }
10896
10897 pub fn get_attack_score_4_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10898 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[139]
10899 }
10900
10901 pub fn get_entrust_attack_score_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10902 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[140]
10903 }
10904
10905 pub fn get_entrust_attack_score_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10906 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[141]
10907 }
10908
10909 pub fn get_entrust_attack_score_3_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10910 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[142]
10911 }
10912
10913 pub fn get_attack_range_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10914 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[143]
10915 }
10916
10917 pub fn is_weapon_prohibit_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10918 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[144]
10919 }
10920
10921 pub fn get_command_skill_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10922 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[145]
10923 }
10924
10925 pub fn get_god_skill_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10926 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[146]
10927 }
10928
10929 pub fn get_god_skill_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10930 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[147]
10931 }
10932
10933 pub fn is_god_skill_decoy_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10934 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[148]
10935 }
10936
10937 pub fn is_god_skill_trimasteries_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10938 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[149]
10939 }
10940
10941 pub fn is_god_skill_strategy_holy_shield_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10942 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[150]
10943 }
10944
10945 pub fn is_god_skill_gaze_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10946 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[151]
10947 }
10948
10949 pub fn can_give_bad_states_for_bullet_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10950 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[152]
10951 }
10952
10953 pub fn get_give_bad_states_for_bullet_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10954 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[153]
10955 }
10956
10957 pub fn dbg_check_get_give_bad_states_for_bullet_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10958 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[154]
10959 }
10960
10961 pub fn get_rod_prohibit_min_max_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10962 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[155]
10963 }
10964
10965 pub fn is_rod_permission_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10966 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[156]
10967 }
10968
10969 pub fn decide_to_prohibit_rod_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10970 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[157]
10971 }
10972
10973 pub fn rod_warp_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10974 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[158]
10975 }
10976
10977 pub fn get_warp_rod_evalution_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10978 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[159]
10979 }
10980
10981 pub fn get_warp_rod_far_z_evalution_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10982 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[160]
10983 }
10984
10985 pub fn rod_rescue_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10986 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[161]
10987 }
10988
10989 pub fn get_rescue_rod_score_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10990 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[162]
10991 }
10992
10993 pub fn is_enemy_inside_interference_area_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10994 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[163]
10995 }
10996
10997 pub fn interference_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10998 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[164]
10999 }
11000
11001 pub fn get_interference_score_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11002 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[165]
11003 }
11004
11005 pub fn rod_heal_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11006 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[166]
11007 }
11008
11009 pub fn is_heal_rod_permission_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11010 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[167]
11011 }
11012
11013 pub fn calc_heal_rod_score_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11014 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[168]
11015 }
11016
11017 pub fn get_heal_rod_score_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11018 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[169]
11019 }
11020
11021 pub fn get_heal_rod_score_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11022 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[170]
11023 }
11024
11025 pub fn get_range_heal_rod_score_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11026 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[171]
11027 }
11028
11029 pub fn get_heal_rod_position_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11030 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[172]
11031 }
11032
11033 pub fn get_heal_rod_range_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11034 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[173]
11035 }
11036
11037 pub fn update_heal_condition_by_rod_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11038 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[174]
11039 }
11040
11041 pub fn update_heal_condition_by_rod_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11042 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[175]
11043 }
11044
11045 pub fn heal_mind_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11046 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[176]
11047 }
11048
11049 pub fn heal_mind_to_vulnerary_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11050 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[177]
11051 }
11052
11053 pub fn heal_mind_to_terrain_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11054 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[178]
11055 }
11056
11057 pub fn has_heal_rod_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11058 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[179]
11059 }
11060
11061 pub fn get_terrain_heal_position_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11062 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[180]
11063 }
11064
11065 pub fn get_terrain_heal_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11066 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[181]
11067 }
11068
11069 pub fn dance_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11070 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[182]
11071 }
11072
11073 pub fn guard_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11074 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[183]
11075 }
11076
11077 pub fn terrain_destroy_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11078 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[184]
11079 }
11080
11081 pub fn is_destroy_target_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11082 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[185]
11083 }
11084
11085 pub fn engage_attack_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11086 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[186]
11087 }
11088
11089 pub fn deploy_for_engage_attack_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11090 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[187]
11091 }
11092
11093 pub fn get_engage_rewarp_pos_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11094 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[188]
11095 }
11096
11097 pub fn engage_dance_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11098 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[189]
11099 }
11100
11101 pub fn engage_dance_to_common_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11102 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[190]
11103 }
11104
11105 pub fn engage_pierce_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11106 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[191]
11107 }
11108
11109 pub fn engage_charge_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11110 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[192]
11111 }
11112
11113 pub fn engage_charge_to_common_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11114 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[193]
11115 }
11116
11117 pub fn engage_heal_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11118 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[194]
11119 }
11120
11121 pub fn engage_heal_to_common_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11122 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[195]
11123 }
11124
11125 pub fn engage_heal_to_count_target_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11126 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[196]
11127 }
11128
11129 pub fn engage_vision_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11130 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[197]
11131 }
11132
11133 pub fn engage_support_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11134 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[198]
11135 }
11136
11137 pub fn engage_support_to_common_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11138 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[199]
11139 }
11140
11141 pub fn engage_pull_back_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11142 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[200]
11143 }
11144
11145 pub fn engage_pull_back_to_common_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11146 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[201]
11147 }
11148
11149 pub fn engage_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11150 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[202]
11151 }
11152
11153 pub fn god_change_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11154 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[203]
11155 }
11156
11157 pub fn get_engage_prohibit_min_max_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11158 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[204]
11159 }
11160
11161 pub fn is_engage_permission_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11162 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[205]
11163 }
11164
11165 pub fn is_engage_permission_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11166 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[206]
11167 }
11168
11169 pub fn decide_to_prohibit_engage_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11170 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[207]
11171 }
11172
11173 pub fn can_use_engage_attack_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11174 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[208]
11175 }
11176
11177 pub fn is_engage_rewarp_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11178 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[209]
11179 }
11180
11181 pub fn engage_check_and_equip_item_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11182 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[210]
11183 }
11184
11185 pub fn get_real_engage_attack_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11186 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[211]
11187 }
11188
11189 pub fn move_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11190 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[212]
11191 }
11192
11193 pub fn to_break_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11194 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[213]
11195 }
11196
11197 pub fn to_door_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11198 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[214]
11199 }
11200
11201 pub fn to_block_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11202 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[215]
11203 }
11204
11205 pub fn each_block_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11206 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[216]
11207 }
11208
11209 pub fn each_block_for_entrust_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11210 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[217]
11211 }
11212
11213 pub fn is_move_near_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11214 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[218]
11215 }
11216
11217 pub fn check_move_target_with_attack_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11218 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[219]
11219 }
11220
11221 pub fn get_side_position_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11222 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[220]
11223 }
11224
11225 pub fn is_escape_position_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11226 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[221]
11227 }
11228
11229 pub fn get_move_power_slow_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11230 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[222]
11231 }
11232
11233 pub fn get_move_power_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11234 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[223]
11235 }
11236
11237 pub fn is_not_move_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11238 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[224]
11239 }
11240
11241 pub fn get_blow_score_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11242 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[225]
11243 }
11244
11245 pub fn command_skill_overlap_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11246 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[226]
11247 }
11248
11249 pub fn command_skill_overlap_to_common_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11250 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[227]
11251 }
11252
11253 pub fn check_dir_for_overlap_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11254 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[228]
11255 }
11256
11257 pub fn is_positive_overlap_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11258 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[229]
11259 }
11260
11261 pub fn is_heal_overlap_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11262 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[230]
11263 }
11264
11265 pub fn update_target_one_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11266 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[231]
11267 }
11268
11269 pub fn caution_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11270 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[232]
11271 }
11272
11273 pub fn get_caution_info_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11274 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[233]
11275 }
11276
11277 pub fn get_prohibited_turn_min_max_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11278 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[234]
11279 }
11280
11281 pub fn is_prohibited_turn_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11282 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[235]
11283 }
11284
11285 pub fn decide_to_prohibited_turn_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11286 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[236]
11287 }
11288
11289 pub fn dbg_patch_version_check_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11290 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[237]
11291 }
11292
11293 pub fn dbg_patch_version_check_log_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11294 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[238]
11295 }
11296
11297 pub fn action_engage_bless_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11298 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[239]
11299 }
11300
11301 pub fn engage_bless_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11302 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[240]
11303 }
11304
11305 pub fn engage_bless_to_common_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11306 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[241]
11307 }
11308
11309 pub fn engage_bless_get_score_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11310 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[242]
11311 }
11312
11313 pub fn action_engage_wait_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11314 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[243]
11315 }
11316
11317 pub fn engage_wait_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11318 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[244]
11319 }
11320
11321 pub fn engage_wait_to_common_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11322 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[245]
11323 }
11324
11325 pub fn engage_wait_calc_additional_attack_image_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11326 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[246]
11327 }
11328
11329 pub fn engage_wait_get_score_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11330 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[247]
11331 }
11332
11333 pub fn engage_wait_check_range_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11334 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[248]
11335 }
11336
11337 pub fn action_engage_summon_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11338 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[249]
11339 }
11340
11341 pub fn engage_summon_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11342 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[250]
11343 }
11344
11345 pub fn engage_summon_to_common_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11346 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[251]
11347 }
11348
11349 pub fn engage_summon_decide_color_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11350 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[252]
11351 }
11352
11353 pub fn engage_summon_weapon2_color_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11354 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[253]
11355 }
11356
11357 pub fn action_engage_overlap_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11358 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[254]
11359 }
11360
11361 pub fn engage_overlap_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11362 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[255]
11363 }
11364
11365 pub fn engage_overlap_to_common_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11366 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[256]
11367 }
11368
11369 pub fn action_attack_breath_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11370 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[257]
11371 }
11372
11373 pub fn action_attack_breath_middle_low_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11374 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[258]
11375 }
11376
11377 pub fn attack_breath_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11378 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[259]
11379 }
11380
11381 pub fn action_rod_magic_shield_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11382 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[260]
11383 }
11384
11385 pub fn magic_shield_find_index_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11386 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[261]
11387 }
11388
11389 pub fn magic_shield_calc_unit_score_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11390 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[262]
11391 }
11392
11393 pub fn magic_shield_calc_unit_score_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11394 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[263]
11395 }
11396
11397 pub fn action_command_skill_decoy_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11398 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[264]
11399 }
11400
11401 pub fn command_skill_decoy_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11402 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[265]
11403 }
11404
11405 pub fn decoy_get_score_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11406 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[266]
11407 }
11408
11409 pub fn action_command_skill_strategy_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11410 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[267]
11411 }
11412
11413 pub fn command_skill_strategy_holy_shield_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11414 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[268]
11415 }
11416
11417 pub fn action_command_skill_trimasteries_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11418 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[269]
11419 }
11420
11421 pub fn command_skill_trimasteries_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11422 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[270]
11423 }
11424
11425 pub fn trimasteries_can_kill_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11426 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[271]
11427 }
11428
11429 pub fn trimasteries_count_kill_enemies_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11430 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[272]
11431 }
11432
11433 pub fn trimasteries_think_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11434 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[273]
11435 }
11436
11437 pub fn entrust_trimasteries_count_kill_enemies_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11438 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[274]
11439 }
11440
11441 pub fn entrust_trimasteries_think_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11442 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[275]
11443 }
11444
11445 pub fn entrust_trimasteries_deploy_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11446 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[276]
11447 }
11448
11449 pub fn action_command_skill_contract_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11450 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[277]
11451 }
11452
11453 pub fn command_skill_contract_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11454 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[278]
11455 }
11456
11457 pub fn contract_get_battle_score_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11458 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[279]
11459 }
11460
11461 pub fn contract_get_entrust_battle_score_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11462 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[280]
11463 }
11464
11465 pub fn action_command_skill_yell_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11466 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[281]
11467 }
11468
11469 pub fn action_command_skill_gaze_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11470 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[282]
11471 }
11472
11473 pub fn get_bullet_pattern_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11474 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[283]
11475 }
11476
11477 pub fn get_next_bullet_pattern_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11478 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[284]
11479 }
11480
11481 pub fn is_bullet_pattern_matched_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11482 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[285]
11483 }
11484
11485 pub fn is_bullet_pattern_a_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11486 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[286]
11487 }
11488
11489 pub fn is_bullet_pattern_b_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11490 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[287]
11491 }
11492
11493 pub fn action_command_skill_full_bullet_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11494 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[288]
11495 }
11496
11497 pub fn command_skill_full_bullet_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11498 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[289]
11499 }
11500
11501 pub fn full_bullet_can_use_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11502 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[290]
11503 }
11504
11505 pub fn full_bullet_get_range_bit_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11506 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[291]
11507 }
11508
11509 pub fn full_bullet_get_item_range_bit_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11510 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[292]
11511 }
11512
11513 pub fn full_bullet_deploy_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11514 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[293]
11515 }
11516
11517 pub fn full_bullet_get_move_pos_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11518 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[294]
11519 }
11520
11521 pub fn full_bullet_get_move_pos_versus_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11522 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[295]
11523 }
11524
11525 pub fn full_bullet_can_be_target_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11526 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[296]
11527 }
11528
11529 pub fn action_command_skill_enchant_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11530 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[297]
11531 }
11532
11533 pub fn action_command_skill_enchant_heal_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11534 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[298]
11535 }
11536
11537 pub fn command_skill_enchant_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11538 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[299]
11539 }
11540
11541 pub fn command_skill_enchant_heal_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11542 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[300]
11543 }
11544
11545 pub fn entrust_enchant_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11546 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[301]
11547 }
11548
11549 pub fn entrust_enchant_heal_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11550 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[302]
11551 }
11552
11553 pub fn command_skill_enchant_to_common_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11554 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[303]
11555 }
11556
11557 pub fn command_skill_enchant_heal_to_common_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11558 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[304]
11559 }
11560
11561 pub fn enchant_deploy_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11562 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[305]
11563 }
11564
11565 pub fn enchant_heal_get_item_bit_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11566 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[306]
11567 }
11568
11569 pub fn enchant_heal_get_score_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11570 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[307]
11571 }
11572
11573 pub fn enchant_heal_update_heal_condition_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11574 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[308]
11575 }
11576
11577 pub fn processing_entrust_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11578 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[309]
11579 }
11580
11581 pub fn processing_entrust_remove_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11582 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[310]
11583 }
11584
11585 pub fn processing_entrust_remagic_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11586 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[311]
11587 }
11588
11589 pub fn get_entrust_hero_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11590 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[312]
11591 }
11592
11593 pub fn get_entrust_hero_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11594 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[313]
11595 }
11596
11597 pub fn get_entrust_hero_excluding_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11598 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[314]
11599 }
11600
11601 pub fn entrust_get_deploy_free_move_flag_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11602 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[315]
11603 }
11604
11605 pub fn entrust_heal_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11606 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[316]
11607 }
11608
11609 pub fn entrust_heal_mind_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11610 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[317]
11611 }
11612
11613 pub fn entrust_heal_mind_to_terrain_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11614 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[318]
11615 }
11616
11617 pub fn entrust_heal_rod_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11618 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[319]
11619 }
11620
11621 pub fn entrust_engage_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11622 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[320]
11623 }
11624
11625 pub fn entrust_engage_attack_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11626 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[321]
11627 }
11628
11629 pub fn entrust_engage_heal_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11630 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[322]
11631 }
11632
11633 pub fn entrust_engage_attack_check_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11634 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[323]
11635 }
11636
11637 pub fn entrust_engage_attack_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11638 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[324]
11639 }
11640
11641 pub fn entrust_engage_pierce_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11642 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[325]
11643 }
11644
11645 pub fn entrust_engage_charge_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11646 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[326]
11647 }
11648
11649 pub fn entrust_engage_dance_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11650 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[327]
11651 }
11652
11653 pub fn entrust_engage_heal_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11654 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[328]
11655 }
11656
11657 pub fn entrust_engage_bless_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11658 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[329]
11659 }
11660
11661 pub fn entrust_engage_wait_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11662 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[330]
11663 }
11664
11665 pub fn entrust_engage_summon_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11666 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[331]
11667 }
11668
11669 pub fn entrust_engage_overlap_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11670 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[332]
11671 }
11672
11673 pub fn entrust_god_skill_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11674 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[333]
11675 }
11676
11677 pub fn entrust_command_skill_overlap_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11678 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[334]
11679 }
11680
11681 pub fn entrust_engage_support_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11682 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[335]
11683 }
11684
11685 pub fn entrust_engage_pull_back_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11686 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[336]
11687 }
11688
11689 pub fn entrust_attack_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11690 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[337]
11691 }
11692
11693 pub fn entrust_attack_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11694 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[338]
11695 }
11696
11697 pub fn entrust_set_attack_target_to_mind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11698 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[339]
11699 }
11700
11701 pub fn entrust_get_escort_area_if_needed_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11702 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[340]
11703 }
11704
11705 pub fn entrust_mind_fire_cannon_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11706 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[341]
11707 }
11708
11709 pub fn entrust_mind_destination_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11710 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[342]
11711 }
11712
11713 pub fn entrust_mind_treasure_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11714 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[343]
11715 }
11716
11717 pub fn entrust_mind_door_and_destroy_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11718 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[344]
11719 }
11720
11721 pub fn entrust_mind_guard_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11722 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[345]
11723 }
11724
11725 pub fn entrust_guard_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11726 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[346]
11727 }
11728
11729 pub fn entrust_move_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11730 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[347]
11731 }
11732
11733 pub fn entrust_remove_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11734 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[348]
11735 }
11736
11737 pub fn entrust_move_rush_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11738 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[349]
11739 }
11740
11741 pub fn entrust_move_escort_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11742 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[350]
11743 }
11744
11745 pub fn entrust_move_tracking_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11746 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[351]
11747 }
11748
11749 pub fn entrust_move_retreat_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11750 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[352]
11751 }
11752
11753 pub fn entrust_move_enemy_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11754 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[353]
11755 }
11756
11757 pub fn entrust_move_destination_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11758 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[354]
11759 }
11760
11761 pub fn entrust_move_treasure_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11762 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[355]
11763 }
11764
11765 pub fn entrust_move_door_and_destroy_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11766 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[356]
11767 }
11768
11769 pub fn entrust_move_engage_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11770 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[357]
11771 }
11772
11773 pub fn entrust_move_hero_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11774 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[358]
11775 }
11776
11777 pub fn entrust_move_self_force_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11778 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[359]
11779 }
11780
11781 pub fn entrust_move_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11782 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[360]
11783 }
11784
11785 pub fn entrust_get_range_distance_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11786 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[361]
11787 }
11788
11789 pub fn entrust_get_range_distance_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11790 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[362]
11791 }
11792
11793 pub fn entrust_fixed_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11794 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[363]
11795 }
11796
11797 pub fn processing_uncontroll_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11798 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[364]
11799 }
11800
11801 pub fn uncontroll_heal_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11802 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[365]
11803 }
11804
11805 pub fn uncontroll_attack_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11806 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[366]
11807 }
11808
11809 pub fn uncontroll_move_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11810 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[367]
11811 }
11812
11813 pub fn uncontroll_fixed_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11814 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[368]
11815 }
11816
11817 pub fn charm_heal_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11818 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[369]
11819 }
11820
11821 pub fn confusion_attack_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11822 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[370]
11823 }
11824
11825 pub fn charm_attack_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11826 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[371]
11827 }
11828
11829 pub fn confusion_move_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11830 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[372]
11831 }
11832
11833 pub fn charm_move_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11834 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[373]
11835 }
11836
11837 pub fn get_uncontroll_attack_score_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11838 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[374]
11839 }
11840
11841 pub fn get_uncontroll_move_score_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11842 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[375]
11843 }
11844
11845 pub fn action_vs_plan_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11846 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[376]
11847 }
11848
11849 pub fn action_vs_engage_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11850 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[377]
11851 }
11852
11853 pub fn action_vs_engage_attack_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11854 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[378]
11855 }
11856
11857 pub fn action_vs_attack_middle_low_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11858 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[379]
11859 }
11860
11861 pub fn action_vs_god_skill_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11862 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[380]
11863 }
11864
11865 pub fn action_vs_mind_dance_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11866 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[381]
11867 }
11868
11869 pub fn action_vs_mind_guard_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11870 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[382]
11871 }
11872
11873 pub fn action_vs_mind_fire_cannon_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11874 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[383]
11875 }
11876
11877 pub fn action_vs_mind_terrain_destroy_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11878 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[384]
11879 }
11880
11881 pub fn action_vs_command_skill_enchant_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11882 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[385]
11883 }
11884
11885 pub fn action_vs_command_skill_enchant_heal_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11886 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[386]
11887 }
11888
11889 pub fn action_vs_command_skill_full_bullet_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11890 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[387]
11891 }
11892
11893 pub fn can_vs_engage_attack_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11894 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[388]
11895 }
11896
11897 pub fn can_vs_engage_attack_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11898 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[389]
11899 }
11900
11901 pub fn is_vs_think_timing_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11902 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[390]
11903 }
11904
11905 pub fn cctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11906 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[391]
11907 }
11908}
11909
11910#[cfg(feature = "app-aithink")]
11911impl AIThink {
11912 #[doc = "`.ctor()` — no args"]
11913 pub fn new() -> Self {
11914 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
11915 panic!(
11916 "{}
11917::{}
11918 failed to instantiate",
11919 ::core::stringify!(AIThink),
11920 ::core::stringify!(new),
11921 )
11922 });
11923 <Self as IAIThinkMethods>::ctor(this);
11924 this
11925 }
11926}
11927
11928#[cfg(feature = "app-aithink")]
11929pub trait IAIThink_AcFuncMethods: IAIThink_AcFunc {
11930 #[doc = "`.ctor(crate::system::object::Object, ::unity::IntPtr)` overload"]
11931 fn ctor(self, object: impl ::core::convert::Into<crate::system::object::Object>, method: impl ::core::convert::Into<::unity::IntPtr>) -> () {
11932 unsafe {
11933 let __receiver = <AIThink_AcFunc as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
11934 ::unity::il2cpp_call!((::unity::module_base()+0x28fb020usize)as*mut u8,();
11935(AIThink_AcFunc)__receiver,(crate::system::object::Object)::core::convert::Into::into(object),(::unity::IntPtr)::core::convert::Into::into(method))
11936 }
11937 }
11938 #[doc = "`Invoke(i32, crate::app::aivalue::AIValue, crate::app::aivalue::AIValue)` overload"]
11939 fn invoke(
11940 self,
11941 command: impl ::core::convert::Into<i32>,
11942 v0: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
11943 v1: impl ::core::convert::Into<crate::app::aivalue::AIValue>,
11944 ) -> bool {
11945 unsafe {
11946 let __receiver = <AIThink_AcFunc as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
11947 {
11948 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
11949 let __vi = *__vt.get(13usize).unwrap_or_else(|| {
11950 panic!(
11951 "unity: virtual slot {}
11952 out of range (vtable len {}
11953) on the runtime class behind {}
11954 (method `{}
11955`)",
11956 13usize,
11957 __vt.len(),
11958 <AIThink_AcFunc as ::unity::ClassIdentity>::NAME,
11959 "Invoke",
11960 )
11961 });
11962 let __inner: extern "C" fn(
11963 AIThink_AcFunc,
11964 i32,
11965 crate::app::aivalue::AIValue,
11966 crate::app::aivalue::AIValue,
11967 ::unity::OptionalMethod,
11968 ) -> bool = ::core::mem::transmute(__vi.method_ptr);
11969 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
11970 __inner(
11971 __receiver,
11972 ::core::convert::Into::into(command),
11973 ::core::convert::Into::into(v0),
11974 ::core::convert::Into::into(v1),
11975 __mi,
11976 )
11977 }
11978 }
11979 }
11980}
11981
11982#[cfg(feature = "app-aithink")]
11983impl<__T: IAIThink_AcFunc> IAIThink_AcFuncMethods for __T {}
11984
11985#[cfg(feature = "app-aithink")]
11986impl AIThink_AcFunc {
11987 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11988 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
11989 }
11990
11991 pub fn invoke_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11992 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
11993 }
11994}
11995
11996#[cfg(feature = "app-aithink")]
11997impl AIThink_AcFunc {
11998 #[doc = "Direct (non-virtual) call to `AIThink_AcFunc`'s own `Invoke`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
11999 pub unsafe fn invoke(
12000 this: impl ::core::convert::Into<::unity::IlInstance>,
12001 command: i32,
12002 v0: crate::app::aivalue::AIValue,
12003 v1: crate::app::aivalue::AIValue,
12004 ) -> bool {
12005 let __mi = Self::invoke_method_info();
12006 let __inner: extern "C" fn(
12007 ::unity::IlInstance,
12008 i32,
12009 crate::app::aivalue::AIValue,
12010 crate::app::aivalue::AIValue,
12011 ::unity::OptionalMethod,
12012 ) -> bool = ::core::mem::transmute(__mi.method_ptr);
12013 __inner(this.into(), command, v0, v1, ::core::option::Option::None)
12014 }
12015}
12016
12017#[cfg(feature = "app-aithink")]
12018impl AIThink_AcFunc {
12019 #[doc = "`.ctor(crate::system::object::Object, ::unity::IntPtr)` — overload selector"]
12020 pub fn new(object: crate::system::object::Object, method: ::unity::IntPtr) -> Self {
12021 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
12022 panic!(
12023 "{}
12024::{}
12025 failed to instantiate",
12026 ::core::stringify!(AIThink_AcFunc),
12027 ::core::stringify!(new),
12028 )
12029 });
12030 <Self as IAIThink_AcFuncMethods>::ctor(this, object, method);
12031 this
12032 }
12033}
12034
12035#[cfg(feature = "app-aithink")]
12036pub trait IAIThink_EngageWaitAdditionalAttackImageMethods: IAIThink_EngageWaitAdditionalAttackImage {
12037 #[doc = "`Add(i32, u16)` overload"]
12038 fn add(self, index: impl ::core::convert::Into<i32>, v: impl ::core::convert::Into<u16>) -> () {
12039 unsafe {
12040 let __receiver = <AIThink_EngageWaitAdditionalAttackImage as ::unity::FromIlInstance>::from_il_instance(
12041 <Self as ::unity::SystemObject>::as_instance(self),
12042 );
12043 {
12044 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
12045 let __vi = *__vt.get(5usize).unwrap_or_else(|| {
12046 panic!(
12047 "unity: virtual slot {}
12048 out of range (vtable len {}
12049) on the runtime class behind {}
12050 (method `{}
12051`)",
12052 5usize,
12053 __vt.len(),
12054 <AIThink_EngageWaitAdditionalAttackImage as ::unity::ClassIdentity>::NAME,
12055 "Add",
12056 )
12057 });
12058 let __inner: extern "C" fn(AIThink_EngageWaitAdditionalAttackImage, i32, u16, ::unity::OptionalMethod) -> () =
12059 ::core::mem::transmute(__vi.method_ptr);
12060 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
12061 __inner(__receiver, ::core::convert::Into::into(index), ::core::convert::Into::into(v), __mi)
12062 }
12063 }
12064 }
12065 #[doc = "`IncRange1(i32, i32)` overload"]
12066 fn inc_range1(self, x: impl ::core::convert::Into<i32>, z: impl ::core::convert::Into<i32>) -> () {
12067 unsafe {
12068 let __receiver = <AIThink_EngageWaitAdditionalAttackImage as ::unity::FromIlInstance>::from_il_instance(
12069 <Self as ::unity::SystemObject>::as_instance(self),
12070 );
12071 ::unity::il2cpp_call!((::unity::module_base()+0x28ef680usize)as*mut u8,();
12072(AIThink_EngageWaitAdditionalAttackImage)__receiver,(i32)::core::convert::Into::into(x),(i32)::core::convert::Into::into(z))
12073 }
12074 }
12075 #[doc = "`IncRange2(i32, i32)` overload"]
12076 fn inc_range2(self, x: impl ::core::convert::Into<i32>, z: impl ::core::convert::Into<i32>) -> () {
12077 unsafe {
12078 let __receiver = <AIThink_EngageWaitAdditionalAttackImage as ::unity::FromIlInstance>::from_il_instance(
12079 <Self as ::unity::SystemObject>::as_instance(self),
12080 );
12081 ::unity::il2cpp_call!((::unity::module_base()+0x28ef750usize)as*mut u8,();
12082(AIThink_EngageWaitAdditionalAttackImage)__receiver,(i32)::core::convert::Into::into(x),(i32)::core::convert::Into::into(z))
12083 }
12084 }
12085 #[doc = "`SetRange12(i32, i32, u8, u8)` overload"]
12086 fn set_range12(
12087 self,
12088 x: impl ::core::convert::Into<i32>,
12089 z: impl ::core::convert::Into<i32>,
12090 range1: impl ::core::convert::Into<u8>,
12091 range2: impl ::core::convert::Into<u8>,
12092 ) -> () {
12093 unsafe {
12094 let __receiver = <AIThink_EngageWaitAdditionalAttackImage as ::unity::FromIlInstance>::from_il_instance(
12095 <Self as ::unity::SystemObject>::as_instance(self),
12096 );
12097 ::unity::il2cpp_call!((::unity::module_base()+0x2900070usize)as*mut u8,();
12098(AIThink_EngageWaitAdditionalAttackImage)__receiver,(i32)::core::convert::Into::into(x),(i32)::core::convert::Into::into(z),(u8)::core::convert::Into::into(range1),(u8)::core::convert::Into::into(range2))
12099 }
12100 }
12101 #[doc = "`GetRange12(i32, i32, *mutu8, *mutu8)` overload"]
12102 fn get_range12(self, x: impl ::core::convert::Into<i32>, z: impl ::core::convert::Into<i32>) -> (u8, u8) {
12103 unsafe {
12104 let __receiver = <AIThink_EngageWaitAdditionalAttackImage as ::unity::FromIlInstance>::from_il_instance(
12105 <Self as ::unity::SystemObject>::as_instance(self),
12106 );
12107 let mut __out_0 = ::core::mem::MaybeUninit::<u8>::uninit();
12108 let mut __out_1 = ::core::mem::MaybeUninit::<u8>::uninit();
12109 ::unity::il2cpp_call!((::unity::module_base()+0x28fffe0usize)as*mut u8,();
12110(AIThink_EngageWaitAdditionalAttackImage)__receiver,(i32)::core::convert::Into::into(x),(i32)::core::convert::Into::into(z),(*mut u8)__out_0.as_mut_ptr(),(*mut u8)__out_1.as_mut_ptr());
12111 (__out_0.assume_init(), __out_1.assume_init())
12112 }
12113 }
12114 #[doc = "`.ctor()` overload"]
12115 fn ctor(self) -> () {
12116 unsafe {
12117 let __receiver = <AIThink_EngageWaitAdditionalAttackImage as ::unity::FromIlInstance>::from_il_instance(
12118 <Self as ::unity::SystemObject>::as_instance(self),
12119 );
12120 ::unity::il2cpp_call!((::unity::module_base()+0x2900100usize)as*mut u8,();
12121(AIThink_EngageWaitAdditionalAttackImage)__receiver)
12122 }
12123 }
12124}
12125
12126#[cfg(feature = "app-aithink")]
12127impl<__T: IAIThink_EngageWaitAdditionalAttackImage> IAIThink_EngageWaitAdditionalAttackImageMethods for __T {}
12128
12129#[cfg(feature = "app-aithink")]
12130impl AIThink_EngageWaitAdditionalAttackImage {
12131 pub fn add_method_info() -> &'static ::unity::il2cpp::MethodInfo {
12132 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
12133 }
12134
12135 pub fn inc_range1_method_info() -> &'static ::unity::il2cpp::MethodInfo {
12136 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
12137 }
12138
12139 pub fn inc_range2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
12140 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
12141 }
12142
12143 pub fn set_range12_method_info() -> &'static ::unity::il2cpp::MethodInfo {
12144 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
12145 }
12146
12147 pub fn get_range12_method_info() -> &'static ::unity::il2cpp::MethodInfo {
12148 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
12149 }
12150
12151 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
12152 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
12153 }
12154}
12155
12156#[cfg(feature = "app-aithink")]
12157impl AIThink_EngageWaitAdditionalAttackImage {
12158 #[doc = "Direct (non-virtual) call to `AIThink_EngageWaitAdditionalAttackImage`'s own `Add`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
12159 pub unsafe fn add(this: impl ::core::convert::Into<::unity::IlInstance>, index: i32, v: u16) -> () {
12160 let __mi = Self::add_method_info();
12161 let __inner: extern "C" fn(::unity::IlInstance, i32, u16, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
12162 __inner(this.into(), index, v, ::core::option::Option::None)
12163 }
12164}
12165
12166#[cfg(feature = "app-aithink")]
12167impl AIThink_EngageWaitAdditionalAttackImage {
12168 #[doc = "`.ctor()` — no args"]
12169 pub fn new() -> Self {
12170 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
12171 panic!(
12172 "{}
12173::{}
12174 failed to instantiate",
12175 ::core::stringify!(AIThink_EngageWaitAdditionalAttackImage),
12176 ::core::stringify!(new),
12177 )
12178 });
12179 <Self as IAIThink_EngageWaitAdditionalAttackImageMethods>::ctor(this);
12180 this
12181 }
12182}
12183
12184#[cfg(feature = "app-aithink")]
12185#[doc(hidden)]
12186pub mod prelude {
12187 pub use super::{
12188 AIThink, AIThink_AcFunc, AIThink_ActionFunc, AIThink_AttackFlag, AIThink_AttackPositionResult, AIThink_AttackScoreResult,
12189 AIThink_AttackTarget, AIThink_CGBSResult, AIThink_Command, AIThink_EnchantThink, AIThink_EnchantThink_CalcUnitScoreFunction,
12190 AIThink_EnchantThink_DMPTResult, AIThink_EnchantThink_Desc, AIThink_EnchantThink_ItemInfo, AIThink_EnchantThink_Kinds,
12191 AIThink_EnchantThink_SurroundingInfo, AIThink_EngageWaitAdditionalAttackImage, AIThink_EngageWaitRangeScore, AIThink_EngageWaitResult,
12192 AIThink_EntrustAttackScoreResult, AIThink_EntrustAttackTarget, AIThink_GodSkillTypes, AIThink_HealRodPositionResult,
12193 AIThink_HealRodScoreImplResult, AIThink_HealRodScoreResult, AIThink_InterferenceScoreResult, AIThink_InterferenceTarget, AIThink_MoveFlag,
12194 AIThink_OverlapSkills, AIThink_RcFunc, AIThink_RescueRodScoreResult, AIThink_RescueRodTarget, AIThink_Result, AIThink_Think,
12195 AIThink_TrimasteriesSkills, AIThink_TrimasteriesSkills_Kinds, AIThink_UncontrollAttackScoreResult, AIThink_UncontrollAttackTarget,
12196 AIThink_UpdateFlag, AIThink_WarpRodEvaluationResult, AIThink_WarpRodTarget, IAIThink, IAIThinkMethods, IAIThink_AcFunc,
12197 IAIThink_AcFuncMethods, IAIThink_ActionFunc, IAIThink_ActionFuncMethods, IAIThink_AttackFlag, IAIThink_AttackFlagMethods,
12198 IAIThink_EnchantThink, IAIThink_EnchantThinkMethods, IAIThink_EnchantThink_CalcUnitScoreFunction,
12199 IAIThink_EnchantThink_CalcUnitScoreFunctionMethods, IAIThink_EngageWaitAdditionalAttackImage,
12200 IAIThink_EngageWaitAdditionalAttackImageMethods, IAIThink_MoveFlag, IAIThink_MoveFlagMethods, IAIThink_RcFunc, IAIThink_RcFuncMethods,
12201 IAIThink_UpdateFlag, IAIThink_UpdateFlagMethods,
12202 };
12203 #[cfg(feature = "app-bitfield32")]
12204 pub use crate::app::bitfield32::IBitField32Methods;
12205 #[cfg(feature = "app-bitfieldcommon")]
12206 pub use crate::app::bitfieldcommon::IBitFieldCommonMethods;
12207 #[cfg(feature = "app-mapimagecore_1")]
12208 pub use crate::app::mapimagecore_1::IMapImageCore_1Methods;
12209 #[cfg(feature = "app-mapimageindex")]
12210 pub use crate::app::mapimageindex::IMapImageIndexMethods;
12211 #[cfg(feature = "system-delegate")]
12212 pub use crate::system::delegate::IDelegateMethods;
12213 #[cfg(feature = "system-multicastdelegate")]
12214 pub use crate::system::multicastdelegate::IMulticastDelegateMethods;
12215 #[cfg(feature = "system-object")]
12216 pub use crate::system::object::IObjectMethods;
12217 #[cfg(feature = "system-enum")]
12218 pub use crate::system::r#enum::IEnumMethods;
12219 #[cfg(feature = "system-valuetype")]
12220 pub use crate::system::valuetype::IValueTypeMethods;
12221 pub use crate::{
12222 app::{bitfield32::IBitField32, bitfieldcommon::IBitFieldCommon, mapimagecore_1::IMapImageCore_1, mapimageindex::IMapImageIndex},
12223 system::{delegate::IDelegate, multicastdelegate::IMulticastDelegate, object::IObject, r#enum::IEnum, valuetype::IValueType},
12224 };
12225}