1#[cfg(feature = "app-battledetail-types")]
4mod __types {
5 #[allow(unused_imports)] use ::unity::prelude::*;
6
7 use super::*;
8 use crate::{
9 app::{
10 battleparam::{BattleParam, IBattleParam},
11 pool::{IPool_Node, Pool_Node},
12 },
13 system::{
14 object::{IObject, Object},
15 r#enum::{Enum, IEnum},
16 valuetype::{IValueType, ValueType},
17 },
18 };
19
20 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/battledetail/BattleDetail_BaseParams.md"))]
21 #[repr(C)]
22 #[derive(::core::clone::Clone, ::core::marker::Copy, ::core::fmt::Debug, ::core::cmp::PartialEq, ::core::cmp::Eq)]
23 pub struct BattleDetail_BaseParams {
24 pub value: i32,
25 }
26 impl ::unity::ClassIdentity for BattleDetail_BaseParams {
27 const NAME: &'static str = "BattleDetail.BaseParams";
28 const NAMESPACE: &'static str = "App";
29
30 fn class() -> ::unity::Class {
31 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
32 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
33 }
34 }
35 impl ::unity::IlType for BattleDetail_BaseParams {
36 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
37 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
38 }
39 }
40 impl BattleDetail_BaseParams {
41 pub fn battle_count() -> Self {
42 Self { value: 0 }
43 }
44
45 pub fn action_count() -> Self {
46 Self { value: 1 }
47 }
48
49 pub fn attack_count() -> Self {
50 Self { value: 2 }
51 }
52
53 pub fn terrain_defense() -> Self {
54 Self { value: 3 }
55 }
56
57 pub fn terrain_avoid() -> Self {
58 Self { value: 4 }
59 }
60
61 pub fn support_hit() -> Self {
62 Self { value: 5 }
63 }
64
65 pub fn support_avoid() -> Self {
66 Self { value: 6 }
67 }
68
69 pub fn support_critical() -> Self {
70 Self { value: 7 }
71 }
72
73 pub fn support_secure() -> Self {
74 Self { value: 8 }
75 }
76
77 pub fn weapon_attack() -> Self {
78 Self { value: 9 }
79 }
80
81 pub fn weapon_efficacy() -> Self {
82 Self { value: 10 }
83 }
84
85 pub fn weapon_hit() -> Self {
86 Self { value: 11 }
87 }
88
89 pub fn weapon_avoid() -> Self {
90 Self { value: 12 }
91 }
92
93 pub fn weapon_critical() -> Self {
94 Self { value: 13 }
95 }
96
97 pub fn weapon_secure() -> Self {
98 Self { value: 14 }
99 }
100
101 pub fn weapon_weight() -> Self {
102 Self { value: 15 }
103 }
104
105 pub fn skill_correct() -> Self {
106 Self { value: 16 }
107 }
108
109 pub fn god_skill_correct() -> Self {
110 Self { value: 17 }
111 }
112
113 pub fn blow_ratio() -> Self {
114 Self { value: 18 }
115 }
116
117 pub fn blow_distance() -> Self {
118 Self { value: 19 }
119 }
120
121 pub fn num() -> Self {
122 Self { value: 20 }
123 }
124 }
125
126 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/battledetail/BattleDetail_BattleParams.md"))]
127 #[repr(C)]
128 #[derive(::core::clone::Clone, ::core::marker::Copy, ::core::fmt::Debug, ::core::cmp::PartialEq, ::core::cmp::Eq)]
129 pub struct BattleDetail_BattleParams {
130 pub value: i32,
131 }
132 impl ::unity::ClassIdentity for BattleDetail_BattleParams {
133 const NAME: &'static str = "BattleDetail.BattleParams";
134 const NAMESPACE: &'static str = "App";
135
136 fn class() -> ::unity::Class {
137 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
138 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
139 }
140 }
141 impl ::unity::IlType for BattleDetail_BattleParams {
142 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
143 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
144 }
145 }
146 impl BattleDetail_BattleParams {
147 pub fn unit_attack() -> Self {
148 Self { value: 0 }
149 }
150
151 pub fn unit_defense() -> Self {
152 Self { value: 1 }
153 }
154
155 pub fn attack() -> Self {
156 Self { value: 2 }
157 }
158
159 pub fn defense() -> Self {
160 Self { value: 3 }
161 }
162
163 pub fn hit() -> Self {
164 Self { value: 4 }
165 }
166
167 pub fn avoid() -> Self {
168 Self { value: 5 }
169 }
170
171 pub fn critical() -> Self {
172 Self { value: 6 }
173 }
174
175 pub fn secure() -> Self {
176 Self { value: 7 }
177 }
178
179 pub fn continuous() -> Self {
180 Self { value: 8 }
181 }
182
183 pub fn simple_power() -> Self {
184 Self { value: 9 }
185 }
186
187 pub fn simple_hit() -> Self {
188 Self { value: 10 }
189 }
190
191 pub fn simple_critical() -> Self {
192 Self { value: 11 }
193 }
194
195 pub fn num() -> Self {
196 Self { value: 12 }
197 }
198 }
199
200 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/battledetail/BattleDetail_SimpleHitParam.md"))]
201 #[::unity::class(namespace = "App", name = "BattleDetail.SimpleHitParam")]
202 #[parent(crate::app::battledetail::BattleDetail_CommandParam)]
203 pub struct BattleDetail_SimpleHitParam {}
204
205 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/battledetail/BattleDetail_CommandParam.md"))]
206 #[::unity::class(namespace = "App", name = "BattleDetail.CommandParam")]
207 #[parent(crate::app::battleparam::BattleParam)]
208 pub struct BattleDetail_CommandParam {
209 #[offset(32)]
210 #[rename(name = "m_Command")]
211 pub m_command: crate::app::calculatorcommand::CalculatorCommand,
212 }
213
214 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/battledetail/BattleDetail_DefenseParam.md"))]
215 #[::unity::class(namespace = "App", name = "BattleDetail.DefenseParam")]
216 #[parent(crate::app::battledetail::BattleDetail_DetailParam)]
217 pub struct BattleDetail_DefenseParam {}
218
219 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/battledetail/BattleDetail_AttackParam.md"))]
220 #[::unity::class(namespace = "App", name = "BattleDetail.AttackParam")]
221 #[parent(crate::app::battledetail::BattleDetail_DetailParam)]
222 pub struct BattleDetail_AttackParam {}
223
224 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/battledetail/BattleDetail_SimpleCriticalParam.md"))]
225 #[::unity::class(namespace = "App", name = "BattleDetail.SimpleCriticalParam")]
226 #[parent(crate::app::battledetail::BattleDetail_CommandParam)]
227 pub struct BattleDetail_SimpleCriticalParam {}
228
229 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/battledetail/BattleDetail_ContinuousParam.md"))]
230 #[::unity::class(namespace = "App", name = "BattleDetail.ContinuousParam")]
231 #[parent(crate::app::battledetail::BattleDetail_DetailParam)]
232 pub struct BattleDetail_ContinuousParam {}
233
234 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/battledetail/BattleDetail_SecureParam.md"))]
235 #[::unity::class(namespace = "App", name = "BattleDetail.SecureParam")]
236 #[parent(crate::app::battledetail::BattleDetail_DetailParam)]
237 pub struct BattleDetail_SecureParam {}
238
239 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/battledetail/BattleDetail_SimplePowerParam.md"))]
240 #[::unity::class(namespace = "App", name = "BattleDetail.SimplePowerParam")]
241 #[parent(crate::app::battledetail::BattleDetail_CommandParam)]
242 pub struct BattleDetail_SimplePowerParam {}
243
244 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/battledetail/BattleDetail_UnitAttackParam.md"))]
245 #[::unity::class(namespace = "App", name = "BattleDetail.UnitAttackParam")]
246 #[parent(crate::app::battledetail::BattleDetail_DetailParam)]
247 pub struct BattleDetail_UnitAttackParam {}
248
249 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/battledetail/BattleDetail_CriticalParam.md"))]
250 #[::unity::class(namespace = "App", name = "BattleDetail.CriticalParam")]
251 #[parent(crate::app::battledetail::BattleDetail_DetailParam)]
252 pub struct BattleDetail_CriticalParam {}
253
254 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/battledetail/BattleDetail_DetailParam.md"))]
255 #[::unity::class(namespace = "App", name = "BattleDetail.DetailParam")]
256 #[parent(crate::app::battledetail::BattleDetail_CommandParam)]
257 pub struct BattleDetail_DetailParam {
258 #[offset(40)]
259 #[rename(name = "m_Detail")]
260 pub m_detail: crate::app::battledetail::BattleDetail,
261 }
262
263 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/battledetail/BattleDetail_UnitDefenseParam.md"))]
264 #[::unity::class(namespace = "App", name = "BattleDetail.UnitDefenseParam")]
265 #[parent(crate::app::battledetail::BattleDetail_DetailParam)]
266 pub struct BattleDetail_UnitDefenseParam {}
267
268 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/battledetail/BattleDetail_AvoidParam.md"))]
269 #[::unity::class(namespace = "App", name = "BattleDetail.AvoidParam")]
270 #[parent(crate::app::battledetail::BattleDetail_DetailParam)]
271 pub struct BattleDetail_AvoidParam {}
272
273 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/battledetail/BattleDetail.md"))]
274 #[::unity::class(namespace = "App", name = "BattleDetail")]
275 #[parent(crate::app::pool::Pool_Node)]
276 pub struct BattleDetail {
277 #[offset(24)]
278 #[rename(name = "m_BaseParams")]
279 pub m_base_params: ::unity::Array<i32>,
280 #[offset(32)]
281 #[rename(name = "m_BattleParams")]
282 pub m_battle_params: ::unity::Array<crate::app::battleparam::BattleParam>,
283 #[offset(48)]
284 #[rename(name = "m_ActiveSkill")]
285 pub m_active_skill: crate::app::skillarray::SkillArray,
286 }
287
288 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/battledetail/BattleDetail_HitParam.md"))]
289 #[::unity::class(namespace = "App", name = "BattleDetail.HitParam")]
290 #[parent(crate::app::battledetail::BattleDetail_DetailParam)]
291 pub struct BattleDetail_HitParam {
292 #[offset(48)]
293 #[rename(name = "m_InterferenceRod")]
294 pub m_interference_rod: crate::app::calculatorcommand::CalculatorCommand,
295 }
296}
297
298#[cfg(feature = "app-battledetail-types")]
299pub use __types::*;
300
301#[cfg(feature = "app-battledetail")]
302pub trait IBattleDetail_SimpleHitParamMethods: IBattleDetail_SimpleHitParam {
303 #[doc = "`.ctor()` overload"]
304 fn ctor(self) -> () {
305 unsafe {
306 let __receiver =
307 <BattleDetail_SimpleHitParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
308 ::unity::il2cpp_call!((::unity::module_base()+0x19b7b30usize)as*mut u8,();
309(BattleDetail_SimpleHitParam)__receiver)
310 }
311 }
312 #[doc = "`get_Kind()` overload"]
313 fn get_kind(self) -> crate::app::battleparam::BattleParam_Kinds {
314 unsafe {
315 let __receiver =
316 <BattleDetail_SimpleHitParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
317 {
318 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
319 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
320 panic!(
321 "unity: virtual slot {}
322 out of range (vtable len {}
323) on the runtime class behind {}
324 (method `{}
325`)",
326 4usize,
327 __vt.len(),
328 <BattleDetail_SimpleHitParam as ::unity::ClassIdentity>::NAME,
329 "get_Kind",
330 )
331 });
332 let __inner: extern "C" fn(BattleDetail_SimpleHitParam, ::unity::OptionalMethod) -> crate::app::battleparam::BattleParam_Kinds =
333 ::core::mem::transmute(__vi.method_ptr);
334 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
335 __inner(__receiver, __mi)
336 }
337 }
338 }
339 #[doc = "`Calculate(crate::app::battleinfoside::BattleInfoSide)` overload"]
340 fn calculate(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
341 unsafe {
342 let __receiver =
343 <BattleDetail_SimpleHitParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
344 {
345 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
346 let __vi = *__vt.get(6usize).unwrap_or_else(|| {
347 panic!(
348 "unity: virtual slot {}
349 out of range (vtable len {}
350) on the runtime class behind {}
351 (method `{}
352`)",
353 6usize,
354 __vt.len(),
355 <BattleDetail_SimpleHitParam as ::unity::ClassIdentity>::NAME,
356 "Calculate",
357 )
358 });
359 let __inner: extern "C" fn(BattleDetail_SimpleHitParam, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
360 ::core::mem::transmute(__vi.method_ptr);
361 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
362 __inner(__receiver, ::core::convert::Into::into(side), __mi)
363 }
364 }
365 }
366}
367
368#[cfg(feature = "app-battledetail")]
369impl<__T: IBattleDetail_SimpleHitParam> IBattleDetail_SimpleHitParamMethods for __T {}
370
371#[cfg(feature = "app-battledetail")]
372impl BattleDetail_SimpleHitParam {
373 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
374 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
375 }
376
377 pub fn get_kind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
378 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
379 }
380
381 pub fn calculate_method_info() -> &'static ::unity::il2cpp::MethodInfo {
382 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
383 }
384}
385
386#[cfg(feature = "app-battledetail")]
387impl BattleDetail_SimpleHitParam {
388 #[doc = "Direct (non-virtual) call to `BattleDetail_SimpleHitParam`'s own `get_Kind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
389 pub unsafe fn get_kind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::battleparam::BattleParam_Kinds {
390 let __mi = Self::get_kind_method_info();
391 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::battleparam::BattleParam_Kinds =
392 ::core::mem::transmute(__mi.method_ptr);
393 __inner(this.into(), ::core::option::Option::None)
394 }
395
396 #[doc = "Direct (non-virtual) call to `BattleDetail_SimpleHitParam`'s own `Calculate`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
397 pub unsafe fn calculate(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
398 let __mi = Self::calculate_method_info();
399 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
400 ::core::mem::transmute(__mi.method_ptr);
401 __inner(this.into(), side, ::core::option::Option::None)
402 }
403}
404
405#[cfg(feature = "app-battledetail")]
406impl BattleDetail_SimpleHitParam {
407 #[doc = "`.ctor()` — no args"]
408 pub fn new() -> Self {
409 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
410 panic!(
411 "{}
412::{}
413 failed to instantiate",
414 ::core::stringify!(BattleDetail_SimpleHitParam),
415 ::core::stringify!(new),
416 )
417 });
418 <Self as IBattleDetail_SimpleHitParamMethods>::ctor(this);
419 this
420 }
421}
422
423#[cfg(feature = "app-battledetail")]
424pub trait IBattleDetail_CommandParamMethods: IBattleDetail_CommandParam {
425 #[doc = "`.ctor(::unity::Il2CppString)` overload"]
426 fn ctor(self, command: impl ::core::convert::Into<::unity::Il2CppString>) -> () {
427 unsafe {
428 let __receiver =
429 <BattleDetail_CommandParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
430 ::unity::il2cpp_call!((::unity::module_base()+0x19b7530usize)as*mut u8,();
431(BattleDetail_CommandParam)__receiver,(::unity::Il2CppString)::core::convert::Into::into(command))
432 }
433 }
434 #[doc = "`get_Command()` overload"]
435 fn get_command(self) -> crate::app::calculatorcommand::CalculatorCommand {
436 unsafe {
437 let __receiver =
438 <BattleDetail_CommandParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
439 ::unity::il2cpp_call!((::unity::module_base()+0x19b7630usize)as*mut u8,crate::app::calculatorcommand::CalculatorCommand;
440(BattleDetail_CommandParam)__receiver)
441 }
442 }
443 #[doc = "`Get(::unity::Il2CppString, crate::app::battleinfoside::BattleInfoSide)` overload"]
444 fn get(
445 self,
446 name: impl ::core::convert::Into<::unity::Il2CppString>,
447 side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
448 ) -> f32 {
449 unsafe {
450 let __receiver =
451 <BattleDetail_CommandParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
452 ::unity::il2cpp_call!((::unity::module_base()+0x19b7470usize)as*mut u8,f32;
453(BattleDetail_CommandParam)__receiver,(::unity::Il2CppString)::core::convert::Into::into(name),(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(side))
454 }
455 }
456 #[doc = "`Calculate(crate::app::battleinfoside::BattleInfoSide)` overload"]
457 fn calculate(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
458 unsafe {
459 let __receiver =
460 <BattleDetail_CommandParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
461 {
462 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
463 let __vi = *__vt.get(6usize).unwrap_or_else(|| {
464 panic!(
465 "unity: virtual slot {}
466 out of range (vtable len {}
467) on the runtime class behind {}
468 (method `{}
469`)",
470 6usize,
471 __vt.len(),
472 <BattleDetail_CommandParam as ::unity::ClassIdentity>::NAME,
473 "Calculate",
474 )
475 });
476 let __inner: extern "C" fn(BattleDetail_CommandParam, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
477 ::core::mem::transmute(__vi.method_ptr);
478 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
479 __inner(__receiver, ::core::convert::Into::into(side), __mi)
480 }
481 }
482 }
483}
484
485#[cfg(feature = "app-battledetail")]
486impl<__T: IBattleDetail_CommandParam> IBattleDetail_CommandParamMethods for __T {}
487
488#[cfg(feature = "app-battledetail")]
489impl BattleDetail_CommandParam {
490 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
491 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
492 }
493
494 pub fn get_command_method_info() -> &'static ::unity::il2cpp::MethodInfo {
495 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
496 }
497
498 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
499 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
500 }
501
502 pub fn calculate_method_info() -> &'static ::unity::il2cpp::MethodInfo {
503 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
504 }
505}
506
507#[cfg(feature = "app-battledetail")]
508impl BattleDetail_CommandParam {
509 #[doc = "Direct (non-virtual) call to `BattleDetail_CommandParam`'s own `Calculate`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
510 pub unsafe fn calculate(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
511 let __mi = Self::calculate_method_info();
512 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
513 ::core::mem::transmute(__mi.method_ptr);
514 __inner(this.into(), side, ::core::option::Option::None)
515 }
516}
517
518#[cfg(feature = "app-battledetail")]
519impl BattleDetail_CommandParam {
520 #[doc = "`.ctor(::unity::Il2CppString)` — overload selector"]
521 pub fn new(command: ::unity::Il2CppString) -> Self {
522 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
523 panic!(
524 "{}
525::{}
526 failed to instantiate",
527 ::core::stringify!(BattleDetail_CommandParam),
528 ::core::stringify!(new),
529 )
530 });
531 <Self as IBattleDetail_CommandParamMethods>::ctor(this, command);
532 this
533 }
534}
535
536#[cfg(feature = "app-battledetail")]
537pub trait IBattleDetail_DefenseParamMethods: IBattleDetail_DefenseParam {
538 #[doc = "`.ctor(crate::app::battledetail::BattleDetail)` overload"]
539 fn ctor(self, detail: impl ::core::convert::Into<crate::app::battledetail::BattleDetail>) -> () {
540 unsafe {
541 let __receiver =
542 <BattleDetail_DefenseParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
543 ::unity::il2cpp_call!((::unity::module_base()+0x19b7740usize)as*mut u8,();
544(BattleDetail_DefenseParam)__receiver,(crate::app::battledetail::BattleDetail)::core::convert::Into::into(detail))
545 }
546 }
547}
548
549#[cfg(feature = "app-battledetail")]
550impl<__T: IBattleDetail_DefenseParam> IBattleDetail_DefenseParamMethods for __T {}
551
552#[cfg(feature = "app-battledetail")]
553impl BattleDetail_DefenseParam {
554 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
555 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
556 }
557}
558
559#[cfg(feature = "app-battledetail")]
560impl BattleDetail_DefenseParam {
561 #[doc = "`.ctor(crate::app::battledetail::BattleDetail)` — overload selector"]
562 pub fn new(detail: crate::app::battledetail::BattleDetail) -> Self {
563 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
564 panic!(
565 "{}
566::{}
567 failed to instantiate",
568 ::core::stringify!(BattleDetail_DefenseParam),
569 ::core::stringify!(new),
570 )
571 });
572 <Self as IBattleDetail_DefenseParamMethods>::ctor(this, detail);
573 this
574 }
575}
576
577#[cfg(feature = "app-battledetail")]
578pub trait IBattleDetail_AttackParamMethods: IBattleDetail_AttackParam {
579 #[doc = "`.ctor(crate::app::battledetail::BattleDetail)` overload"]
580 fn ctor(self, detail: impl ::core::convert::Into<crate::app::battledetail::BattleDetail>) -> () {
581 unsafe {
582 let __receiver =
583 <BattleDetail_AttackParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
584 ::unity::il2cpp_call!((::unity::module_base()+0x19b7200usize)as*mut u8,();
585(BattleDetail_AttackParam)__receiver,(crate::app::battledetail::BattleDetail)::core::convert::Into::into(detail))
586 }
587 }
588 #[doc = "`Calculate(crate::app::battleinfoside::BattleInfoSide)` overload"]
589 fn calculate(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
590 unsafe {
591 let __receiver =
592 <BattleDetail_AttackParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
593 {
594 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
595 let __vi = *__vt.get(6usize).unwrap_or_else(|| {
596 panic!(
597 "unity: virtual slot {}
598 out of range (vtable len {}
599) on the runtime class behind {}
600 (method `{}
601`)",
602 6usize,
603 __vt.len(),
604 <BattleDetail_AttackParam as ::unity::ClassIdentity>::NAME,
605 "Calculate",
606 )
607 });
608 let __inner: extern "C" fn(BattleDetail_AttackParam, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
609 ::core::mem::transmute(__vi.method_ptr);
610 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
611 __inner(__receiver, ::core::convert::Into::into(side), __mi)
612 }
613 }
614 }
615}
616
617#[cfg(feature = "app-battledetail")]
618impl<__T: IBattleDetail_AttackParam> IBattleDetail_AttackParamMethods for __T {}
619
620#[cfg(feature = "app-battledetail")]
621impl BattleDetail_AttackParam {
622 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
623 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
624 }
625
626 pub fn calculate_method_info() -> &'static ::unity::il2cpp::MethodInfo {
627 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
628 }
629}
630
631#[cfg(feature = "app-battledetail")]
632impl BattleDetail_AttackParam {
633 #[doc = "Direct (non-virtual) call to `BattleDetail_AttackParam`'s own `Calculate`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
634 pub unsafe fn calculate(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
635 let __mi = Self::calculate_method_info();
636 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
637 ::core::mem::transmute(__mi.method_ptr);
638 __inner(this.into(), side, ::core::option::Option::None)
639 }
640}
641
642#[cfg(feature = "app-battledetail")]
643impl BattleDetail_AttackParam {
644 #[doc = "`.ctor(crate::app::battledetail::BattleDetail)` — overload selector"]
645 pub fn new(detail: crate::app::battledetail::BattleDetail) -> Self {
646 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
647 panic!(
648 "{}
649::{}
650 failed to instantiate",
651 ::core::stringify!(BattleDetail_AttackParam),
652 ::core::stringify!(new),
653 )
654 });
655 <Self as IBattleDetail_AttackParamMethods>::ctor(this, detail);
656 this
657 }
658}
659
660#[cfg(feature = "app-battledetail")]
661pub trait IBattleDetail_SimpleCriticalParamMethods: IBattleDetail_SimpleCriticalParam {
662 #[doc = "`.ctor()` overload"]
663 fn ctor(self) -> () {
664 unsafe {
665 let __receiver =
666 <BattleDetail_SimpleCriticalParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
667 ::unity::il2cpp_call!((::unity::module_base()+0x19b79b0usize)as*mut u8,();
668(BattleDetail_SimpleCriticalParam)__receiver)
669 }
670 }
671 #[doc = "`get_Kind()` overload"]
672 fn get_kind(self) -> crate::app::battleparam::BattleParam_Kinds {
673 unsafe {
674 let __receiver =
675 <BattleDetail_SimpleCriticalParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
676 {
677 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
678 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
679 panic!(
680 "unity: virtual slot {}
681 out of range (vtable len {}
682) on the runtime class behind {}
683 (method `{}
684`)",
685 4usize,
686 __vt.len(),
687 <BattleDetail_SimpleCriticalParam as ::unity::ClassIdentity>::NAME,
688 "get_Kind",
689 )
690 });
691 let __inner: extern "C" fn(BattleDetail_SimpleCriticalParam, ::unity::OptionalMethod) -> crate::app::battleparam::BattleParam_Kinds =
692 ::core::mem::transmute(__vi.method_ptr);
693 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
694 __inner(__receiver, __mi)
695 }
696 }
697 }
698 #[doc = "`Calculate(crate::app::battleinfoside::BattleInfoSide)` overload"]
699 fn calculate(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
700 unsafe {
701 let __receiver =
702 <BattleDetail_SimpleCriticalParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
703 {
704 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
705 let __vi = *__vt.get(6usize).unwrap_or_else(|| {
706 panic!(
707 "unity: virtual slot {}
708 out of range (vtable len {}
709) on the runtime class behind {}
710 (method `{}
711`)",
712 6usize,
713 __vt.len(),
714 <BattleDetail_SimpleCriticalParam as ::unity::ClassIdentity>::NAME,
715 "Calculate",
716 )
717 });
718 let __inner: extern "C" fn(
719 BattleDetail_SimpleCriticalParam,
720 crate::app::battleinfoside::BattleInfoSide,
721 ::unity::OptionalMethod,
722 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
723 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
724 __inner(__receiver, ::core::convert::Into::into(side), __mi)
725 }
726 }
727 }
728}
729
730#[cfg(feature = "app-battledetail")]
731impl<__T: IBattleDetail_SimpleCriticalParam> IBattleDetail_SimpleCriticalParamMethods for __T {}
732
733#[cfg(feature = "app-battledetail")]
734impl BattleDetail_SimpleCriticalParam {
735 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
736 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
737 }
738
739 pub fn get_kind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
740 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
741 }
742
743 pub fn calculate_method_info() -> &'static ::unity::il2cpp::MethodInfo {
744 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
745 }
746}
747
748#[cfg(feature = "app-battledetail")]
749impl BattleDetail_SimpleCriticalParam {
750 #[doc = "Direct (non-virtual) call to `BattleDetail_SimpleCriticalParam`'s own `get_Kind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
751 pub unsafe fn get_kind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::battleparam::BattleParam_Kinds {
752 let __mi = Self::get_kind_method_info();
753 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::battleparam::BattleParam_Kinds =
754 ::core::mem::transmute(__mi.method_ptr);
755 __inner(this.into(), ::core::option::Option::None)
756 }
757
758 #[doc = "Direct (non-virtual) call to `BattleDetail_SimpleCriticalParam`'s own `Calculate`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
759 pub unsafe fn calculate(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
760 let __mi = Self::calculate_method_info();
761 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
762 ::core::mem::transmute(__mi.method_ptr);
763 __inner(this.into(), side, ::core::option::Option::None)
764 }
765}
766
767#[cfg(feature = "app-battledetail")]
768impl BattleDetail_SimpleCriticalParam {
769 #[doc = "`.ctor()` — no args"]
770 pub fn new() -> Self {
771 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
772 panic!(
773 "{}
774::{}
775 failed to instantiate",
776 ::core::stringify!(BattleDetail_SimpleCriticalParam),
777 ::core::stringify!(new),
778 )
779 });
780 <Self as IBattleDetail_SimpleCriticalParamMethods>::ctor(this);
781 this
782 }
783}
784
785#[cfg(feature = "app-battledetail")]
786pub trait IBattleDetail_ContinuousParamMethods: IBattleDetail_ContinuousParam {
787 #[doc = "`.ctor(crate::app::battledetail::BattleDetail)` overload"]
788 fn ctor(self, detail: impl ::core::convert::Into<crate::app::battledetail::BattleDetail>) -> () {
789 unsafe {
790 let __receiver =
791 <BattleDetail_ContinuousParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
792 ::unity::il2cpp_call!((::unity::module_base()+0x19b7660usize)as*mut u8,();
793(BattleDetail_ContinuousParam)__receiver,(crate::app::battledetail::BattleDetail)::core::convert::Into::into(detail))
794 }
795 }
796}
797
798#[cfg(feature = "app-battledetail")]
799impl<__T: IBattleDetail_ContinuousParam> IBattleDetail_ContinuousParamMethods for __T {}
800
801#[cfg(feature = "app-battledetail")]
802impl BattleDetail_ContinuousParam {
803 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
804 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
805 }
806}
807
808#[cfg(feature = "app-battledetail")]
809impl BattleDetail_ContinuousParam {
810 #[doc = "`.ctor(crate::app::battledetail::BattleDetail)` — overload selector"]
811 pub fn new(detail: crate::app::battledetail::BattleDetail) -> Self {
812 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
813 panic!(
814 "{}
815::{}
816 failed to instantiate",
817 ::core::stringify!(BattleDetail_ContinuousParam),
818 ::core::stringify!(new),
819 )
820 });
821 <Self as IBattleDetail_ContinuousParamMethods>::ctor(this, detail);
822 this
823 }
824}
825
826#[cfg(feature = "app-battledetail")]
827pub trait IBattleDetail_SecureParamMethods: IBattleDetail_SecureParam {
828 #[doc = "`.ctor(crate::app::battledetail::BattleDetail)` overload"]
829 fn ctor(self, detail: impl ::core::convert::Into<crate::app::battledetail::BattleDetail>) -> () {
830 unsafe {
831 let __receiver =
832 <BattleDetail_SecureParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
833 ::unity::il2cpp_call!((::unity::module_base()+0x19b7940usize)as*mut u8,();
834(BattleDetail_SecureParam)__receiver,(crate::app::battledetail::BattleDetail)::core::convert::Into::into(detail))
835 }
836 }
837}
838
839#[cfg(feature = "app-battledetail")]
840impl<__T: IBattleDetail_SecureParam> IBattleDetail_SecureParamMethods for __T {}
841
842#[cfg(feature = "app-battledetail")]
843impl BattleDetail_SecureParam {
844 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
845 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
846 }
847}
848
849#[cfg(feature = "app-battledetail")]
850impl BattleDetail_SecureParam {
851 #[doc = "`.ctor(crate::app::battledetail::BattleDetail)` — overload selector"]
852 pub fn new(detail: crate::app::battledetail::BattleDetail) -> Self {
853 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
854 panic!(
855 "{}
856::{}
857 failed to instantiate",
858 ::core::stringify!(BattleDetail_SecureParam),
859 ::core::stringify!(new),
860 )
861 });
862 <Self as IBattleDetail_SecureParamMethods>::ctor(this, detail);
863 this
864 }
865}
866
867#[cfg(feature = "app-battledetail")]
868pub trait IBattleDetail_SimplePowerParamMethods: IBattleDetail_SimplePowerParam {
869 #[doc = "`.ctor()` overload"]
870 fn ctor(self) -> () {
871 unsafe {
872 let __receiver =
873 <BattleDetail_SimplePowerParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
874 ::unity::il2cpp_call!((::unity::module_base()+0x19b7c80usize)as*mut u8,();
875(BattleDetail_SimplePowerParam)__receiver)
876 }
877 }
878 #[doc = "`Calculate(crate::app::battleinfoside::BattleInfoSide)` overload"]
879 fn calculate(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
880 unsafe {
881 let __receiver =
882 <BattleDetail_SimplePowerParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
883 {
884 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
885 let __vi = *__vt.get(6usize).unwrap_or_else(|| {
886 panic!(
887 "unity: virtual slot {}
888 out of range (vtable len {}
889) on the runtime class behind {}
890 (method `{}
891`)",
892 6usize,
893 __vt.len(),
894 <BattleDetail_SimplePowerParam as ::unity::ClassIdentity>::NAME,
895 "Calculate",
896 )
897 });
898 let __inner: extern "C" fn(
899 BattleDetail_SimplePowerParam,
900 crate::app::battleinfoside::BattleInfoSide,
901 ::unity::OptionalMethod,
902 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
903 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
904 __inner(__receiver, ::core::convert::Into::into(side), __mi)
905 }
906 }
907 }
908}
909
910#[cfg(feature = "app-battledetail")]
911impl<__T: IBattleDetail_SimplePowerParam> IBattleDetail_SimplePowerParamMethods for __T {}
912
913#[cfg(feature = "app-battledetail")]
914impl BattleDetail_SimplePowerParam {
915 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
916 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
917 }
918
919 pub fn calculate_method_info() -> &'static ::unity::il2cpp::MethodInfo {
920 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
921 }
922}
923
924#[cfg(feature = "app-battledetail")]
925impl BattleDetail_SimplePowerParam {
926 #[doc = "Direct (non-virtual) call to `BattleDetail_SimplePowerParam`'s own `Calculate`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
927 pub unsafe fn calculate(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
928 let __mi = Self::calculate_method_info();
929 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
930 ::core::mem::transmute(__mi.method_ptr);
931 __inner(this.into(), side, ::core::option::Option::None)
932 }
933}
934
935#[cfg(feature = "app-battledetail")]
936impl BattleDetail_SimplePowerParam {
937 #[doc = "`.ctor()` — no args"]
938 pub fn new() -> Self {
939 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
940 panic!(
941 "{}
942::{}
943 failed to instantiate",
944 ::core::stringify!(BattleDetail_SimplePowerParam),
945 ::core::stringify!(new),
946 )
947 });
948 <Self as IBattleDetail_SimplePowerParamMethods>::ctor(this);
949 this
950 }
951}
952
953#[cfg(feature = "app-battledetail")]
954pub trait IBattleDetail_UnitAttackParamMethods: IBattleDetail_UnitAttackParam {
955 #[doc = "`.ctor(crate::app::battledetail::BattleDetail)` overload"]
956 fn ctor(self, detail: impl ::core::convert::Into<crate::app::battledetail::BattleDetail>) -> () {
957 unsafe {
958 let __receiver =
959 <BattleDetail_UnitAttackParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
960 ::unity::il2cpp_call!((::unity::module_base()+0x19b7e20usize)as*mut u8,();
961(BattleDetail_UnitAttackParam)__receiver,(crate::app::battledetail::BattleDetail)::core::convert::Into::into(detail))
962 }
963 }
964}
965
966#[cfg(feature = "app-battledetail")]
967impl<__T: IBattleDetail_UnitAttackParam> IBattleDetail_UnitAttackParamMethods for __T {}
968
969#[cfg(feature = "app-battledetail")]
970impl BattleDetail_UnitAttackParam {
971 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
972 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
973 }
974}
975
976#[cfg(feature = "app-battledetail")]
977impl BattleDetail_UnitAttackParam {
978 #[doc = "`.ctor(crate::app::battledetail::BattleDetail)` — overload selector"]
979 pub fn new(detail: crate::app::battledetail::BattleDetail) -> Self {
980 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
981 panic!(
982 "{}
983::{}
984 failed to instantiate",
985 ::core::stringify!(BattleDetail_UnitAttackParam),
986 ::core::stringify!(new),
987 )
988 });
989 <Self as IBattleDetail_UnitAttackParamMethods>::ctor(this, detail);
990 this
991 }
992}
993
994#[cfg(feature = "app-battledetail")]
995pub trait IBattleDetail_CriticalParamMethods: IBattleDetail_CriticalParam {
996 #[doc = "`.ctor(crate::app::battledetail::BattleDetail)` overload"]
997 fn ctor(self, detail: impl ::core::convert::Into<crate::app::battledetail::BattleDetail>) -> () {
998 unsafe {
999 let __receiver =
1000 <BattleDetail_CriticalParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1001 ::unity::il2cpp_call!((::unity::module_base()+0x19b76d0usize)as*mut u8,();
1002(BattleDetail_CriticalParam)__receiver,(crate::app::battledetail::BattleDetail)::core::convert::Into::into(detail))
1003 }
1004 }
1005}
1006
1007#[cfg(feature = "app-battledetail")]
1008impl<__T: IBattleDetail_CriticalParam> IBattleDetail_CriticalParamMethods for __T {}
1009
1010#[cfg(feature = "app-battledetail")]
1011impl BattleDetail_CriticalParam {
1012 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1013 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1014 }
1015}
1016
1017#[cfg(feature = "app-battledetail")]
1018impl BattleDetail_CriticalParam {
1019 #[doc = "`.ctor(crate::app::battledetail::BattleDetail)` — overload selector"]
1020 pub fn new(detail: crate::app::battledetail::BattleDetail) -> Self {
1021 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1022 panic!(
1023 "{}
1024::{}
1025 failed to instantiate",
1026 ::core::stringify!(BattleDetail_CriticalParam),
1027 ::core::stringify!(new),
1028 )
1029 });
1030 <Self as IBattleDetail_CriticalParamMethods>::ctor(this, detail);
1031 this
1032 }
1033}
1034
1035#[cfg(feature = "app-battledetail")]
1036pub trait IBattleDetail_DetailParamMethods: IBattleDetail_DetailParam {
1037 #[doc = "`.ctor(crate::app::battledetail::BattleDetail, ::unity::Il2CppString)` overload"]
1038 fn ctor(
1039 self,
1040 detail: impl ::core::convert::Into<crate::app::battledetail::BattleDetail>,
1041 command: impl ::core::convert::Into<::unity::Il2CppString>,
1042 ) -> () {
1043 unsafe {
1044 let __receiver =
1045 <BattleDetail_DetailParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1046 ::unity::il2cpp_call!((::unity::module_base()+0x19b7270usize)as*mut u8,();
1047(BattleDetail_DetailParam)__receiver,(crate::app::battledetail::BattleDetail)::core::convert::Into::into(detail),(::unity::Il2CppString)::core::convert::Into::into(command))
1048 }
1049 }
1050 #[doc = "`get_Detail()` overload"]
1051 fn get_detail(self) -> crate::app::battledetail::BattleDetail {
1052 unsafe {
1053 let __receiver =
1054 <BattleDetail_DetailParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1055 ::unity::il2cpp_call!((::unity::module_base()+0x19b77b0usize)as*mut u8,crate::app::battledetail::BattleDetail;
1056(BattleDetail_DetailParam)__receiver)
1057 }
1058 }
1059 #[doc = "`Calculate(crate::app::battleinfoside::BattleInfoSide)` overload"]
1060 fn calculate(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
1061 unsafe {
1062 let __receiver =
1063 <BattleDetail_DetailParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1064 {
1065 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1066 let __vi = *__vt.get(6usize).unwrap_or_else(|| {
1067 panic!(
1068 "unity: virtual slot {}
1069 out of range (vtable len {}
1070) on the runtime class behind {}
1071 (method `{}
1072`)",
1073 6usize,
1074 __vt.len(),
1075 <BattleDetail_DetailParam as ::unity::ClassIdentity>::NAME,
1076 "Calculate",
1077 )
1078 });
1079 let __inner: extern "C" fn(BattleDetail_DetailParam, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
1080 ::core::mem::transmute(__vi.method_ptr);
1081 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1082 __inner(__receiver, ::core::convert::Into::into(side), __mi)
1083 }
1084 }
1085 }
1086}
1087
1088#[cfg(feature = "app-battledetail")]
1089impl<__T: IBattleDetail_DetailParam> IBattleDetail_DetailParamMethods for __T {}
1090
1091#[cfg(feature = "app-battledetail")]
1092impl BattleDetail_DetailParam {
1093 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1094 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1095 }
1096
1097 pub fn get_detail_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1098 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1099 }
1100
1101 pub fn calculate_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1102 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1103 }
1104}
1105
1106#[cfg(feature = "app-battledetail")]
1107impl BattleDetail_DetailParam {
1108 #[doc = "Direct (non-virtual) call to `BattleDetail_DetailParam`'s own `Calculate`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1109 pub unsafe fn calculate(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
1110 let __mi = Self::calculate_method_info();
1111 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
1112 ::core::mem::transmute(__mi.method_ptr);
1113 __inner(this.into(), side, ::core::option::Option::None)
1114 }
1115}
1116
1117#[cfg(feature = "app-battledetail")]
1118impl BattleDetail_DetailParam {
1119 #[doc = "`.ctor(crate::app::battledetail::BattleDetail, ::unity::Il2CppString)` — overload selector"]
1120 pub fn new(detail: crate::app::battledetail::BattleDetail, command: ::unity::Il2CppString) -> Self {
1121 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1122 panic!(
1123 "{}
1124::{}
1125 failed to instantiate",
1126 ::core::stringify!(BattleDetail_DetailParam),
1127 ::core::stringify!(new),
1128 )
1129 });
1130 <Self as IBattleDetail_DetailParamMethods>::ctor(this, detail, command);
1131 this
1132 }
1133}
1134
1135#[cfg(feature = "app-battledetail")]
1136pub trait IBattleDetail_UnitDefenseParamMethods: IBattleDetail_UnitDefenseParam {
1137 #[doc = "`.ctor(crate::app::battledetail::BattleDetail)` overload"]
1138 fn ctor(self, detail: impl ::core::convert::Into<crate::app::battledetail::BattleDetail>) -> () {
1139 unsafe {
1140 let __receiver =
1141 <BattleDetail_UnitDefenseParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1142 ::unity::il2cpp_call!((::unity::module_base()+0x19b7e90usize)as*mut u8,();
1143(BattleDetail_UnitDefenseParam)__receiver,(crate::app::battledetail::BattleDetail)::core::convert::Into::into(detail))
1144 }
1145 }
1146}
1147
1148#[cfg(feature = "app-battledetail")]
1149impl<__T: IBattleDetail_UnitDefenseParam> IBattleDetail_UnitDefenseParamMethods for __T {}
1150
1151#[cfg(feature = "app-battledetail")]
1152impl BattleDetail_UnitDefenseParam {
1153 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1154 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1155 }
1156}
1157
1158#[cfg(feature = "app-battledetail")]
1159impl BattleDetail_UnitDefenseParam {
1160 #[doc = "`.ctor(crate::app::battledetail::BattleDetail)` — overload selector"]
1161 pub fn new(detail: crate::app::battledetail::BattleDetail) -> Self {
1162 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1163 panic!(
1164 "{}
1165::{}
1166 failed to instantiate",
1167 ::core::stringify!(BattleDetail_UnitDefenseParam),
1168 ::core::stringify!(new),
1169 )
1170 });
1171 <Self as IBattleDetail_UnitDefenseParamMethods>::ctor(this, detail);
1172 this
1173 }
1174}
1175
1176#[cfg(feature = "app-battledetail")]
1177pub trait IBattleDetail_AvoidParamMethods: IBattleDetail_AvoidParam {
1178 #[doc = "`.ctor(crate::app::battledetail::BattleDetail)` overload"]
1179 fn ctor(self, detail: impl ::core::convert::Into<crate::app::battledetail::BattleDetail>) -> () {
1180 unsafe {
1181 let __receiver =
1182 <BattleDetail_AvoidParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1183 ::unity::il2cpp_call!((::unity::module_base()+0x19b7350usize)as*mut u8,();
1184(BattleDetail_AvoidParam)__receiver,(crate::app::battledetail::BattleDetail)::core::convert::Into::into(detail))
1185 }
1186 }
1187 #[doc = "`Calculate(crate::app::battleinfoside::BattleInfoSide)` overload"]
1188 fn calculate(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
1189 unsafe {
1190 let __receiver =
1191 <BattleDetail_AvoidParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1192 {
1193 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1194 let __vi = *__vt.get(6usize).unwrap_or_else(|| {
1195 panic!(
1196 "unity: virtual slot {}
1197 out of range (vtable len {}
1198) on the runtime class behind {}
1199 (method `{}
1200`)",
1201 6usize,
1202 __vt.len(),
1203 <BattleDetail_AvoidParam as ::unity::ClassIdentity>::NAME,
1204 "Calculate",
1205 )
1206 });
1207 let __inner: extern "C" fn(BattleDetail_AvoidParam, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
1208 ::core::mem::transmute(__vi.method_ptr);
1209 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1210 __inner(__receiver, ::core::convert::Into::into(side), __mi)
1211 }
1212 }
1213 }
1214}
1215
1216#[cfg(feature = "app-battledetail")]
1217impl<__T: IBattleDetail_AvoidParam> IBattleDetail_AvoidParamMethods for __T {}
1218
1219#[cfg(feature = "app-battledetail")]
1220impl BattleDetail_AvoidParam {
1221 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1222 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1223 }
1224
1225 pub fn calculate_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1226 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1227 }
1228}
1229
1230#[cfg(feature = "app-battledetail")]
1231impl BattleDetail_AvoidParam {
1232 #[doc = "Direct (non-virtual) call to `BattleDetail_AvoidParam`'s own `Calculate`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1233 pub unsafe fn calculate(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
1234 let __mi = Self::calculate_method_info();
1235 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
1236 ::core::mem::transmute(__mi.method_ptr);
1237 __inner(this.into(), side, ::core::option::Option::None)
1238 }
1239}
1240
1241#[cfg(feature = "app-battledetail")]
1242impl BattleDetail_AvoidParam {
1243 #[doc = "`.ctor(crate::app::battledetail::BattleDetail)` — overload selector"]
1244 pub fn new(detail: crate::app::battledetail::BattleDetail) -> Self {
1245 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1246 panic!(
1247 "{}
1248::{}
1249 failed to instantiate",
1250 ::core::stringify!(BattleDetail_AvoidParam),
1251 ::core::stringify!(new),
1252 )
1253 });
1254 <Self as IBattleDetail_AvoidParamMethods>::ctor(this, detail);
1255 this
1256 }
1257}
1258
1259#[cfg(feature = "app-battledetail")]
1260pub trait IBattleDetailMethods: IBattleDetail {
1261 #[doc = "`.ctor()` overload"]
1262 fn ctor(self) -> () {
1263 unsafe {
1264 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1265 ::unity::il2cpp_call!((::unity::module_base()+0x1e73070usize)as*mut u8,();
1266(BattleDetail)__receiver)
1267 }
1268 }
1269 #[doc = "`OnEnter()` overload"]
1270 fn on_enter(self) -> () {
1271 unsafe {
1272 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1273 {
1274 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1275 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
1276 panic!(
1277 "unity: virtual slot {}
1278 out of range (vtable len {}
1279) on the runtime class behind {}
1280 (method `{}
1281`)",
1282 4usize,
1283 __vt.len(),
1284 <BattleDetail as ::unity::ClassIdentity>::NAME,
1285 "OnEnter",
1286 )
1287 });
1288 let __inner: extern "C" fn(BattleDetail, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
1289 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1290 __inner(__receiver, __mi)
1291 }
1292 }
1293 }
1294 #[doc = "`OnExit()` overload"]
1295 fn on_exit(self) -> () {
1296 unsafe {
1297 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1298 {
1299 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1300 let __vi = *__vt.get(5usize).unwrap_or_else(|| {
1301 panic!(
1302 "unity: virtual slot {}
1303 out of range (vtable len {}
1304) on the runtime class behind {}
1305 (method `{}
1306`)",
1307 5usize,
1308 __vt.len(),
1309 <BattleDetail as ::unity::ClassIdentity>::NAME,
1310 "OnExit",
1311 )
1312 });
1313 let __inner: extern "C" fn(BattleDetail, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
1314 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1315 __inner(__receiver, __mi)
1316 }
1317 }
1318 }
1319 #[doc = "`Clear()` overload"]
1320 fn clear(self) -> () {
1321 unsafe {
1322 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1323 ::unity::il2cpp_call!((::unity::module_base()+0x1e73660usize)as*mut u8,();
1324(BattleDetail)__receiver)
1325 }
1326 }
1327 #[doc = "`Copy(crate::app::battledetail::BattleDetail)` overload"]
1328 fn copy(self, src: impl ::core::convert::Into<crate::app::battledetail::BattleDetail>) -> () {
1329 unsafe {
1330 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1331 ::unity::il2cpp_call!((::unity::module_base()+0x1e739e0usize)as*mut u8,();
1332(BattleDetail)__receiver,(crate::app::battledetail::BattleDetail)::core::convert::Into::into(src))
1333 }
1334 }
1335 #[doc = "`CalcBattle(crate::app::battleinfoside::BattleInfoSide, crate::app::battleinfoside::BattleInfoSide)` overload"]
1336 fn calc_battle(
1337 self,
1338 current: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
1339 reverse: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
1340 ) -> () {
1341 unsafe {
1342 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1343 ::unity::il2cpp_call!((::unity::module_base()+0x1e74300usize)as*mut u8,();
1344(BattleDetail)__receiver,(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(current),(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(reverse))
1345 }
1346 }
1347 #[doc = "`CalcInterferenceRod(crate::app::battleinfoside::BattleInfoSide)` overload"]
1348 fn calc_interference_rod(self, current: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> () {
1349 unsafe {
1350 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1351 ::unity::il2cpp_call!((::unity::module_base()+0x1e74d50usize)as*mut u8,();
1352(BattleDetail)__receiver,(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(current))
1353 }
1354 }
1355 #[doc = "`get_Capability()` overload"]
1356 fn get_capability(self) -> crate::app::capabilityint::CapabilityInt {
1357 unsafe {
1358 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1359 ::unity::il2cpp_call!((::unity::module_base()+0x1e74d90usize)as*mut u8,crate::app::capabilityint::CapabilityInt;
1360(BattleDetail)__receiver)
1361 }
1362 }
1363 #[doc = "`set_Capability(crate::app::capabilityint::CapabilityInt)` overload"]
1364 fn set_capability(self, value: impl ::core::convert::Into<crate::app::capabilityint::CapabilityInt>) -> () {
1365 unsafe {
1366 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1367 ::unity::il2cpp_call!((::unity::module_base()+0x1e74da0usize)as*mut u8,();
1368(BattleDetail)__receiver,(crate::app::capabilityint::CapabilityInt)::core::convert::Into::into(value))
1369 }
1370 }
1371 #[doc = "`CalcCapability(crate::app::battleinfoside::BattleInfoSide, crate::app::battleinfoside::BattleInfoSide)` overload"]
1372 fn calc_capability(
1373 self,
1374 current: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
1375 reverse: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
1376 ) -> () {
1377 unsafe {
1378 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1379 ::unity::il2cpp_call!((::unity::module_base()+0x1e74db0usize)as*mut u8,();
1380(BattleDetail)__receiver,(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(current),(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(reverse))
1381 }
1382 }
1383 #[doc = "`get_BattleCount()` overload"]
1384 fn get_battle_count(self) -> i32 {
1385 unsafe {
1386 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1387 ::unity::il2cpp_call!((::unity::module_base()+0x1e75f90usize)as*mut u8,i32;
1388(BattleDetail)__receiver)
1389 }
1390 }
1391 #[doc = "`set_BattleCount(i32)` overload"]
1392 fn set_battle_count(self, value: impl ::core::convert::Into<i32>) -> () {
1393 unsafe {
1394 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1395 ::unity::il2cpp_call!((::unity::module_base()+0x1e75fc0usize)as*mut u8,();
1396(BattleDetail)__receiver,(i32)::core::convert::Into::into(value))
1397 }
1398 }
1399 #[doc = "`get_ActionCount()` overload"]
1400 fn get_action_count(self) -> i32 {
1401 unsafe {
1402 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1403 ::unity::il2cpp_call!((::unity::module_base()+0x1e75ff0usize)as*mut u8,i32;
1404(BattleDetail)__receiver)
1405 }
1406 }
1407 #[doc = "`set_ActionCount(i32)` overload"]
1408 fn set_action_count(self, value: impl ::core::convert::Into<i32>) -> () {
1409 unsafe {
1410 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1411 ::unity::il2cpp_call!((::unity::module_base()+0x1e74cf0usize)as*mut u8,();
1412(BattleDetail)__receiver,(i32)::core::convert::Into::into(value))
1413 }
1414 }
1415 #[doc = "`get_AttackCount()` overload"]
1416 fn get_attack_count(self) -> i32 {
1417 unsafe {
1418 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1419 ::unity::il2cpp_call!((::unity::module_base()+0x1e76020usize)as*mut u8,i32;
1420(BattleDetail)__receiver)
1421 }
1422 }
1423 #[doc = "`set_AttackCount(i32)` overload"]
1424 fn set_attack_count(self, value: impl ::core::convert::Into<i32>) -> () {
1425 unsafe {
1426 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1427 ::unity::il2cpp_call!((::unity::module_base()+0x1e74d20usize)as*mut u8,();
1428(BattleDetail)__receiver,(i32)::core::convert::Into::into(value))
1429 }
1430 }
1431 #[doc = "`get_TerrainDefense()` overload"]
1432 fn get_terrain_defense(self) -> i32 {
1433 unsafe {
1434 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1435 ::unity::il2cpp_call!((::unity::module_base()+0x1e76050usize)as*mut u8,i32;
1436(BattleDetail)__receiver)
1437 }
1438 }
1439 #[doc = "`set_TerrainDefense(i32)` overload"]
1440 fn set_terrain_defense(self, value: impl ::core::convert::Into<i32>) -> () {
1441 unsafe {
1442 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1443 ::unity::il2cpp_call!((::unity::module_base()+0x1e76080usize)as*mut u8,();
1444(BattleDetail)__receiver,(i32)::core::convert::Into::into(value))
1445 }
1446 }
1447 #[doc = "`get_TerrainAvoid()` overload"]
1448 fn get_terrain_avoid(self) -> i32 {
1449 unsafe {
1450 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1451 ::unity::il2cpp_call!((::unity::module_base()+0x1e760b0usize)as*mut u8,i32;
1452(BattleDetail)__receiver)
1453 }
1454 }
1455 #[doc = "`set_TerrainAvoid(i32)` overload"]
1456 fn set_terrain_avoid(self, value: impl ::core::convert::Into<i32>) -> () {
1457 unsafe {
1458 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1459 ::unity::il2cpp_call!((::unity::module_base()+0x1e760e0usize)as*mut u8,();
1460(BattleDetail)__receiver,(i32)::core::convert::Into::into(value))
1461 }
1462 }
1463 #[doc = "`get_SupportHit()` overload"]
1464 fn get_support_hit(self) -> i32 {
1465 unsafe {
1466 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1467 ::unity::il2cpp_call!((::unity::module_base()+0x1e76110usize)as*mut u8,i32;
1468(BattleDetail)__receiver)
1469 }
1470 }
1471 #[doc = "`set_SupportHit(i32)` overload"]
1472 fn set_support_hit(self, value: impl ::core::convert::Into<i32>) -> () {
1473 unsafe {
1474 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1475 ::unity::il2cpp_call!((::unity::module_base()+0x1e76140usize)as*mut u8,();
1476(BattleDetail)__receiver,(i32)::core::convert::Into::into(value))
1477 }
1478 }
1479 #[doc = "`get_SupportAvoid()` overload"]
1480 fn get_support_avoid(self) -> i32 {
1481 unsafe {
1482 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1483 ::unity::il2cpp_call!((::unity::module_base()+0x1e76170usize)as*mut u8,i32;
1484(BattleDetail)__receiver)
1485 }
1486 }
1487 #[doc = "`set_SupportAvoid(i32)` overload"]
1488 fn set_support_avoid(self, value: impl ::core::convert::Into<i32>) -> () {
1489 unsafe {
1490 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1491 ::unity::il2cpp_call!((::unity::module_base()+0x1e761a0usize)as*mut u8,();
1492(BattleDetail)__receiver,(i32)::core::convert::Into::into(value))
1493 }
1494 }
1495 #[doc = "`get_SupportCritical()` overload"]
1496 fn get_support_critical(self) -> i32 {
1497 unsafe {
1498 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1499 ::unity::il2cpp_call!((::unity::module_base()+0x1e761d0usize)as*mut u8,i32;
1500(BattleDetail)__receiver)
1501 }
1502 }
1503 #[doc = "`set_SupportCritical(i32)` overload"]
1504 fn set_support_critical(self, value: impl ::core::convert::Into<i32>) -> () {
1505 unsafe {
1506 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1507 ::unity::il2cpp_call!((::unity::module_base()+0x1e76200usize)as*mut u8,();
1508(BattleDetail)__receiver,(i32)::core::convert::Into::into(value))
1509 }
1510 }
1511 #[doc = "`get_SupportSecure()` overload"]
1512 fn get_support_secure(self) -> i32 {
1513 unsafe {
1514 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1515 ::unity::il2cpp_call!((::unity::module_base()+0x1e76230usize)as*mut u8,i32;
1516(BattleDetail)__receiver)
1517 }
1518 }
1519 #[doc = "`set_SupportSecure(i32)` overload"]
1520 fn set_support_secure(self, value: impl ::core::convert::Into<i32>) -> () {
1521 unsafe {
1522 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1523 ::unity::il2cpp_call!((::unity::module_base()+0x1e76260usize)as*mut u8,();
1524(BattleDetail)__receiver,(i32)::core::convert::Into::into(value))
1525 }
1526 }
1527 #[doc = "`get_WeaponAttack()` overload"]
1528 fn get_weapon_attack(self) -> i32 {
1529 unsafe {
1530 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1531 ::unity::il2cpp_call!((::unity::module_base()+0x1e76290usize)as*mut u8,i32;
1532(BattleDetail)__receiver)
1533 }
1534 }
1535 #[doc = "`set_WeaponAttack(i32)` overload"]
1536 fn set_weapon_attack(self, value: impl ::core::convert::Into<i32>) -> () {
1537 unsafe {
1538 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1539 ::unity::il2cpp_call!((::unity::module_base()+0x1e762c0usize)as*mut u8,();
1540(BattleDetail)__receiver,(i32)::core::convert::Into::into(value))
1541 }
1542 }
1543 #[doc = "`get_WeaponEfficacy()` overload"]
1544 fn get_weapon_efficacy(self) -> i32 {
1545 unsafe {
1546 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1547 ::unity::il2cpp_call!((::unity::module_base()+0x1e762f0usize)as*mut u8,i32;
1548(BattleDetail)__receiver)
1549 }
1550 }
1551 #[doc = "`set_WeaponEfficacy(i32)` overload"]
1552 fn set_weapon_efficacy(self, value: impl ::core::convert::Into<i32>) -> () {
1553 unsafe {
1554 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1555 ::unity::il2cpp_call!((::unity::module_base()+0x1e76320usize)as*mut u8,();
1556(BattleDetail)__receiver,(i32)::core::convert::Into::into(value))
1557 }
1558 }
1559 #[doc = "`get_WeaponHit()` overload"]
1560 fn get_weapon_hit(self) -> i32 {
1561 unsafe {
1562 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1563 ::unity::il2cpp_call!((::unity::module_base()+0x1e76350usize)as*mut u8,i32;
1564(BattleDetail)__receiver)
1565 }
1566 }
1567 #[doc = "`set_WeaponHit(i32)` overload"]
1568 fn set_weapon_hit(self, value: impl ::core::convert::Into<i32>) -> () {
1569 unsafe {
1570 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1571 ::unity::il2cpp_call!((::unity::module_base()+0x1e76380usize)as*mut u8,();
1572(BattleDetail)__receiver,(i32)::core::convert::Into::into(value))
1573 }
1574 }
1575 #[doc = "`get_WeaponAvoid()` overload"]
1576 fn get_weapon_avoid(self) -> i32 {
1577 unsafe {
1578 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1579 ::unity::il2cpp_call!((::unity::module_base()+0x1e763b0usize)as*mut u8,i32;
1580(BattleDetail)__receiver)
1581 }
1582 }
1583 #[doc = "`set_WeaponAvoid(i32)` overload"]
1584 fn set_weapon_avoid(self, value: impl ::core::convert::Into<i32>) -> () {
1585 unsafe {
1586 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1587 ::unity::il2cpp_call!((::unity::module_base()+0x1e763e0usize)as*mut u8,();
1588(BattleDetail)__receiver,(i32)::core::convert::Into::into(value))
1589 }
1590 }
1591 #[doc = "`get_WeaponCritical()` overload"]
1592 fn get_weapon_critical(self) -> i32 {
1593 unsafe {
1594 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1595 ::unity::il2cpp_call!((::unity::module_base()+0x1e76410usize)as*mut u8,i32;
1596(BattleDetail)__receiver)
1597 }
1598 }
1599 #[doc = "`set_WeaponCritical(i32)` overload"]
1600 fn set_weapon_critical(self, value: impl ::core::convert::Into<i32>) -> () {
1601 unsafe {
1602 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1603 ::unity::il2cpp_call!((::unity::module_base()+0x1e76440usize)as*mut u8,();
1604(BattleDetail)__receiver,(i32)::core::convert::Into::into(value))
1605 }
1606 }
1607 #[doc = "`get_WeaponSecure()` overload"]
1608 fn get_weapon_secure(self) -> i32 {
1609 unsafe {
1610 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1611 ::unity::il2cpp_call!((::unity::module_base()+0x1e76470usize)as*mut u8,i32;
1612(BattleDetail)__receiver)
1613 }
1614 }
1615 #[doc = "`set_WeaponSecure(i32)` overload"]
1616 fn set_weapon_secure(self, value: impl ::core::convert::Into<i32>) -> () {
1617 unsafe {
1618 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1619 ::unity::il2cpp_call!((::unity::module_base()+0x1e764a0usize)as*mut u8,();
1620(BattleDetail)__receiver,(i32)::core::convert::Into::into(value))
1621 }
1622 }
1623 #[doc = "`get_WeaponWeight()` overload"]
1624 fn get_weapon_weight(self) -> i32 {
1625 unsafe {
1626 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1627 ::unity::il2cpp_call!((::unity::module_base()+0x1e764d0usize)as*mut u8,i32;
1628(BattleDetail)__receiver)
1629 }
1630 }
1631 #[doc = "`set_WeaponWeight(i32)` overload"]
1632 fn set_weapon_weight(self, value: impl ::core::convert::Into<i32>) -> () {
1633 unsafe {
1634 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1635 ::unity::il2cpp_call!((::unity::module_base()+0x1e75f60usize)as*mut u8,();
1636(BattleDetail)__receiver,(i32)::core::convert::Into::into(value))
1637 }
1638 }
1639 #[doc = "`get_SkillCorrect()` overload"]
1640 fn get_skill_correct(self) -> i32 {
1641 unsafe {
1642 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1643 ::unity::il2cpp_call!((::unity::module_base()+0x1e76500usize)as*mut u8,i32;
1644(BattleDetail)__receiver)
1645 }
1646 }
1647 #[doc = "`set_SkillCorrect(i32)` overload"]
1648 fn set_skill_correct(self, value: impl ::core::convert::Into<i32>) -> () {
1649 unsafe {
1650 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1651 ::unity::il2cpp_call!((::unity::module_base()+0x1e76530usize)as*mut u8,();
1652(BattleDetail)__receiver,(i32)::core::convert::Into::into(value))
1653 }
1654 }
1655 #[doc = "`get_GodSkillCorrect()` overload"]
1656 fn get_god_skill_correct(self) -> i32 {
1657 unsafe {
1658 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1659 ::unity::il2cpp_call!((::unity::module_base()+0x1e76560usize)as*mut u8,i32;
1660(BattleDetail)__receiver)
1661 }
1662 }
1663 #[doc = "`set_GodSkillCorrect(i32)` overload"]
1664 fn set_god_skill_correct(self, value: impl ::core::convert::Into<i32>) -> () {
1665 unsafe {
1666 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1667 ::unity::il2cpp_call!((::unity::module_base()+0x1e76590usize)as*mut u8,();
1668(BattleDetail)__receiver,(i32)::core::convert::Into::into(value))
1669 }
1670 }
1671 #[doc = "`get_BlowRatio()` overload"]
1672 fn get_blow_ratio(self) -> i32 {
1673 unsafe {
1674 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1675 ::unity::il2cpp_call!((::unity::module_base()+0x1e765c0usize)as*mut u8,i32;
1676(BattleDetail)__receiver)
1677 }
1678 }
1679 #[doc = "`set_BlowRatio(i32)` overload"]
1680 fn set_blow_ratio(self, value: impl ::core::convert::Into<i32>) -> () {
1681 unsafe {
1682 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1683 ::unity::il2cpp_call!((::unity::module_base()+0x1e765f0usize)as*mut u8,();
1684(BattleDetail)__receiver,(i32)::core::convert::Into::into(value))
1685 }
1686 }
1687 #[doc = "`get_BlowDistance()` overload"]
1688 fn get_blow_distance(self) -> i32 {
1689 unsafe {
1690 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1691 ::unity::il2cpp_call!((::unity::module_base()+0x1e76620usize)as*mut u8,i32;
1692(BattleDetail)__receiver)
1693 }
1694 }
1695 #[doc = "`set_BlowDistance(i32)` overload"]
1696 fn set_blow_distance(self, value: impl ::core::convert::Into<i32>) -> () {
1697 unsafe {
1698 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1699 ::unity::il2cpp_call!((::unity::module_base()+0x1e76650usize)as*mut u8,();
1700(BattleDetail)__receiver,(i32)::core::convert::Into::into(value))
1701 }
1702 }
1703 #[doc = "`get_UnitAttack()` overload"]
1704 fn get_unit_attack(self) -> crate::app::battleparam::BattleParam {
1705 unsafe {
1706 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1707 ::unity::il2cpp_call!((::unity::module_base()+0x1e76680usize)as*mut u8,crate::app::battleparam::BattleParam;
1708(BattleDetail)__receiver)
1709 }
1710 }
1711 #[doc = "`get_UnitDefense()` overload"]
1712 fn get_unit_defense(self) -> crate::app::battleparam::BattleParam {
1713 unsafe {
1714 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1715 ::unity::il2cpp_call!((::unity::module_base()+0x1e766b0usize)as*mut u8,crate::app::battleparam::BattleParam;
1716(BattleDetail)__receiver)
1717 }
1718 }
1719 #[doc = "`get_Attack()` overload"]
1720 fn get_attack(self) -> crate::app::battleparam::BattleParam {
1721 unsafe {
1722 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1723 ::unity::il2cpp_call!((::unity::module_base()+0x1e766e0usize)as*mut u8,crate::app::battleparam::BattleParam;
1724(BattleDetail)__receiver)
1725 }
1726 }
1727 #[doc = "`get_Defense()` overload"]
1728 fn get_defense(self) -> crate::app::battleparam::BattleParam {
1729 unsafe {
1730 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1731 ::unity::il2cpp_call!((::unity::module_base()+0x1e76710usize)as*mut u8,crate::app::battleparam::BattleParam;
1732(BattleDetail)__receiver)
1733 }
1734 }
1735 #[doc = "`get_Hit()` overload"]
1736 fn get_hit(self) -> crate::app::battleparam::BattleParam {
1737 unsafe {
1738 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1739 ::unity::il2cpp_call!((::unity::module_base()+0x1e76740usize)as*mut u8,crate::app::battleparam::BattleParam;
1740(BattleDetail)__receiver)
1741 }
1742 }
1743 #[doc = "`get_Avoid()` overload"]
1744 fn get_avoid(self) -> crate::app::battleparam::BattleParam {
1745 unsafe {
1746 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1747 ::unity::il2cpp_call!((::unity::module_base()+0x1e76770usize)as*mut u8,crate::app::battleparam::BattleParam;
1748(BattleDetail)__receiver)
1749 }
1750 }
1751 #[doc = "`get_Critical()` overload"]
1752 fn get_critical(self) -> crate::app::battleparam::BattleParam {
1753 unsafe {
1754 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1755 ::unity::il2cpp_call!((::unity::module_base()+0x1e767a0usize)as*mut u8,crate::app::battleparam::BattleParam;
1756(BattleDetail)__receiver)
1757 }
1758 }
1759 #[doc = "`get_Secure()` overload"]
1760 fn get_secure(self) -> crate::app::battleparam::BattleParam {
1761 unsafe {
1762 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1763 ::unity::il2cpp_call!((::unity::module_base()+0x1e767d0usize)as*mut u8,crate::app::battleparam::BattleParam;
1764(BattleDetail)__receiver)
1765 }
1766 }
1767 #[doc = "`get_Continuous()` overload"]
1768 fn get_continuous(self) -> crate::app::battleparam::BattleParam {
1769 unsafe {
1770 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1771 ::unity::il2cpp_call!((::unity::module_base()+0x1e76800usize)as*mut u8,crate::app::battleparam::BattleParam;
1772(BattleDetail)__receiver)
1773 }
1774 }
1775 #[doc = "`get_SimplePower()` overload"]
1776 fn get_simple_power(self) -> crate::app::battleparam::BattleParam {
1777 unsafe {
1778 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1779 ::unity::il2cpp_call!((::unity::module_base()+0x1e76830usize)as*mut u8,crate::app::battleparam::BattleParam;
1780(BattleDetail)__receiver)
1781 }
1782 }
1783 #[doc = "`get_SimpleHit()` overload"]
1784 fn get_simple_hit(self) -> crate::app::battleparam::BattleParam {
1785 unsafe {
1786 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1787 ::unity::il2cpp_call!((::unity::module_base()+0x1e76860usize)as*mut u8,crate::app::battleparam::BattleParam;
1788(BattleDetail)__receiver)
1789 }
1790 }
1791 #[doc = "`get_SimpleCritical()` overload"]
1792 fn get_simple_critical(self) -> crate::app::battleparam::BattleParam {
1793 unsafe {
1794 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1795 ::unity::il2cpp_call!((::unity::module_base()+0x1e76890usize)as*mut u8,crate::app::battleparam::BattleParam;
1796(BattleDetail)__receiver)
1797 }
1798 }
1799 #[doc = "`CalcAttack(crate::app::battleinfoside::BattleInfoSide, crate::app::battleinfoside::BattleInfoSide)` overload"]
1800 fn calc_attack(
1801 self,
1802 current: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
1803 reverse: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
1804 ) -> () {
1805 unsafe {
1806 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1807 ::unity::il2cpp_call!((::unity::module_base()+0x1e74400usize)as*mut u8,();
1808(BattleDetail)__receiver,(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(current),(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(reverse))
1809 }
1810 }
1811 #[doc = "`IsEfficacy()` overload"]
1812 fn is_efficacy(self) -> bool {
1813 unsafe {
1814 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1815 ::unity::il2cpp_call!((::unity::module_base()+0x1e768c0usize)as*mut u8,bool;
1816(BattleDetail)__receiver)
1817 }
1818 }
1819 #[doc = "`CalcDefense(crate::app::battleinfoside::BattleInfoSide, crate::app::battleinfoside::BattleInfoSide)` overload"]
1820 fn calc_defense(
1821 self,
1822 current: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
1823 reverse: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
1824 ) -> () {
1825 unsafe {
1826 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1827 ::unity::il2cpp_call!((::unity::module_base()+0x1e746c0usize)as*mut u8,();
1828(BattleDetail)__receiver,(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(current),(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(reverse))
1829 }
1830 }
1831 #[doc = "`CalcHit(crate::app::battleinfoside::BattleInfoSide, crate::app::battleinfoside::BattleInfoSide)` overload"]
1832 fn calc_hit(
1833 self,
1834 current: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
1835 reverse: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
1836 ) -> () {
1837 unsafe {
1838 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1839 ::unity::il2cpp_call!((::unity::module_base()+0x1e74810usize)as*mut u8,();
1840(BattleDetail)__receiver,(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(current),(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(reverse))
1841 }
1842 }
1843 #[doc = "`CalcAvoid(crate::app::battleinfoside::BattleInfoSide, crate::app::battleinfoside::BattleInfoSide)` overload"]
1844 fn calc_avoid(
1845 self,
1846 current: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
1847 reverse: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
1848 ) -> () {
1849 unsafe {
1850 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1851 ::unity::il2cpp_call!((::unity::module_base()+0x1e74900usize)as*mut u8,();
1852(BattleDetail)__receiver,(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(current),(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(reverse))
1853 }
1854 }
1855 #[doc = "`CalcCritical(crate::app::battleinfoside::BattleInfoSide, crate::app::battleinfoside::BattleInfoSide)` overload"]
1856 fn calc_critical(
1857 self,
1858 current: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
1859 reverse: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
1860 ) -> () {
1861 unsafe {
1862 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1863 ::unity::il2cpp_call!((::unity::module_base()+0x1e74b00usize)as*mut u8,();
1864(BattleDetail)__receiver,(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(current),(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(reverse))
1865 }
1866 }
1867 #[doc = "`CalcSecure(crate::app::battleinfoside::BattleInfoSide, crate::app::battleinfoside::BattleInfoSide)` overload"]
1868 fn calc_secure(
1869 self,
1870 current: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
1871 reverse: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
1872 ) -> () {
1873 unsafe {
1874 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1875 ::unity::il2cpp_call!((::unity::module_base()+0x1e74bf0usize)as*mut u8,();
1876(BattleDetail)__receiver,(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(current),(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(reverse))
1877 }
1878 }
1879 #[doc = "`CalcContinuous(crate::app::battleinfoside::BattleInfoSide, crate::app::battleinfoside::BattleInfoSide)` overload"]
1880 fn calc_continuous(
1881 self,
1882 current: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
1883 reverse: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
1884 ) -> () {
1885 unsafe {
1886 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1887 ::unity::il2cpp_call!((::unity::module_base()+0x1e74cc0usize)as*mut u8,();
1888(BattleDetail)__receiver,(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(current),(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(reverse))
1889 }
1890 }
1891 #[doc = "`get_AttackAttribute()` overload"]
1892 fn get_attack_attribute(self) -> crate::app::battlecalculator::BattleCalculator_Attributes {
1893 unsafe {
1894 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1895 ::unity::il2cpp_call!((::unity::module_base()+0x1e76920usize)as*mut u8,crate::app::battlecalculator::BattleCalculator_Attributes;
1896(BattleDetail)__receiver)
1897 }
1898 }
1899 #[doc = "`set_AttackAttribute(crate::app::battlecalculator::BattleCalculator_Attributes)` overload"]
1900 fn set_attack_attribute(self, value: impl ::core::convert::Into<crate::app::battlecalculator::BattleCalculator_Attributes>) -> () {
1901 unsafe {
1902 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1903 ::unity::il2cpp_call!((::unity::module_base()+0x1e76930usize)as*mut u8,();
1904(BattleDetail)__receiver,(crate::app::battlecalculator::BattleCalculator_Attributes)::core::convert::Into::into(value))
1905 }
1906 }
1907 #[doc = "`get_SkillLayers()` overload"]
1908 fn get_skill_layers(self) -> crate::app::skilldata::SkillData_Layers {
1909 unsafe {
1910 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1911 ::unity::il2cpp_call!((::unity::module_base()+0x1e76940usize)as*mut u8,crate::app::skilldata::SkillData_Layers;
1912(BattleDetail)__receiver)
1913 }
1914 }
1915 #[doc = "`set_SkillLayers(crate::app::skilldata::SkillData_Layers)` overload"]
1916 fn set_skill_layers(self, value: impl ::core::convert::Into<crate::app::skilldata::SkillData_Layers>) -> () {
1917 unsafe {
1918 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1919 ::unity::il2cpp_call!((::unity::module_base()+0x1e76950usize)as*mut u8,();
1920(BattleDetail)__receiver,(crate::app::skilldata::SkillData_Layers)::core::convert::Into::into(value))
1921 }
1922 }
1923 #[doc = "`get_ActiveSkill()` overload"]
1924 fn get_active_skill(self) -> crate::app::skillarray::SkillArray {
1925 unsafe {
1926 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1927 ::unity::il2cpp_call!((::unity::module_base()+0x1e76960usize)as*mut u8,crate::app::skillarray::SkillArray;
1928(BattleDetail)__receiver)
1929 }
1930 }
1931 #[doc = "`IsEnable(crate::app::skilldata::SkillData)` overload"]
1932 fn is_enable(self, skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>) -> bool {
1933 unsafe {
1934 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1935 ::unity::il2cpp_call!((::unity::module_base()+0x1e76970usize)as*mut u8,bool;
1936(BattleDetail)__receiver,(crate::app::skilldata::SkillData)::core::convert::Into::into(skill))
1937 }
1938 }
1939 #[doc = "`AddActiveSkill(crate::app::skilldata::SkillData)` overload"]
1940 fn add_active_skill(self, skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>) -> () {
1941 unsafe {
1942 let __receiver = <BattleDetail as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1943 ::unity::il2cpp_call!((::unity::module_base()+0x1e769c0usize)as*mut u8,();
1944(BattleDetail)__receiver,(crate::app::skilldata::SkillData)::core::convert::Into::into(skill))
1945 }
1946 }
1947}
1948
1949#[cfg(feature = "app-battledetail")]
1950impl<__T: IBattleDetail> IBattleDetailMethods for __T {}
1951
1952#[cfg(feature = "app-battledetail")]
1953impl BattleDetail {
1954 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1955 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1956 }
1957
1958 pub fn on_enter_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1959 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1960 }
1961
1962 pub fn on_exit_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1963 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1964 }
1965
1966 pub fn clear_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1967 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
1968 }
1969
1970 pub fn copy_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1971 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
1972 }
1973
1974 pub fn calc_battle_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1975 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
1976 }
1977
1978 pub fn calc_interference_rod_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1979 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
1980 }
1981
1982 pub fn get_capability_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1983 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
1984 }
1985
1986 pub fn set_capability_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1987 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
1988 }
1989
1990 pub fn calc_capability_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1991 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
1992 }
1993
1994 pub fn get_battle_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1995 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
1996 }
1997
1998 pub fn set_battle_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1999 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
2000 }
2001
2002 pub fn get_action_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2003 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
2004 }
2005
2006 pub fn set_action_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2007 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
2008 }
2009
2010 pub fn get_attack_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2011 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[14]
2012 }
2013
2014 pub fn set_attack_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2015 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[15]
2016 }
2017
2018 pub fn get_terrain_defense_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2019 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[16]
2020 }
2021
2022 pub fn set_terrain_defense_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2023 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[17]
2024 }
2025
2026 pub fn get_terrain_avoid_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2027 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[18]
2028 }
2029
2030 pub fn set_terrain_avoid_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2031 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[19]
2032 }
2033
2034 pub fn get_support_hit_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2035 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[20]
2036 }
2037
2038 pub fn set_support_hit_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2039 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[21]
2040 }
2041
2042 pub fn get_support_avoid_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2043 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[22]
2044 }
2045
2046 pub fn set_support_avoid_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2047 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[23]
2048 }
2049
2050 pub fn get_support_critical_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2051 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[24]
2052 }
2053
2054 pub fn set_support_critical_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2055 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[25]
2056 }
2057
2058 pub fn get_support_secure_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2059 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[26]
2060 }
2061
2062 pub fn set_support_secure_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2063 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[27]
2064 }
2065
2066 pub fn get_weapon_attack_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2067 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[28]
2068 }
2069
2070 pub fn set_weapon_attack_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2071 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[29]
2072 }
2073
2074 pub fn get_weapon_efficacy_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2075 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[30]
2076 }
2077
2078 pub fn set_weapon_efficacy_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2079 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[31]
2080 }
2081
2082 pub fn get_weapon_hit_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2083 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[32]
2084 }
2085
2086 pub fn set_weapon_hit_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2087 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[33]
2088 }
2089
2090 pub fn get_weapon_avoid_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2091 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[34]
2092 }
2093
2094 pub fn set_weapon_avoid_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2095 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[35]
2096 }
2097
2098 pub fn get_weapon_critical_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2099 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[36]
2100 }
2101
2102 pub fn set_weapon_critical_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2103 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[37]
2104 }
2105
2106 pub fn get_weapon_secure_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2107 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[38]
2108 }
2109
2110 pub fn set_weapon_secure_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2111 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[39]
2112 }
2113
2114 pub fn get_weapon_weight_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2115 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[40]
2116 }
2117
2118 pub fn set_weapon_weight_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2119 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[41]
2120 }
2121
2122 pub fn get_skill_correct_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2123 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[42]
2124 }
2125
2126 pub fn set_skill_correct_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2127 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[43]
2128 }
2129
2130 pub fn get_god_skill_correct_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2131 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[44]
2132 }
2133
2134 pub fn set_god_skill_correct_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2135 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[45]
2136 }
2137
2138 pub fn get_blow_ratio_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2139 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[46]
2140 }
2141
2142 pub fn set_blow_ratio_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2143 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[47]
2144 }
2145
2146 pub fn get_blow_distance_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2147 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[48]
2148 }
2149
2150 pub fn set_blow_distance_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2151 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[49]
2152 }
2153
2154 pub fn get_unit_attack_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2155 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[50]
2156 }
2157
2158 pub fn get_unit_defense_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2159 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[51]
2160 }
2161
2162 pub fn get_attack_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2163 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[52]
2164 }
2165
2166 pub fn get_defense_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2167 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[53]
2168 }
2169
2170 pub fn get_hit_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2171 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[54]
2172 }
2173
2174 pub fn get_avoid_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2175 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[55]
2176 }
2177
2178 pub fn get_critical_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2179 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[56]
2180 }
2181
2182 pub fn get_secure_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2183 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[57]
2184 }
2185
2186 pub fn get_continuous_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2187 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[58]
2188 }
2189
2190 pub fn get_simple_power_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2191 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[59]
2192 }
2193
2194 pub fn get_simple_hit_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2195 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[60]
2196 }
2197
2198 pub fn get_simple_critical_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2199 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[61]
2200 }
2201
2202 pub fn calc_attack_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2203 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[62]
2204 }
2205
2206 pub fn is_efficacy_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2207 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[63]
2208 }
2209
2210 pub fn calc_defense_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2211 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[64]
2212 }
2213
2214 pub fn calc_hit_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2215 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[65]
2216 }
2217
2218 pub fn calc_avoid_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2219 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[66]
2220 }
2221
2222 pub fn calc_critical_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2223 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[67]
2224 }
2225
2226 pub fn calc_secure_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2227 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[68]
2228 }
2229
2230 pub fn calc_continuous_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2231 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[69]
2232 }
2233
2234 pub fn get_attack_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2235 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[70]
2236 }
2237
2238 pub fn set_attack_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2239 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[71]
2240 }
2241
2242 pub fn get_skill_layers_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2243 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[72]
2244 }
2245
2246 pub fn set_skill_layers_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2247 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[73]
2248 }
2249
2250 pub fn get_active_skill_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2251 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[74]
2252 }
2253
2254 pub fn is_enable_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2255 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[75]
2256 }
2257
2258 pub fn add_active_skill_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2259 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[76]
2260 }
2261}
2262
2263#[cfg(feature = "app-battledetail")]
2264impl BattleDetail {
2265 #[doc = "Direct (non-virtual) call to `BattleDetail`'s own `OnEnter`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2266 pub unsafe fn on_enter(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
2267 let __mi = Self::on_enter_method_info();
2268 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
2269 __inner(this.into(), ::core::option::Option::None)
2270 }
2271
2272 #[doc = "Direct (non-virtual) call to `BattleDetail`'s own `OnExit`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2273 pub unsafe fn on_exit(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
2274 let __mi = Self::on_exit_method_info();
2275 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
2276 __inner(this.into(), ::core::option::Option::None)
2277 }
2278}
2279
2280#[cfg(feature = "app-battledetail")]
2281impl BattleDetail {
2282 #[doc = "`.ctor()` — no args"]
2283 pub fn new() -> Self {
2284 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2285 panic!(
2286 "{}
2287::{}
2288 failed to instantiate",
2289 ::core::stringify!(BattleDetail),
2290 ::core::stringify!(new),
2291 )
2292 });
2293 <Self as IBattleDetailMethods>::ctor(this);
2294 this
2295 }
2296}
2297
2298#[cfg(feature = "app-battledetail")]
2299pub trait IBattleDetail_HitParamMethods: IBattleDetail_HitParam {
2300 #[doc = "`.ctor(crate::app::battledetail::BattleDetail)` overload"]
2301 fn ctor(self, detail: impl ::core::convert::Into<crate::app::battledetail::BattleDetail>) -> () {
2302 unsafe {
2303 let __receiver = <BattleDetail_HitParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2304 ::unity::il2cpp_call!((::unity::module_base()+0x19b77e0usize)as*mut u8,();
2305(BattleDetail_HitParam)__receiver,(crate::app::battledetail::BattleDetail)::core::convert::Into::into(detail))
2306 }
2307 }
2308 #[doc = "`Calculate(crate::app::battleinfoside::BattleInfoSide)` overload"]
2309 fn calculate(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
2310 unsafe {
2311 let __receiver = <BattleDetail_HitParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2312 {
2313 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2314 let __vi = *__vt.get(6usize).unwrap_or_else(|| {
2315 panic!(
2316 "unity: virtual slot {}
2317 out of range (vtable len {}
2318) on the runtime class behind {}
2319 (method `{}
2320`)",
2321 6usize,
2322 __vt.len(),
2323 <BattleDetail_HitParam as ::unity::ClassIdentity>::NAME,
2324 "Calculate",
2325 )
2326 });
2327 let __inner: extern "C" fn(BattleDetail_HitParam, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
2328 ::core::mem::transmute(__vi.method_ptr);
2329 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2330 __inner(__receiver, ::core::convert::Into::into(side), __mi)
2331 }
2332 }
2333 }
2334}
2335
2336#[cfg(feature = "app-battledetail")]
2337impl<__T: IBattleDetail_HitParam> IBattleDetail_HitParamMethods for __T {}
2338
2339#[cfg(feature = "app-battledetail")]
2340impl BattleDetail_HitParam {
2341 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2342 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2343 }
2344
2345 pub fn calculate_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2346 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2347 }
2348}
2349
2350#[cfg(feature = "app-battledetail")]
2351impl BattleDetail_HitParam {
2352 #[doc = "Direct (non-virtual) call to `BattleDetail_HitParam`'s own `Calculate`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2353 pub unsafe fn calculate(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
2354 let __mi = Self::calculate_method_info();
2355 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
2356 ::core::mem::transmute(__mi.method_ptr);
2357 __inner(this.into(), side, ::core::option::Option::None)
2358 }
2359}
2360
2361#[cfg(feature = "app-battledetail")]
2362impl BattleDetail_HitParam {
2363 #[doc = "`.ctor(crate::app::battledetail::BattleDetail)` — overload selector"]
2364 pub fn new(detail: crate::app::battledetail::BattleDetail) -> Self {
2365 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2366 panic!(
2367 "{}
2368::{}
2369 failed to instantiate",
2370 ::core::stringify!(BattleDetail_HitParam),
2371 ::core::stringify!(new),
2372 )
2373 });
2374 <Self as IBattleDetail_HitParamMethods>::ctor(this, detail);
2375 this
2376 }
2377}
2378
2379#[cfg(feature = "app-battledetail")]
2380#[doc(hidden)]
2381pub mod prelude {
2382 pub use super::{
2383 BattleDetail, BattleDetail_AttackParam, BattleDetail_AvoidParam, BattleDetail_BaseParams, BattleDetail_BattleParams,
2384 BattleDetail_CommandParam, BattleDetail_ContinuousParam, BattleDetail_CriticalParam, BattleDetail_DefenseParam, BattleDetail_DetailParam,
2385 BattleDetail_HitParam, BattleDetail_SecureParam, BattleDetail_SimpleCriticalParam, BattleDetail_SimpleHitParam,
2386 BattleDetail_SimplePowerParam, BattleDetail_UnitAttackParam, BattleDetail_UnitDefenseParam, IBattleDetail, IBattleDetailMethods,
2387 IBattleDetail_AttackParam, IBattleDetail_AttackParamMethods, IBattleDetail_AvoidParam, IBattleDetail_AvoidParamMethods,
2388 IBattleDetail_CommandParam, IBattleDetail_CommandParamMethods, IBattleDetail_ContinuousParam, IBattleDetail_ContinuousParamMethods,
2389 IBattleDetail_CriticalParam, IBattleDetail_CriticalParamMethods, IBattleDetail_DefenseParam, IBattleDetail_DefenseParamMethods,
2390 IBattleDetail_DetailParam, IBattleDetail_DetailParamMethods, IBattleDetail_HitParam, IBattleDetail_HitParamMethods,
2391 IBattleDetail_SecureParam, IBattleDetail_SecureParamMethods, IBattleDetail_SimpleCriticalParam, IBattleDetail_SimpleCriticalParamMethods,
2392 IBattleDetail_SimpleHitParam, IBattleDetail_SimpleHitParamMethods, IBattleDetail_SimplePowerParam, IBattleDetail_SimplePowerParamMethods,
2393 IBattleDetail_UnitAttackParam, IBattleDetail_UnitAttackParamMethods, IBattleDetail_UnitDefenseParam, IBattleDetail_UnitDefenseParamMethods,
2394 };
2395 #[cfg(feature = "app-battleparam")]
2396 pub use crate::app::battleparam::IBattleParamMethods;
2397 #[cfg(feature = "app-pool")]
2398 pub use crate::app::pool::IPool_NodeMethods;
2399 #[cfg(feature = "system-object")]
2400 pub use crate::system::object::IObjectMethods;
2401 #[cfg(feature = "system-enum")]
2402 pub use crate::system::r#enum::IEnumMethods;
2403 #[cfg(feature = "system-valuetype")]
2404 pub use crate::system::valuetype::IValueTypeMethods;
2405 pub use crate::{
2406 app::{battleparam::IBattleParam, pool::IPool_Node},
2407 system::{object::IObject, r#enum::IEnum, valuetype::IValueType},
2408 };
2409}