1#[cfg(feature = "app-battlecalculator-types")]
4mod __types {
5 #[allow(unused_imports)] use ::unity::prelude::*;
6
7 use super::*;
8 use crate::{
9 app::{
10 bitfield32::{BitField32, IBitField32},
11 bitfieldcommon::{BitFieldCommon, IBitFieldCommon},
12 bitfieldtemplate32_1::{BitFieldTemplate32_1, IBitFieldTemplate32_1},
13 pool::{IPool_List_1, IPool_Node, Pool_List_1, Pool_Node},
14 },
15 system::{
16 delegate::{Delegate, IDelegate},
17 multicastdelegate::{IMulticastDelegate, MulticastDelegate},
18 object::{IObject, Object},
19 r#enum::{Enum, IEnum},
20 valuetype::{IValueType, ValueType},
21 },
22 };
23
24 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/battlecalculator/BattleCalculator_Flags.md"))]
25 #[repr(C)]
26 #[derive(::core::clone::Clone, ::core::marker::Copy, ::core::fmt::Debug, ::core::cmp::PartialEq, ::core::cmp::Eq)]
27 pub struct BattleCalculator_Flags {
28 pub value: i32,
29 }
30 impl ::unity::ClassIdentity for BattleCalculator_Flags {
31 const NAME: &'static str = "BattleCalculator.Flags";
32 const NAMESPACE: &'static str = "App";
33
34 fn class() -> ::unity::Class {
35 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
36 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
37 }
38 }
39 impl ::unity::IlType for BattleCalculator_Flags {
40 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
41 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
42 }
43 }
44 impl BattleCalculator_Flags {
45 pub fn interrupt_offense() -> Self {
46 Self { value: 1 }
47 }
48
49 pub fn interrupt_defense() -> Self {
50 Self { value: 2 }
51 }
52
53 pub fn interrupting() -> Self {
54 Self { value: 4 }
55 }
56
57 pub fn continue_battle() -> Self {
58 Self { value: 8 }
59 }
60
61 pub fn swap_order() -> Self {
62 Self { value: 16 }
63 }
64
65 pub fn dead() -> Self {
66 Self { value: 32 }
67 }
68
69 pub fn chain_attacked() -> Self {
70 Self { value: 64 }
71 }
72
73 pub fn commited() -> Self {
74 Self { value: 128 }
75 }
76
77 pub fn mask_interrupt() -> Self {
78 Self { value: 7 }
79 }
80 }
81
82 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/battlecalculator/BattleCalculator.md"))]
83 #[::unity::class(namespace = "App", name = "BattleCalculator")]
84 #[parent(crate::system::object::Object)]
85 pub struct BattleCalculator {
86 #[offset(16)]
87 #[rename(name = "m_Mode")]
88 pub m_mode: crate::app::battlecalculator::BattleCalculator_Mode,
89 #[offset(24)]
90 #[rename(name = "m_Info")]
91 pub m_info: crate::app::battleinfo::BattleInfo,
92 #[offset(32)]
93 #[rename(name = "m_Flag")]
94 pub m_flag: crate::app::battlecalculator::BattleCalculator_FlagField,
95 #[offset(40)]
96 #[rename(name = "m_SceneList")]
97 pub m_scene_list: crate::app::battlescenelist::BattleSceneList,
98 #[offset(48)]
99 #[rename(name = "m_Orders")]
100 pub m_orders: crate::app::battlecalculator::BattleCalculator_OrderList,
101 #[offset(56)]
102 #[rename(name = "m_NextOrderIndex")]
103 pub m_next_order_index: i32,
104 #[offset(64)]
105 #[rename(name = "m_EquipSkill")]
106 pub m_equip_skill: crate::app::skilldata::SkillData,
107 #[offset(72)]
108 #[rename(name = "m_ChainOffenses")]
109 pub m_chain_offenses: crate::system::collections::generic::list_1::List_1<crate::app::battleinfoside::BattleInfoSide>,
110 #[offset(80)]
111 #[rename(name = "m_ChainDefenses")]
112 pub m_chain_defenses: crate::system::collections::generic::list_1::List_1<crate::app::battleinfoside::BattleInfoSide>,
113 #[offset(88)]
114 #[rename(name = "m_HitSkillPool")]
115 pub m_hit_skill_pool: crate::app::battlecalculator::BattleCalculator_HitSkillPool,
116 #[offset(96)]
117 #[rename(name = "m_CommitSkillUnits")]
118 pub m_commit_skill_units: crate::system::collections::generic::hashset_1::HashSet_1<i32>,
119 #[static_field]
120 #[rename(name = "CannonConditions")]
121 pub cannon_conditions: ::unity::Array<::unity::Il2CppString>,
122 #[static_field]
123 #[rename(name = "DanceConditions")]
124 pub dance_conditions: ::unity::Array<::unity::Il2CppString>,
125 #[static_field]
126 #[rename(name = "EngageSummon3")]
127 pub engage_summon3: ::unity::Array<::unity::Il2CppString>,
128 #[static_field]
129 #[rename(name = "EngageSummon5")]
130 pub engage_summon5: ::unity::Array<::unity::Il2CppString>,
131 }
132
133 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/battlecalculator/BattleCalculator_TargetScope.md"))]
134 #[repr(C)]
135 #[derive(::core::clone::Clone, ::core::marker::Copy)]
136 pub struct BattleCalculator_TargetScope {
137 pub m_current: crate::app::battleinfoside::BattleInfoSide,
138 pub m_reverse: crate::app::battleinfoside::BattleInfoSide,
139 pub m_is_dump: bool,
140 }
141 impl ::unity::ClassIdentity for BattleCalculator_TargetScope {
142 const NAME: &'static str = "BattleCalculator.TargetScope";
143 const NAMESPACE: &'static str = "App";
144
145 fn class() -> ::unity::Class {
146 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
147 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
148 }
149 }
150 impl ::unity::IlType for BattleCalculator_TargetScope {
151 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
152 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
153 }
154 }
155
156 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/battlecalculator/BattleCalculator_HitSkill.md"))]
157 #[::unity::class(namespace = "App", name = "BattleCalculator.HitSkill")]
158 #[parent(crate::app::pool::Pool_Node)]
159 pub struct BattleCalculator_HitSkill {
160 #[offset(16)]
161 #[rename(name = "Side")]
162 pub side: crate::app::battleinfoside::BattleInfoSide,
163 #[offset(24)]
164 #[rename(name = "Action")]
165 pub action: crate::app::skilldata::SkillData_Actions,
166 #[offset(32)]
167 #[rename(name = "Skill")]
168 pub skill: crate::app::skilldata::SkillData,
169 }
170
171 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/battlecalculator/BattleCalculator_TrainingResult.md"))]
172 #[repr(C)]
173 #[derive(::core::clone::Clone, ::core::marker::Copy, ::core::fmt::Debug, ::core::cmp::PartialEq, ::core::cmp::Eq)]
174 pub struct BattleCalculator_TrainingResult {
175 pub value: i32,
176 }
177 impl ::unity::ClassIdentity for BattleCalculator_TrainingResult {
178 const NAME: &'static str = "BattleCalculator.TrainingResult";
179 const NAMESPACE: &'static str = "App";
180
181 fn class() -> ::unity::Class {
182 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
183 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
184 }
185 }
186 impl ::unity::IlType for BattleCalculator_TrainingResult {
187 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
188 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
189 }
190 }
191 impl BattleCalculator_TrainingResult {
192 pub fn win() -> Self {
193 Self { value: 0 }
194 }
195
196 pub fn lose() -> Self {
197 Self { value: 1 }
198 }
199 }
200
201 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/battlecalculator/BattleCalculator_SeparatorScope.md"))]
202 #[repr(C)]
203 #[derive(::core::clone::Clone, ::core::marker::Copy)]
204 pub struct BattleCalculator_SeparatorScope {
205 pub m_calc: crate::app::battlecalculator::BattleCalculator,
206 pub m_push: crate::app::battlescene::BattleScene_Kind,
207 pub m_pop: crate::app::battlescene::BattleScene_Kind,
208 pub m_side: crate::app::battleside::BattleSide_Type,
209 pub m_equip_skill: crate::app::skilldata::SkillData,
210 pub m_is_dump: bool,
211 }
212 impl ::unity::ClassIdentity for BattleCalculator_SeparatorScope {
213 const NAME: &'static str = "BattleCalculator.SeparatorScope";
214 const NAMESPACE: &'static str = "App";
215
216 fn class() -> ::unity::Class {
217 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
218 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
219 }
220 }
221 impl ::unity::IlType for BattleCalculator_SeparatorScope {
222 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
223 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
224 }
225 }
226
227 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/battlecalculator/BattleCalculator_FlagField.md"))]
228 #[::unity::class(namespace = "App", name = "BattleCalculator.FlagField")]
229 #[parent(crate::app::bitfieldtemplate32_1::BitFieldTemplate32_1<crate::app::battlecalculator::BattleCalculator_Flags>)]
230 pub struct BattleCalculator_FlagField {}
231
232 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/battlecalculator/BattleCalculator_Order.md"))]
233 #[::unity::class(namespace = "App", name = "BattleCalculator.Order")]
234 #[parent(crate::app::pool::Pool_Node)]
235 pub struct BattleCalculator_Order {
236 #[offset(16)]
237 #[rename(name = "Side")]
238 pub side: crate::app::battleside::BattleSide_Type,
239 }
240
241 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/battlecalculator/BattleCalculator_Attributes.md"))]
242 #[repr(C)]
243 #[derive(::core::clone::Clone, ::core::marker::Copy, ::core::fmt::Debug, ::core::cmp::PartialEq, ::core::cmp::Eq)]
244 pub struct BattleCalculator_Attributes {
245 pub value: i32,
246 }
247 impl ::unity::ClassIdentity for BattleCalculator_Attributes {
248 const NAME: &'static str = "BattleCalculator.Attributes";
249 const NAMESPACE: &'static str = "App";
250
251 fn class() -> ::unity::Class {
252 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
253 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
254 }
255 }
256 impl ::unity::IlType for BattleCalculator_Attributes {
257 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
258 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
259 }
260 }
261 impl BattleCalculator_Attributes {
262 pub fn none() -> Self {
263 Self { value: 0 }
264 }
265
266 pub fn physical() -> Self {
267 Self { value: 1 }
268 }
269
270 pub fn magic() -> Self {
271 Self { value: 2 }
272 }
273 }
274
275 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/battlecalculator/BattleCalculator_DetailScope.md"))]
276 #[repr(C)]
277 #[derive(::core::clone::Clone, ::core::marker::Copy)]
278 pub struct BattleCalculator_DetailScope {
279 pub m_info: crate::app::battleinfo::BattleInfo,
280 }
281 impl ::unity::ClassIdentity for BattleCalculator_DetailScope {
282 const NAME: &'static str = "BattleCalculator.DetailScope";
283 const NAMESPACE: &'static str = "App";
284
285 fn class() -> ::unity::Class {
286 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
287 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
288 }
289 }
290 impl ::unity::IlType for BattleCalculator_DetailScope {
291 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
292 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
293 }
294 }
295
296 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/battlecalculator/BattleCalculator_Mode.md"))]
297 #[repr(C)]
298 #[derive(::core::clone::Clone, ::core::marker::Copy, ::core::fmt::Debug, ::core::cmp::PartialEq, ::core::cmp::Eq)]
299 pub struct BattleCalculator_Mode {
300 pub value: i32,
301 }
302 impl ::unity::ClassIdentity for BattleCalculator_Mode {
303 const NAME: &'static str = "BattleCalculator.Mode";
304 const NAMESPACE: &'static str = "App";
305
306 fn class() -> ::unity::Class {
307 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
308 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
309 }
310 }
311 impl ::unity::IlType for BattleCalculator_Mode {
312 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
313 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
314 }
315 }
316 impl BattleCalculator_Mode {
317 pub fn battle() -> Self {
318 Self { value: 0 }
319 }
320
321 pub fn job_intro() -> Self {
322 Self { value: 1 }
323 }
324
325 pub fn class_change() -> Self {
326 Self { value: 2 }
327 }
328 }
329
330 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/battlecalculator/BattleCalculator_HitSkillPool.md"))]
331 #[::unity::class(namespace = "App", name = "BattleCalculator.HitSkillPool")]
332 #[parent(crate::app::pool::Pool_List_1<crate::app::battlecalculator::BattleCalculator_HitSkill>)]
333 pub struct BattleCalculator_HitSkillPool {}
334
335 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/battlecalculator/BattleCalculator_FuncExp2.md"))]
336 #[::unity::class(namespace = "App", name = "BattleCalculator.FuncExp2")]
337 #[parent(crate::system::multicastdelegate::MulticastDelegate)]
338 pub struct BattleCalculator_FuncExp2 {}
339
340 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/battlecalculator/BattleCalculator_FuncExp1.md"))]
341 #[::unity::class(namespace = "App", name = "BattleCalculator.FuncExp1")]
342 #[parent(crate::system::multicastdelegate::MulticastDelegate)]
343 pub struct BattleCalculator_FuncExp1 {}
344
345 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/battlecalculator/BattleCalculator_OrderList.md"))]
346 #[::unity::class(namespace = "App", name = "BattleCalculator.OrderList")]
347 #[parent(crate::app::pool::Pool_List_1<crate::app::battlecalculator::BattleCalculator_Order>)]
348 pub struct BattleCalculator_OrderList {
349 #[static_field]
350 #[rename(name = "MaxOrder")]
351 pub max_order: i32,
352 }
353}
354
355#[cfg(feature = "app-battlecalculator-types")]
356pub use __types::*;
357
358#[cfg(feature = "app-battlecalculator")]
359impl BattleCalculator {
360 #[doc = "`FindIgnoreSkill(crate::app::battleinfoside::BattleInfoSide, crate::app::skilldata::SkillData)` overload"]
361 pub fn find_ignore_skill(
362 target: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
363 skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>,
364 ) -> crate::app::skilldata::SkillData {
365 unsafe {
366 ::unity::il2cpp_call!((::unity::module_base()+0x246de90usize)as*mut u8,crate::app::skilldata::SkillData;
367(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(target),(crate::app::skilldata::SkillData)::core::convert::Into::into(skill))
368 }
369 }
370
371 #[doc = "`AddDebugIndent(::unity::Il2CppString)` overload"]
372 pub fn add_debug_indent(name: impl ::core::convert::Into<::unity::Il2CppString>) -> () {
373 unsafe {
374 ::unity::il2cpp_call!((::unity::module_base()+0x246f200usize)as*mut u8,();
375(::unity::Il2CppString)::core::convert::Into::into(name))
376 }
377 }
378
379 #[doc = "`DecDebugIndent()` overload"]
380 pub fn dec_debug_indent() -> () {
381 unsafe {
382 ::unity::il2cpp_call!((::unity::module_base()+0x246f210usize)as*mut u8,();
383 )
384 }
385 }
386
387 #[doc = "`GetCommandValue(::unity::Il2CppString, crate::app::battleinfoside::BattleInfoSide, crate::app::battleinfoside::BattleInfoSide)` overload"]
388 pub fn get_command_value(
389 key: impl ::core::convert::Into<::unity::Il2CppString>,
390 current: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
391 reverse: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
392 ) -> i32 {
393 unsafe {
394 ::unity::il2cpp_call!((::unity::module_base()+0x2471ff0usize)as*mut u8,i32;
395(::unity::Il2CppString)::core::convert::Into::into(key),(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(current),(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(reverse))
396 }
397 }
398
399 #[doc = "`GetChainGuardDamage(crate::app::battleinfoside::BattleInfoSide, crate::app::battleinfoside::BattleInfoSide)` overload"]
400 pub fn get_chain_guard_damage(
401 current: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
402 reverse: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
403 ) -> i32 {
404 unsafe {
405 ::unity::il2cpp_call!((::unity::module_base()+0x24720c0usize)as*mut u8,i32;
406(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(current),(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(reverse))
407 }
408 }
409
410 #[doc = "`.cctor()` overload"]
411 pub fn cctor() -> () {
412 unsafe {
413 ::unity::il2cpp_call!((::unity::module_base()+0x2479720usize)as*mut u8,();
414 )
415 }
416 }
417}
418
419#[cfg(feature = "app-battlecalculator")]
420pub trait IBattleCalculatorMethods: IBattleCalculator {
421 #[doc = "`.ctor(crate::app::battleinfo::BattleInfo)` overload"]
422 fn ctor(self, info: impl ::core::convert::Into<crate::app::battleinfo::BattleInfo>) -> () {
423 unsafe {
424 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
425 ::unity::il2cpp_call!((::unity::module_base()+0x24695a0usize)as*mut u8,();
426(BattleCalculator)__receiver,(crate::app::battleinfo::BattleInfo)::core::convert::Into::into(info))
427 }
428 }
429 #[doc = "`Dispose()` overload"]
430 fn dispose(self) -> () {
431 unsafe {
432 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
433 {
434 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
435 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
436 panic!(
437 "unity: virtual slot {}
438 out of range (vtable len {}
439) on the runtime class behind {}
440 (method `{}
441`)",
442 4usize,
443 __vt.len(),
444 <BattleCalculator as ::unity::ClassIdentity>::NAME,
445 "Dispose",
446 )
447 });
448 let __inner: extern "C" fn(BattleCalculator, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
449 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
450 __inner(__receiver, __mi)
451 }
452 }
453 }
454 #[doc = "`GetMode()` overload"]
455 fn get_mode(self) -> crate::app::battlecalculator::BattleCalculator_Mode {
456 unsafe {
457 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
458 ::unity::il2cpp_call!((::unity::module_base()+0x24697a0usize)as*mut u8,crate::app::battlecalculator::BattleCalculator_Mode;
459(BattleCalculator)__receiver)
460 }
461 }
462 #[doc = "`CalcBattle()` overload"]
463 fn calc_battle(self) -> crate::app::battlecalculator::BattleCalculator {
464 unsafe {
465 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
466 ::unity::il2cpp_call!((::unity::module_base()+0x24697b0usize)as*mut u8,crate::app::battlecalculator::BattleCalculator;
467(BattleCalculator)__receiver)
468 }
469 }
470 #[doc = "`Dump()` overload"]
471 fn dump(self) -> () {
472 unsafe {
473 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
474 ::unity::il2cpp_call!((::unity::module_base()+0x2469c80usize)as*mut u8,();
475(BattleCalculator)__receiver)
476 }
477 }
478 #[doc = "`TryAddSkillScene(crate::app::battlescene::BattleScene_Kind, crate::app::battleside::BattleSide_Type, crate::app::skilldata::SkillData)` overload"]
479 fn try_add_skill_scene(
480 self,
481 kind: impl ::core::convert::Into<crate::app::battlescene::BattleScene_Kind>,
482 side: impl ::core::convert::Into<crate::app::battleside::BattleSide_Type>,
483 skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>,
484 ) -> bool {
485 unsafe {
486 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
487 ::unity::il2cpp_call!((::unity::module_base()+0x2469c90usize)as*mut u8,bool;
488(BattleCalculator)__receiver,(crate::app::battlescene::BattleScene_Kind)::core::convert::Into::into(kind),(crate::app::battleside::BattleSide_Type)::core::convert::Into::into(side),(crate::app::skilldata::SkillData)::core::convert::Into::into(skill))
489 }
490 }
491 #[doc = "`CalcEngageStart(crate::app::battleside::BattleSide_Type)` overload"]
492 fn calc_engage_start(self, side: impl ::core::convert::Into<crate::app::battleside::BattleSide_Type>) -> () {
493 unsafe {
494 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
495 ::unity::il2cpp_call!((::unity::module_base()+0x2469d20usize)as*mut u8,();
496(BattleCalculator)__receiver,(crate::app::battleside::BattleSide_Type)::core::convert::Into::into(side))
497 }
498 }
499 #[doc = "`CalcInvokeSkill(crate::app::battleside::BattleSide_Type)` overload"]
500 fn calc_invoke_skill(self, side: impl ::core::convert::Into<crate::app::battleside::BattleSide_Type>) -> () {
501 unsafe {
502 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
503 ::unity::il2cpp_call!((::unity::module_base()+0x2469eb0usize)as*mut u8,();
504(BattleCalculator)__receiver,(crate::app::battleside::BattleSide_Type)::core::convert::Into::into(side))
505 }
506 }
507 #[doc = "`CalcEngageEnd(crate::app::battleside::BattleSide_Type)` overload"]
508 fn calc_engage_end(self, side: impl ::core::convert::Into<crate::app::battleside::BattleSide_Type>) -> () {
509 unsafe {
510 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
511 ::unity::il2cpp_call!((::unity::module_base()+0x246a010usize)as*mut u8,();
512(BattleCalculator)__receiver,(crate::app::battleside::BattleSide_Type)::core::convert::Into::into(side))
513 }
514 }
515 #[doc = "`CalcDetailSkill()` overload"]
516 fn calc_detail_skill(self) -> () {
517 unsafe {
518 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
519 ::unity::il2cpp_call!((::unity::module_base()+0x246a0b0usize)as*mut u8,();
520(BattleCalculator)__receiver)
521 }
522 }
523 #[doc = "`CalcBranch()` overload"]
524 fn calc_branch(self) -> () {
525 unsafe {
526 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
527 ::unity::il2cpp_call!((::unity::module_base()+0x24697e0usize)as*mut u8,();
528(BattleCalculator)__receiver)
529 }
530 }
531 #[doc = "`IsLateOrder()` overload"]
532 fn is_late_order(self) -> bool {
533 unsafe {
534 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
535 ::unity::il2cpp_call!((::unity::module_base()+0x246ba50usize)as*mut u8,bool;
536(BattleCalculator)__receiver)
537 }
538 }
539 #[doc = "`SeparatorTotalOrder()` overload"]
540 fn separator_total_order(self) -> () {
541 unsafe {
542 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
543 ::unity::il2cpp_call!((::unity::module_base()+0x246bb20usize)as*mut u8,();
544(BattleCalculator)__receiver)
545 }
546 }
547 #[doc = "`CalcNormalBattle()` overload"]
548 fn calc_normal_battle(self) -> () {
549 unsafe {
550 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
551 ::unity::il2cpp_call!((::unity::module_base()+0x246b580usize)as*mut u8,();
552(BattleCalculator)__receiver)
553 }
554 }
555 #[doc = "`CalcDestroy()` overload"]
556 fn calc_destroy(self) -> () {
557 unsafe {
558 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
559 ::unity::il2cpp_call!((::unity::module_base()+0x246af20usize)as*mut u8,();
560(BattleCalculator)__receiver)
561 }
562 }
563 #[doc = "`AddSkillSceneResult(crate::app::battlescene::BattleScene_Result)` overload"]
564 fn add_skill_scene_result(self, result: impl ::core::convert::Into<crate::app::battlescene::BattleScene_Result>) -> () {
565 unsafe {
566 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
567 ::unity::il2cpp_call!((::unity::module_base()+0x246c620usize)as*mut u8,();
568(BattleCalculator)__receiver,(crate::app::battlescene::BattleScene_Result)::core::convert::Into::into(result))
569 }
570 }
571 #[doc = "`CalcDestroyAttack(crate::app::battleside::BattleSide_Type)` overload"]
572 fn calc_destroy_attack(self, side: impl ::core::convert::Into<crate::app::battleside::BattleSide_Type>) -> bool {
573 unsafe {
574 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
575 ::unity::il2cpp_call!((::unity::module_base()+0x246bdb0usize)as*mut u8,bool;
576(BattleCalculator)__receiver,(crate::app::battleside::BattleSide_Type)::core::convert::Into::into(side))
577 }
578 }
579 #[doc = "`CalcWarmup()` overload"]
580 fn calc_warmup(self) -> crate::app::battlecalculator::BattleCalculator {
581 unsafe {
582 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
583 ::unity::il2cpp_call!((::unity::module_base()+0x246d590usize)as*mut u8,crate::app::battlecalculator::BattleCalculator;
584(BattleCalculator)__receiver)
585 }
586 }
587 #[doc = "`CalcSimulation()` overload"]
588 fn calc_simulation(self) -> crate::app::battlecalculator::BattleCalculator {
589 unsafe {
590 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
591 ::unity::il2cpp_call!((::unity::module_base()+0x246d610usize)as*mut u8,crate::app::battlecalculator::BattleCalculator;
592(BattleCalculator)__receiver)
593 }
594 }
595 #[doc = "`CalcJobIntro()` overload"]
596 fn calc_job_intro(self) -> crate::app::battlecalculator::BattleCalculator {
597 unsafe {
598 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
599 ::unity::il2cpp_call!((::unity::module_base()+0x246d6a0usize)as*mut u8,crate::app::battlecalculator::BattleCalculator;
600(BattleCalculator)__receiver)
601 }
602 }
603 #[doc = "`CalcClassChange()` overload"]
604 fn calc_class_change(self) -> crate::app::battlecalculator::BattleCalculator {
605 unsafe {
606 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
607 ::unity::il2cpp_call!((::unity::module_base()+0x246d6b0usize)as*mut u8,crate::app::battlecalculator::BattleCalculator;
608(BattleCalculator)__receiver)
609 }
610 }
611 #[doc = "`GetHp(crate::app::battleside::BattleSide_Type)` overload"]
612 fn get_hp(self, side: impl ::core::convert::Into<crate::app::battleside::BattleSide_Type>) -> i32 {
613 unsafe {
614 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
615 ::unity::il2cpp_call!((::unity::module_base()+0x246d6c0usize)as*mut u8,i32;
616(BattleCalculator)__receiver,(crate::app::battleside::BattleSide_Type)::core::convert::Into::into(side))
617 }
618 }
619 #[doc = "`GetStatus(crate::app::battleside::BattleSide_Type)` overload"]
620 fn get_status(
621 self,
622 side: impl ::core::convert::Into<crate::app::battleside::BattleSide_Type>,
623 ) -> crate::app::battleinfoside::BattleInfoSide_BitFieldStatus {
624 unsafe {
625 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
626 ::unity::il2cpp_call!((::unity::module_base()+0x246d730usize)as*mut u8,crate::app::battleinfoside::BattleInfoSide_BitFieldStatus;
627(BattleCalculator)__receiver,(crate::app::battleside::BattleSide_Type)::core::convert::Into::into(side))
628 }
629 }
630 #[doc = "`get_Info()` overload"]
631 fn get_info(self) -> crate::app::battleinfo::BattleInfo {
632 unsafe {
633 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
634 ::unity::il2cpp_call!((::unity::module_base()+0x246d7a0usize)as*mut u8,crate::app::battleinfo::BattleInfo;
635(BattleCalculator)__receiver)
636 }
637 }
638 #[doc = "`get_SceneList()` overload"]
639 fn get_scene_list(self) -> crate::app::battlescenelist::BattleSceneList {
640 unsafe {
641 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
642 ::unity::il2cpp_call!((::unity::module_base()+0x246d7b0usize)as*mut u8,crate::app::battlescenelist::BattleSceneList;
643(BattleCalculator)__receiver)
644 }
645 }
646 #[doc = "`CalcActiveSkill(crate::app::skilldata::SkillData_Timings, crate::app::battleside::BattleSide_Type)` overload"]
647 fn calc_active_skill(
648 self,
649 timing: impl ::core::convert::Into<crate::app::skilldata::SkillData_Timings>,
650 side: impl ::core::convert::Into<crate::app::battleside::BattleSide_Type>,
651 ) -> crate::app::battlescene::BattleScene_Result {
652 unsafe {
653 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
654 ::unity::il2cpp_call!((::unity::module_base()+0x2469f60usize)as*mut u8,crate::app::battlescene::BattleScene_Result;
655(BattleCalculator)__receiver,(crate::app::skilldata::SkillData_Timings)::core::convert::Into::into(timing),(crate::app::battleside::BattleSide_Type)::core::convert::Into::into(side))
656 }
657 }
658 #[doc = "`CanAttack(crate::app::battleinfoside::BattleInfoSide)` overload"]
659 fn can_attack(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> bool {
660 unsafe {
661 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
662 ::unity::il2cpp_call!((::unity::module_base()+0x246d9f0usize)as*mut u8,bool;
663(BattleCalculator)__receiver,(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(side))
664 }
665 }
666 #[doc = "`AddSkillScene(crate::app::skilldata::SkillData, crate::app::skilldata::SkillData_Actions, crate::app::battleinfoside::BattleInfoSide)` overload"]
667 fn add_skill_scene(
668 self,
669 skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>,
670 action: impl ::core::convert::Into<crate::app::skilldata::SkillData_Actions>,
671 current: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
672 ) -> () {
673 unsafe {
674 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
675 ::unity::il2cpp_call!((::unity::module_base()+0x246a350usize)as*mut u8,();
676(BattleCalculator)__receiver,(crate::app::skilldata::SkillData)::core::convert::Into::into(skill),(crate::app::skilldata::SkillData_Actions)::core::convert::Into::into(action),(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(current))
677 }
678 }
679 #[doc = "`GetBreaked(crate::app::battleinfoside::BattleInfoSide)` overload"]
680 fn get_breaked(
681 self,
682 target: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
683 ) -> crate::app::battlescene::BattleScene_Result {
684 unsafe {
685 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
686 ::unity::il2cpp_call!((::unity::module_base()+0x246db90usize)as*mut u8,crate::app::battlescene::BattleScene_Result;
687(BattleCalculator)__receiver,(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(target))
688 }
689 }
690 #[doc = "`AddGiveScene(crate::app::skilldata::SkillData, crate::app::battleinfoside::BattleInfoSide, crate::app::battleinfoside::BattleInfoSide, crate::app::battlescene::BattleScene_Kind)` overload"]
691 fn add_give_scene(
692 self,
693 give: impl ::core::convert::Into<crate::app::skilldata::SkillData>,
694 current: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
695 target: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
696 kind: impl ::core::convert::Into<crate::app::battlescene::BattleScene_Kind>,
697 ) -> crate::app::battlescene::BattleScene_Result {
698 unsafe {
699 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
700 ::unity::il2cpp_call!((::unity::module_base()+0x246dca0usize)as*mut u8,crate::app::battlescene::BattleScene_Result;
701(BattleCalculator)__receiver,(crate::app::skilldata::SkillData)::core::convert::Into::into(give),(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(current),(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(target),(crate::app::battlescene::BattleScene_Kind)::core::convert::Into::into(kind))
702 }
703 }
704 #[doc = "`AddGiveScene(crate::app::skilldata::SkillData, crate::app::battleinfoside::BattleInfoSide, crate::app::battleinfoside::BattleInfoSide)` overload"]
705 fn add_give_scene_2(
706 self,
707 give: impl ::core::convert::Into<crate::app::skilldata::SkillData>,
708 current: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
709 target: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
710 ) -> crate::app::battlescene::BattleScene_Result {
711 unsafe {
712 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
713 ::unity::il2cpp_call!((::unity::module_base()+0x246e0c0usize)as*mut u8,crate::app::battlescene::BattleScene_Result;
714(BattleCalculator)__receiver,(crate::app::skilldata::SkillData)::core::convert::Into::into(give),(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(current),(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(target))
715 }
716 }
717 #[doc = "`AddGivesScene(crate::app::skilldata::SkillData, crate::app::battleinfoside::BattleInfoSide, crate::app::battleinfoside::BattleInfoSide)` overload"]
718 fn add_gives_scene(
719 self,
720 skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>,
721 current: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
722 target: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
723 ) -> crate::app::battlescene::BattleScene_Result {
724 unsafe {
725 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
726 ::unity::il2cpp_call!((::unity::module_base()+0x246e770usize)as*mut u8,crate::app::battlescene::BattleScene_Result;
727(BattleCalculator)__receiver,(crate::app::skilldata::SkillData)::core::convert::Into::into(skill),(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(current),(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(target))
728 }
729 }
730 #[doc = "`AddGivesScene(crate::app::skilldata::SkillData, crate::app::skilldata::SkillData_Actions, crate::app::battleinfoside::BattleInfoSide)` overload"]
731 fn add_gives_scene_2(
732 self,
733 skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>,
734 action: impl ::core::convert::Into<crate::app::skilldata::SkillData_Actions>,
735 current: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
736 ) -> crate::app::battlescene::BattleScene_Result {
737 unsafe {
738 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
739 ::unity::il2cpp_call!((::unity::module_base()+0x246a520usize)as*mut u8,crate::app::battlescene::BattleScene_Result;
740(BattleCalculator)__receiver,(crate::app::skilldata::SkillData)::core::convert::Into::into(skill),(crate::app::skilldata::SkillData_Actions)::core::convert::Into::into(action),(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(current))
741 }
742 }
743 #[doc = "`CalcHitSkill(crate::app::battleinfoside::BattleInfoSide, crate::app::unititem::UnitItem)` overload"]
744 fn calc_hit_skill(
745 self,
746 current: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
747 unit_item: impl ::core::convert::Into<crate::app::unititem::UnitItem>,
748 ) -> crate::app::battlescene::BattleScene_Result {
749 unsafe {
750 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
751 ::unity::il2cpp_call!((::unity::module_base()+0x246e930usize)as*mut u8,crate::app::battlescene::BattleScene_Result;
752(BattleCalculator)__receiver,(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(current),(crate::app::unititem::UnitItem)::core::convert::Into::into(unit_item))
753 }
754 }
755 #[doc = "`CalcActiveSkill(crate::app::skilldata::SkillData_Timings, crate::app::skilldata::SkillData_Actions, crate::app::battleinfoside::BattleInfoSide)` overload"]
756 fn calc_active_skill_2(
757 self,
758 timing: impl ::core::convert::Into<crate::app::skilldata::SkillData_Timings>,
759 action: impl ::core::convert::Into<crate::app::skilldata::SkillData_Actions>,
760 current: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
761 ) -> crate::app::battlescene::BattleScene_Result {
762 unsafe {
763 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
764 ::unity::il2cpp_call!((::unity::module_base()+0x246d7c0usize)as*mut u8,crate::app::battlescene::BattleScene_Result;
765(BattleCalculator)__receiver,(crate::app::skilldata::SkillData_Timings)::core::convert::Into::into(timing),(crate::app::skilldata::SkillData_Actions)::core::convert::Into::into(action),(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(current))
766 }
767 }
768 #[doc = "`CanOrederSkill(crate::app::skilldata::SkillData, crate::app::battleinfoside::BattleInfoSide)` overload"]
769 fn can_oreder_skill(
770 self,
771 skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>,
772 current: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
773 ) -> bool {
774 unsafe {
775 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
776 ::unity::il2cpp_call!((::unity::module_base()+0x246ebd0usize)as*mut u8,bool;
777(BattleCalculator)__receiver,(crate::app::skilldata::SkillData)::core::convert::Into::into(skill),(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(current))
778 }
779 }
780 #[doc = "`CalcActiveSkill(crate::app::skilldata::SkillData, crate::app::skilldata::SkillData_Actions, crate::app::battleinfoside::BattleInfoSide)` overload"]
781 fn calc_active_skill_3(
782 self,
783 skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>,
784 action: impl ::core::convert::Into<crate::app::skilldata::SkillData_Actions>,
785 current: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
786 ) -> crate::app::battlescene::BattleScene_Result {
787 unsafe {
788 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
789 ::unity::il2cpp_call!((::unity::module_base()+0x246eb40usize)as*mut u8,crate::app::battlescene::BattleScene_Result;
790(BattleCalculator)__receiver,(crate::app::skilldata::SkillData)::core::convert::Into::into(skill),(crate::app::skilldata::SkillData_Actions)::core::convert::Into::into(action),(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(current))
791 }
792 }
793 #[doc = "`CalcHitSkill(crate::app::battleinfoside::BattleInfoSide, crate::app::battleinfoside::BattleInfoSide)` overload"]
794 fn calc_hit_skill_2(
795 self,
796 current: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
797 reverse: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
798 ) -> crate::app::battlescene::BattleScene_Result {
799 unsafe {
800 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
801 ::unity::il2cpp_call!((::unity::module_base()+0x246c660usize)as*mut u8,crate::app::battlescene::BattleScene_Result;
802(BattleCalculator)__receiver,(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(current),(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(reverse))
803 }
804 }
805 #[doc = "`CalcHitSkill(crate::app::battleinfoside::BattleInfoSide, crate::app::skilldata::SkillData_Actions, crate::app::skilldata::SkillData)` overload"]
806 fn calc_hit_skill_3(
807 self,
808 current: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
809 action: impl ::core::convert::Into<crate::app::skilldata::SkillData_Actions>,
810 skill: impl ::core::convert::Into<crate::app::skilldata::SkillData>,
811 ) -> () {
812 unsafe {
813 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
814 ::unity::il2cpp_call!((::unity::module_base()+0x246eda0usize)as*mut u8,();
815(BattleCalculator)__receiver,(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(current),(crate::app::skilldata::SkillData_Actions)::core::convert::Into::into(action),(crate::app::skilldata::SkillData)::core::convert::Into::into(skill))
816 }
817 }
818 #[doc = "`CalcResultSkill(crate::app::battleinfoside::BattleInfoSide)` overload"]
819 fn calc_result_skill(self, current: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> () {
820 unsafe {
821 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
822 ::unity::il2cpp_call!((::unity::module_base()+0x246eea0usize)as*mut u8,();
823(BattleCalculator)__receiver,(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(current))
824 }
825 }
826 #[doc = "`CalcResultSkill()` overload"]
827 fn calc_result_skill_2(self) -> () {
828 unsafe {
829 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
830 ::unity::il2cpp_call!((::unity::module_base()+0x246f0f0usize)as*mut u8,();
831(BattleCalculator)__receiver)
832 }
833 }
834 #[doc = "`CalcChainAttackSides(crate::app::battleinfoside::BattleInfoSide)` overload"]
835 fn calc_chain_attack_sides(
836 self,
837 current: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
838 ) -> crate::system::collections::generic::list_1::List_1<crate::app::battleinfoside::BattleInfoSide> {
839 unsafe {
840 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
841 ::unity::il2cpp_call!((::unity::module_base()+0x246f220usize)as*mut u8,crate::system::collections::generic::list_1::List_1<crate::app::battleinfoside::BattleInfoSide> ;
842(BattleCalculator)__receiver,(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(current))
843 }
844 }
845 #[doc = "`CalcChainGuardSide(crate::app::battleinfoside::BattleInfoSide)` overload"]
846 fn calc_chain_guard_side(
847 self,
848 reverse: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
849 ) -> crate::app::battleside::BattleSide_Type {
850 unsafe {
851 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
852 ::unity::il2cpp_call!((::unity::module_base()+0x246f3c0usize)as*mut u8,crate::app::battleside::BattleSide_Type;
853(BattleCalculator)__receiver,(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(reverse))
854 }
855 }
856 #[doc = "`CanChainAttack(crate::app::battleside::BattleSide_Type)` overload"]
857 fn can_chain_attack(self, side: impl ::core::convert::Into<crate::app::battleside::BattleSide_Type>) -> bool {
858 unsafe {
859 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
860 ::unity::il2cpp_call!((::unity::module_base()+0x246f610usize)as*mut u8,bool;
861(BattleCalculator)__receiver,(crate::app::battleside::BattleSide_Type)::core::convert::Into::into(side))
862 }
863 }
864 #[doc = "`CalcChainAttack(crate::app::battleside::BattleSide_Type)` overload"]
865 fn calc_chain_attack(self, side: impl ::core::convert::Into<crate::app::battleside::BattleSide_Type>) -> bool {
866 unsafe {
867 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
868 ::unity::il2cpp_call!((::unity::module_base()+0x246f690usize)as*mut u8,bool;
869(BattleCalculator)__receiver,(crate::app::battleside::BattleSide_Type)::core::convert::Into::into(side))
870 }
871 }
872 #[doc = "`CalcOrders(crate::app::battlecalculator::BattleCalculator_OrderList)` overload"]
873 fn calc_orders(self, orders: impl ::core::convert::Into<crate::app::battlecalculator::BattleCalculator_OrderList>) -> bool {
874 unsafe {
875 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
876 ::unity::il2cpp_call!((::unity::module_base()+0x246bc30usize)as*mut u8,bool;
877(BattleCalculator)__receiver,(crate::app::battlecalculator::BattleCalculator_OrderList)::core::convert::Into::into(orders))
878 }
879 }
880 #[doc = "`CalcInterruptOrder(crate::app::battleside::BattleSide_Type)` overload"]
881 fn calc_interrupt_order(self, side: impl ::core::convert::Into<crate::app::battleside::BattleSide_Type>) -> bool {
882 unsafe {
883 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
884 ::unity::il2cpp_call!((::unity::module_base()+0x24700b0usize)as*mut u8,bool;
885(BattleCalculator)__receiver,(crate::app::battleside::BattleSide_Type)::core::convert::Into::into(side))
886 }
887 }
888 #[doc = "`CalcInterrupt(crate::app::battleside::BattleSide_Type)` overload"]
889 fn calc_interrupt(self, side: impl ::core::convert::Into<crate::app::battleside::BattleSide_Type>) -> bool {
890 unsafe {
891 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
892 ::unity::il2cpp_call!((::unity::module_base()+0x2470530usize)as*mut u8,bool;
893(BattleCalculator)__receiver,(crate::app::battleside::BattleSide_Type)::core::convert::Into::into(side))
894 }
895 }
896 #[doc = "`AddEngageCount(crate::app::battleinfoside::BattleInfoSide)` overload"]
897 fn add_engage_count(self, current: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> () {
898 unsafe {
899 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
900 ::unity::il2cpp_call!((::unity::module_base()+0x2470740usize)as*mut u8,();
901(BattleCalculator)__receiver,(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(current))
902 }
903 }
904 #[doc = "`AddEngageCount(crate::app::battleside::BattleSide_Type)` overload"]
905 fn add_engage_count_2(self, side: impl ::core::convert::Into<crate::app::battleside::BattleSide_Type>) -> () {
906 unsafe {
907 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
908 ::unity::il2cpp_call!((::unity::module_base()+0x24709d0usize)as*mut u8,();
909(BattleCalculator)__receiver,(crate::app::battleside::BattleSide_Type)::core::convert::Into::into(side))
910 }
911 }
912 #[doc = "`CalcOrders(crate::app::battleside::BattleSide_Type)` overload"]
913 fn calc_orders_2(self, side: impl ::core::convert::Into<crate::app::battleside::BattleSide_Type>) -> bool {
914 unsafe {
915 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
916 ::unity::il2cpp_call!((::unity::module_base()+0x246fa50usize)as*mut u8,bool;
917(BattleCalculator)__receiver,(crate::app::battleside::BattleSide_Type)::core::convert::Into::into(side))
918 }
919 }
920 #[doc = "`CalcAssistSkill(crate::app::battleside::BattleSide_Type)` overload"]
921 fn calc_assist_skill(self, side: impl ::core::convert::Into<crate::app::battleside::BattleSide_Type>) -> () {
922 unsafe {
923 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
924 ::unity::il2cpp_call!((::unity::module_base()+0x2470b50usize)as*mut u8,();
925(BattleCalculator)__receiver,(crate::app::battleside::BattleSide_Type)::core::convert::Into::into(side))
926 }
927 }
928 #[doc = "`CalcOrder(crate::app::battleside::BattleSide_Type)` overload"]
929 fn calc_order(self, side: impl ::core::convert::Into<crate::app::battleside::BattleSide_Type>) -> bool {
930 unsafe {
931 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
932 ::unity::il2cpp_call!((::unity::module_base()+0x2470220usize)as*mut u8,bool;
933(BattleCalculator)__receiver,(crate::app::battleside::BattleSide_Type)::core::convert::Into::into(side))
934 }
935 }
936 #[doc = "`CalcAction(crate::app::battleside::BattleSide_Type)` overload"]
937 fn calc_action(self, side: impl ::core::convert::Into<crate::app::battleside::BattleSide_Type>) -> bool {
938 unsafe {
939 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
940 ::unity::il2cpp_call!((::unity::module_base()+0x2470d60usize)as*mut u8,bool;
941(BattleCalculator)__receiver,(crate::app::battleside::BattleSide_Type)::core::convert::Into::into(side))
942 }
943 }
944 #[doc = "`RandomCheckHit(i32)` overload"]
945 fn random_check_hit(self, ratio: impl ::core::convert::Into<i32>) -> bool {
946 unsafe {
947 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
948 ::unity::il2cpp_call!((::unity::module_base()+0x24722d0usize)as*mut u8,bool;
949(BattleCalculator)__receiver,(i32)::core::convert::Into::into(ratio))
950 }
951 }
952 #[doc = "`CalcAttack(crate::app::battleside::BattleSide_Type)` overload"]
953 fn calc_attack(self, side_type: impl ::core::convert::Into<crate::app::battleside::BattleSide_Type>) -> bool {
954 unsafe {
955 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
956 ::unity::il2cpp_call!((::unity::module_base()+0x2471060usize)as*mut u8,bool;
957(BattleCalculator)__receiver,(crate::app::battleside::BattleSide_Type)::core::convert::Into::into(side_type))
958 }
959 }
960 #[doc = "`CanEnter(crate::app::battleinfoside::BattleInfoSide, i32, i32)` overload"]
961 fn can_enter(
962 self,
963 side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
964 x: impl ::core::convert::Into<i32>,
965 z: impl ::core::convert::Into<i32>,
966 ) -> bool {
967 unsafe {
968 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
969 ::unity::il2cpp_call!((::unity::module_base()+0x2472a90usize)as*mut u8,bool;
970(BattleCalculator)__receiver,(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(side),(i32)::core::convert::Into::into(x),(i32)::core::convert::Into::into(z))
971 }
972 }
973 #[doc = "`CanBlow(crate::app::battleinfoside::BattleInfoSide, crate::app::battleinfoside::BattleInfoSide)` overload"]
974 fn can_blow(
975 self,
976 current: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
977 reverse: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
978 ) -> bool {
979 unsafe {
980 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
981 ::unity::il2cpp_call!((::unity::module_base()+0x2472bb0usize)as*mut u8,bool;
982(BattleCalculator)__receiver,(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(current),(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(reverse))
983 }
984 }
985 #[doc = "`CalcAttackHit(crate::app::battleinfoside::BattleInfoSide, crate::app::battleinfoside::BattleInfoSide, *muti32)` overload"]
986 fn calc_attack_hit(
987 self,
988 current: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
989 reverse: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
990 ) -> (crate::app::battlescene::BattleScene_Result, i32) {
991 unsafe {
992 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
993 let mut __out_0 = ::core::mem::MaybeUninit::<i32>::uninit();
994 let __ret = {
995 ::unity::il2cpp_call!((::unity::module_base()+0x24723a0usize)as*mut u8,crate::app::battlescene::BattleScene_Result;
996(BattleCalculator)__receiver,(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(current),(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(reverse),(*mut i32)__out_0.as_mut_ptr())
997 };
998 (__ret, __out_0.assume_init())
999 }
1000 }
1001 #[doc = "`TryAddDeadScene(crate::app::battleinfoside::BattleInfoSide, crate::app::battlescene::BattleScene_Result)` overload"]
1002 fn try_add_dead_scene(
1003 self,
1004 side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
1005 result: impl ::core::convert::Into<crate::app::battlescene::BattleScene_Result>,
1006 ) -> bool {
1007 unsafe {
1008 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1009 ::unity::il2cpp_call!((::unity::module_base()+0x2472d20usize)as*mut u8,bool;
1010(BattleCalculator)__receiver,(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(side),(crate::app::battlescene::BattleScene_Result)::core::convert::Into::into(result))
1011 }
1012 }
1013 #[doc = "`CalcAttackPost(crate::app::battleside::BattleSide_Type, i32, crate::app::battlescene::BattleScene_Result)` overload"]
1014 fn calc_attack_post(
1015 self,
1016 side_type: impl ::core::convert::Into<crate::app::battleside::BattleSide_Type>,
1017 damage: impl ::core::convert::Into<i32>,
1018 result: impl ::core::convert::Into<crate::app::battlescene::BattleScene_Result>,
1019 ) -> bool {
1020 unsafe {
1021 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1022 ::unity::il2cpp_call!((::unity::module_base()+0x2472840usize)as*mut u8,bool;
1023(BattleCalculator)__receiver,(crate::app::battleside::BattleSide_Type)::core::convert::Into::into(side_type),(i32)::core::convert::Into::into(damage),(crate::app::battlescene::BattleScene_Result)::core::convert::Into::into(result))
1024 }
1025 }
1026 #[doc = "`get_SceneResult()` overload"]
1027 fn get_scene_result(self) -> crate::app::battlescene::BattleScene_Result {
1028 unsafe {
1029 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1030 ::unity::il2cpp_call!((::unity::module_base()+0x246c640usize)as*mut u8,crate::app::battlescene::BattleScene_Result;
1031(BattleCalculator)__receiver)
1032 }
1033 }
1034 #[doc = "`set_SceneResult(crate::app::battlescene::BattleScene_Result)` overload"]
1035 fn set_scene_result(self, value: impl ::core::convert::Into<crate::app::battlescene::BattleScene_Result>) -> () {
1036 unsafe {
1037 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1038 ::unity::il2cpp_call!((::unity::module_base()+0x246c650usize)as*mut u8,();
1039(BattleCalculator)__receiver,(crate::app::battlescene::BattleScene_Result)::core::convert::Into::into(value))
1040 }
1041 }
1042 #[doc = "`CalcRod()` overload"]
1043 fn calc_rod(self) -> () {
1044 unsafe {
1045 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1046 ::unity::il2cpp_call!((::unity::module_base()+0x246b410usize)as*mut u8,();
1047(BattleCalculator)__receiver)
1048 }
1049 }
1050 #[doc = "`CalcRodOrder(crate::app::battleside::BattleSide_Type)` overload"]
1051 fn calc_rod_order(self, side: impl ::core::convert::Into<crate::app::battleside::BattleSide_Type>) -> () {
1052 unsafe {
1053 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1054 ::unity::il2cpp_call!((::unity::module_base()+0x2472ee0usize)as*mut u8,();
1055(BattleCalculator)__receiver,(crate::app::battleside::BattleSide_Type)::core::convert::Into::into(side))
1056 }
1057 }
1058 #[doc = "`CalcRodAction(crate::app::battleside::BattleSide_Type)` overload"]
1059 fn calc_rod_action(self, side: impl ::core::convert::Into<crate::app::battleside::BattleSide_Type>) -> () {
1060 unsafe {
1061 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1062 ::unity::il2cpp_call!((::unity::module_base()+0x2473060usize)as*mut u8,();
1063(BattleCalculator)__receiver,(crate::app::battleside::BattleSide_Type)::core::convert::Into::into(side))
1064 }
1065 }
1066 #[doc = "`CalcRodAttack(crate::app::battleside::BattleSide_Type)` overload"]
1067 fn calc_rod_attack(self, side: impl ::core::convert::Into<crate::app::battleside::BattleSide_Type>) -> () {
1068 unsafe {
1069 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1070 ::unity::il2cpp_call!((::unity::module_base()+0x24731e0usize)as*mut u8,();
1071(BattleCalculator)__receiver,(crate::app::battleside::BattleSide_Type)::core::convert::Into::into(side))
1072 }
1073 }
1074 #[doc = "`CalcDance()` overload"]
1075 fn calc_dance(self) -> () {
1076 unsafe {
1077 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1078 ::unity::il2cpp_call!((::unity::module_base()+0x246a7d0usize)as*mut u8,();
1079(BattleCalculator)__receiver)
1080 }
1081 }
1082 #[doc = "`CalcDanceOrder()` overload"]
1083 fn calc_dance_order(self) -> () {
1084 unsafe {
1085 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1086 ::unity::il2cpp_call!((::unity::module_base()+0x24741a0usize)as*mut u8,();
1087(BattleCalculator)__receiver)
1088 }
1089 }
1090 #[doc = "`CalcDanceAction()` overload"]
1091 fn calc_dance_action(self) -> () {
1092 unsafe {
1093 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1094 ::unity::il2cpp_call!((::unity::module_base()+0x2474310usize)as*mut u8,();
1095(BattleCalculator)__receiver)
1096 }
1097 }
1098 #[doc = "`CalcDanceAttack()` overload"]
1099 fn calc_dance_attack(self) -> () {
1100 unsafe {
1101 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1102 ::unity::il2cpp_call!((::unity::module_base()+0x2474480usize)as*mut u8,();
1103(BattleCalculator)__receiver)
1104 }
1105 }
1106 #[doc = "`CalcEnchant()` overload"]
1107 fn calc_enchant(self) -> () {
1108 unsafe {
1109 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1110 ::unity::il2cpp_call!((::unity::module_base()+0x246a940usize)as*mut u8,();
1111(BattleCalculator)__receiver)
1112 }
1113 }
1114 #[doc = "`CalcRodHit(crate::app::battleinfoside::BattleInfoSide, crate::app::battleinfoside::BattleInfoSide, crate::app::unititem::UnitItem, crate::app::itemdata::ItemData)` overload"]
1115 fn calc_rod_hit(
1116 self,
1117 current: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
1118 reverse: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
1119 unit_item: impl ::core::convert::Into<crate::app::unititem::UnitItem>,
1120 item: impl ::core::convert::Into<crate::app::itemdata::ItemData>,
1121 ) -> () {
1122 unsafe {
1123 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1124 ::unity::il2cpp_call!((::unity::module_base()+0x2473e10usize)as*mut u8,();
1125(BattleCalculator)__receiver,(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(current),(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(reverse),(crate::app::unititem::UnitItem)::core::convert::Into::into(unit_item),(crate::app::itemdata::ItemData)::core::convert::Into::into(item))
1126 }
1127 }
1128 #[doc = "`CalcResult()` overload"]
1129 fn calc_result(self) -> () {
1130 unsafe {
1131 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1132 ::unity::il2cpp_call!((::unity::module_base()+0x2469bc0usize)as*mut u8,();
1133(BattleCalculator)__receiver)
1134 }
1135 }
1136 #[doc = "`CanBattleRecord(crate::app::battleinfoside::BattleInfoSide)` overload"]
1137 fn can_battle_record(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> bool {
1138 unsafe {
1139 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1140 ::unity::il2cpp_call!((::unity::module_base()+0x24751d0usize)as*mut u8,bool;
1141(BattleCalculator)__receiver,(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(side))
1142 }
1143 }
1144 #[doc = "`CalcRecord()` overload"]
1145 fn calc_record(self) -> () {
1146 unsafe {
1147 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1148 ::unity::il2cpp_call!((::unity::module_base()+0x2475400usize)as*mut u8,();
1149(BattleCalculator)__receiver)
1150 }
1151 }
1152 #[doc = "`GetSide(crate::app::force::Force_Type)` overload"]
1153 fn get_side(self, force: impl ::core::convert::Into<crate::app::force::Force_Type>) -> crate::app::battleinfoside::BattleInfoSide {
1154 unsafe {
1155 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1156 ::unity::il2cpp_call!((::unity::module_base()+0x24766a0usize)as*mut u8,crate::app::battleinfoside::BattleInfoSide;
1157(BattleCalculator)__receiver,(crate::app::force::Force_Type)::core::convert::Into::into(force))
1158 }
1159 }
1160 #[doc = "`CalcAchieve()` overload"]
1161 fn calc_achieve(self) -> () {
1162 unsafe {
1163 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1164 ::unity::il2cpp_call!((::unity::module_base()+0x24767d0usize)as*mut u8,();
1165(BattleCalculator)__receiver)
1166 }
1167 }
1168 #[doc = "`CalcExpendCount()` overload"]
1169 fn calc_expend_count(self) -> () {
1170 unsafe {
1171 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1172 ::unity::il2cpp_call!((::unity::module_base()+0x24750a0usize)as*mut u8,();
1173(BattleCalculator)__receiver)
1174 }
1175 }
1176 #[doc = "`IsChainAttackDead()` overload"]
1177 fn is_chain_attack_dead(self) -> bool {
1178 unsafe {
1179 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1180 ::unity::il2cpp_call!((::unity::module_base()+0x24773e0usize)as*mut u8,bool;
1181(BattleCalculator)__receiver)
1182 }
1183 }
1184 #[doc = "`CalcExp(crate::app::battlecalculator::BattleCalculator_FuncExp1, crate::app::battleinfoside::BattleInfoSide)` overload"]
1185 fn calc_exp(
1186 self,
1187 func: impl ::core::convert::Into<crate::app::battlecalculator::BattleCalculator_FuncExp1>,
1188 current: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
1189 ) -> () {
1190 unsafe {
1191 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1192 ::unity::il2cpp_call!((::unity::module_base()+0x2477540usize)as*mut u8,();
1193(BattleCalculator)__receiver,(crate::app::battlecalculator::BattleCalculator_FuncExp1)::core::convert::Into::into(func),(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(current))
1194 }
1195 }
1196 #[doc = "`CalcExp(crate::app::battlecalculator::BattleCalculator_FuncExp2, crate::app::battleinfoside::BattleInfoSide, crate::app::battleinfoside::BattleInfoSide)` overload"]
1197 fn calc_exp_2(
1198 self,
1199 func: impl ::core::convert::Into<crate::app::battlecalculator::BattleCalculator_FuncExp2>,
1200 current: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
1201 reverse: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
1202 ) -> () {
1203 unsafe {
1204 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1205 ::unity::il2cpp_call!((::unity::module_base()+0x2477570usize)as*mut u8,();
1206(BattleCalculator)__receiver,(crate::app::battlecalculator::BattleCalculator_FuncExp2)::core::convert::Into::into(func),(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(current),(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(reverse))
1207 }
1208 }
1209 #[doc = "`CalcResultGain()` overload"]
1210 fn calc_result_gain(self) -> () {
1211 unsafe {
1212 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1213 ::unity::il2cpp_call!((::unity::module_base()+0x2474630usize)as*mut u8,();
1214(BattleCalculator)__receiver)
1215 }
1216 }
1217 #[doc = "`CalcExpCount()` overload"]
1218 fn calc_exp_count(self) -> () {
1219 unsafe {
1220 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1221 ::unity::il2cpp_call!((::unity::module_base()+0x2474c60usize)as*mut u8,();
1222(BattleCalculator)__receiver)
1223 }
1224 }
1225 #[doc = "`CommitHP(crate::app::battleinfoside::BattleInfoSide, i32)` overload"]
1226 fn commit_hp(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>, hp: impl ::core::convert::Into<i32>) -> () {
1227 unsafe {
1228 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1229 ::unity::il2cpp_call!((::unity::module_base()+0x24775b0usize)as*mut u8,();
1230(BattleCalculator)__receiver,(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(side),(i32)::core::convert::Into::into(hp))
1231 }
1232 }
1233 #[doc = "`CommitEngageCount(crate::app::battleinfoside::BattleInfoSide, i32)` overload"]
1234 fn commit_engage_count(
1235 self,
1236 side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
1237 count: impl ::core::convert::Into<i32>,
1238 ) -> () {
1239 unsafe {
1240 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1241 ::unity::il2cpp_call!((::unity::module_base()+0x24775e0usize)as*mut u8,();
1242(BattleCalculator)__receiver,(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(side),(i32)::core::convert::Into::into(count))
1243 }
1244 }
1245 #[doc = "`UpdateScene()` overload"]
1246 fn update_scene(self) -> () {
1247 unsafe {
1248 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1249 ::unity::il2cpp_call!((::unity::module_base()+0x2477620usize)as*mut u8,();
1250(BattleCalculator)__receiver)
1251 }
1252 }
1253 #[doc = "`UpdateScene(i32, bool)` overload"]
1254 fn update_scene_2(self, index: impl ::core::convert::Into<i32>, is_engae_count: impl ::core::convert::Into<bool>) -> () {
1255 unsafe {
1256 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1257 ::unity::il2cpp_call!((::unity::module_base()+0x2477730usize)as*mut u8,();
1258(BattleCalculator)__receiver,(i32)::core::convert::Into::into(index),(bool)::core::convert::Into::into(is_engae_count))
1259 }
1260 }
1261 #[doc = "`UpdateScene(crate::app::battlescene::BattleScene, bool)` overload"]
1262 fn update_scene_3(
1263 self,
1264 scene: impl ::core::convert::Into<crate::app::battlescene::BattleScene>,
1265 is_engae_count: impl ::core::convert::Into<bool>,
1266 ) -> () {
1267 unsafe {
1268 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1269 ::unity::il2cpp_call!((::unity::module_base()+0x2477810usize)as*mut u8,();
1270(BattleCalculator)__receiver,(crate::app::battlescene::BattleScene)::core::convert::Into::into(scene),(bool)::core::convert::Into::into(is_engae_count))
1271 }
1272 }
1273 #[doc = "`CommitUnit()` overload"]
1274 fn commit_unit(self) -> () {
1275 unsafe {
1276 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1277 ::unity::il2cpp_call!((::unity::module_base()+0x2477b70usize)as*mut u8,();
1278(BattleCalculator)__receiver)
1279 }
1280 }
1281 #[doc = "`CommitSkill()` overload"]
1282 fn commit_skill(self) -> () {
1283 unsafe {
1284 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1285 ::unity::il2cpp_call!((::unity::module_base()+0x2478070usize)as*mut u8,();
1286(BattleCalculator)__receiver)
1287 }
1288 }
1289 #[doc = "`CommitDestroy()` overload"]
1290 fn commit_destroy(self) -> () {
1291 unsafe {
1292 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1293 ::unity::il2cpp_call!((::unity::module_base()+0x2478520usize)as*mut u8,();
1294(BattleCalculator)__receiver)
1295 }
1296 }
1297 #[doc = "`CommitBattle()` overload"]
1298 fn commit_battle(self) -> () {
1299 unsafe {
1300 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1301 ::unity::il2cpp_call!((::unity::module_base()+0x2478560usize)as*mut u8,();
1302(BattleCalculator)__receiver)
1303 }
1304 }
1305 #[doc = "`MapHistoryCommitSkill(crate::app::unit::Unit)` overload"]
1306 fn map_history_commit_skill(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> () {
1307 unsafe {
1308 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1309 ::unity::il2cpp_call!((::unity::module_base()+0x24783e0usize)as*mut u8,();
1310(BattleCalculator)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(unit))
1311 }
1312 }
1313 #[doc = "`IsTraining()` overload"]
1314 fn is_training(self) -> bool {
1315 unsafe {
1316 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1317 ::unity::il2cpp_call!((::unity::module_base()+0x2478740usize)as*mut u8,bool;
1318(BattleCalculator)__receiver)
1319 }
1320 }
1321 #[doc = "`IsRod()` overload"]
1322 fn is_rod(self) -> bool {
1323 unsafe {
1324 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1325 ::unity::il2cpp_call!((::unity::module_base()+0x2475360usize)as*mut u8,bool;
1326(BattleCalculator)__receiver)
1327 }
1328 }
1329 #[doc = "`GetUnit(i32)` overload"]
1330 fn get_unit(self, index: impl ::core::convert::Into<i32>) -> crate::app::unit::Unit {
1331 unsafe {
1332 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1333 ::unity::il2cpp_call!((::unity::module_base()+0x24787b0usize)as*mut u8,crate::app::unit::Unit;
1334(BattleCalculator)__receiver,(i32)::core::convert::Into::into(index))
1335 }
1336 }
1337 #[doc = "`GetUnit(crate::app::battleside::BattleSide_Type)` overload"]
1338 fn get_unit_2(self, side: impl ::core::convert::Into<crate::app::battleside::BattleSide_Type>) -> crate::app::unit::Unit {
1339 unsafe {
1340 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1341 ::unity::il2cpp_call!((::unity::module_base()+0x2469e40usize)as*mut u8,crate::app::unit::Unit;
1342(BattleCalculator)__receiver,(crate::app::battleside::BattleSide_Type)::core::convert::Into::into(side))
1343 }
1344 }
1345 #[doc = "`GetSide(i32)` overload"]
1346 fn get_side_2(self, index: impl ::core::convert::Into<i32>) -> crate::app::battleinfoside::BattleInfoSide {
1347 unsafe {
1348 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1349 ::unity::il2cpp_call!((::unity::module_base()+0x2478820usize)as*mut u8,crate::app::battleinfoside::BattleInfoSide;
1350(BattleCalculator)__receiver,(i32)::core::convert::Into::into(index))
1351 }
1352 }
1353 #[doc = "`GetSide(crate::app::battleside::BattleSide_Type)` overload"]
1354 fn get_side_3(self, side: impl ::core::convert::Into<crate::app::battleside::BattleSide_Type>) -> crate::app::battleinfoside::BattleInfoSide {
1355 unsafe {
1356 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1357 ::unity::il2cpp_call!((::unity::module_base()+0x246f1a0usize)as*mut u8,crate::app::battleinfoside::BattleInfoSide;
1358(BattleCalculator)__receiver,(crate::app::battleside::BattleSide_Type)::core::convert::Into::into(side))
1359 }
1360 }
1361 #[doc = "`GetDeadSide()` overload"]
1362 fn get_dead_side(self) -> crate::app::battleside::BattleSide_Type {
1363 unsafe {
1364 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1365 ::unity::il2cpp_call!((::unity::module_base()+0x2476300usize)as*mut u8,crate::app::battleside::BattleSide_Type;
1366(BattleCalculator)__receiver)
1367 }
1368 }
1369 #[doc = "`GetDeadUnit()` overload"]
1370 fn get_dead_unit(self) -> crate::app::unit::Unit {
1371 unsafe {
1372 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1373 ::unity::il2cpp_call!((::unity::module_base()+0x2478880usize)as*mut u8,crate::app::unit::Unit;
1374(BattleCalculator)__receiver)
1375 }
1376 }
1377 #[doc = "`GetExpendCount(crate::app::battleinfoside::BattleInfoSide)` overload"]
1378 fn get_expend_count(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> i32 {
1379 unsafe {
1380 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1381 ::unity::il2cpp_call!((::unity::module_base()+0x24771d0usize)as*mut u8,i32;
1382(BattleCalculator)__receiver,(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(side))
1383 }
1384 }
1385 #[doc = "`CanSkyBattle()` overload"]
1386 fn can_sky_battle(self) -> bool {
1387 unsafe {
1388 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1389 ::unity::il2cpp_call!((::unity::module_base()+0x2478910usize)as*mut u8,bool;
1390(BattleCalculator)__receiver)
1391 }
1392 }
1393 #[doc = "`IsMultiBattle()` overload"]
1394 fn is_multi_battle(self) -> bool {
1395 unsafe {
1396 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1397 ::unity::il2cpp_call!((::unity::module_base()+0x2478c80usize)as*mut u8,bool;
1398(BattleCalculator)__receiver)
1399 }
1400 }
1401 #[doc = "`IsCannonBattle()` overload"]
1402 fn is_cannon_battle(self) -> bool {
1403 unsafe {
1404 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1405 ::unity::il2cpp_call!((::unity::module_base()+0x2478cf0usize)as*mut u8,bool;
1406(BattleCalculator)__receiver)
1407 }
1408 }
1409 #[doc = "`IsFireCannon()` overload"]
1410 fn is_fire_cannon(self) -> bool {
1411 unsafe {
1412 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1413 ::unity::il2cpp_call!((::unity::module_base()+0x2478d60usize)as*mut u8,bool;
1414(BattleCalculator)__receiver)
1415 }
1416 }
1417 #[doc = "`IsFullBullet()` overload"]
1418 fn is_full_bullet(self) -> bool {
1419 unsafe {
1420 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1421 ::unity::il2cpp_call!((::unity::module_base()+0x2478dd0usize)as*mut u8,bool;
1422(BattleCalculator)__receiver)
1423 }
1424 }
1425 #[doc = "`IsLastBossDie()` overload"]
1426 fn is_last_boss_die(self) -> bool {
1427 unsafe {
1428 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1429 ::unity::il2cpp_call!((::unity::module_base()+0x2478e40usize)as*mut u8,bool;
1430(BattleCalculator)__receiver)
1431 }
1432 }
1433 #[doc = "`IsBattleGrow()` overload"]
1434 fn is_battle_grow(self) -> bool {
1435 unsafe {
1436 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1437 ::unity::il2cpp_call!((::unity::module_base()+0x2479040usize)as*mut u8,bool;
1438(BattleCalculator)__receiver)
1439 }
1440 }
1441 #[doc = "`IsCombatDie()` overload"]
1442 fn is_combat_die(self) -> bool {
1443 unsafe {
1444 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1445 ::unity::il2cpp_call!((::unity::module_base()+0x2479230usize)as*mut u8,bool;
1446(BattleCalculator)__receiver)
1447 }
1448 }
1449 #[doc = "`IsCombatGrow()` overload"]
1450 fn is_combat_grow(self) -> bool {
1451 unsafe {
1452 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1453 ::unity::il2cpp_call!((::unity::module_base()+0x2479300usize)as*mut u8,bool;
1454(BattleCalculator)__receiver)
1455 }
1456 }
1457 #[doc = "`GetAssetConditions(crate::app::battleside::BattleSide_Type)` overload"]
1458 fn get_asset_conditions(
1459 self,
1460 side_type: impl ::core::convert::Into<crate::app::battleside::BattleSide_Type>,
1461 ) -> ::unity::Array<::unity::Il2CppString> {
1462 unsafe {
1463 let __receiver = <BattleCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1464 ::unity::il2cpp_call!((::unity::module_base()+0x2479410usize)as*mut u8, ::unity::Array< ::unity::Il2CppString> ;
1465(BattleCalculator)__receiver,(crate::app::battleside::BattleSide_Type)::core::convert::Into::into(side_type))
1466 }
1467 }
1468}
1469
1470#[cfg(feature = "app-battlecalculator")]
1471impl<__T: IBattleCalculator> IBattleCalculatorMethods for __T {}
1472
1473#[cfg(feature = "app-battlecalculator")]
1474impl BattleCalculator {
1475 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1476 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1477 }
1478
1479 pub fn dispose_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1480 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1481 }
1482
1483 pub fn get_mode_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1484 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1485 }
1486
1487 pub fn calc_battle_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1488 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
1489 }
1490
1491 pub fn dump_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1492 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
1493 }
1494
1495 pub fn try_add_skill_scene_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1496 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
1497 }
1498
1499 pub fn calc_engage_start_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1500 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
1501 }
1502
1503 pub fn calc_invoke_skill_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1504 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
1505 }
1506
1507 pub fn calc_engage_end_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1508 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
1509 }
1510
1511 pub fn calc_detail_skill_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1512 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
1513 }
1514
1515 pub fn calc_branch_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1516 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
1517 }
1518
1519 pub fn is_late_order_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1520 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
1521 }
1522
1523 pub fn separator_total_order_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1524 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
1525 }
1526
1527 pub fn calc_normal_battle_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1528 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
1529 }
1530
1531 pub fn calc_destroy_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1532 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[14]
1533 }
1534
1535 pub fn add_skill_scene_result_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1536 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[15]
1537 }
1538
1539 pub fn calc_destroy_attack_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1540 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[16]
1541 }
1542
1543 pub fn calc_warmup_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1544 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[17]
1545 }
1546
1547 pub fn calc_simulation_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1548 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[18]
1549 }
1550
1551 pub fn calc_job_intro_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1552 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[19]
1553 }
1554
1555 pub fn calc_class_change_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1556 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[20]
1557 }
1558
1559 pub fn get_hp_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1560 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[21]
1561 }
1562
1563 pub fn get_status_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1564 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[22]
1565 }
1566
1567 pub fn get_info_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1568 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[23]
1569 }
1570
1571 pub fn get_scene_list_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1572 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[24]
1573 }
1574
1575 pub fn calc_active_skill_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1576 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[25]
1577 }
1578
1579 pub fn can_attack_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1580 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[26]
1581 }
1582
1583 pub fn add_skill_scene_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1584 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[27]
1585 }
1586
1587 pub fn get_breaked_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1588 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[28]
1589 }
1590
1591 pub fn add_give_scene_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1592 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[29]
1593 }
1594
1595 pub fn find_ignore_skill_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1596 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[30]
1597 }
1598
1599 pub fn add_give_scene_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1600 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[31]
1601 }
1602
1603 pub fn add_gives_scene_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1604 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[32]
1605 }
1606
1607 pub fn add_gives_scene_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1608 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[33]
1609 }
1610
1611 pub fn calc_hit_skill_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1612 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[34]
1613 }
1614
1615 pub fn calc_active_skill_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1616 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[35]
1617 }
1618
1619 pub fn can_oreder_skill_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1620 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[36]
1621 }
1622
1623 pub fn calc_active_skill_3_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1624 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[37]
1625 }
1626
1627 pub fn calc_hit_skill_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1628 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[38]
1629 }
1630
1631 pub fn calc_hit_skill_3_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1632 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[39]
1633 }
1634
1635 pub fn calc_result_skill_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1636 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[40]
1637 }
1638
1639 pub fn calc_result_skill_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1640 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[41]
1641 }
1642
1643 pub fn add_debug_indent_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1644 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[42]
1645 }
1646
1647 pub fn dec_debug_indent_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1648 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[43]
1649 }
1650
1651 pub fn calc_chain_attack_sides_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1652 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[44]
1653 }
1654
1655 pub fn calc_chain_guard_side_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1656 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[45]
1657 }
1658
1659 pub fn can_chain_attack_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1660 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[46]
1661 }
1662
1663 pub fn calc_chain_attack_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1664 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[47]
1665 }
1666
1667 pub fn calc_orders_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1668 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[48]
1669 }
1670
1671 pub fn calc_interrupt_order_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1672 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[49]
1673 }
1674
1675 pub fn calc_interrupt_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1676 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[50]
1677 }
1678
1679 pub fn add_engage_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1680 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[51]
1681 }
1682
1683 pub fn add_engage_count_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1684 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[52]
1685 }
1686
1687 pub fn calc_orders_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1688 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[53]
1689 }
1690
1691 pub fn calc_assist_skill_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1692 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[54]
1693 }
1694
1695 pub fn calc_order_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1696 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[55]
1697 }
1698
1699 pub fn calc_action_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1700 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[56]
1701 }
1702
1703 pub fn get_command_value_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1704 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[57]
1705 }
1706
1707 pub fn get_chain_guard_damage_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1708 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[58]
1709 }
1710
1711 pub fn random_check_hit_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1712 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[59]
1713 }
1714
1715 pub fn calc_attack_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1716 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[60]
1717 }
1718
1719 pub fn can_enter_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1720 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[61]
1721 }
1722
1723 pub fn can_blow_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1724 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[62]
1725 }
1726
1727 pub fn calc_attack_hit_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1728 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[63]
1729 }
1730
1731 pub fn try_add_dead_scene_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1732 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[64]
1733 }
1734
1735 pub fn calc_attack_post_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1736 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[65]
1737 }
1738
1739 pub fn get_scene_result_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1740 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[66]
1741 }
1742
1743 pub fn set_scene_result_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1744 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[67]
1745 }
1746
1747 pub fn calc_rod_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1748 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[68]
1749 }
1750
1751 pub fn calc_rod_order_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1752 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[69]
1753 }
1754
1755 pub fn calc_rod_action_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1756 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[70]
1757 }
1758
1759 pub fn calc_rod_attack_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1760 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[71]
1761 }
1762
1763 pub fn calc_dance_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1764 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[72]
1765 }
1766
1767 pub fn calc_dance_order_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1768 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[73]
1769 }
1770
1771 pub fn calc_dance_action_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1772 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[74]
1773 }
1774
1775 pub fn calc_dance_attack_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1776 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[75]
1777 }
1778
1779 pub fn calc_enchant_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1780 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[76]
1781 }
1782
1783 pub fn calc_rod_hit_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1784 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[77]
1785 }
1786
1787 pub fn calc_result_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1788 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[78]
1789 }
1790
1791 pub fn can_battle_record_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1792 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[79]
1793 }
1794
1795 pub fn calc_record_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1796 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[80]
1797 }
1798
1799 pub fn get_side_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1800 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[81]
1801 }
1802
1803 pub fn calc_achieve_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1804 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[82]
1805 }
1806
1807 pub fn calc_expend_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1808 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[83]
1809 }
1810
1811 pub fn is_chain_attack_dead_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1812 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[84]
1813 }
1814
1815 pub fn calc_exp_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1816 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[85]
1817 }
1818
1819 pub fn calc_exp_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1820 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[86]
1821 }
1822
1823 pub fn calc_result_gain_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1824 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[87]
1825 }
1826
1827 pub fn calc_exp_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1828 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[88]
1829 }
1830
1831 pub fn commit_hp_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1832 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[89]
1833 }
1834
1835 pub fn commit_engage_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1836 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[90]
1837 }
1838
1839 pub fn update_scene_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1840 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[91]
1841 }
1842
1843 pub fn update_scene_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1844 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[92]
1845 }
1846
1847 pub fn update_scene_3_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1848 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[93]
1849 }
1850
1851 pub fn commit_unit_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1852 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[94]
1853 }
1854
1855 pub fn commit_skill_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1856 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[95]
1857 }
1858
1859 pub fn commit_destroy_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1860 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[96]
1861 }
1862
1863 pub fn commit_battle_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1864 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[97]
1865 }
1866
1867 pub fn map_history_commit_skill_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1868 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[98]
1869 }
1870
1871 pub fn is_training_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1872 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[99]
1873 }
1874
1875 pub fn is_rod_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1876 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[100]
1877 }
1878
1879 pub fn get_unit_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1880 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[101]
1881 }
1882
1883 pub fn get_unit_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1884 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[102]
1885 }
1886
1887 pub fn get_side_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1888 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[103]
1889 }
1890
1891 pub fn get_side_3_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1892 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[104]
1893 }
1894
1895 pub fn get_dead_side_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1896 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[105]
1897 }
1898
1899 pub fn get_dead_unit_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1900 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[106]
1901 }
1902
1903 pub fn get_expend_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1904 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[107]
1905 }
1906
1907 pub fn can_sky_battle_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1908 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[108]
1909 }
1910
1911 pub fn is_multi_battle_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1912 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[109]
1913 }
1914
1915 pub fn is_cannon_battle_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1916 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[110]
1917 }
1918
1919 pub fn is_fire_cannon_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1920 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[111]
1921 }
1922
1923 pub fn is_full_bullet_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1924 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[112]
1925 }
1926
1927 pub fn is_last_boss_die_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1928 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[113]
1929 }
1930
1931 pub fn is_battle_grow_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1932 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[114]
1933 }
1934
1935 pub fn is_combat_die_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1936 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[115]
1937 }
1938
1939 pub fn is_combat_grow_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1940 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[116]
1941 }
1942
1943 pub fn get_asset_conditions_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1944 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[117]
1945 }
1946
1947 pub fn cctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1948 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[118]
1949 }
1950}
1951
1952#[cfg(feature = "app-battlecalculator")]
1953impl BattleCalculator {
1954 #[doc = "Direct (non-virtual) call to `BattleCalculator`'s own `Dispose`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1955 pub unsafe fn dispose(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
1956 let __mi = Self::dispose_method_info();
1957 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1958 __inner(this.into(), ::core::option::Option::None)
1959 }
1960}
1961
1962#[cfg(feature = "app-battlecalculator")]
1963impl BattleCalculator {
1964 #[doc = "`.ctor(crate::app::battleinfo::BattleInfo)` — overload selector"]
1965 pub fn new(info: crate::app::battleinfo::BattleInfo) -> Self {
1966 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1967 panic!(
1968 "{}
1969::{}
1970 failed to instantiate",
1971 ::core::stringify!(BattleCalculator),
1972 ::core::stringify!(new),
1973 )
1974 });
1975 <Self as IBattleCalculatorMethods>::ctor(this, info);
1976 this
1977 }
1978}
1979
1980#[cfg(feature = "app-battlecalculator")]
1981impl BattleCalculator_TargetScope {
1982 #[doc = "`.ctor(crate::app::battleinfoside::BattleInfoSide, crate::app::battleinfoside::BattleInfoSide, bool)` overload"]
1983 pub fn ctor(
1984 &mut self,
1985 current: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
1986 reverse: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
1987 is_dump: impl ::core::convert::Into<bool>,
1988 ) -> () {
1989 unsafe {
1990 ::unity::il2cpp_call!((::unity::module_base()+0x19b7030usize)as*mut u8,();
1991(*mut BattleCalculator_TargetScope)self as*mut BattleCalculator_TargetScope,(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(current),(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(reverse),(bool)::core::convert::Into::into(is_dump))
1992 }
1993 }
1994
1995 #[doc = "`Dispose()` overload"]
1996 pub fn dispose(&mut self) -> () {
1997 unsafe {
1998 ::unity::il2cpp_call!((::unity::module_base()+0x19b7170usize)as*mut u8,();
1999(*mut BattleCalculator_TargetScope)self as*mut BattleCalculator_TargetScope)
2000 }
2001 }
2002}
2003
2004#[cfg(feature = "app-battlecalculator")]
2005impl BattleCalculator_TargetScope {
2006 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2007 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2008 }
2009
2010 pub fn dispose_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2011 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2012 }
2013}
2014
2015#[cfg(feature = "app-battlecalculator")]
2016pub trait IBattleCalculator_HitSkillMethods: IBattleCalculator_HitSkill {
2017 #[doc = "`OnEnter()` overload"]
2018 fn on_enter(self) -> () {
2019 unsafe {
2020 let __receiver =
2021 <BattleCalculator_HitSkill as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2022 {
2023 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2024 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
2025 panic!(
2026 "unity: virtual slot {}
2027 out of range (vtable len {}
2028) on the runtime class behind {}
2029 (method `{}
2030`)",
2031 4usize,
2032 __vt.len(),
2033 <BattleCalculator_HitSkill as ::unity::ClassIdentity>::NAME,
2034 "OnEnter",
2035 )
2036 });
2037 let __inner: extern "C" fn(BattleCalculator_HitSkill, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
2038 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2039 __inner(__receiver, __mi)
2040 }
2041 }
2042 }
2043 #[doc = "`OnExit()` overload"]
2044 fn on_exit(self) -> () {
2045 unsafe {
2046 let __receiver =
2047 <BattleCalculator_HitSkill as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2048 {
2049 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2050 let __vi = *__vt.get(5usize).unwrap_or_else(|| {
2051 panic!(
2052 "unity: virtual slot {}
2053 out of range (vtable len {}
2054) on the runtime class behind {}
2055 (method `{}
2056`)",
2057 5usize,
2058 __vt.len(),
2059 <BattleCalculator_HitSkill as ::unity::ClassIdentity>::NAME,
2060 "OnExit",
2061 )
2062 });
2063 let __inner: extern "C" fn(BattleCalculator_HitSkill, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
2064 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2065 __inner(__receiver, __mi)
2066 }
2067 }
2068 }
2069 #[doc = "`Clear()` overload"]
2070 fn clear(self) -> () {
2071 unsafe {
2072 let __receiver =
2073 <BattleCalculator_HitSkill as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2074 ::unity::il2cpp_call!((::unity::module_base()+0x19b60b0usize)as*mut u8,();
2075(BattleCalculator_HitSkill)__receiver)
2076 }
2077 }
2078 #[doc = "`get_SortKey()` overload"]
2079 fn get_sort_key(self) -> i32 {
2080 unsafe {
2081 let __receiver =
2082 <BattleCalculator_HitSkill as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2083 {
2084 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2085 let __vi = *__vt.get(6usize).unwrap_or_else(|| {
2086 panic!(
2087 "unity: virtual slot {}
2088 out of range (vtable len {}
2089) on the runtime class behind {}
2090 (method `{}
2091`)",
2092 6usize,
2093 __vt.len(),
2094 <BattleCalculator_HitSkill as ::unity::ClassIdentity>::NAME,
2095 "get_SortKey",
2096 )
2097 });
2098 let __inner: extern "C" fn(BattleCalculator_HitSkill, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__vi.method_ptr);
2099 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2100 __inner(__receiver, __mi)
2101 }
2102 }
2103 }
2104 #[doc = "`.ctor()` overload"]
2105 fn ctor(self) -> () {
2106 unsafe {
2107 let __receiver =
2108 <BattleCalculator_HitSkill as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2109 ::unity::il2cpp_call!((::unity::module_base()+0x19b6110usize)as*mut u8,();
2110(BattleCalculator_HitSkill)__receiver)
2111 }
2112 }
2113}
2114
2115#[cfg(feature = "app-battlecalculator")]
2116impl<__T: IBattleCalculator_HitSkill> IBattleCalculator_HitSkillMethods for __T {}
2117
2118#[cfg(feature = "app-battlecalculator")]
2119impl BattleCalculator_HitSkill {
2120 pub fn on_enter_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2121 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2122 }
2123
2124 pub fn on_exit_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2125 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2126 }
2127
2128 pub fn clear_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2129 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2130 }
2131
2132 pub fn get_sort_key_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2133 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
2134 }
2135
2136 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2137 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
2138 }
2139}
2140
2141#[cfg(feature = "app-battlecalculator")]
2142impl BattleCalculator_HitSkill {
2143 #[doc = "Direct (non-virtual) call to `BattleCalculator_HitSkill`'s own `OnEnter`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2144 pub unsafe fn on_enter(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
2145 let __mi = Self::on_enter_method_info();
2146 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
2147 __inner(this.into(), ::core::option::Option::None)
2148 }
2149
2150 #[doc = "Direct (non-virtual) call to `BattleCalculator_HitSkill`'s own `OnExit`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2151 pub unsafe fn on_exit(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
2152 let __mi = Self::on_exit_method_info();
2153 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
2154 __inner(this.into(), ::core::option::Option::None)
2155 }
2156
2157 #[doc = "Direct (non-virtual) call to `BattleCalculator_HitSkill`'s own `get_SortKey`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2158 pub unsafe fn get_sort_key(this: impl ::core::convert::Into<::unity::IlInstance>) -> i32 {
2159 let __mi = Self::get_sort_key_method_info();
2160 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__mi.method_ptr);
2161 __inner(this.into(), ::core::option::Option::None)
2162 }
2163}
2164
2165#[cfg(feature = "app-battlecalculator")]
2166impl BattleCalculator_HitSkill {
2167 #[doc = "`.ctor()` — no args"]
2168 pub fn new() -> Self {
2169 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2170 panic!(
2171 "{}
2172::{}
2173 failed to instantiate",
2174 ::core::stringify!(BattleCalculator_HitSkill),
2175 ::core::stringify!(new),
2176 )
2177 });
2178 <Self as IBattleCalculator_HitSkillMethods>::ctor(this);
2179 this
2180 }
2181}
2182
2183#[cfg(feature = "app-battlecalculator")]
2184impl BattleCalculator_SeparatorScope {
2185 #[doc = "`.ctor(crate::app::battlecalculator::BattleCalculator, crate::app::battleside::BattleSide_Type, crate::app::battlescene::BattleScene_Kind, crate::app::battlescene::BattleScene_Kind, bool)` overload"]
2186 pub fn ctor(
2187 &mut self,
2188 calc: impl ::core::convert::Into<crate::app::battlecalculator::BattleCalculator>,
2189 side: impl ::core::convert::Into<crate::app::battleside::BattleSide_Type>,
2190 push: impl ::core::convert::Into<crate::app::battlescene::BattleScene_Kind>,
2191 pop: impl ::core::convert::Into<crate::app::battlescene::BattleScene_Kind>,
2192 is_dump: impl ::core::convert::Into<bool>,
2193 ) -> () {
2194 unsafe {
2195 ::unity::il2cpp_call!((::unity::module_base()+0x19b6a70usize)as*mut u8,();
2196(*mut BattleCalculator_SeparatorScope)self as*mut BattleCalculator_SeparatorScope,(crate::app::battlecalculator::BattleCalculator)::core::convert::Into::into(calc),(crate::app::battleside::BattleSide_Type)::core::convert::Into::into(side),(crate::app::battlescene::BattleScene_Kind)::core::convert::Into::into(push),(crate::app::battlescene::BattleScene_Kind)::core::convert::Into::into(pop),(bool)::core::convert::Into::into(is_dump))
2197 }
2198 }
2199
2200 #[doc = "`Dispose()` overload"]
2201 pub fn dispose(&mut self) -> () {
2202 unsafe {
2203 ::unity::il2cpp_call!((::unity::module_base()+0x19b6e60usize)as*mut u8,();
2204(*mut BattleCalculator_SeparatorScope)self as*mut BattleCalculator_SeparatorScope)
2205 }
2206 }
2207
2208 #[doc = "`GetSide()` overload"]
2209 pub fn get_side(&mut self) -> crate::app::battleinfoside::BattleInfoSide {
2210 unsafe {
2211 ::unity::il2cpp_call!((::unity::module_base()+0x19b7000usize)as*mut u8,crate::app::battleinfoside::BattleInfoSide;
2212(*mut BattleCalculator_SeparatorScope)self as*mut BattleCalculator_SeparatorScope)
2213 }
2214 }
2215
2216 #[doc = "`GetSide(crate::app::battleside::BattleSide_Type)` overload"]
2217 pub fn get_side_2(
2218 &mut self,
2219 side: impl ::core::convert::Into<crate::app::battleside::BattleSide_Type>,
2220 ) -> crate::app::battleinfoside::BattleInfoSide {
2221 unsafe {
2222 ::unity::il2cpp_call!((::unity::module_base()+0x19b7020usize)as*mut u8,crate::app::battleinfoside::BattleInfoSide;
2223(*mut BattleCalculator_SeparatorScope)self as*mut BattleCalculator_SeparatorScope,(crate::app::battleside::BattleSide_Type)::core::convert::Into::into(side))
2224 }
2225 }
2226}
2227
2228#[cfg(feature = "app-battlecalculator")]
2229impl BattleCalculator_SeparatorScope {
2230 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2231 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2232 }
2233
2234 pub fn dispose_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2235 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2236 }
2237
2238 pub fn get_side_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2239 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2240 }
2241
2242 pub fn get_side_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2243 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
2244 }
2245}
2246
2247#[cfg(feature = "app-battlecalculator")]
2248pub trait IBattleCalculator_FlagFieldMethods: IBattleCalculator_FlagField {
2249 #[doc = "`ToInt(crate::app::battlecalculator::BattleCalculator_Flags)` overload"]
2250 fn to_int(self, value: impl ::core::convert::Into<crate::app::battlecalculator::BattleCalculator_Flags>) -> i32 {
2251 unsafe {
2252 let __receiver =
2253 <BattleCalculator_FlagField as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2254 {
2255 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2256 let __vi = *__vt.get(5usize).unwrap_or_else(|| {
2257 panic!(
2258 "unity: virtual slot {}
2259 out of range (vtable len {}
2260) on the runtime class behind {}
2261 (method `{}
2262`)",
2263 5usize,
2264 __vt.len(),
2265 <BattleCalculator_FlagField as ::unity::ClassIdentity>::NAME,
2266 "ToInt",
2267 )
2268 });
2269 let __inner: extern "C" fn(
2270 BattleCalculator_FlagField,
2271 crate::app::battlecalculator::BattleCalculator_Flags,
2272 ::unity::OptionalMethod,
2273 ) -> i32 = ::core::mem::transmute(__vi.method_ptr);
2274 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2275 __inner(__receiver, ::core::convert::Into::into(value), __mi)
2276 }
2277 }
2278 }
2279 #[doc = "`.ctor()` overload"]
2280 fn ctor(self) -> () {
2281 unsafe {
2282 let __receiver =
2283 <BattleCalculator_FlagField as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2284 ::unity::il2cpp_call!((::unity::module_base()+0x19b5820usize)as*mut u8,();
2285(BattleCalculator_FlagField)__receiver)
2286 }
2287 }
2288}
2289
2290#[cfg(feature = "app-battlecalculator")]
2291impl<__T: IBattleCalculator_FlagField> IBattleCalculator_FlagFieldMethods for __T {}
2292
2293#[cfg(feature = "app-battlecalculator")]
2294impl BattleCalculator_FlagField {
2295 pub fn to_int_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2296 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2297 }
2298
2299 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2300 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2301 }
2302}
2303
2304#[cfg(feature = "app-battlecalculator")]
2305impl BattleCalculator_FlagField {
2306 #[doc = "Direct (non-virtual) call to `BattleCalculator_FlagField`'s own `ToInt`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2307 pub unsafe fn to_int(this: impl ::core::convert::Into<::unity::IlInstance>, value: crate::app::battlecalculator::BattleCalculator_Flags) -> i32 {
2308 let __mi = Self::to_int_method_info();
2309 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battlecalculator::BattleCalculator_Flags, ::unity::OptionalMethod) -> i32 =
2310 ::core::mem::transmute(__mi.method_ptr);
2311 __inner(this.into(), value, ::core::option::Option::None)
2312 }
2313}
2314
2315#[cfg(feature = "app-battlecalculator")]
2316impl BattleCalculator_FlagField {
2317 #[doc = "`.ctor()` — no args"]
2318 pub fn new() -> Self {
2319 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2320 panic!(
2321 "{}
2322::{}
2323 failed to instantiate",
2324 ::core::stringify!(BattleCalculator_FlagField),
2325 ::core::stringify!(new),
2326 )
2327 });
2328 <Self as IBattleCalculator_FlagFieldMethods>::ctor(this);
2329 this
2330 }
2331}
2332
2333#[cfg(feature = "app-battlecalculator")]
2334pub trait IBattleCalculator_OrderMethods: IBattleCalculator_Order {
2335 #[doc = "`OnEnter()` overload"]
2336 fn on_enter(self) -> () {
2337 unsafe {
2338 let __receiver =
2339 <BattleCalculator_Order as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2340 {
2341 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2342 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
2343 panic!(
2344 "unity: virtual slot {}
2345 out of range (vtable len {}
2346) on the runtime class behind {}
2347 (method `{}
2348`)",
2349 4usize,
2350 __vt.len(),
2351 <BattleCalculator_Order as ::unity::ClassIdentity>::NAME,
2352 "OnEnter",
2353 )
2354 });
2355 let __inner: extern "C" fn(BattleCalculator_Order, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
2356 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2357 __inner(__receiver, __mi)
2358 }
2359 }
2360 }
2361 #[doc = "`OnExit()` overload"]
2362 fn on_exit(self) -> () {
2363 unsafe {
2364 let __receiver =
2365 <BattleCalculator_Order as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2366 {
2367 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2368 let __vi = *__vt.get(5usize).unwrap_or_else(|| {
2369 panic!(
2370 "unity: virtual slot {}
2371 out of range (vtable len {}
2372) on the runtime class behind {}
2373 (method `{}
2374`)",
2375 5usize,
2376 __vt.len(),
2377 <BattleCalculator_Order as ::unity::ClassIdentity>::NAME,
2378 "OnExit",
2379 )
2380 });
2381 let __inner: extern "C" fn(BattleCalculator_Order, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
2382 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2383 __inner(__receiver, __mi)
2384 }
2385 }
2386 }
2387 #[doc = "`.ctor()` overload"]
2388 fn ctor(self) -> () {
2389 unsafe {
2390 let __receiver =
2391 <BattleCalculator_Order as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2392 ::unity::il2cpp_call!((::unity::module_base()+0x19b68b0usize)as*mut u8,();
2393(BattleCalculator_Order)__receiver)
2394 }
2395 }
2396}
2397
2398#[cfg(feature = "app-battlecalculator")]
2399impl<__T: IBattleCalculator_Order> IBattleCalculator_OrderMethods for __T {}
2400
2401#[cfg(feature = "app-battlecalculator")]
2402impl BattleCalculator_Order {
2403 pub fn on_enter_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2404 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2405 }
2406
2407 pub fn on_exit_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2408 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2409 }
2410
2411 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2412 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2413 }
2414}
2415
2416#[cfg(feature = "app-battlecalculator")]
2417impl BattleCalculator_Order {
2418 #[doc = "Direct (non-virtual) call to `BattleCalculator_Order`'s own `OnEnter`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2419 pub unsafe fn on_enter(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
2420 let __mi = Self::on_enter_method_info();
2421 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
2422 __inner(this.into(), ::core::option::Option::None)
2423 }
2424
2425 #[doc = "Direct (non-virtual) call to `BattleCalculator_Order`'s own `OnExit`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2426 pub unsafe fn on_exit(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
2427 let __mi = Self::on_exit_method_info();
2428 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
2429 __inner(this.into(), ::core::option::Option::None)
2430 }
2431}
2432
2433#[cfg(feature = "app-battlecalculator")]
2434impl BattleCalculator_Order {
2435 #[doc = "`.ctor()` — no args"]
2436 pub fn new() -> Self {
2437 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2438 panic!(
2439 "{}
2440::{}
2441 failed to instantiate",
2442 ::core::stringify!(BattleCalculator_Order),
2443 ::core::stringify!(new),
2444 )
2445 });
2446 <Self as IBattleCalculator_OrderMethods>::ctor(this);
2447 this
2448 }
2449}
2450
2451#[cfg(feature = "app-battlecalculator")]
2452impl BattleCalculator_DetailScope {
2453 #[doc = "`.ctor(crate::app::battleinfo::BattleInfo)` overload"]
2454 pub fn ctor(&mut self, info: impl ::core::convert::Into<crate::app::battleinfo::BattleInfo>) -> () {
2455 unsafe {
2456 ::unity::il2cpp_call!((::unity::module_base()+0x19b5790usize)as*mut u8,();
2457(*mut BattleCalculator_DetailScope)self as*mut BattleCalculator_DetailScope,(crate::app::battleinfo::BattleInfo)::core::convert::Into::into(info))
2458 }
2459 }
2460
2461 #[doc = "`Dispose()` overload"]
2462 pub fn dispose(&mut self) -> () {
2463 unsafe {
2464 ::unity::il2cpp_call!((::unity::module_base()+0x19b57d0usize)as*mut u8,();
2465(*mut BattleCalculator_DetailScope)self as*mut BattleCalculator_DetailScope)
2466 }
2467 }
2468}
2469
2470#[cfg(feature = "app-battlecalculator")]
2471impl BattleCalculator_DetailScope {
2472 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2473 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2474 }
2475
2476 pub fn dispose_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2477 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2478 }
2479}
2480
2481#[cfg(feature = "app-battlecalculator")]
2482pub trait IBattleCalculator_HitSkillPoolMethods: IBattleCalculator_HitSkillPool {
2483 #[doc = "`.ctor()` overload"]
2484 fn ctor(self) -> () {
2485 unsafe {
2486 let __receiver =
2487 <BattleCalculator_HitSkillPool as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2488 ::unity::il2cpp_call!((::unity::module_base()+0x19b6120usize)as*mut u8,();
2489(BattleCalculator_HitSkillPool)__receiver)
2490 }
2491 }
2492 #[doc = "`Add(crate::app::battleinfoside::BattleInfoSide, crate::app::skilldata::SkillData_Timings, crate::app::skilldata::SkillData_Actions)` overload"]
2493 fn add(
2494 self,
2495 side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
2496 timing: impl ::core::convert::Into<crate::app::skilldata::SkillData_Timings>,
2497 action: impl ::core::convert::Into<crate::app::skilldata::SkillData_Actions>,
2498 ) -> () {
2499 unsafe {
2500 let __receiver =
2501 <BattleCalculator_HitSkillPool as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2502 ::unity::il2cpp_call!((::unity::module_base()+0x19b6180usize)as*mut u8,();
2503(BattleCalculator_HitSkillPool)__receiver,(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(side),(crate::app::skilldata::SkillData_Timings)::core::convert::Into::into(timing),(crate::app::skilldata::SkillData_Actions)::core::convert::Into::into(action))
2504 }
2505 }
2506}
2507
2508#[cfg(feature = "app-battlecalculator")]
2509impl<__T: IBattleCalculator_HitSkillPool> IBattleCalculator_HitSkillPoolMethods for __T {}
2510
2511#[cfg(feature = "app-battlecalculator")]
2512impl BattleCalculator_HitSkillPool {
2513 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2514 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2515 }
2516
2517 pub fn add_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2518 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2519 }
2520}
2521
2522#[cfg(feature = "app-battlecalculator")]
2523impl BattleCalculator_HitSkillPool {
2524 #[doc = "`.ctor()` — no args"]
2525 pub fn new() -> Self {
2526 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2527 panic!(
2528 "{}
2529::{}
2530 failed to instantiate",
2531 ::core::stringify!(BattleCalculator_HitSkillPool),
2532 ::core::stringify!(new),
2533 )
2534 });
2535 <Self as IBattleCalculator_HitSkillPoolMethods>::ctor(this);
2536 this
2537 }
2538}
2539
2540#[cfg(feature = "app-battlecalculator")]
2541pub trait IBattleCalculator_FuncExp2Methods: IBattleCalculator_FuncExp2 {
2542 #[doc = "`.ctor(crate::system::object::Object, ::unity::IntPtr)` overload"]
2543 fn ctor(self, object: impl ::core::convert::Into<crate::system::object::Object>, method: impl ::core::convert::Into<::unity::IntPtr>) -> () {
2544 unsafe {
2545 let __receiver =
2546 <BattleCalculator_FuncExp2 as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2547 ::unity::il2cpp_call!((::unity::module_base()+0x19b5c60usize)as*mut u8,();
2548(BattleCalculator_FuncExp2)__receiver,(crate::system::object::Object)::core::convert::Into::into(object),(::unity::IntPtr)::core::convert::Into::into(method))
2549 }
2550 }
2551 #[doc = "`Invoke(crate::app::battleinfoside::BattleInfoSide, crate::app::battleinfoside::BattleInfoSide)` overload"]
2552 fn invoke(
2553 self,
2554 current: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
2555 reverse: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
2556 ) -> i32 {
2557 unsafe {
2558 let __receiver =
2559 <BattleCalculator_FuncExp2 as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2560 {
2561 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2562 let __vi = *__vt.get(13usize).unwrap_or_else(|| {
2563 panic!(
2564 "unity: virtual slot {}
2565 out of range (vtable len {}
2566) on the runtime class behind {}
2567 (method `{}
2568`)",
2569 13usize,
2570 __vt.len(),
2571 <BattleCalculator_FuncExp2 as ::unity::ClassIdentity>::NAME,
2572 "Invoke",
2573 )
2574 });
2575 let __inner: extern "C" fn(
2576 BattleCalculator_FuncExp2,
2577 crate::app::battleinfoside::BattleInfoSide,
2578 crate::app::battleinfoside::BattleInfoSide,
2579 ::unity::OptionalMethod,
2580 ) -> i32 = ::core::mem::transmute(__vi.method_ptr);
2581 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2582 __inner(
2583 __receiver,
2584 ::core::convert::Into::into(current),
2585 ::core::convert::Into::into(reverse),
2586 __mi,
2587 )
2588 }
2589 }
2590 }
2591}
2592
2593#[cfg(feature = "app-battlecalculator")]
2594impl<__T: IBattleCalculator_FuncExp2> IBattleCalculator_FuncExp2Methods for __T {}
2595
2596#[cfg(feature = "app-battlecalculator")]
2597impl BattleCalculator_FuncExp2 {
2598 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2599 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2600 }
2601
2602 pub fn invoke_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2603 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2604 }
2605}
2606
2607#[cfg(feature = "app-battlecalculator")]
2608impl BattleCalculator_FuncExp2 {
2609 #[doc = "Direct (non-virtual) call to `BattleCalculator_FuncExp2`'s own `Invoke`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2610 pub unsafe fn invoke(
2611 this: impl ::core::convert::Into<::unity::IlInstance>,
2612 current: crate::app::battleinfoside::BattleInfoSide,
2613 reverse: crate::app::battleinfoside::BattleInfoSide,
2614 ) -> i32 {
2615 let __mi = Self::invoke_method_info();
2616 let __inner: extern "C" fn(
2617 ::unity::IlInstance,
2618 crate::app::battleinfoside::BattleInfoSide,
2619 crate::app::battleinfoside::BattleInfoSide,
2620 ::unity::OptionalMethod,
2621 ) -> i32 = ::core::mem::transmute(__mi.method_ptr);
2622 __inner(this.into(), current, reverse, ::core::option::Option::None)
2623 }
2624}
2625
2626#[cfg(feature = "app-battlecalculator")]
2627impl BattleCalculator_FuncExp2 {
2628 #[doc = "`.ctor(crate::system::object::Object, ::unity::IntPtr)` — overload selector"]
2629 pub fn new(object: crate::system::object::Object, method: ::unity::IntPtr) -> Self {
2630 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2631 panic!(
2632 "{}
2633::{}
2634 failed to instantiate",
2635 ::core::stringify!(BattleCalculator_FuncExp2),
2636 ::core::stringify!(new),
2637 )
2638 });
2639 <Self as IBattleCalculator_FuncExp2Methods>::ctor(this, object, method);
2640 this
2641 }
2642}
2643
2644#[cfg(feature = "app-battlecalculator")]
2645pub trait IBattleCalculator_FuncExp1Methods: IBattleCalculator_FuncExp1 {
2646 #[doc = "`.ctor(crate::system::object::Object, ::unity::IntPtr)` overload"]
2647 fn ctor(self, object: impl ::core::convert::Into<crate::system::object::Object>, method: impl ::core::convert::Into<::unity::IntPtr>) -> () {
2648 unsafe {
2649 let __receiver =
2650 <BattleCalculator_FuncExp1 as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2651 ::unity::il2cpp_call!((::unity::module_base()+0x19b5880usize)as*mut u8,();
2652(BattleCalculator_FuncExp1)__receiver,(crate::system::object::Object)::core::convert::Into::into(object),(::unity::IntPtr)::core::convert::Into::into(method))
2653 }
2654 }
2655 #[doc = "`Invoke(crate::app::battleinfoside::BattleInfoSide)` overload"]
2656 fn invoke(self, current: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> i32 {
2657 unsafe {
2658 let __receiver =
2659 <BattleCalculator_FuncExp1 as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2660 {
2661 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2662 let __vi = *__vt.get(13usize).unwrap_or_else(|| {
2663 panic!(
2664 "unity: virtual slot {}
2665 out of range (vtable len {}
2666) on the runtime class behind {}
2667 (method `{}
2668`)",
2669 13usize,
2670 __vt.len(),
2671 <BattleCalculator_FuncExp1 as ::unity::ClassIdentity>::NAME,
2672 "Invoke",
2673 )
2674 });
2675 let __inner: extern "C" fn(BattleCalculator_FuncExp1, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> i32 =
2676 ::core::mem::transmute(__vi.method_ptr);
2677 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2678 __inner(__receiver, ::core::convert::Into::into(current), __mi)
2679 }
2680 }
2681 }
2682}
2683
2684#[cfg(feature = "app-battlecalculator")]
2685impl<__T: IBattleCalculator_FuncExp1> IBattleCalculator_FuncExp1Methods for __T {}
2686
2687#[cfg(feature = "app-battlecalculator")]
2688impl BattleCalculator_FuncExp1 {
2689 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2690 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2691 }
2692
2693 pub fn invoke_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2694 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2695 }
2696}
2697
2698#[cfg(feature = "app-battlecalculator")]
2699impl BattleCalculator_FuncExp1 {
2700 #[doc = "Direct (non-virtual) call to `BattleCalculator_FuncExp1`'s own `Invoke`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2701 pub unsafe fn invoke(this: impl ::core::convert::Into<::unity::IlInstance>, current: crate::app::battleinfoside::BattleInfoSide) -> i32 {
2702 let __mi = Self::invoke_method_info();
2703 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> i32 =
2704 ::core::mem::transmute(__mi.method_ptr);
2705 __inner(this.into(), current, ::core::option::Option::None)
2706 }
2707}
2708
2709#[cfg(feature = "app-battlecalculator")]
2710impl BattleCalculator_FuncExp1 {
2711 #[doc = "`.ctor(crate::system::object::Object, ::unity::IntPtr)` — overload selector"]
2712 pub fn new(object: crate::system::object::Object, method: ::unity::IntPtr) -> Self {
2713 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2714 panic!(
2715 "{}
2716::{}
2717 failed to instantiate",
2718 ::core::stringify!(BattleCalculator_FuncExp1),
2719 ::core::stringify!(new),
2720 )
2721 });
2722 <Self as IBattleCalculator_FuncExp1Methods>::ctor(this, object, method);
2723 this
2724 }
2725}
2726
2727#[cfg(feature = "app-battlecalculator")]
2728pub trait IBattleCalculator_OrderListMethods: IBattleCalculator_OrderList {
2729 #[doc = "`.ctor()` overload"]
2730 fn ctor(self) -> () {
2731 unsafe {
2732 let __receiver =
2733 <BattleCalculator_OrderList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2734 ::unity::il2cpp_call!((::unity::module_base()+0x19b68c0usize)as*mut u8,();
2735(BattleCalculator_OrderList)__receiver)
2736 }
2737 }
2738 #[doc = "`TryAdd(crate::app::battleinfo::BattleInfo, crate::app::battleside::BattleSide_Type)` overload"]
2739 fn try_add(
2740 self,
2741 info: impl ::core::convert::Into<crate::app::battleinfo::BattleInfo>,
2742 side: impl ::core::convert::Into<crate::app::battleside::BattleSide_Type>,
2743 ) -> () {
2744 unsafe {
2745 let __receiver =
2746 <BattleCalculator_OrderList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2747 ::unity::il2cpp_call!((::unity::module_base()+0x19b6920usize)as*mut u8,();
2748(BattleCalculator_OrderList)__receiver,(crate::app::battleinfo::BattleInfo)::core::convert::Into::into(info),(crate::app::battleside::BattleSide_Type)::core::convert::Into::into(side))
2749 }
2750 }
2751 #[doc = "`CanSwap(crate::app::battleside::BattleSide_Type, i32)` overload"]
2752 fn can_swap(self, side: impl ::core::convert::Into<crate::app::battleside::BattleSide_Type>, index: impl ::core::convert::Into<i32>) -> bool {
2753 unsafe {
2754 let __receiver =
2755 <BattleCalculator_OrderList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2756 ::unity::il2cpp_call!((::unity::module_base()+0x19b6950usize)as*mut u8,bool;
2757(BattleCalculator_OrderList)__receiver,(crate::app::battleside::BattleSide_Type)::core::convert::Into::into(side),(i32)::core::convert::Into::into(index))
2758 }
2759 }
2760}
2761
2762#[cfg(feature = "app-battlecalculator")]
2763impl<__T: IBattleCalculator_OrderList> IBattleCalculator_OrderListMethods for __T {}
2764
2765#[cfg(feature = "app-battlecalculator")]
2766impl BattleCalculator_OrderList {
2767 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2768 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2769 }
2770
2771 pub fn try_add_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2772 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2773 }
2774
2775 pub fn can_swap_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2776 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2777 }
2778}
2779
2780#[cfg(feature = "app-battlecalculator")]
2781impl BattleCalculator_OrderList {
2782 #[doc = "`.ctor()` — no args"]
2783 pub fn new() -> Self {
2784 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2785 panic!(
2786 "{}
2787::{}
2788 failed to instantiate",
2789 ::core::stringify!(BattleCalculator_OrderList),
2790 ::core::stringify!(new),
2791 )
2792 });
2793 <Self as IBattleCalculator_OrderListMethods>::ctor(this);
2794 this
2795 }
2796}
2797
2798#[cfg(feature = "app-battlecalculator")]
2799#[doc(hidden)]
2800pub mod prelude {
2801 pub use super::{
2802 BattleCalculator, BattleCalculator_Attributes, BattleCalculator_DetailScope, BattleCalculator_FlagField, BattleCalculator_Flags,
2803 BattleCalculator_FuncExp1, BattleCalculator_FuncExp2, BattleCalculator_HitSkill, BattleCalculator_HitSkillPool, BattleCalculator_Mode,
2804 BattleCalculator_Order, BattleCalculator_OrderList, BattleCalculator_SeparatorScope, BattleCalculator_TargetScope,
2805 BattleCalculator_TrainingResult, IBattleCalculator, IBattleCalculatorMethods, IBattleCalculator_FlagField,
2806 IBattleCalculator_FlagFieldMethods, IBattleCalculator_FuncExp1, IBattleCalculator_FuncExp1Methods, IBattleCalculator_FuncExp2,
2807 IBattleCalculator_FuncExp2Methods, IBattleCalculator_HitSkill, IBattleCalculator_HitSkillMethods, IBattleCalculator_HitSkillPool,
2808 IBattleCalculator_HitSkillPoolMethods, IBattleCalculator_Order, IBattleCalculator_OrderList, IBattleCalculator_OrderListMethods,
2809 IBattleCalculator_OrderMethods,
2810 };
2811 #[cfg(feature = "app-bitfield32")]
2812 pub use crate::app::bitfield32::IBitField32Methods;
2813 #[cfg(feature = "app-bitfieldcommon")]
2814 pub use crate::app::bitfieldcommon::IBitFieldCommonMethods;
2815 #[cfg(feature = "app-bitfieldtemplate32_1")]
2816 pub use crate::app::bitfieldtemplate32_1::IBitFieldTemplate32_1Methods;
2817 #[cfg(feature = "app-pool")]
2818 pub use crate::app::pool::IPool_List_1Methods;
2819 #[cfg(feature = "app-pool")]
2820 pub use crate::app::pool::IPool_NodeMethods;
2821 #[cfg(feature = "system-delegate")]
2822 pub use crate::system::delegate::IDelegateMethods;
2823 #[cfg(feature = "system-multicastdelegate")]
2824 pub use crate::system::multicastdelegate::IMulticastDelegateMethods;
2825 #[cfg(feature = "system-object")]
2826 pub use crate::system::object::IObjectMethods;
2827 #[cfg(feature = "system-enum")]
2828 pub use crate::system::r#enum::IEnumMethods;
2829 #[cfg(feature = "system-valuetype")]
2830 pub use crate::system::valuetype::IValueTypeMethods;
2831 pub use crate::{
2832 app::{
2833 bitfield32::IBitField32,
2834 bitfieldcommon::IBitFieldCommon,
2835 bitfieldtemplate32_1::IBitFieldTemplate32_1,
2836 pool::{IPool_List_1, IPool_Node},
2837 },
2838 system::{delegate::IDelegate, multicastdelegate::IMulticastDelegate, object::IObject, r#enum::IEnum, valuetype::IValueType},
2839 };
2840}