1#[cfg(feature = "app-unitcalculator-types")]
4mod __types {
5 #[allow(unused_imports)] use ::unity::prelude::*;
6
7 use super::*;
8 use crate::{
9 app::{
10 calculatorcommand::{CalculatorCommand, ICalculatorCommand},
11 gamecalculatorcommand::{GameCalculatorCommand, IGameCalculatorCommand},
12 },
13 system::{
14 object::{IObject, Object},
15 r#enum::{Enum, IEnum},
16 valuetype::{IValueType, ValueType},
17 },
18 };
19
20 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_WeaponInteractCommand.md"))]
21 #[::unity::class(namespace = "App", name = "UnitCalculator.WeaponInteractCommand")]
22 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
23 pub struct UnitCalculator_WeaponInteractCommand {}
24
25 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_MapUnitCountCommand.md"))]
26 #[::unity::class(namespace = "App", name = "UnitCalculator.MapUnitCountCommand")]
27 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
28 pub struct UnitCalculator_MapUnitCountCommand {}
29
30 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_WeaponLevelBaseCommand.md"))]
31 #[::unity::class(namespace = "App", name = "UnitCalculator.WeaponLevelBaseCommand")]
32 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
33 pub struct UnitCalculator_WeaponLevelBaseCommand {}
34
35 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_PosZCommand.md"))]
36 #[::unity::class(namespace = "App", name = "UnitCalculator.PosZCommand")]
37 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
38 pub struct UnitCalculator_PosZCommand {}
39
40 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_BattleChainAttackDefeatCommand.md"))]
41 #[::unity::class(namespace = "App", name = "UnitCalculator.BattleChainAttackDefeatCommand")]
42 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
43 pub struct UnitCalculator_BattleChainAttackDefeatCommand {}
44
45 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_SupportLevelCommand.md"))]
46 #[::unity::class(namespace = "App", name = "UnitCalculator.SupportLevelCommand")]
47 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
48 pub struct UnitCalculator_SupportLevelCommand {}
49
50 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_TerrainDefenseCommand.md"))]
51 #[::unity::class(namespace = "App", name = "UnitCalculator.TerrainDefenseCommand")]
52 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
53 pub struct UnitCalculator_TerrainDefenseCommand {}
54
55 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_WeaponHitCommand.md"))]
56 #[::unity::class(namespace = "App", name = "UnitCalculator.WeaponHitCommand")]
57 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
58 pub struct UnitCalculator_WeaponHitCommand {}
59
60 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_PhysCommand.md"))]
61 #[::unity::class(namespace = "App", name = "UnitCalculator.PhysCommand")]
62 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
63 pub struct UnitCalculator_PhysCommand {}
64
65 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_RodExpCommand.md"))]
66 #[::unity::class(namespace = "App", name = "UnitCalculator.RodExpCommand")]
67 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
68 pub struct UnitCalculator_RodExpCommand {}
69
70 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_LinkPhysCommand.md"))]
71 #[::unity::class(namespace = "App", name = "UnitCalculator.LinkPhysCommand")]
72 #[parent(crate::app::unitcalculator::UnitCalculator_LinkGodCommand)]
73 pub struct UnitCalculator_LinkPhysCommand {}
74
75 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_BattleSceneResultEfficacyCommand.md"))]
76 #[::unity::class(namespace = "App", name = "UnitCalculator.BattleSceneResultEfficacyCommand")]
77 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
78 pub struct UnitCalculator_BattleSceneResultEfficacyCommand {}
79
80 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_AttackAttributeCommand.md"))]
81 #[::unity::class(namespace = "App", name = "UnitCalculator.AttackAttributeCommand")]
82 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
83 pub struct UnitCalculator_AttackAttributeCommand {}
84
85 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_ExpCommand.md"))]
86 #[::unity::class(namespace = "App", name = "UnitCalculator.ExpCommand")]
87 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
88 pub struct UnitCalculator_ExpCommand {}
89
90 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_EngageCountLimitCommand.md"))]
91 #[::unity::class(namespace = "App", name = "UnitCalculator.EngageCountLimitCommand")]
92 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
93 pub struct UnitCalculator_EngageCountLimitCommand {}
94
95 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_MapUnitCountCommand_Candidates.md"))]
96 #[repr(C)]
97 #[derive(::core::clone::Clone, ::core::marker::Copy, ::core::fmt::Debug, ::core::cmp::PartialEq, ::core::cmp::Eq)]
98 pub struct UnitCalculator_MapUnitCountCommand_Candidates {
99 pub value: i32,
100 }
101 impl ::unity::ClassIdentity for UnitCalculator_MapUnitCountCommand_Candidates {
102 const NAME: &'static str = "UnitCalculator.MapUnitCountCommand.Candidates";
103 const NAMESPACE: &'static str = "App";
104
105 fn class() -> ::unity::Class {
106 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
107 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
108 }
109 }
110 impl ::unity::IlType for UnitCalculator_MapUnitCountCommand_Candidates {
111 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
112 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
113 }
114 }
115 impl UnitCalculator_MapUnitCountCommand_Candidates {
116 pub fn friend() -> Self {
117 Self { value: 0 }
118 }
119
120 pub fn enemy() -> Self {
121 Self { value: 1 }
122 }
123
124 pub fn whole() -> Self {
125 Self { value: 2 }
126 }
127 }
128
129 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_PickupItemCommand.md"))]
130 #[::unity::class(namespace = "App", name = "UnitCalculator.PickupItemCommand")]
131 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
132 pub struct UnitCalculator_PickupItemCommand {}
133
134 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_BattleSceneResultCriticalCommand.md"))]
135 #[::unity::class(namespace = "App", name = "UnitCalculator.BattleSceneResultCriticalCommand")]
136 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
137 pub struct UnitCalculator_BattleSceneResultCriticalCommand {}
138
139 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_UnitDefenseCommand.md"))]
140 #[::unity::class(namespace = "App", name = "UnitCalculator.UnitDefenseCommand")]
141 #[parent(crate::app::unitcalculator::UnitCalculator_BattleParamCommand)]
142 pub struct UnitCalculator_UnitDefenseCommand {}
143
144 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_DefenseCommand.md"))]
145 #[::unity::class(namespace = "App", name = "UnitCalculator.DefenseCommand")]
146 #[parent(crate::app::unitcalculator::UnitCalculator_BattleParamCommand)]
147 pub struct UnitCalculator_DefenseCommand {}
148
149 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_JobRankCommand.md"))]
150 #[::unity::class(namespace = "App", name = "UnitCalculator.JobRankCommand")]
151 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
152 pub struct UnitCalculator_JobRankCommand {}
153
154 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_DefCommand.md"))]
155 #[::unity::class(namespace = "App", name = "UnitCalculator.DefCommand")]
156 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
157 pub struct UnitCalculator_DefCommand {}
158
159 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_AroundGenderCountCommand.md"))]
160 #[::unity::class(namespace = "App", name = "UnitCalculator.AroundGenderCountCommand")]
161 #[parent(crate::app::unitcalculator::UnitCalculator_MapUnitCountCommand)]
162 pub struct UnitCalculator_AroundGenderCountCommand {}
163
164 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_SimplePowerCommand.md"))]
165 #[::unity::class(namespace = "App", name = "UnitCalculator.SimplePowerCommand")]
166 #[parent(crate::app::unitcalculator::UnitCalculator_BattleParamCommand)]
167 pub struct UnitCalculator_SimplePowerCommand {}
168
169 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_GodLevelCommand.md"))]
170 #[::unity::class(namespace = "App", name = "UnitCalculator.GodLevelCommand")]
171 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
172 pub struct UnitCalculator_GodLevelCommand {}
173
174 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_SecureCommand.md"))]
175 #[::unity::class(namespace = "App", name = "UnitCalculator.SecureCommand")]
176 #[parent(crate::app::unitcalculator::UnitCalculator_BattleParamCommand)]
177 pub struct UnitCalculator_SecureCommand {}
178
179 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_RangeFriendCountCommand.md"))]
180 #[::unity::class(namespace = "App", name = "UnitCalculator.RangeFriendCountCommand")]
181 #[parent(crate::app::unitcalculator::UnitCalculator_MapUnitCountCommand)]
182 pub struct UnitCalculator_RangeFriendCountCommand {}
183
184 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_LinkMagicCommand.md"))]
185 #[::unity::class(namespace = "App", name = "UnitCalculator.LinkMagicCommand")]
186 #[parent(crate::app::unitcalculator::UnitCalculator_LinkGodCommand)]
187 pub struct UnitCalculator_LinkMagicCommand {}
188
189 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_BattleSceneResultBreakCommand.md"))]
190 #[::unity::class(namespace = "App", name = "UnitCalculator.BattleSceneResultBreakCommand")]
191 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
192 pub struct UnitCalculator_BattleSceneResultBreakCommand {}
193
194 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_BattleDeadCommand.md"))]
195 #[::unity::class(namespace = "App", name = "UnitCalculator.BattleDeadCommand")]
196 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
197 pub struct UnitCalculator_BattleDeadCommand {}
198
199 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_ProbabilitySkillCommand.md"))]
200 #[::unity::class(namespace = "App", name = "UnitCalculator.ProbabilitySkillCommand")]
201 #[parent(crate::app::unitcalculator::UnitCalculator_ProbabilityCommand)]
202 pub struct UnitCalculator_ProbabilitySkillCommand {}
203
204 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_BattleEscortCommand.md"))]
205 #[::unity::class(namespace = "App", name = "UnitCalculator.BattleEscortCommand")]
206 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
207 pub struct UnitCalculator_BattleEscortCommand {}
208
209 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_HitCommand.md"))]
210 #[::unity::class(namespace = "App", name = "UnitCalculator.HitCommand")]
211 #[parent(crate::app::unitcalculator::UnitCalculator_BattleParamCommand)]
212 pub struct UnitCalculator_HitCommand {}
213
214 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_GainExpCommand.md"))]
215 #[::unity::class(namespace = "App", name = "UnitCalculator.GainExpCommand")]
216 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
217 pub struct UnitCalculator_GainExpCommand {}
218
219 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_BattleSceneResultHitCommand.md"))]
220 #[::unity::class(namespace = "App", name = "UnitCalculator.BattleSceneResultHitCommand")]
221 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
222 pub struct UnitCalculator_BattleSceneResultHitCommand {}
223
224 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_ForceCommand.md"))]
225 #[::unity::class(namespace = "App", name = "UnitCalculator.ForceCommand")]
226 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
227 pub struct UnitCalculator_ForceCommand {}
228
229 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_DamageCommand.md"))]
230 #[::unity::class(namespace = "App", name = "UnitCalculator.DamageCommand")]
231 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
232 pub struct UnitCalculator_DamageCommand {}
233
234 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_BattleChainGuardCountCommand.md"))]
235 #[::unity::class(namespace = "App", name = "UnitCalculator.BattleChainGuardCountCommand")]
236 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
237 pub struct UnitCalculator_BattleChainGuardCountCommand {}
238
239 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_ProbabilityGodSkillCommand.md"))]
240 #[::unity::class(namespace = "App", name = "UnitCalculator.ProbabilityGodSkillCommand")]
241 #[parent(crate::app::unitcalculator::UnitCalculator_ProbabilityCommand)]
242 pub struct UnitCalculator_ProbabilityGodSkillCommand {}
243
244 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_LuukCommand.md"))]
245 #[::unity::class(namespace = "App", name = "UnitCalculator.LuukCommand")]
246 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
247 pub struct UnitCalculator_LuukCommand {}
248
249 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_ReciveAttackCountCommand.md"))]
250 #[::unity::class(namespace = "App", name = "UnitCalculator.ReciveAttackCountCommand")]
251 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
252 pub struct UnitCalculator_ReciveAttackCountCommand {}
253
254 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_WeaponCriticalCommand.md"))]
255 #[::unity::class(namespace = "App", name = "UnitCalculator.WeaponCriticalCommand")]
256 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
257 pub struct UnitCalculator_WeaponCriticalCommand {}
258
259 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_GodEngagingCommand.md"))]
260 #[::unity::class(namespace = "App", name = "UnitCalculator.GodEngagingCommand")]
261 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
262 pub struct UnitCalculator_GodEngagingCommand {}
263
264 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_WeaponLevelCommand.md"))]
265 #[::unity::class(namespace = "App", name = "UnitCalculator.WeaponLevelCommand")]
266 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
267 pub struct UnitCalculator_WeaponLevelCommand {}
268
269 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_FixedEnemyCountCommand.md"))]
270 #[::unity::class(namespace = "App", name = "UnitCalculator.FixedEnemyCountCommand")]
271 #[parent(crate::app::unitcalculator::UnitCalculator_MapUnitCountCommand)]
272 pub struct UnitCalculator_FixedEnemyCountCommand {}
273
274 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_MagicCommand.md"))]
275 #[::unity::class(namespace = "App", name = "UnitCalculator.MagicCommand")]
276 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
277 pub struct UnitCalculator_MagicCommand {}
278
279 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_TotalOrderCommand.md"))]
280 #[::unity::class(namespace = "App", name = "UnitCalculator.TotalOrderCommand")]
281 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
282 pub struct UnitCalculator_TotalOrderCommand {}
283
284 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_ExpInterferenceCountCommand.md"))]
285 #[::unity::class(namespace = "App", name = "UnitCalculator.ExpInterferenceCountCommand")]
286 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
287 pub struct UnitCalculator_ExpInterferenceCountCommand {}
288
289 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_RangeGenderCountCommand.md"))]
290 #[::unity::class(namespace = "App", name = "UnitCalculator.RangeGenderCountCommand")]
291 #[parent(crate::app::unitcalculator::UnitCalculator_MapUnitCountCommand)]
292 pub struct UnitCalculator_RangeGenderCountCommand {}
293
294 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_ExpRodCountCommand.md"))]
295 #[::unity::class(namespace = "App", name = "UnitCalculator.ExpRodCountCommand")]
296 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
297 pub struct UnitCalculator_ExpRodCountCommand {}
298
299 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_SupportHitCommand.md"))]
300 #[::unity::class(namespace = "App", name = "UnitCalculator.SupportHitCommand")]
301 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
302 pub struct UnitCalculator_SupportHitCommand {}
303
304 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_UnitIdentCommand.md"))]
305 #[::unity::class(namespace = "App", name = "UnitCalculator.UnitIdentCommand")]
306 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
307 pub struct UnitCalculator_UnitIdentCommand {}
308
309 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_BattleParamCommand.md"))]
310 #[::unity::class(namespace = "App", name = "UnitCalculator.BattleParamCommand")]
311 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
312 pub struct UnitCalculator_BattleParamCommand {}
313
314 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_LinkTechCommand.md"))]
315 #[::unity::class(namespace = "App", name = "UnitCalculator.LinkTechCommand")]
316 #[parent(crate::app::unitcalculator::UnitCalculator_LinkGodCommand)]
317 pub struct UnitCalculator_LinkTechCommand {}
318
319 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_MoveTypeCommand.md"))]
320 #[::unity::class(namespace = "App", name = "UnitCalculator.MoveTypeCommand")]
321 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
322 pub struct UnitCalculator_MoveTypeCommand {}
323
324 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_BattleSceneResultCommand.md"))]
325 #[::unity::class(namespace = "App", name = "UnitCalculator.BattleSceneResultCommand")]
326 #[parent(crate::app::unitcalculator::UnitCalculator_IBattleSceneResultCommand)]
327 pub struct UnitCalculator_BattleSceneResultCommand {}
328
329 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_LinkMdefCommand.md"))]
330 #[::unity::class(namespace = "App", name = "UnitCalculator.LinkMdefCommand")]
331 #[parent(crate::app::unitcalculator::UnitCalculator_LinkGodCommand)]
332 pub struct UnitCalculator_LinkMdefCommand {}
333
334 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_BattleDistanceCommand.md"))]
335 #[::unity::class(namespace = "App", name = "UnitCalculator.BattleDistanceCommand")]
336 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
337 pub struct UnitCalculator_BattleDistanceCommand {}
338
339 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_MdefCommand.md"))]
340 #[::unity::class(namespace = "App", name = "UnitCalculator.MdefCommand")]
341 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
342 pub struct UnitCalculator_MdefCommand {}
343
344 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_StrCommand.md"))]
345 #[::unity::class(namespace = "App", name = "UnitCalculator.StrCommand")]
346 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
347 pub struct UnitCalculator_StrCommand {}
348
349 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_ContinuousCommand.md"))]
350 #[::unity::class(namespace = "App", name = "UnitCalculator.ContinuousCommand")]
351 #[parent(crate::app::unitcalculator::UnitCalculator_BattleParamCommand)]
352 pub struct UnitCalculator_ContinuousCommand {}
353
354 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_UnitPersonCommand.md"))]
355 #[::unity::class(namespace = "App", name = "UnitCalculator.UnitPersonCommand")]
356 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
357 pub struct UnitCalculator_UnitPersonCommand {}
358
359 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_BattleAliveCommand.md"))]
360 #[::unity::class(namespace = "App", name = "UnitCalculator.BattleAliveCommand")]
361 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
362 pub struct UnitCalculator_BattleAliveCommand {}
363
364 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_WeaponAvoidCommand.md"))]
365 #[::unity::class(namespace = "App", name = "UnitCalculator.WeaponAvoidCommand")]
366 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
367 pub struct UnitCalculator_WeaponAvoidCommand {}
368
369 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_InternalLevelCommand.md"))]
370 #[::unity::class(namespace = "App", name = "UnitCalculator.InternalLevelCommand")]
371 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
372 pub struct UnitCalculator_InternalLevelCommand {}
373
374 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_LinkQuickCommand.md"))]
375 #[::unity::class(namespace = "App", name = "UnitCalculator.LinkQuickCommand")]
376 #[parent(crate::app::unitcalculator::UnitCalculator_LinkGodCommand)]
377 pub struct UnitCalculator_LinkQuickCommand {}
378
379 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_UnitAttackCommand.md"))]
380 #[::unity::class(namespace = "App", name = "UnitCalculator.UnitAttackCommand")]
381 #[parent(crate::app::unitcalculator::UnitCalculator_BattleParamCommand)]
382 pub struct UnitCalculator_UnitAttackCommand {}
383
384 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_UnitJobCommand.md"))]
385 #[::unity::class(namespace = "App", name = "UnitCalculator.UnitJobCommand")]
386 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
387 pub struct UnitCalculator_UnitJobCommand {}
388
389 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_GodGoodWeaponCommand.md"))]
390 #[::unity::class(namespace = "App", name = "UnitCalculator.GodGoodWeaponCommand")]
391 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
392 pub struct UnitCalculator_GodGoodWeaponCommand {}
393
394 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_ProbabilityCommand.md"))]
395 #[::unity::class(namespace = "App", name = "UnitCalculator.ProbabilityCommand")]
396 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
397 pub struct UnitCalculator_ProbabilityCommand {}
398
399 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_BattleReviveCommand.md"))]
400 #[::unity::class(namespace = "App", name = "UnitCalculator.BattleReviveCommand")]
401 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
402 pub struct UnitCalculator_BattleReviveCommand {}
403
404 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_EngageCountCommand.md"))]
405 #[::unity::class(namespace = "App", name = "UnitCalculator.EngageCountCommand")]
406 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
407 pub struct UnitCalculator_EngageCountCommand {}
408
409 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_SimpleCriticalCommand.md"))]
410 #[::unity::class(namespace = "App", name = "UnitCalculator.SimpleCriticalCommand")]
411 #[parent(crate::app::unitcalculator::UnitCalculator_BattleParamCommand)]
412 pub struct UnitCalculator_SimpleCriticalCommand {}
413
414 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_DropItemRatioCommand.md"))]
415 #[::unity::class(namespace = "App", name = "UnitCalculator.DropItemRatioCommand")]
416 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
417 pub struct UnitCalculator_DropItemRatioCommand {}
418
419 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_MapPhaseCommand.md"))]
420 #[::unity::class(namespace = "App", name = "UnitCalculator.MapPhaseCommand")]
421 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
422 pub struct UnitCalculator_MapPhaseCommand {}
423
424 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_SkillCorrectCommand.md"))]
425 #[::unity::class(namespace = "App", name = "UnitCalculator.SkillCorrectCommand")]
426 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
427 pub struct UnitCalculator_SkillCorrectCommand {}
428
429 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_GodSkillCorrectCommand.md"))]
430 #[::unity::class(namespace = "App", name = "UnitCalculator.GodSkillCorrectCommand")]
431 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
432 pub struct UnitCalculator_GodSkillCorrectCommand {}
433
434 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_LevelCommand.md"))]
435 #[::unity::class(namespace = "App", name = "UnitCalculator.LevelCommand")]
436 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
437 pub struct UnitCalculator_LevelCommand {}
438
439 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_WeaponEnduranceCommand.md"))]
440 #[::unity::class(namespace = "App", name = "UnitCalculator.WeaponEnduranceCommand")]
441 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
442 pub struct UnitCalculator_WeaponEnduranceCommand {}
443
444 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_WeaponSecureCommand.md"))]
445 #[::unity::class(namespace = "App", name = "UnitCalculator.WeaponSecureCommand")]
446 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
447 pub struct UnitCalculator_WeaponSecureCommand {}
448
449 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_BattleTimesCommand.md"))]
450 #[::unity::class(namespace = "App", name = "UnitCalculator.BattleTimesCommand")]
451 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
452 pub struct UnitCalculator_BattleTimesCommand {}
453
454 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_TotalAttackCommand.md"))]
455 #[::unity::class(namespace = "App", name = "UnitCalculator.TotalAttackCommand")]
456 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
457 pub struct UnitCalculator_TotalAttackCommand {}
458
459 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_ExpBattleGiveCountCommand.md"))]
460 #[::unity::class(namespace = "App", name = "UnitCalculator.ExpBattleGiveCountCommand")]
461 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
462 pub struct UnitCalculator_ExpBattleGiveCountCommand {}
463
464 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_PosLowXCommand.md"))]
465 #[::unity::class(namespace = "App", name = "UnitCalculator.PosLowXCommand")]
466 #[parent(crate::app::unitcalculator::UnitCalculator_PosXCommand)]
467 pub struct UnitCalculator_PosLowXCommand {}
468
469 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_BattleLastTargetCommand.md"))]
470 #[::unity::class(namespace = "App", name = "UnitCalculator.BattleLastTargetCommand")]
471 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
472 pub struct UnitCalculator_BattleLastTargetCommand {}
473
474 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_BattleSceneResultMissCommand.md"))]
475 #[::unity::class(namespace = "App", name = "UnitCalculator.BattleSceneResultMissCommand")]
476 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
477 pub struct UnitCalculator_BattleSceneResultMissCommand {}
478
479 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_WeaponAttackCommand.md"))]
480 #[::unity::class(namespace = "App", name = "UnitCalculator.WeaponAttackCommand")]
481 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
482 pub struct UnitCalculator_WeaponAttackCommand {}
483
484 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_RangeEnemyCountCommand.md"))]
485 #[::unity::class(namespace = "App", name = "UnitCalculator.RangeEnemyCountCommand")]
486 #[parent(crate::app::unitcalculator::UnitCalculator_MapUnitCountCommand)]
487 pub struct UnitCalculator_RangeEnemyCountCommand {}
488
489 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator.md"))]
490 #[::unity::class(namespace = "App", name = "UnitCalculator")]
491 #[parent(crate::system::object::Object)]
492 pub struct UnitCalculator {}
493
494 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_BattleArenaCommand.md"))]
495 #[::unity::class(namespace = "App", name = "UnitCalculator.BattleArenaCommand")]
496 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
497 pub struct UnitCalculator_BattleArenaCommand {}
498
499 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_AvoidCommand.md"))]
500 #[::unity::class(namespace = "App", name = "UnitCalculator.AvoidCommand")]
501 #[parent(crate::app::unitcalculator::UnitCalculator_BattleParamCommand)]
502 pub struct UnitCalculator_AvoidCommand {}
503
504 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_PosLowZCommand.md"))]
505 #[::unity::class(namespace = "App", name = "UnitCalculator.PosLowZCommand")]
506 #[parent(crate::app::unitcalculator::UnitCalculator_PosZCommand)]
507 pub struct UnitCalculator_PosLowZCommand {}
508
509 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_GainGoldCommand.md"))]
510 #[::unity::class(namespace = "App", name = "UnitCalculator.GainGoldCommand")]
511 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
512 pub struct UnitCalculator_GainGoldCommand {}
513
514 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_RelianceAroundTotalCommand.md"))]
515 #[::unity::class(namespace = "App", name = "UnitCalculator.RelianceAroundTotalCommand")]
516 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
517 pub struct UnitCalculator_RelianceAroundTotalCommand {}
518
519 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_LinkStrCommand.md"))]
520 #[::unity::class(namespace = "App", name = "UnitCalculator.LinkStrCommand")]
521 #[parent(crate::app::unitcalculator::UnitCalculator_LinkGodCommand)]
522 pub struct UnitCalculator_LinkStrCommand {}
523
524 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_BlowRatioCommand.md"))]
525 #[::unity::class(namespace = "App", name = "UnitCalculator.BlowRatioCommand")]
526 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
527 pub struct UnitCalculator_BlowRatioCommand {}
528
529 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_PosXCommand.md"))]
530 #[::unity::class(namespace = "App", name = "UnitCalculator.PosXCommand")]
531 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
532 pub struct UnitCalculator_PosXCommand {}
533
534 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_BattleChainAttackCountCommand.md"))]
535 #[::unity::class(namespace = "App", name = "UnitCalculator.BattleChainAttackCountCommand")]
536 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
537 pub struct UnitCalculator_BattleChainAttackCountCommand {}
538
539 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_QuickCommand.md"))]
540 #[::unity::class(namespace = "App", name = "UnitCalculator.QuickCommand")]
541 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
542 pub struct UnitCalculator_QuickCommand {}
543
544 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_ExpDestroyCountCommand.md"))]
545 #[::unity::class(namespace = "App", name = "UnitCalculator.ExpDestroyCountCommand")]
546 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
547 pub struct UnitCalculator_ExpDestroyCountCommand {}
548
549 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_TerrainAvoidCommand.md"))]
550 #[::unity::class(namespace = "App", name = "UnitCalculator.TerrainAvoidCommand")]
551 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
552 pub struct UnitCalculator_TerrainAvoidCommand {}
553
554 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_LinkDefCommand.md"))]
555 #[::unity::class(namespace = "App", name = "UnitCalculator.LinkDefCommand")]
556 #[parent(crate::app::unitcalculator::UnitCalculator_LinkGodCommand)]
557 pub struct UnitCalculator_LinkDefCommand {}
558
559 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_TechCommand.md"))]
560 #[::unity::class(namespace = "App", name = "UnitCalculator.TechCommand")]
561 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
562 pub struct UnitCalculator_TechCommand {}
563
564 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_TemporaryCommand.md"))]
565 #[::unity::class(namespace = "App", name = "UnitCalculator.TemporaryCommand")]
566 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
567 pub struct UnitCalculator_TemporaryCommand {}
568
569 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_WeaponEfficacyCommand.md"))]
570 #[::unity::class(namespace = "App", name = "UnitCalculator.WeaponEfficacyCommand")]
571 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
572 pub struct UnitCalculator_WeaponEfficacyCommand {}
573
574 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_HealCommand.md"))]
575 #[::unity::class(namespace = "App", name = "UnitCalculator.HealCommand")]
576 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
577 pub struct UnitCalculator_HealCommand {}
578
579 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_MoveDistanceCommand.md"))]
580 #[::unity::class(namespace = "App", name = "UnitCalculator.MoveDistanceCommand")]
581 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
582 pub struct UnitCalculator_MoveDistanceCommand {}
583
584 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_BattleStyleCommand.md"))]
585 #[::unity::class(namespace = "App", name = "UnitCalculator.BattleStyleCommand")]
586 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
587 pub struct UnitCalculator_BattleStyleCommand {}
588
589 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_TotalResultCommand.md"))]
590 #[::unity::class(namespace = "App", name = "UnitCalculator.TotalResultCommand")]
591 #[parent(crate::app::unitcalculator::UnitCalculator_IBattleSceneResultCommand)]
592 pub struct UnitCalculator_TotalResultCommand {}
593
594 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_LinkLuukCommand.md"))]
595 #[::unity::class(namespace = "App", name = "UnitCalculator.LinkLuukCommand")]
596 #[parent(crate::app::unitcalculator::UnitCalculator_LinkGodCommand)]
597 pub struct UnitCalculator_LinkLuukCommand {}
598
599 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_WeaponWeightCommand.md"))]
600 #[::unity::class(namespace = "App", name = "UnitCalculator.WeaponWeightCommand")]
601 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
602 pub struct UnitCalculator_WeaponWeightCommand {}
603
604 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_SupportAvoidCommand.md"))]
605 #[::unity::class(namespace = "App", name = "UnitCalculator.SupportAvoidCommand")]
606 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
607 pub struct UnitCalculator_SupportAvoidCommand {}
608
609 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_UnitSkillCommand.md"))]
610 #[::unity::class(namespace = "App", name = "UnitCalculator.UnitSkillCommand")]
611 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
612 pub struct UnitCalculator_UnitSkillCommand {}
613
614 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_AttackCommand.md"))]
615 #[::unity::class(namespace = "App", name = "UnitCalculator.AttackCommand")]
616 #[parent(crate::app::unitcalculator::UnitCalculator_BattleParamCommand)]
617 pub struct UnitCalculator_AttackCommand {}
618
619 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_TotalLevelCommand.md"))]
620 #[::unity::class(namespace = "App", name = "UnitCalculator.TotalLevelCommand")]
621 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
622 pub struct UnitCalculator_TotalLevelCommand {}
623
624 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_TotalActionCommand.md"))]
625 #[::unity::class(namespace = "App", name = "UnitCalculator.TotalActionCommand")]
626 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
627 pub struct UnitCalculator_TotalActionCommand {}
628
629 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_BattleCountCommand.md"))]
630 #[::unity::class(namespace = "App", name = "UnitCalculator.BattleCountCommand")]
631 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
632 pub struct UnitCalculator_BattleCountCommand {}
633
634 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_RangeUnitCountCommand.md"))]
635 #[::unity::class(namespace = "App", name = "UnitCalculator.RangeUnitCountCommand")]
636 #[parent(crate::app::unitcalculator::UnitCalculator_MapUnitCountCommand)]
637 pub struct UnitCalculator_RangeUnitCountCommand {}
638
639 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_UnitAroundCountdCommand.md"))]
640 #[::unity::class(namespace = "App", name = "UnitCalculator.UnitAroundCountdCommand")]
641 #[parent(crate::app::unitcalculator::UnitCalculator_MapUnitCountCommand)]
642 pub struct UnitCalculator_UnitAroundCountdCommand {}
643
644 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_MaxHPCommand.md"))]
645 #[::unity::class(namespace = "App", name = "UnitCalculator.MaxHPCommand")]
646 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
647 pub struct UnitCalculator_MaxHPCommand {}
648
649 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_BattleSideCommand.md"))]
650 #[::unity::class(namespace = "App", name = "UnitCalculator.BattleSideCommand")]
651 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
652 pub struct UnitCalculator_BattleSideCommand {}
653
654 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_AttackCountCommand.md"))]
655 #[::unity::class(namespace = "App", name = "UnitCalculator.AttackCountCommand")]
656 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
657 pub struct UnitCalculator_AttackCountCommand {}
658
659 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_SupportCriticalCommand.md"))]
660 #[::unity::class(namespace = "App", name = "UnitCalculator.SupportCriticalCommand")]
661 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
662 pub struct UnitCalculator_SupportCriticalCommand {}
663
664 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_TotalDamageCommand.md"))]
665 #[::unity::class(namespace = "App", name = "UnitCalculator.TotalDamageCommand")]
666 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
667 pub struct UnitCalculator_TotalDamageCommand {}
668
669 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_OverlapCanRemoveCommand.md"))]
670 #[::unity::class(namespace = "App", name = "UnitCalculator.OverlapCanRemoveCommand")]
671 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
672 pub struct UnitCalculator_OverlapCanRemoveCommand {}
673
674 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_HPCommand.md"))]
675 #[::unity::class(namespace = "App", name = "UnitCalculator.HPCommand")]
676 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
677 pub struct UnitCalculator_HPCommand {}
678
679 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_IBattleSceneResultCommand.md"))]
680 #[::unity::class(namespace = "App", name = "UnitCalculator.IBattleSceneResultCommand")]
681 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
682 pub struct UnitCalculator_IBattleSceneResultCommand {}
683
684 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_WeaponKindCommand.md"))]
685 #[::unity::class(namespace = "App", name = "UnitCalculator.WeaponKindCommand")]
686 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
687 pub struct UnitCalculator_WeaponKindCommand {}
688
689 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_ExpDanceCountCommand.md"))]
690 #[::unity::class(namespace = "App", name = "UnitCalculator.ExpDanceCountCommand")]
691 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
692 pub struct UnitCalculator_ExpDanceCountCommand {}
693
694 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_SupportSecureCommand.md"))]
695 #[::unity::class(namespace = "App", name = "UnitCalculator.SupportSecureCommand")]
696 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
697 pub struct UnitCalculator_SupportSecureCommand {}
698
699 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_SimpleHitCommand.md"))]
700 #[::unity::class(namespace = "App", name = "UnitCalculator.SimpleHitCommand")]
701 #[parent(crate::app::unitcalculator::UnitCalculator_BattleParamCommand)]
702 pub struct UnitCalculator_SimpleHitCommand {}
703
704 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_BattlePinchingCommand.md"))]
705 #[::unity::class(namespace = "App", name = "UnitCalculator.BattlePinchingCommand")]
706 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
707 pub struct UnitCalculator_BattlePinchingCommand {}
708
709 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_ActionCountCommand.md"))]
710 #[::unity::class(namespace = "App", name = "UnitCalculator.ActionCountCommand")]
711 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
712 pub struct UnitCalculator_ActionCountCommand {}
713
714 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_GenderCommand.md"))]
715 #[::unity::class(namespace = "App", name = "UnitCalculator.GenderCommand")]
716 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
717 pub struct UnitCalculator_GenderCommand {}
718
719 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_UnitGodCommand.md"))]
720 #[::unity::class(namespace = "App", name = "UnitCalculator.UnitGodCommand")]
721 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
722 pub struct UnitCalculator_UnitGodCommand {}
723
724 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_BlowDistanceCommand.md"))]
725 #[::unity::class(namespace = "App", name = "UnitCalculator.BlowDistanceCommand")]
726 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
727 pub struct UnitCalculator_BlowDistanceCommand {}
728
729 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_WeaponExpendCommand.md"))]
730 #[::unity::class(namespace = "App", name = "UnitCalculator.WeaponExpendCommand")]
731 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
732 pub struct UnitCalculator_WeaponExpendCommand {}
733
734 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_WeaponAttributeCommand.md"))]
735 #[::unity::class(namespace = "App", name = "UnitCalculator.WeaponAttributeCommand")]
736 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
737 pub struct UnitCalculator_WeaponAttributeCommand {}
738
739 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_JobInternalLevelCommand.md"))]
740 #[::unity::class(namespace = "App", name = "UnitCalculator.JobInternalLevelCommand")]
741 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
742 pub struct UnitCalculator_JobInternalLevelCommand {}
743
744 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_CriticalCommand.md"))]
745 #[::unity::class(namespace = "App", name = "UnitCalculator.CriticalCommand")]
746 #[parent(crate::app::unitcalculator::UnitCalculator_BattleParamCommand)]
747 pub struct UnitCalculator_CriticalCommand {}
748
749 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_FixedFriendCountCommand.md"))]
750 #[::unity::class(namespace = "App", name = "UnitCalculator.FixedFriendCountCommand")]
751 #[parent(crate::app::unitcalculator::UnitCalculator_MapUnitCountCommand)]
752 pub struct UnitCalculator_FixedFriendCountCommand {}
753
754 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_LinkGodCommand.md"))]
755 #[::unity::class(namespace = "App", name = "UnitCalculator.LinkGodCommand")]
756 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
757 pub struct UnitCalculator_LinkGodCommand {}
758
759 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_UnitAttributeCommand.md"))]
760 #[::unity::class(namespace = "App", name = "UnitCalculator.UnitAttributeCommand")]
761 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
762 pub struct UnitCalculator_UnitAttributeCommand {}
763
764 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitcalculator/UnitCalculator_RodTypeCommand.md"))]
765 #[::unity::class(namespace = "App", name = "UnitCalculator.RodTypeCommand")]
766 #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
767 pub struct UnitCalculator_RodTypeCommand {}
768}
769
770#[cfg(feature = "app-unitcalculator-types")]
771pub use __types::*;
772
773#[cfg(feature = "app-unitcalculator")]
774pub trait IUnitCalculator_WeaponInteractCommandMethods: IUnitCalculator_WeaponInteractCommand {
775 #[doc = "`get_Name()` overload"]
776 fn get_name(self) -> ::unity::Il2CppString {
777 unsafe {
778 let __receiver = <UnitCalculator_WeaponInteractCommand as ::unity::FromIlInstance>::from_il_instance(
779 <Self as ::unity::SystemObject>::as_instance(self),
780 );
781 {
782 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
783 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
784 panic!(
785 "unity: virtual slot {}
786 out of range (vtable len {}
787) on the runtime class behind {}
788 (method `{}
789`)",
790 4usize,
791 __vt.len(),
792 <UnitCalculator_WeaponInteractCommand as ::unity::ClassIdentity>::NAME,
793 "get_Name",
794 )
795 });
796 let __inner: extern "C" fn(UnitCalculator_WeaponInteractCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
797 ::core::mem::transmute(__vi.method_ptr);
798 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
799 __inner(__receiver, __mi)
800 }
801 }
802 }
803 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
804 fn get_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
805 unsafe {
806 let __receiver = <UnitCalculator_WeaponInteractCommand as ::unity::FromIlInstance>::from_il_instance(
807 <Self as ::unity::SystemObject>::as_instance(self),
808 );
809 {
810 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
811 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
812 panic!(
813 "unity: virtual slot {}
814 out of range (vtable len {}
815) on the runtime class behind {}
816 (method `{}
817`)",
818 31usize,
819 __vt.len(),
820 <UnitCalculator_WeaponInteractCommand as ::unity::ClassIdentity>::NAME,
821 "GetImpl",
822 )
823 });
824 let __inner: extern "C" fn(
825 UnitCalculator_WeaponInteractCommand,
826 crate::app::battleinfoside::BattleInfoSide,
827 ::unity::OptionalMethod,
828 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
829 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
830 __inner(__receiver, ::core::convert::Into::into(side), __mi)
831 }
832 }
833 }
834 #[doc = "`IsVisible()` overload"]
835 fn is_visible(self) -> bool {
836 unsafe {
837 let __receiver = <UnitCalculator_WeaponInteractCommand as ::unity::FromIlInstance>::from_il_instance(
838 <Self as ::unity::SystemObject>::as_instance(self),
839 );
840 {
841 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
842 let __vi = *__vt.get(43usize).unwrap_or_else(|| {
843 panic!(
844 "unity: virtual slot {}
845 out of range (vtable len {}
846) on the runtime class behind {}
847 (method `{}
848`)",
849 43usize,
850 __vt.len(),
851 <UnitCalculator_WeaponInteractCommand as ::unity::ClassIdentity>::NAME,
852 "IsVisible",
853 )
854 });
855 let __inner: extern "C" fn(UnitCalculator_WeaponInteractCommand, ::unity::OptionalMethod) -> bool =
856 ::core::mem::transmute(__vi.method_ptr);
857 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
858 __inner(__receiver, __mi)
859 }
860 }
861 }
862 #[doc = "`.ctor()` overload"]
863 fn ctor(self) -> () {
864 unsafe {
865 let __receiver = <UnitCalculator_WeaponInteractCommand as ::unity::FromIlInstance>::from_il_instance(
866 <Self as ::unity::SystemObject>::as_instance(self),
867 );
868 ::unity::il2cpp_call!((::unity::module_base()+0x1b4e500usize)as*mut u8,();
869(UnitCalculator_WeaponInteractCommand)__receiver)
870 }
871 }
872}
873
874#[cfg(feature = "app-unitcalculator")]
875impl<__T: IUnitCalculator_WeaponInteractCommand> IUnitCalculator_WeaponInteractCommandMethods for __T {}
876
877#[cfg(feature = "app-unitcalculator")]
878impl UnitCalculator_WeaponInteractCommand {
879 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
880 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
881 }
882
883 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
884 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
885 }
886
887 pub fn is_visible_method_info() -> &'static ::unity::il2cpp::MethodInfo {
888 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
889 }
890
891 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
892 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
893 }
894}
895
896#[cfg(feature = "app-unitcalculator")]
897impl UnitCalculator_WeaponInteractCommand {
898 #[doc = "Direct (non-virtual) call to `UnitCalculator_WeaponInteractCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
899 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
900 let __mi = Self::get_name_method_info();
901 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
902 __inner(this.into(), ::core::option::Option::None)
903 }
904
905 #[doc = "Direct (non-virtual) call to `UnitCalculator_WeaponInteractCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
906 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
907 let __mi = Self::get_impl_method_info();
908 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
909 ::core::mem::transmute(__mi.method_ptr);
910 __inner(this.into(), side, ::core::option::Option::None)
911 }
912
913 #[doc = "Direct (non-virtual) call to `UnitCalculator_WeaponInteractCommand`'s own `IsVisible`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
914 pub unsafe fn is_visible(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
915 let __mi = Self::is_visible_method_info();
916 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
917 __inner(this.into(), ::core::option::Option::None)
918 }
919}
920
921#[cfg(feature = "app-unitcalculator")]
922impl UnitCalculator_WeaponInteractCommand {
923 #[doc = "`.ctor()` — no args"]
924 pub fn new() -> Self {
925 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
926 panic!(
927 "{}
928::{}
929 failed to instantiate",
930 ::core::stringify!(UnitCalculator_WeaponInteractCommand),
931 ::core::stringify!(new),
932 )
933 });
934 <Self as IUnitCalculator_WeaponInteractCommandMethods>::ctor(this);
935 this
936 }
937}
938
939#[cfg(feature = "app-unitcalculator")]
940impl UnitCalculator_MapUnitCountCommand {
941 #[doc = "`GetTargetForceMask(crate::app::unit::Unit, crate::app::unitcalculator::UnitCalculator_MapUnitCountCommand_Candidates)` overload"]
942 pub fn get_target_force_mask(
943 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
944 candidate: impl ::core::convert::Into<crate::app::unitcalculator::UnitCalculator_MapUnitCountCommand_Candidates>,
945 ) -> u32 {
946 unsafe {
947 ::unity::il2cpp_call!((::unity::module_base()+0x1b49480usize)as*mut u8,u32;
948(crate::app::unit::Unit)::core::convert::Into::into(unit),(crate::app::unitcalculator::UnitCalculator_MapUnitCountCommand_Candidates)::core::convert::Into::into(candidate))
949 }
950 }
951
952 #[doc = "`GetRangeCount(crate::app::unit::Unit, i32, crate::app::itemdata::ItemData_Kinds, crate::app::unitcalculator::UnitCalculator_MapUnitCountCommand_Candidates)` overload"]
953 pub fn get_range_count(
954 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
955 range: impl ::core::convert::Into<i32>,
956 kind: impl ::core::convert::Into<crate::app::itemdata::ItemData_Kinds>,
957 candidate: impl ::core::convert::Into<crate::app::unitcalculator::UnitCalculator_MapUnitCountCommand_Candidates>,
958 ) -> i32 {
959 unsafe {
960 ::unity::il2cpp_call!((::unity::module_base()+0x1b496a0usize)as*mut u8,i32;
961(crate::app::unit::Unit)::core::convert::Into::into(unit),(i32)::core::convert::Into::into(range),(crate::app::itemdata::ItemData_Kinds)::core::convert::Into::into(kind),(crate::app::unitcalculator::UnitCalculator_MapUnitCountCommand_Candidates)::core::convert::Into::into(candidate))
962 }
963 }
964
965 #[doc = "`GetFixedCount(crate::app::unit::Unit, crate::app::unitcalculator::UnitCalculator_MapUnitCountCommand_Candidates)` overload"]
966 pub fn get_fixed_count(
967 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
968 candidate: impl ::core::convert::Into<crate::app::unitcalculator::UnitCalculator_MapUnitCountCommand_Candidates>,
969 ) -> i32 {
970 unsafe {
971 ::unity::il2cpp_call!((::unity::module_base()+0x1b47470usize)as*mut u8,i32;
972(crate::app::unit::Unit)::core::convert::Into::into(unit),(crate::app::unitcalculator::UnitCalculator_MapUnitCountCommand_Candidates)::core::convert::Into::into(candidate))
973 }
974 }
975
976 #[doc = "`GetGenderCount(crate::app::unit::Unit, i32, crate::app::gender::Gender)` overload"]
977 pub fn get_gender_count(
978 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
979 range: impl ::core::convert::Into<i32>,
980 gender: impl ::core::convert::Into<crate::app::gender::Gender>,
981 ) -> i32 {
982 unsafe {
983 ::unity::il2cpp_call!((::unity::module_base()+0x1b49950usize)as*mut u8,i32;
984(crate::app::unit::Unit)::core::convert::Into::into(unit),(i32)::core::convert::Into::into(range),(crate::app::gender::Gender)::core::convert::Into::into(gender))
985 }
986 }
987
988 #[doc = "`GetGenderCount(crate::app::unit::Unit, i32, crate::app::gender::Gender, crate::app::gender::Gender)` overload"]
989 pub fn get_gender_count_2(
990 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
991 range: impl ::core::convert::Into<i32>,
992 gender1: impl ::core::convert::Into<crate::app::gender::Gender>,
993 gender2: impl ::core::convert::Into<crate::app::gender::Gender>,
994 ) -> i32 {
995 unsafe {
996 ::unity::il2cpp_call!((::unity::module_base()+0x1b44a90usize)as*mut u8,i32;
997(crate::app::unit::Unit)::core::convert::Into::into(unit),(i32)::core::convert::Into::into(range),(crate::app::gender::Gender)::core::convert::Into::into(gender1),(crate::app::gender::Gender)::core::convert::Into::into(gender2))
998 }
999 }
1000}
1001
1002#[cfg(feature = "app-unitcalculator")]
1003pub trait IUnitCalculator_MapUnitCountCommandMethods: IUnitCalculator_MapUnitCountCommand {
1004 #[doc = "`GetRangeCount(crate::app::unit::Unit, crate::system::collections::generic::list_1::List_1<f32>, crate::app::unitcalculator::UnitCalculator_MapUnitCountCommand_Candidates)` overload"]
1005 fn get_range_count_2(
1006 self,
1007 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
1008 args: impl ::core::convert::Into<crate::system::collections::generic::list_1::List_1<f32>>,
1009 candidate: impl ::core::convert::Into<crate::app::unitcalculator::UnitCalculator_MapUnitCountCommand_Candidates>,
1010 ) -> i32 {
1011 unsafe {
1012 let __receiver =
1013 <UnitCalculator_MapUnitCountCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1014 ::unity::il2cpp_call!((::unity::module_base()+0x1b49810usize)as*mut u8,i32;
1015(UnitCalculator_MapUnitCountCommand)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(unit),(crate::system::collections::generic::list_1::List_1<f32>)::core::convert::Into::into(args),(crate::app::unitcalculator::UnitCalculator_MapUnitCountCommand_Candidates)::core::convert::Into::into(candidate))
1016 }
1017 }
1018 #[doc = "`.ctor()` overload"]
1019 fn ctor(self) -> () {
1020 unsafe {
1021 let __receiver =
1022 <UnitCalculator_MapUnitCountCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1023 ::unity::il2cpp_call!((::unity::module_base()+0x1b45350usize)as*mut u8,();
1024(UnitCalculator_MapUnitCountCommand)__receiver)
1025 }
1026 }
1027}
1028
1029#[cfg(feature = "app-unitcalculator")]
1030impl<__T: IUnitCalculator_MapUnitCountCommand> IUnitCalculator_MapUnitCountCommandMethods for __T {}
1031
1032#[cfg(feature = "app-unitcalculator")]
1033impl UnitCalculator_MapUnitCountCommand {
1034 pub fn get_target_force_mask_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1035 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1036 }
1037
1038 pub fn get_range_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1039 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1040 }
1041
1042 pub fn get_range_count_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1043 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1044 }
1045
1046 pub fn get_fixed_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1047 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
1048 }
1049
1050 pub fn get_gender_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1051 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
1052 }
1053
1054 pub fn get_gender_count_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1055 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
1056 }
1057
1058 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1059 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
1060 }
1061}
1062
1063#[cfg(feature = "app-unitcalculator")]
1064impl UnitCalculator_MapUnitCountCommand {
1065 #[doc = "`.ctor()` — no args"]
1066 pub fn new() -> Self {
1067 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1068 panic!(
1069 "{}
1070::{}
1071 failed to instantiate",
1072 ::core::stringify!(UnitCalculator_MapUnitCountCommand),
1073 ::core::stringify!(new),
1074 )
1075 });
1076 <Self as IUnitCalculator_MapUnitCountCommandMethods>::ctor(this);
1077 this
1078 }
1079}
1080
1081#[cfg(feature = "app-unitcalculator")]
1082pub trait IUnitCalculator_WeaponLevelBaseCommandMethods: IUnitCalculator_WeaponLevelBaseCommand {
1083 #[doc = "`GetUnitWeaponLevel(crate::app::unit::Unit, crate::app::unititem::UnitItem)` overload"]
1084 fn get_unit_weapon_level(
1085 self,
1086 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
1087 unit_item: impl ::core::convert::Into<crate::app::unititem::UnitItem>,
1088 ) -> crate::app::weaponlevel::WeaponLevel_Kind {
1089 unsafe {
1090 let __receiver = <UnitCalculator_WeaponLevelBaseCommand as ::unity::FromIlInstance>::from_il_instance(
1091 <Self as ::unity::SystemObject>::as_instance(self),
1092 );
1093 ::unity::il2cpp_call!((::unity::module_base()+0x1b4e770usize)as*mut u8,crate::app::weaponlevel::WeaponLevel_Kind;
1094(UnitCalculator_WeaponLevelBaseCommand)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(unit),(crate::app::unititem::UnitItem)::core::convert::Into::into(unit_item))
1095 }
1096 }
1097 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
1098 fn get_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
1099 unsafe {
1100 let __receiver = <UnitCalculator_WeaponLevelBaseCommand as ::unity::FromIlInstance>::from_il_instance(
1101 <Self as ::unity::SystemObject>::as_instance(self),
1102 );
1103 {
1104 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1105 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
1106 panic!(
1107 "unity: virtual slot {}
1108 out of range (vtable len {}
1109) on the runtime class behind {}
1110 (method `{}
1111`)",
1112 31usize,
1113 __vt.len(),
1114 <UnitCalculator_WeaponLevelBaseCommand as ::unity::ClassIdentity>::NAME,
1115 "GetImpl",
1116 )
1117 });
1118 let __inner: extern "C" fn(
1119 UnitCalculator_WeaponLevelBaseCommand,
1120 crate::app::battleinfoside::BattleInfoSide,
1121 ::unity::OptionalMethod,
1122 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
1123 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1124 __inner(__receiver, ::core::convert::Into::into(side), __mi)
1125 }
1126 }
1127 }
1128 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
1129 fn get_impl_2(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
1130 unsafe {
1131 let __receiver = <UnitCalculator_WeaponLevelBaseCommand as ::unity::FromIlInstance>::from_il_instance(
1132 <Self as ::unity::SystemObject>::as_instance(self),
1133 );
1134 {
1135 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1136 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
1137 panic!(
1138 "unity: virtual slot {}
1139 out of range (vtable len {}
1140) on the runtime class behind {}
1141 (method `{}
1142`)",
1143 30usize,
1144 __vt.len(),
1145 <UnitCalculator_WeaponLevelBaseCommand as ::unity::ClassIdentity>::NAME,
1146 "GetImpl",
1147 )
1148 });
1149 let __inner: extern "C" fn(UnitCalculator_WeaponLevelBaseCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
1150 ::core::mem::transmute(__vi.method_ptr);
1151 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1152 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
1153 }
1154 }
1155 }
1156 #[doc = "`GetValue(crate::app::weaponlevel::WeaponLevel_Kind)` overload"]
1157 fn get_value(self, level: impl ::core::convert::Into<crate::app::weaponlevel::WeaponLevel_Kind>) -> f32 {
1158 unsafe {
1159 let __receiver = <UnitCalculator_WeaponLevelBaseCommand as ::unity::FromIlInstance>::from_il_instance(
1160 <Self as ::unity::SystemObject>::as_instance(self),
1161 );
1162 {
1163 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1164 let __vi = *__vt.get(44usize).unwrap_or_else(|| {
1165 panic!(
1166 "unity: virtual slot {}
1167 out of range (vtable len {}
1168) on the runtime class behind {}
1169 (method `{}
1170`)",
1171 44usize,
1172 __vt.len(),
1173 <UnitCalculator_WeaponLevelBaseCommand as ::unity::ClassIdentity>::NAME,
1174 "GetValue",
1175 )
1176 });
1177 let __inner: extern "C" fn(
1178 UnitCalculator_WeaponLevelBaseCommand,
1179 crate::app::weaponlevel::WeaponLevel_Kind,
1180 ::unity::OptionalMethod,
1181 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
1182 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1183 __inner(__receiver, ::core::convert::Into::into(level), __mi)
1184 }
1185 }
1186 }
1187 #[doc = "`.ctor()` overload"]
1188 fn ctor(self) -> () {
1189 unsafe {
1190 let __receiver = <UnitCalculator_WeaponLevelBaseCommand as ::unity::FromIlInstance>::from_il_instance(
1191 <Self as ::unity::SystemObject>::as_instance(self),
1192 );
1193 ::unity::il2cpp_call!((::unity::module_base()+0x1b4ea20usize)as*mut u8,();
1194(UnitCalculator_WeaponLevelBaseCommand)__receiver)
1195 }
1196 }
1197}
1198
1199#[cfg(feature = "app-unitcalculator")]
1200impl<__T: IUnitCalculator_WeaponLevelBaseCommand> IUnitCalculator_WeaponLevelBaseCommandMethods for __T {}
1201
1202#[cfg(feature = "app-unitcalculator")]
1203impl UnitCalculator_WeaponLevelBaseCommand {
1204 pub fn get_unit_weapon_level_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1205 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1206 }
1207
1208 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1209 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1210 }
1211
1212 pub fn get_impl_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1213 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1214 }
1215
1216 pub fn get_value_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1217 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
1218 }
1219
1220 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1221 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
1222 }
1223}
1224
1225#[cfg(feature = "app-unitcalculator")]
1226impl UnitCalculator_WeaponLevelBaseCommand {
1227 #[doc = "Direct (non-virtual) call to `UnitCalculator_WeaponLevelBaseCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1228 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
1229 let __mi = Self::get_impl_method_info();
1230 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
1231 ::core::mem::transmute(__mi.method_ptr);
1232 __inner(this.into(), side, ::core::option::Option::None)
1233 }
1234
1235 #[doc = "Direct (non-virtual) call to `UnitCalculator_WeaponLevelBaseCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1236 pub unsafe fn get_impl_2(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
1237 let __mi = Self::get_impl_2_method_info();
1238 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
1239 ::core::mem::transmute(__mi.method_ptr);
1240 __inner(this.into(), unit, ::core::option::Option::None)
1241 }
1242
1243 #[doc = "Direct (non-virtual) call to `UnitCalculator_WeaponLevelBaseCommand`'s own `GetValue`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1244 pub unsafe fn get_value(this: impl ::core::convert::Into<::unity::IlInstance>, level: crate::app::weaponlevel::WeaponLevel_Kind) -> f32 {
1245 let __mi = Self::get_value_method_info();
1246 let __inner: extern "C" fn(::unity::IlInstance, crate::app::weaponlevel::WeaponLevel_Kind, ::unity::OptionalMethod) -> f32 =
1247 ::core::mem::transmute(__mi.method_ptr);
1248 __inner(this.into(), level, ::core::option::Option::None)
1249 }
1250}
1251
1252#[cfg(feature = "app-unitcalculator")]
1253impl UnitCalculator_WeaponLevelBaseCommand {
1254 #[doc = "`.ctor()` — no args"]
1255 pub fn new() -> Self {
1256 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1257 panic!(
1258 "{}
1259::{}
1260 failed to instantiate",
1261 ::core::stringify!(UnitCalculator_WeaponLevelBaseCommand),
1262 ::core::stringify!(new),
1263 )
1264 });
1265 <Self as IUnitCalculator_WeaponLevelBaseCommandMethods>::ctor(this);
1266 this
1267 }
1268}
1269
1270#[cfg(feature = "app-unitcalculator")]
1271pub trait IUnitCalculator_PosZCommandMethods: IUnitCalculator_PosZCommand {
1272 #[doc = "`get_Name()` overload"]
1273 fn get_name(self) -> ::unity::Il2CppString {
1274 unsafe {
1275 let __receiver =
1276 <UnitCalculator_PosZCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1277 {
1278 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1279 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
1280 panic!(
1281 "unity: virtual slot {}
1282 out of range (vtable len {}
1283) on the runtime class behind {}
1284 (method `{}
1285`)",
1286 4usize,
1287 __vt.len(),
1288 <UnitCalculator_PosZCommand as ::unity::ClassIdentity>::NAME,
1289 "get_Name",
1290 )
1291 });
1292 let __inner: extern "C" fn(UnitCalculator_PosZCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1293 ::core::mem::transmute(__vi.method_ptr);
1294 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1295 __inner(__receiver, __mi)
1296 }
1297 }
1298 }
1299 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
1300 fn get_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
1301 unsafe {
1302 let __receiver =
1303 <UnitCalculator_PosZCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1304 {
1305 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1306 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
1307 panic!(
1308 "unity: virtual slot {}
1309 out of range (vtable len {}
1310) on the runtime class behind {}
1311 (method `{}
1312`)",
1313 30usize,
1314 __vt.len(),
1315 <UnitCalculator_PosZCommand as ::unity::ClassIdentity>::NAME,
1316 "GetImpl",
1317 )
1318 });
1319 let __inner: extern "C" fn(UnitCalculator_PosZCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
1320 ::core::mem::transmute(__vi.method_ptr);
1321 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1322 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
1323 }
1324 }
1325 }
1326 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
1327 fn get_impl_2(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
1328 unsafe {
1329 let __receiver =
1330 <UnitCalculator_PosZCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1331 {
1332 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1333 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
1334 panic!(
1335 "unity: virtual slot {}
1336 out of range (vtable len {}
1337) on the runtime class behind {}
1338 (method `{}
1339`)",
1340 31usize,
1341 __vt.len(),
1342 <UnitCalculator_PosZCommand as ::unity::ClassIdentity>::NAME,
1343 "GetImpl",
1344 )
1345 });
1346 let __inner: extern "C" fn(UnitCalculator_PosZCommand, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
1347 ::core::mem::transmute(__vi.method_ptr);
1348 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1349 __inner(__receiver, ::core::convert::Into::into(side), __mi)
1350 }
1351 }
1352 }
1353 #[doc = "`GetInvalid()` overload"]
1354 fn get_invalid(self) -> f32 {
1355 unsafe {
1356 let __receiver =
1357 <UnitCalculator_PosZCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1358 {
1359 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1360 let __vi = *__vt.get(42usize).unwrap_or_else(|| {
1361 panic!(
1362 "unity: virtual slot {}
1363 out of range (vtable len {}
1364) on the runtime class behind {}
1365 (method `{}
1366`)",
1367 42usize,
1368 __vt.len(),
1369 <UnitCalculator_PosZCommand as ::unity::ClassIdentity>::NAME,
1370 "GetInvalid",
1371 )
1372 });
1373 let __inner: extern "C" fn(UnitCalculator_PosZCommand, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__vi.method_ptr);
1374 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1375 __inner(__receiver, __mi)
1376 }
1377 }
1378 }
1379 #[doc = "`.ctor()` overload"]
1380 fn ctor(self) -> () {
1381 unsafe {
1382 let __receiver =
1383 <UnitCalculator_PosZCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1384 ::unity::il2cpp_call!((::unity::module_base()+0x1b4abb0usize)as*mut u8,();
1385(UnitCalculator_PosZCommand)__receiver)
1386 }
1387 }
1388}
1389
1390#[cfg(feature = "app-unitcalculator")]
1391impl<__T: IUnitCalculator_PosZCommand> IUnitCalculator_PosZCommandMethods for __T {}
1392
1393#[cfg(feature = "app-unitcalculator")]
1394impl UnitCalculator_PosZCommand {
1395 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1396 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1397 }
1398
1399 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1400 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1401 }
1402
1403 pub fn get_impl_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1404 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1405 }
1406
1407 pub fn get_invalid_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1408 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
1409 }
1410
1411 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1412 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
1413 }
1414}
1415
1416#[cfg(feature = "app-unitcalculator")]
1417impl UnitCalculator_PosZCommand {
1418 #[doc = "Direct (non-virtual) call to `UnitCalculator_PosZCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1419 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1420 let __mi = Self::get_name_method_info();
1421 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1422 __inner(this.into(), ::core::option::Option::None)
1423 }
1424
1425 #[doc = "Direct (non-virtual) call to `UnitCalculator_PosZCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1426 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
1427 let __mi = Self::get_impl_method_info();
1428 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
1429 ::core::mem::transmute(__mi.method_ptr);
1430 __inner(this.into(), unit, ::core::option::Option::None)
1431 }
1432
1433 #[doc = "Direct (non-virtual) call to `UnitCalculator_PosZCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1434 pub unsafe fn get_impl_2(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
1435 let __mi = Self::get_impl_2_method_info();
1436 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
1437 ::core::mem::transmute(__mi.method_ptr);
1438 __inner(this.into(), side, ::core::option::Option::None)
1439 }
1440
1441 #[doc = "Direct (non-virtual) call to `UnitCalculator_PosZCommand`'s own `GetInvalid`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1442 pub unsafe fn get_invalid(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
1443 let __mi = Self::get_invalid_method_info();
1444 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
1445 __inner(this.into(), ::core::option::Option::None)
1446 }
1447}
1448
1449#[cfg(feature = "app-unitcalculator")]
1450impl UnitCalculator_PosZCommand {
1451 #[doc = "`.ctor()` — no args"]
1452 pub fn new() -> Self {
1453 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1454 panic!(
1455 "{}
1456::{}
1457 failed to instantiate",
1458 ::core::stringify!(UnitCalculator_PosZCommand),
1459 ::core::stringify!(new),
1460 )
1461 });
1462 <Self as IUnitCalculator_PosZCommandMethods>::ctor(this);
1463 this
1464 }
1465}
1466
1467#[cfg(feature = "app-unitcalculator")]
1468pub trait IUnitCalculator_BattleChainAttackDefeatCommandMethods: IUnitCalculator_BattleChainAttackDefeatCommand {
1469 #[doc = "`get_Name()` overload"]
1470 fn get_name(self) -> ::unity::Il2CppString {
1471 unsafe {
1472 let __receiver = <UnitCalculator_BattleChainAttackDefeatCommand as ::unity::FromIlInstance>::from_il_instance(
1473 <Self as ::unity::SystemObject>::as_instance(self),
1474 );
1475 {
1476 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1477 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
1478 panic!(
1479 "unity: virtual slot {}
1480 out of range (vtable len {}
1481) on the runtime class behind {}
1482 (method `{}
1483`)",
1484 4usize,
1485 __vt.len(),
1486 <UnitCalculator_BattleChainAttackDefeatCommand as ::unity::ClassIdentity>::NAME,
1487 "get_Name",
1488 )
1489 });
1490 let __inner: extern "C" fn(UnitCalculator_BattleChainAttackDefeatCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1491 ::core::mem::transmute(__vi.method_ptr);
1492 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1493 __inner(__receiver, __mi)
1494 }
1495 }
1496 }
1497 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
1498 fn get_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
1499 unsafe {
1500 let __receiver = <UnitCalculator_BattleChainAttackDefeatCommand as ::unity::FromIlInstance>::from_il_instance(
1501 <Self as ::unity::SystemObject>::as_instance(self),
1502 );
1503 {
1504 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1505 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
1506 panic!(
1507 "unity: virtual slot {}
1508 out of range (vtable len {}
1509) on the runtime class behind {}
1510 (method `{}
1511`)",
1512 31usize,
1513 __vt.len(),
1514 <UnitCalculator_BattleChainAttackDefeatCommand as ::unity::ClassIdentity>::NAME,
1515 "GetImpl",
1516 )
1517 });
1518 let __inner: extern "C" fn(
1519 UnitCalculator_BattleChainAttackDefeatCommand,
1520 crate::app::battleinfoside::BattleInfoSide,
1521 ::unity::OptionalMethod,
1522 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
1523 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1524 __inner(__receiver, ::core::convert::Into::into(side), __mi)
1525 }
1526 }
1527 }
1528 #[doc = "`.ctor()` overload"]
1529 fn ctor(self) -> () {
1530 unsafe {
1531 let __receiver = <UnitCalculator_BattleChainAttackDefeatCommand as ::unity::FromIlInstance>::from_il_instance(
1532 <Self as ::unity::SystemObject>::as_instance(self),
1533 );
1534 ::unity::il2cpp_call!((::unity::module_base()+0x1b45840usize)as*mut u8,();
1535(UnitCalculator_BattleChainAttackDefeatCommand)__receiver)
1536 }
1537 }
1538}
1539
1540#[cfg(feature = "app-unitcalculator")]
1541impl<__T: IUnitCalculator_BattleChainAttackDefeatCommand> IUnitCalculator_BattleChainAttackDefeatCommandMethods for __T {}
1542
1543#[cfg(feature = "app-unitcalculator")]
1544impl UnitCalculator_BattleChainAttackDefeatCommand {
1545 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1546 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1547 }
1548
1549 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1550 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1551 }
1552
1553 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1554 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1555 }
1556}
1557
1558#[cfg(feature = "app-unitcalculator")]
1559impl UnitCalculator_BattleChainAttackDefeatCommand {
1560 #[doc = "Direct (non-virtual) call to `UnitCalculator_BattleChainAttackDefeatCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1561 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1562 let __mi = Self::get_name_method_info();
1563 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1564 __inner(this.into(), ::core::option::Option::None)
1565 }
1566
1567 #[doc = "Direct (non-virtual) call to `UnitCalculator_BattleChainAttackDefeatCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1568 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
1569 let __mi = Self::get_impl_method_info();
1570 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
1571 ::core::mem::transmute(__mi.method_ptr);
1572 __inner(this.into(), side, ::core::option::Option::None)
1573 }
1574}
1575
1576#[cfg(feature = "app-unitcalculator")]
1577impl UnitCalculator_BattleChainAttackDefeatCommand {
1578 #[doc = "`.ctor()` — no args"]
1579 pub fn new() -> Self {
1580 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1581 panic!(
1582 "{}
1583::{}
1584 failed to instantiate",
1585 ::core::stringify!(UnitCalculator_BattleChainAttackDefeatCommand),
1586 ::core::stringify!(new),
1587 )
1588 });
1589 <Self as IUnitCalculator_BattleChainAttackDefeatCommandMethods>::ctor(this);
1590 this
1591 }
1592}
1593
1594#[cfg(feature = "app-unitcalculator")]
1595pub trait IUnitCalculator_SupportLevelCommandMethods: IUnitCalculator_SupportLevelCommand {
1596 #[doc = "`get_Name()` overload"]
1597 fn get_name(self) -> ::unity::Il2CppString {
1598 unsafe {
1599 let __receiver =
1600 <UnitCalculator_SupportLevelCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1601 {
1602 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1603 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
1604 panic!(
1605 "unity: virtual slot {}
1606 out of range (vtable len {}
1607) on the runtime class behind {}
1608 (method `{}
1609`)",
1610 4usize,
1611 __vt.len(),
1612 <UnitCalculator_SupportLevelCommand as ::unity::ClassIdentity>::NAME,
1613 "get_Name",
1614 )
1615 });
1616 let __inner: extern "C" fn(UnitCalculator_SupportLevelCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1617 ::core::mem::transmute(__vi.method_ptr);
1618 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1619 __inner(__receiver, __mi)
1620 }
1621 }
1622 }
1623 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
1624 fn get_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
1625 unsafe {
1626 let __receiver =
1627 <UnitCalculator_SupportLevelCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1628 {
1629 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1630 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
1631 panic!(
1632 "unity: virtual slot {}
1633 out of range (vtable len {}
1634) on the runtime class behind {}
1635 (method `{}
1636`)",
1637 31usize,
1638 __vt.len(),
1639 <UnitCalculator_SupportLevelCommand as ::unity::ClassIdentity>::NAME,
1640 "GetImpl",
1641 )
1642 });
1643 let __inner: extern "C" fn(
1644 UnitCalculator_SupportLevelCommand,
1645 crate::app::battleinfoside::BattleInfoSide,
1646 ::unity::OptionalMethod,
1647 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
1648 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1649 __inner(__receiver, ::core::convert::Into::into(side), __mi)
1650 }
1651 }
1652 }
1653 #[doc = "`.ctor()` overload"]
1654 fn ctor(self) -> () {
1655 unsafe {
1656 let __receiver =
1657 <UnitCalculator_SupportLevelCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1658 ::unity::il2cpp_call!((::unity::module_base()+0x1b4c4f0usize)as*mut u8,();
1659(UnitCalculator_SupportLevelCommand)__receiver)
1660 }
1661 }
1662}
1663
1664#[cfg(feature = "app-unitcalculator")]
1665impl<__T: IUnitCalculator_SupportLevelCommand> IUnitCalculator_SupportLevelCommandMethods for __T {}
1666
1667#[cfg(feature = "app-unitcalculator")]
1668impl UnitCalculator_SupportLevelCommand {
1669 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1670 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1671 }
1672
1673 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1674 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1675 }
1676
1677 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1678 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1679 }
1680}
1681
1682#[cfg(feature = "app-unitcalculator")]
1683impl UnitCalculator_SupportLevelCommand {
1684 #[doc = "Direct (non-virtual) call to `UnitCalculator_SupportLevelCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1685 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1686 let __mi = Self::get_name_method_info();
1687 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1688 __inner(this.into(), ::core::option::Option::None)
1689 }
1690
1691 #[doc = "Direct (non-virtual) call to `UnitCalculator_SupportLevelCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1692 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
1693 let __mi = Self::get_impl_method_info();
1694 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
1695 ::core::mem::transmute(__mi.method_ptr);
1696 __inner(this.into(), side, ::core::option::Option::None)
1697 }
1698}
1699
1700#[cfg(feature = "app-unitcalculator")]
1701impl UnitCalculator_SupportLevelCommand {
1702 #[doc = "`.ctor()` — no args"]
1703 pub fn new() -> Self {
1704 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1705 panic!(
1706 "{}
1707::{}
1708 failed to instantiate",
1709 ::core::stringify!(UnitCalculator_SupportLevelCommand),
1710 ::core::stringify!(new),
1711 )
1712 });
1713 <Self as IUnitCalculator_SupportLevelCommandMethods>::ctor(this);
1714 this
1715 }
1716}
1717
1718#[cfg(feature = "app-unitcalculator")]
1719pub trait IUnitCalculator_TerrainDefenseCommandMethods: IUnitCalculator_TerrainDefenseCommand {
1720 #[doc = "`get_Name()` overload"]
1721 fn get_name(self) -> ::unity::Il2CppString {
1722 unsafe {
1723 let __receiver = <UnitCalculator_TerrainDefenseCommand as ::unity::FromIlInstance>::from_il_instance(
1724 <Self as ::unity::SystemObject>::as_instance(self),
1725 );
1726 {
1727 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1728 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
1729 panic!(
1730 "unity: virtual slot {}
1731 out of range (vtable len {}
1732) on the runtime class behind {}
1733 (method `{}
1734`)",
1735 4usize,
1736 __vt.len(),
1737 <UnitCalculator_TerrainDefenseCommand as ::unity::ClassIdentity>::NAME,
1738 "get_Name",
1739 )
1740 });
1741 let __inner: extern "C" fn(UnitCalculator_TerrainDefenseCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1742 ::core::mem::transmute(__vi.method_ptr);
1743 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1744 __inner(__receiver, __mi)
1745 }
1746 }
1747 }
1748 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
1749 fn get_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
1750 unsafe {
1751 let __receiver = <UnitCalculator_TerrainDefenseCommand as ::unity::FromIlInstance>::from_il_instance(
1752 <Self as ::unity::SystemObject>::as_instance(self),
1753 );
1754 {
1755 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1756 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
1757 panic!(
1758 "unity: virtual slot {}
1759 out of range (vtable len {}
1760) on the runtime class behind {}
1761 (method `{}
1762`)",
1763 31usize,
1764 __vt.len(),
1765 <UnitCalculator_TerrainDefenseCommand as ::unity::ClassIdentity>::NAME,
1766 "GetImpl",
1767 )
1768 });
1769 let __inner: extern "C" fn(
1770 UnitCalculator_TerrainDefenseCommand,
1771 crate::app::battleinfoside::BattleInfoSide,
1772 ::unity::OptionalMethod,
1773 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
1774 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1775 __inner(__receiver, ::core::convert::Into::into(side), __mi)
1776 }
1777 }
1778 }
1779 #[doc = "`SetImpl(crate::app::battleinfoside::BattleInfoSide, f32)` overload"]
1780 fn set_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>, value: impl ::core::convert::Into<f32>) -> () {
1781 unsafe {
1782 let __receiver = <UnitCalculator_TerrainDefenseCommand as ::unity::FromIlInstance>::from_il_instance(
1783 <Self as ::unity::SystemObject>::as_instance(self),
1784 );
1785 {
1786 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1787 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
1788 panic!(
1789 "unity: virtual slot {}
1790 out of range (vtable len {}
1791) on the runtime class behind {}
1792 (method `{}
1793`)",
1794 33usize,
1795 __vt.len(),
1796 <UnitCalculator_TerrainDefenseCommand as ::unity::ClassIdentity>::NAME,
1797 "SetImpl",
1798 )
1799 });
1800 let __inner: extern "C" fn(
1801 UnitCalculator_TerrainDefenseCommand,
1802 crate::app::battleinfoside::BattleInfoSide,
1803 f32,
1804 ::unity::OptionalMethod,
1805 ) -> () = ::core::mem::transmute(__vi.method_ptr);
1806 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1807 __inner(__receiver, ::core::convert::Into::into(side), ::core::convert::Into::into(value), __mi)
1808 }
1809 }
1810 }
1811 #[doc = "`IsVisible()` overload"]
1812 fn is_visible(self) -> bool {
1813 unsafe {
1814 let __receiver = <UnitCalculator_TerrainDefenseCommand as ::unity::FromIlInstance>::from_il_instance(
1815 <Self as ::unity::SystemObject>::as_instance(self),
1816 );
1817 {
1818 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1819 let __vi = *__vt.get(43usize).unwrap_or_else(|| {
1820 panic!(
1821 "unity: virtual slot {}
1822 out of range (vtable len {}
1823) on the runtime class behind {}
1824 (method `{}
1825`)",
1826 43usize,
1827 __vt.len(),
1828 <UnitCalculator_TerrainDefenseCommand as ::unity::ClassIdentity>::NAME,
1829 "IsVisible",
1830 )
1831 });
1832 let __inner: extern "C" fn(UnitCalculator_TerrainDefenseCommand, ::unity::OptionalMethod) -> bool =
1833 ::core::mem::transmute(__vi.method_ptr);
1834 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1835 __inner(__receiver, __mi)
1836 }
1837 }
1838 }
1839 #[doc = "`.ctor()` overload"]
1840 fn ctor(self) -> () {
1841 unsafe {
1842 let __receiver = <UnitCalculator_TerrainDefenseCommand as ::unity::FromIlInstance>::from_il_instance(
1843 <Self as ::unity::SystemObject>::as_instance(self),
1844 );
1845 ::unity::il2cpp_call!((::unity::module_base()+0x1b4cae0usize)as*mut u8,();
1846(UnitCalculator_TerrainDefenseCommand)__receiver)
1847 }
1848 }
1849}
1850
1851#[cfg(feature = "app-unitcalculator")]
1852impl<__T: IUnitCalculator_TerrainDefenseCommand> IUnitCalculator_TerrainDefenseCommandMethods for __T {}
1853
1854#[cfg(feature = "app-unitcalculator")]
1855impl UnitCalculator_TerrainDefenseCommand {
1856 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1857 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1858 }
1859
1860 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1861 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1862 }
1863
1864 pub fn set_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1865 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1866 }
1867
1868 pub fn is_visible_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1869 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
1870 }
1871
1872 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1873 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
1874 }
1875}
1876
1877#[cfg(feature = "app-unitcalculator")]
1878impl UnitCalculator_TerrainDefenseCommand {
1879 #[doc = "Direct (non-virtual) call to `UnitCalculator_TerrainDefenseCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1880 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1881 let __mi = Self::get_name_method_info();
1882 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1883 __inner(this.into(), ::core::option::Option::None)
1884 }
1885
1886 #[doc = "Direct (non-virtual) call to `UnitCalculator_TerrainDefenseCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1887 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
1888 let __mi = Self::get_impl_method_info();
1889 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
1890 ::core::mem::transmute(__mi.method_ptr);
1891 __inner(this.into(), side, ::core::option::Option::None)
1892 }
1893
1894 #[doc = "Direct (non-virtual) call to `UnitCalculator_TerrainDefenseCommand`'s own `SetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1895 pub unsafe fn set_impl(
1896 this: impl ::core::convert::Into<::unity::IlInstance>,
1897 side: crate::app::battleinfoside::BattleInfoSide,
1898 value: f32,
1899 ) -> () {
1900 let __mi = Self::set_impl_method_info();
1901 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, f32, ::unity::OptionalMethod) -> () =
1902 ::core::mem::transmute(__mi.method_ptr);
1903 __inner(this.into(), side, value, ::core::option::Option::None)
1904 }
1905
1906 #[doc = "Direct (non-virtual) call to `UnitCalculator_TerrainDefenseCommand`'s own `IsVisible`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1907 pub unsafe fn is_visible(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
1908 let __mi = Self::is_visible_method_info();
1909 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
1910 __inner(this.into(), ::core::option::Option::None)
1911 }
1912}
1913
1914#[cfg(feature = "app-unitcalculator")]
1915impl UnitCalculator_TerrainDefenseCommand {
1916 #[doc = "`.ctor()` — no args"]
1917 pub fn new() -> Self {
1918 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1919 panic!(
1920 "{}
1921::{}
1922 failed to instantiate",
1923 ::core::stringify!(UnitCalculator_TerrainDefenseCommand),
1924 ::core::stringify!(new),
1925 )
1926 });
1927 <Self as IUnitCalculator_TerrainDefenseCommandMethods>::ctor(this);
1928 this
1929 }
1930}
1931
1932#[cfg(feature = "app-unitcalculator")]
1933pub trait IUnitCalculator_WeaponHitCommandMethods: IUnitCalculator_WeaponHitCommand {
1934 #[doc = "`get_Name()` overload"]
1935 fn get_name(self) -> ::unity::Il2CppString {
1936 unsafe {
1937 let __receiver =
1938 <UnitCalculator_WeaponHitCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1939 {
1940 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1941 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
1942 panic!(
1943 "unity: virtual slot {}
1944 out of range (vtable len {}
1945) on the runtime class behind {}
1946 (method `{}
1947`)",
1948 4usize,
1949 __vt.len(),
1950 <UnitCalculator_WeaponHitCommand as ::unity::ClassIdentity>::NAME,
1951 "get_Name",
1952 )
1953 });
1954 let __inner: extern "C" fn(UnitCalculator_WeaponHitCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1955 ::core::mem::transmute(__vi.method_ptr);
1956 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1957 __inner(__receiver, __mi)
1958 }
1959 }
1960 }
1961 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
1962 fn get_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
1963 unsafe {
1964 let __receiver =
1965 <UnitCalculator_WeaponHitCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1966 {
1967 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1968 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
1969 panic!(
1970 "unity: virtual slot {}
1971 out of range (vtable len {}
1972) on the runtime class behind {}
1973 (method `{}
1974`)",
1975 31usize,
1976 __vt.len(),
1977 <UnitCalculator_WeaponHitCommand as ::unity::ClassIdentity>::NAME,
1978 "GetImpl",
1979 )
1980 });
1981 let __inner: extern "C" fn(
1982 UnitCalculator_WeaponHitCommand,
1983 crate::app::battleinfoside::BattleInfoSide,
1984 ::unity::OptionalMethod,
1985 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
1986 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1987 __inner(__receiver, ::core::convert::Into::into(side), __mi)
1988 }
1989 }
1990 }
1991 #[doc = "`SetImpl(crate::app::battleinfoside::BattleInfoSide, f32)` overload"]
1992 fn set_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>, value: impl ::core::convert::Into<f32>) -> () {
1993 unsafe {
1994 let __receiver =
1995 <UnitCalculator_WeaponHitCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1996 {
1997 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1998 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
1999 panic!(
2000 "unity: virtual slot {}
2001 out of range (vtable len {}
2002) on the runtime class behind {}
2003 (method `{}
2004`)",
2005 33usize,
2006 __vt.len(),
2007 <UnitCalculator_WeaponHitCommand as ::unity::ClassIdentity>::NAME,
2008 "SetImpl",
2009 )
2010 });
2011 let __inner: extern "C" fn(
2012 UnitCalculator_WeaponHitCommand,
2013 crate::app::battleinfoside::BattleInfoSide,
2014 f32,
2015 ::unity::OptionalMethod,
2016 ) -> () = ::core::mem::transmute(__vi.method_ptr);
2017 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2018 __inner(__receiver, ::core::convert::Into::into(side), ::core::convert::Into::into(value), __mi)
2019 }
2020 }
2021 }
2022 #[doc = "`IsVisible()` overload"]
2023 fn is_visible(self) -> bool {
2024 unsafe {
2025 let __receiver =
2026 <UnitCalculator_WeaponHitCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2027 {
2028 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2029 let __vi = *__vt.get(43usize).unwrap_or_else(|| {
2030 panic!(
2031 "unity: virtual slot {}
2032 out of range (vtable len {}
2033) on the runtime class behind {}
2034 (method `{}
2035`)",
2036 43usize,
2037 __vt.len(),
2038 <UnitCalculator_WeaponHitCommand as ::unity::ClassIdentity>::NAME,
2039 "IsVisible",
2040 )
2041 });
2042 let __inner: extern "C" fn(UnitCalculator_WeaponHitCommand, ::unity::OptionalMethod) -> bool =
2043 ::core::mem::transmute(__vi.method_ptr);
2044 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2045 __inner(__receiver, __mi)
2046 }
2047 }
2048 }
2049 #[doc = "`.ctor()` overload"]
2050 fn ctor(self) -> () {
2051 unsafe {
2052 let __receiver =
2053 <UnitCalculator_WeaponHitCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2054 ::unity::il2cpp_call!((::unity::module_base()+0x1b4e260usize)as*mut u8,();
2055(UnitCalculator_WeaponHitCommand)__receiver)
2056 }
2057 }
2058}
2059
2060#[cfg(feature = "app-unitcalculator")]
2061impl<__T: IUnitCalculator_WeaponHitCommand> IUnitCalculator_WeaponHitCommandMethods for __T {}
2062
2063#[cfg(feature = "app-unitcalculator")]
2064impl UnitCalculator_WeaponHitCommand {
2065 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2066 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2067 }
2068
2069 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2070 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2071 }
2072
2073 pub fn set_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2074 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2075 }
2076
2077 pub fn is_visible_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2078 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
2079 }
2080
2081 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2082 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
2083 }
2084}
2085
2086#[cfg(feature = "app-unitcalculator")]
2087impl UnitCalculator_WeaponHitCommand {
2088 #[doc = "Direct (non-virtual) call to `UnitCalculator_WeaponHitCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2089 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2090 let __mi = Self::get_name_method_info();
2091 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2092 __inner(this.into(), ::core::option::Option::None)
2093 }
2094
2095 #[doc = "Direct (non-virtual) call to `UnitCalculator_WeaponHitCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2096 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
2097 let __mi = Self::get_impl_method_info();
2098 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
2099 ::core::mem::transmute(__mi.method_ptr);
2100 __inner(this.into(), side, ::core::option::Option::None)
2101 }
2102
2103 #[doc = "Direct (non-virtual) call to `UnitCalculator_WeaponHitCommand`'s own `SetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2104 pub unsafe fn set_impl(
2105 this: impl ::core::convert::Into<::unity::IlInstance>,
2106 side: crate::app::battleinfoside::BattleInfoSide,
2107 value: f32,
2108 ) -> () {
2109 let __mi = Self::set_impl_method_info();
2110 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, f32, ::unity::OptionalMethod) -> () =
2111 ::core::mem::transmute(__mi.method_ptr);
2112 __inner(this.into(), side, value, ::core::option::Option::None)
2113 }
2114
2115 #[doc = "Direct (non-virtual) call to `UnitCalculator_WeaponHitCommand`'s own `IsVisible`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2116 pub unsafe fn is_visible(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
2117 let __mi = Self::is_visible_method_info();
2118 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
2119 __inner(this.into(), ::core::option::Option::None)
2120 }
2121}
2122
2123#[cfg(feature = "app-unitcalculator")]
2124impl UnitCalculator_WeaponHitCommand {
2125 #[doc = "`.ctor()` — no args"]
2126 pub fn new() -> Self {
2127 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2128 panic!(
2129 "{}
2130::{}
2131 failed to instantiate",
2132 ::core::stringify!(UnitCalculator_WeaponHitCommand),
2133 ::core::stringify!(new),
2134 )
2135 });
2136 <Self as IUnitCalculator_WeaponHitCommandMethods>::ctor(this);
2137 this
2138 }
2139}
2140
2141#[cfg(feature = "app-unitcalculator")]
2142pub trait IUnitCalculator_PhysCommandMethods: IUnitCalculator_PhysCommand {
2143 #[doc = "`get_Name()` overload"]
2144 fn get_name(self) -> ::unity::Il2CppString {
2145 unsafe {
2146 let __receiver =
2147 <UnitCalculator_PhysCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2148 {
2149 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2150 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
2151 panic!(
2152 "unity: virtual slot {}
2153 out of range (vtable len {}
2154) on the runtime class behind {}
2155 (method `{}
2156`)",
2157 4usize,
2158 __vt.len(),
2159 <UnitCalculator_PhysCommand as ::unity::ClassIdentity>::NAME,
2160 "get_Name",
2161 )
2162 });
2163 let __inner: extern "C" fn(UnitCalculator_PhysCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
2164 ::core::mem::transmute(__vi.method_ptr);
2165 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2166 __inner(__receiver, __mi)
2167 }
2168 }
2169 }
2170 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
2171 fn get_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
2172 unsafe {
2173 let __receiver =
2174 <UnitCalculator_PhysCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2175 {
2176 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2177 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
2178 panic!(
2179 "unity: virtual slot {}
2180 out of range (vtable len {}
2181) on the runtime class behind {}
2182 (method `{}
2183`)",
2184 30usize,
2185 __vt.len(),
2186 <UnitCalculator_PhysCommand as ::unity::ClassIdentity>::NAME,
2187 "GetImpl",
2188 )
2189 });
2190 let __inner: extern "C" fn(UnitCalculator_PhysCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
2191 ::core::mem::transmute(__vi.method_ptr);
2192 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2193 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
2194 }
2195 }
2196 }
2197 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
2198 fn get_impl_2(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
2199 unsafe {
2200 let __receiver =
2201 <UnitCalculator_PhysCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2202 {
2203 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2204 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
2205 panic!(
2206 "unity: virtual slot {}
2207 out of range (vtable len {}
2208) on the runtime class behind {}
2209 (method `{}
2210`)",
2211 31usize,
2212 __vt.len(),
2213 <UnitCalculator_PhysCommand as ::unity::ClassIdentity>::NAME,
2214 "GetImpl",
2215 )
2216 });
2217 let __inner: extern "C" fn(UnitCalculator_PhysCommand, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
2218 ::core::mem::transmute(__vi.method_ptr);
2219 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2220 __inner(__receiver, ::core::convert::Into::into(side), __mi)
2221 }
2222 }
2223 }
2224 #[doc = "`SetImpl(crate::app::battleinfoside::BattleInfoSide, f32)` overload"]
2225 fn set_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>, value: impl ::core::convert::Into<f32>) -> () {
2226 unsafe {
2227 let __receiver =
2228 <UnitCalculator_PhysCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2229 {
2230 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2231 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
2232 panic!(
2233 "unity: virtual slot {}
2234 out of range (vtable len {}
2235) on the runtime class behind {}
2236 (method `{}
2237`)",
2238 33usize,
2239 __vt.len(),
2240 <UnitCalculator_PhysCommand as ::unity::ClassIdentity>::NAME,
2241 "SetImpl",
2242 )
2243 });
2244 let __inner: extern "C" fn(
2245 UnitCalculator_PhysCommand,
2246 crate::app::battleinfoside::BattleInfoSide,
2247 f32,
2248 ::unity::OptionalMethod,
2249 ) -> () = ::core::mem::transmute(__vi.method_ptr);
2250 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2251 __inner(__receiver, ::core::convert::Into::into(side), ::core::convert::Into::into(value), __mi)
2252 }
2253 }
2254 }
2255 #[doc = "`.ctor()` overload"]
2256 fn ctor(self) -> () {
2257 unsafe {
2258 let __receiver =
2259 <UnitCalculator_PhysCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2260 ::unity::il2cpp_call!((::unity::module_base()+0x1b4aa30usize)as*mut u8,();
2261(UnitCalculator_PhysCommand)__receiver)
2262 }
2263 }
2264}
2265
2266#[cfg(feature = "app-unitcalculator")]
2267impl<__T: IUnitCalculator_PhysCommand> IUnitCalculator_PhysCommandMethods for __T {}
2268
2269#[cfg(feature = "app-unitcalculator")]
2270impl UnitCalculator_PhysCommand {
2271 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2272 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2273 }
2274
2275 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2276 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2277 }
2278
2279 pub fn get_impl_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2280 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2281 }
2282
2283 pub fn set_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2284 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
2285 }
2286
2287 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2288 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
2289 }
2290}
2291
2292#[cfg(feature = "app-unitcalculator")]
2293impl UnitCalculator_PhysCommand {
2294 #[doc = "Direct (non-virtual) call to `UnitCalculator_PhysCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2295 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2296 let __mi = Self::get_name_method_info();
2297 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2298 __inner(this.into(), ::core::option::Option::None)
2299 }
2300
2301 #[doc = "Direct (non-virtual) call to `UnitCalculator_PhysCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2302 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
2303 let __mi = Self::get_impl_method_info();
2304 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
2305 ::core::mem::transmute(__mi.method_ptr);
2306 __inner(this.into(), unit, ::core::option::Option::None)
2307 }
2308
2309 #[doc = "Direct (non-virtual) call to `UnitCalculator_PhysCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2310 pub unsafe fn get_impl_2(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
2311 let __mi = Self::get_impl_2_method_info();
2312 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
2313 ::core::mem::transmute(__mi.method_ptr);
2314 __inner(this.into(), side, ::core::option::Option::None)
2315 }
2316
2317 #[doc = "Direct (non-virtual) call to `UnitCalculator_PhysCommand`'s own `SetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2318 pub unsafe fn set_impl(
2319 this: impl ::core::convert::Into<::unity::IlInstance>,
2320 side: crate::app::battleinfoside::BattleInfoSide,
2321 value: f32,
2322 ) -> () {
2323 let __mi = Self::set_impl_method_info();
2324 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, f32, ::unity::OptionalMethod) -> () =
2325 ::core::mem::transmute(__mi.method_ptr);
2326 __inner(this.into(), side, value, ::core::option::Option::None)
2327 }
2328}
2329
2330#[cfg(feature = "app-unitcalculator")]
2331impl UnitCalculator_PhysCommand {
2332 #[doc = "`.ctor()` — no args"]
2333 pub fn new() -> Self {
2334 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2335 panic!(
2336 "{}
2337::{}
2338 failed to instantiate",
2339 ::core::stringify!(UnitCalculator_PhysCommand),
2340 ::core::stringify!(new),
2341 )
2342 });
2343 <Self as IUnitCalculator_PhysCommandMethods>::ctor(this);
2344 this
2345 }
2346}
2347
2348#[cfg(feature = "app-unitcalculator")]
2349pub trait IUnitCalculator_RodExpCommandMethods: IUnitCalculator_RodExpCommand {
2350 #[doc = "`get_Name()` overload"]
2351 fn get_name(self) -> ::unity::Il2CppString {
2352 unsafe {
2353 let __receiver =
2354 <UnitCalculator_RodExpCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2355 {
2356 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2357 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
2358 panic!(
2359 "unity: virtual slot {}
2360 out of range (vtable len {}
2361) on the runtime class behind {}
2362 (method `{}
2363`)",
2364 4usize,
2365 __vt.len(),
2366 <UnitCalculator_RodExpCommand as ::unity::ClassIdentity>::NAME,
2367 "get_Name",
2368 )
2369 });
2370 let __inner: extern "C" fn(UnitCalculator_RodExpCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
2371 ::core::mem::transmute(__vi.method_ptr);
2372 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2373 __inner(__receiver, __mi)
2374 }
2375 }
2376 }
2377 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
2378 fn get_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
2379 unsafe {
2380 let __receiver =
2381 <UnitCalculator_RodExpCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2382 {
2383 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2384 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
2385 panic!(
2386 "unity: virtual slot {}
2387 out of range (vtable len {}
2388) on the runtime class behind {}
2389 (method `{}
2390`)",
2391 31usize,
2392 __vt.len(),
2393 <UnitCalculator_RodExpCommand as ::unity::ClassIdentity>::NAME,
2394 "GetImpl",
2395 )
2396 });
2397 let __inner: extern "C" fn(UnitCalculator_RodExpCommand, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
2398 ::core::mem::transmute(__vi.method_ptr);
2399 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2400 __inner(__receiver, ::core::convert::Into::into(side), __mi)
2401 }
2402 }
2403 }
2404 #[doc = "`.ctor()` overload"]
2405 fn ctor(self) -> () {
2406 unsafe {
2407 let __receiver =
2408 <UnitCalculator_RodExpCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2409 ::unity::il2cpp_call!((::unity::module_base()+0x1b4ba20usize)as*mut u8,();
2410(UnitCalculator_RodExpCommand)__receiver)
2411 }
2412 }
2413}
2414
2415#[cfg(feature = "app-unitcalculator")]
2416impl<__T: IUnitCalculator_RodExpCommand> IUnitCalculator_RodExpCommandMethods for __T {}
2417
2418#[cfg(feature = "app-unitcalculator")]
2419impl UnitCalculator_RodExpCommand {
2420 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2421 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2422 }
2423
2424 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2425 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2426 }
2427
2428 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2429 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2430 }
2431}
2432
2433#[cfg(feature = "app-unitcalculator")]
2434impl UnitCalculator_RodExpCommand {
2435 #[doc = "Direct (non-virtual) call to `UnitCalculator_RodExpCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2436 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2437 let __mi = Self::get_name_method_info();
2438 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2439 __inner(this.into(), ::core::option::Option::None)
2440 }
2441
2442 #[doc = "Direct (non-virtual) call to `UnitCalculator_RodExpCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2443 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
2444 let __mi = Self::get_impl_method_info();
2445 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
2446 ::core::mem::transmute(__mi.method_ptr);
2447 __inner(this.into(), side, ::core::option::Option::None)
2448 }
2449}
2450
2451#[cfg(feature = "app-unitcalculator")]
2452impl UnitCalculator_RodExpCommand {
2453 #[doc = "`.ctor()` — no args"]
2454 pub fn new() -> Self {
2455 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2456 panic!(
2457 "{}
2458::{}
2459 failed to instantiate",
2460 ::core::stringify!(UnitCalculator_RodExpCommand),
2461 ::core::stringify!(new),
2462 )
2463 });
2464 <Self as IUnitCalculator_RodExpCommandMethods>::ctor(this);
2465 this
2466 }
2467}
2468
2469#[cfg(feature = "app-unitcalculator")]
2470pub trait IUnitCalculator_LinkPhysCommandMethods: IUnitCalculator_LinkPhysCommand {
2471 #[doc = "`get_Name()` overload"]
2472 fn get_name(self) -> ::unity::Il2CppString {
2473 unsafe {
2474 let __receiver =
2475 <UnitCalculator_LinkPhysCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2476 {
2477 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2478 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
2479 panic!(
2480 "unity: virtual slot {}
2481 out of range (vtable len {}
2482) on the runtime class behind {}
2483 (method `{}
2484`)",
2485 4usize,
2486 __vt.len(),
2487 <UnitCalculator_LinkPhysCommand as ::unity::ClassIdentity>::NAME,
2488 "get_Name",
2489 )
2490 });
2491 let __inner: extern "C" fn(UnitCalculator_LinkPhysCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
2492 ::core::mem::transmute(__vi.method_ptr);
2493 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2494 __inner(__receiver, __mi)
2495 }
2496 }
2497 }
2498 #[doc = "`get_CapabilityType()` overload"]
2499 fn get_capability_type(self) -> crate::app::capabilitydefinition::CapabilityDefinition_Type {
2500 unsafe {
2501 let __receiver =
2502 <UnitCalculator_LinkPhysCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2503 {
2504 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2505 let __vi = *__vt.get(44usize).unwrap_or_else(|| {
2506 panic!(
2507 "unity: virtual slot {}
2508 out of range (vtable len {}
2509) on the runtime class behind {}
2510 (method `{}
2511`)",
2512 44usize,
2513 __vt.len(),
2514 <UnitCalculator_LinkPhysCommand as ::unity::ClassIdentity>::NAME,
2515 "get_CapabilityType",
2516 )
2517 });
2518 let __inner: extern "C" fn(
2519 UnitCalculator_LinkPhysCommand,
2520 ::unity::OptionalMethod,
2521 ) -> crate::app::capabilitydefinition::CapabilityDefinition_Type = ::core::mem::transmute(__vi.method_ptr);
2522 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2523 __inner(__receiver, __mi)
2524 }
2525 }
2526 }
2527 #[doc = "`.ctor()` overload"]
2528 fn ctor(self) -> () {
2529 unsafe {
2530 let __receiver =
2531 <UnitCalculator_LinkPhysCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2532 ::unity::il2cpp_call!((::unity::module_base()+0x1b48bf0usize)as*mut u8,();
2533(UnitCalculator_LinkPhysCommand)__receiver)
2534 }
2535 }
2536}
2537
2538#[cfg(feature = "app-unitcalculator")]
2539impl<__T: IUnitCalculator_LinkPhysCommand> IUnitCalculator_LinkPhysCommandMethods for __T {}
2540
2541#[cfg(feature = "app-unitcalculator")]
2542impl UnitCalculator_LinkPhysCommand {
2543 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2544 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2545 }
2546
2547 pub fn get_capability_type_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2548 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2549 }
2550
2551 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2552 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2553 }
2554}
2555
2556#[cfg(feature = "app-unitcalculator")]
2557impl UnitCalculator_LinkPhysCommand {
2558 #[doc = "Direct (non-virtual) call to `UnitCalculator_LinkPhysCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2559 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2560 let __mi = Self::get_name_method_info();
2561 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2562 __inner(this.into(), ::core::option::Option::None)
2563 }
2564
2565 #[doc = "Direct (non-virtual) call to `UnitCalculator_LinkPhysCommand`'s own `get_CapabilityType`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2566 pub unsafe fn get_capability_type(
2567 this: impl ::core::convert::Into<::unity::IlInstance>,
2568 ) -> crate::app::capabilitydefinition::CapabilityDefinition_Type {
2569 let __mi = Self::get_capability_type_method_info();
2570 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::capabilitydefinition::CapabilityDefinition_Type =
2571 ::core::mem::transmute(__mi.method_ptr);
2572 __inner(this.into(), ::core::option::Option::None)
2573 }
2574}
2575
2576#[cfg(feature = "app-unitcalculator")]
2577impl UnitCalculator_LinkPhysCommand {
2578 #[doc = "`.ctor()` — no args"]
2579 pub fn new() -> Self {
2580 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2581 panic!(
2582 "{}
2583::{}
2584 failed to instantiate",
2585 ::core::stringify!(UnitCalculator_LinkPhysCommand),
2586 ::core::stringify!(new),
2587 )
2588 });
2589 <Self as IUnitCalculator_LinkPhysCommandMethods>::ctor(this);
2590 this
2591 }
2592}
2593
2594#[cfg(feature = "app-unitcalculator")]
2595pub trait IUnitCalculator_BattleSceneResultEfficacyCommandMethods: IUnitCalculator_BattleSceneResultEfficacyCommand {
2596 #[doc = "`get_Name()` overload"]
2597 fn get_name(self) -> ::unity::Il2CppString {
2598 unsafe {
2599 let __receiver = <UnitCalculator_BattleSceneResultEfficacyCommand as ::unity::FromIlInstance>::from_il_instance(
2600 <Self as ::unity::SystemObject>::as_instance(self),
2601 );
2602 {
2603 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2604 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
2605 panic!(
2606 "unity: virtual slot {}
2607 out of range (vtable len {}
2608) on the runtime class behind {}
2609 (method `{}
2610`)",
2611 4usize,
2612 __vt.len(),
2613 <UnitCalculator_BattleSceneResultEfficacyCommand as ::unity::ClassIdentity>::NAME,
2614 "get_Name",
2615 )
2616 });
2617 let __inner: extern "C" fn(UnitCalculator_BattleSceneResultEfficacyCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
2618 ::core::mem::transmute(__vi.method_ptr);
2619 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2620 __inner(__receiver, __mi)
2621 }
2622 }
2623 }
2624 #[doc = "`Get()` overload"]
2625 fn get(self) -> f32 {
2626 unsafe {
2627 let __receiver = <UnitCalculator_BattleSceneResultEfficacyCommand as ::unity::FromIlInstance>::from_il_instance(
2628 <Self as ::unity::SystemObject>::as_instance(self),
2629 );
2630 {
2631 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2632 let __vi = *__vt.get(9usize).unwrap_or_else(|| {
2633 panic!(
2634 "unity: virtual slot {}
2635 out of range (vtable len {}
2636) on the runtime class behind {}
2637 (method `{}
2638`)",
2639 9usize,
2640 __vt.len(),
2641 <UnitCalculator_BattleSceneResultEfficacyCommand as ::unity::ClassIdentity>::NAME,
2642 "Get",
2643 )
2644 });
2645 let __inner: extern "C" fn(UnitCalculator_BattleSceneResultEfficacyCommand, ::unity::OptionalMethod) -> f32 =
2646 ::core::mem::transmute(__vi.method_ptr);
2647 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2648 __inner(__receiver, __mi)
2649 }
2650 }
2651 }
2652 #[doc = "`.ctor()` overload"]
2653 fn ctor(self) -> () {
2654 unsafe {
2655 let __receiver = <UnitCalculator_BattleSceneResultEfficacyCommand as ::unity::FromIlInstance>::from_il_instance(
2656 <Self as ::unity::SystemObject>::as_instance(self),
2657 );
2658 ::unity::il2cpp_call!((::unity::module_base()+0x1b46330usize)as*mut u8,();
2659(UnitCalculator_BattleSceneResultEfficacyCommand)__receiver)
2660 }
2661 }
2662}
2663
2664#[cfg(feature = "app-unitcalculator")]
2665impl<__T: IUnitCalculator_BattleSceneResultEfficacyCommand> IUnitCalculator_BattleSceneResultEfficacyCommandMethods for __T {}
2666
2667#[cfg(feature = "app-unitcalculator")]
2668impl UnitCalculator_BattleSceneResultEfficacyCommand {
2669 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2670 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2671 }
2672
2673 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2674 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2675 }
2676
2677 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2678 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2679 }
2680}
2681
2682#[cfg(feature = "app-unitcalculator")]
2683impl UnitCalculator_BattleSceneResultEfficacyCommand {
2684 #[doc = "Direct (non-virtual) call to `UnitCalculator_BattleSceneResultEfficacyCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2685 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2686 let __mi = Self::get_name_method_info();
2687 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2688 __inner(this.into(), ::core::option::Option::None)
2689 }
2690
2691 #[doc = "Direct (non-virtual) call to `UnitCalculator_BattleSceneResultEfficacyCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2692 pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
2693 let __mi = Self::get_method_info();
2694 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
2695 __inner(this.into(), ::core::option::Option::None)
2696 }
2697}
2698
2699#[cfg(feature = "app-unitcalculator")]
2700impl UnitCalculator_BattleSceneResultEfficacyCommand {
2701 #[doc = "`.ctor()` — no args"]
2702 pub fn new() -> Self {
2703 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2704 panic!(
2705 "{}
2706::{}
2707 failed to instantiate",
2708 ::core::stringify!(UnitCalculator_BattleSceneResultEfficacyCommand),
2709 ::core::stringify!(new),
2710 )
2711 });
2712 <Self as IUnitCalculator_BattleSceneResultEfficacyCommandMethods>::ctor(this);
2713 this
2714 }
2715}
2716
2717#[cfg(feature = "app-unitcalculator")]
2718pub trait IUnitCalculator_AttackAttributeCommandMethods: IUnitCalculator_AttackAttributeCommand {
2719 #[doc = "`get_Name()` overload"]
2720 fn get_name(self) -> ::unity::Il2CppString {
2721 unsafe {
2722 let __receiver = <UnitCalculator_AttackAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
2723 <Self as ::unity::SystemObject>::as_instance(self),
2724 );
2725 {
2726 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2727 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
2728 panic!(
2729 "unity: virtual slot {}
2730 out of range (vtable len {}
2731) on the runtime class behind {}
2732 (method `{}
2733`)",
2734 4usize,
2735 __vt.len(),
2736 <UnitCalculator_AttackAttributeCommand as ::unity::ClassIdentity>::NAME,
2737 "get_Name",
2738 )
2739 });
2740 let __inner: extern "C" fn(UnitCalculator_AttackAttributeCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
2741 ::core::mem::transmute(__vi.method_ptr);
2742 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2743 __inner(__receiver, __mi)
2744 }
2745 }
2746 }
2747 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
2748 fn get_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
2749 unsafe {
2750 let __receiver = <UnitCalculator_AttackAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
2751 <Self as ::unity::SystemObject>::as_instance(self),
2752 );
2753 {
2754 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2755 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
2756 panic!(
2757 "unity: virtual slot {}
2758 out of range (vtable len {}
2759) on the runtime class behind {}
2760 (method `{}
2761`)",
2762 31usize,
2763 __vt.len(),
2764 <UnitCalculator_AttackAttributeCommand as ::unity::ClassIdentity>::NAME,
2765 "GetImpl",
2766 )
2767 });
2768 let __inner: extern "C" fn(
2769 UnitCalculator_AttackAttributeCommand,
2770 crate::app::battleinfoside::BattleInfoSide,
2771 ::unity::OptionalMethod,
2772 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
2773 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2774 __inner(__receiver, ::core::convert::Into::into(side), __mi)
2775 }
2776 }
2777 }
2778 #[doc = "`SetImpl(crate::app::battleinfoside::BattleInfoSide, f32)` overload"]
2779 fn set_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>, value: impl ::core::convert::Into<f32>) -> () {
2780 unsafe {
2781 let __receiver = <UnitCalculator_AttackAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
2782 <Self as ::unity::SystemObject>::as_instance(self),
2783 );
2784 {
2785 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2786 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
2787 panic!(
2788 "unity: virtual slot {}
2789 out of range (vtable len {}
2790) on the runtime class behind {}
2791 (method `{}
2792`)",
2793 33usize,
2794 __vt.len(),
2795 <UnitCalculator_AttackAttributeCommand as ::unity::ClassIdentity>::NAME,
2796 "SetImpl",
2797 )
2798 });
2799 let __inner: extern "C" fn(
2800 UnitCalculator_AttackAttributeCommand,
2801 crate::app::battleinfoside::BattleInfoSide,
2802 f32,
2803 ::unity::OptionalMethod,
2804 ) -> () = ::core::mem::transmute(__vi.method_ptr);
2805 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2806 __inner(__receiver, ::core::convert::Into::into(side), ::core::convert::Into::into(value), __mi)
2807 }
2808 }
2809 }
2810 #[doc = "`.ctor()` overload"]
2811 fn ctor(self) -> () {
2812 unsafe {
2813 let __receiver = <UnitCalculator_AttackAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
2814 <Self as ::unity::SystemObject>::as_instance(self),
2815 );
2816 ::unity::il2cpp_call!((::unity::module_base()+0x1b453f0usize)as*mut u8,();
2817(UnitCalculator_AttackAttributeCommand)__receiver)
2818 }
2819 }
2820}
2821
2822#[cfg(feature = "app-unitcalculator")]
2823impl<__T: IUnitCalculator_AttackAttributeCommand> IUnitCalculator_AttackAttributeCommandMethods for __T {}
2824
2825#[cfg(feature = "app-unitcalculator")]
2826impl UnitCalculator_AttackAttributeCommand {
2827 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2828 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2829 }
2830
2831 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2832 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2833 }
2834
2835 pub fn set_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2836 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2837 }
2838
2839 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2840 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
2841 }
2842}
2843
2844#[cfg(feature = "app-unitcalculator")]
2845impl UnitCalculator_AttackAttributeCommand {
2846 #[doc = "Direct (non-virtual) call to `UnitCalculator_AttackAttributeCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2847 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2848 let __mi = Self::get_name_method_info();
2849 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2850 __inner(this.into(), ::core::option::Option::None)
2851 }
2852
2853 #[doc = "Direct (non-virtual) call to `UnitCalculator_AttackAttributeCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2854 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
2855 let __mi = Self::get_impl_method_info();
2856 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
2857 ::core::mem::transmute(__mi.method_ptr);
2858 __inner(this.into(), side, ::core::option::Option::None)
2859 }
2860
2861 #[doc = "Direct (non-virtual) call to `UnitCalculator_AttackAttributeCommand`'s own `SetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2862 pub unsafe fn set_impl(
2863 this: impl ::core::convert::Into<::unity::IlInstance>,
2864 side: crate::app::battleinfoside::BattleInfoSide,
2865 value: f32,
2866 ) -> () {
2867 let __mi = Self::set_impl_method_info();
2868 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, f32, ::unity::OptionalMethod) -> () =
2869 ::core::mem::transmute(__mi.method_ptr);
2870 __inner(this.into(), side, value, ::core::option::Option::None)
2871 }
2872}
2873
2874#[cfg(feature = "app-unitcalculator")]
2875impl UnitCalculator_AttackAttributeCommand {
2876 #[doc = "`.ctor()` — no args"]
2877 pub fn new() -> Self {
2878 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2879 panic!(
2880 "{}
2881::{}
2882 failed to instantiate",
2883 ::core::stringify!(UnitCalculator_AttackAttributeCommand),
2884 ::core::stringify!(new),
2885 )
2886 });
2887 <Self as IUnitCalculator_AttackAttributeCommandMethods>::ctor(this);
2888 this
2889 }
2890}
2891
2892#[cfg(feature = "app-unitcalculator")]
2893pub trait IUnitCalculator_ExpCommandMethods: IUnitCalculator_ExpCommand {
2894 #[doc = "`get_Name()` overload"]
2895 fn get_name(self) -> ::unity::Il2CppString {
2896 unsafe {
2897 let __receiver =
2898 <UnitCalculator_ExpCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2899 {
2900 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2901 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
2902 panic!(
2903 "unity: virtual slot {}
2904 out of range (vtable len {}
2905) on the runtime class behind {}
2906 (method `{}
2907`)",
2908 4usize,
2909 __vt.len(),
2910 <UnitCalculator_ExpCommand as ::unity::ClassIdentity>::NAME,
2911 "get_Name",
2912 )
2913 });
2914 let __inner: extern "C" fn(UnitCalculator_ExpCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
2915 ::core::mem::transmute(__vi.method_ptr);
2916 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2917 __inner(__receiver, __mi)
2918 }
2919 }
2920 }
2921 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
2922 fn get_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
2923 unsafe {
2924 let __receiver =
2925 <UnitCalculator_ExpCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2926 {
2927 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2928 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
2929 panic!(
2930 "unity: virtual slot {}
2931 out of range (vtable len {}
2932) on the runtime class behind {}
2933 (method `{}
2934`)",
2935 30usize,
2936 __vt.len(),
2937 <UnitCalculator_ExpCommand as ::unity::ClassIdentity>::NAME,
2938 "GetImpl",
2939 )
2940 });
2941 let __inner: extern "C" fn(UnitCalculator_ExpCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
2942 ::core::mem::transmute(__vi.method_ptr);
2943 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2944 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
2945 }
2946 }
2947 }
2948 #[doc = "`.ctor()` overload"]
2949 fn ctor(self) -> () {
2950 unsafe {
2951 let __receiver =
2952 <UnitCalculator_ExpCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2953 ::unity::il2cpp_call!((::unity::module_base()+0x1b471b0usize)as*mut u8,();
2954(UnitCalculator_ExpCommand)__receiver)
2955 }
2956 }
2957}
2958
2959#[cfg(feature = "app-unitcalculator")]
2960impl<__T: IUnitCalculator_ExpCommand> IUnitCalculator_ExpCommandMethods for __T {}
2961
2962#[cfg(feature = "app-unitcalculator")]
2963impl UnitCalculator_ExpCommand {
2964 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2965 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2966 }
2967
2968 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2969 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2970 }
2971
2972 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2973 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2974 }
2975}
2976
2977#[cfg(feature = "app-unitcalculator")]
2978impl UnitCalculator_ExpCommand {
2979 #[doc = "Direct (non-virtual) call to `UnitCalculator_ExpCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2980 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2981 let __mi = Self::get_name_method_info();
2982 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2983 __inner(this.into(), ::core::option::Option::None)
2984 }
2985
2986 #[doc = "Direct (non-virtual) call to `UnitCalculator_ExpCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2987 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
2988 let __mi = Self::get_impl_method_info();
2989 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
2990 ::core::mem::transmute(__mi.method_ptr);
2991 __inner(this.into(), unit, ::core::option::Option::None)
2992 }
2993}
2994
2995#[cfg(feature = "app-unitcalculator")]
2996impl UnitCalculator_ExpCommand {
2997 #[doc = "`.ctor()` — no args"]
2998 pub fn new() -> Self {
2999 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
3000 panic!(
3001 "{}
3002::{}
3003 failed to instantiate",
3004 ::core::stringify!(UnitCalculator_ExpCommand),
3005 ::core::stringify!(new),
3006 )
3007 });
3008 <Self as IUnitCalculator_ExpCommandMethods>::ctor(this);
3009 this
3010 }
3011}
3012
3013#[cfg(feature = "app-unitcalculator")]
3014pub trait IUnitCalculator_EngageCountLimitCommandMethods: IUnitCalculator_EngageCountLimitCommand {
3015 #[doc = "`get_Name()` overload"]
3016 fn get_name(self) -> ::unity::Il2CppString {
3017 unsafe {
3018 let __receiver = <UnitCalculator_EngageCountLimitCommand as ::unity::FromIlInstance>::from_il_instance(
3019 <Self as ::unity::SystemObject>::as_instance(self),
3020 );
3021 {
3022 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3023 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
3024 panic!(
3025 "unity: virtual slot {}
3026 out of range (vtable len {}
3027) on the runtime class behind {}
3028 (method `{}
3029`)",
3030 4usize,
3031 __vt.len(),
3032 <UnitCalculator_EngageCountLimitCommand as ::unity::ClassIdentity>::NAME,
3033 "get_Name",
3034 )
3035 });
3036 let __inner: extern "C" fn(UnitCalculator_EngageCountLimitCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
3037 ::core::mem::transmute(__vi.method_ptr);
3038 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3039 __inner(__receiver, __mi)
3040 }
3041 }
3042 }
3043 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
3044 fn get_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
3045 unsafe {
3046 let __receiver = <UnitCalculator_EngageCountLimitCommand as ::unity::FromIlInstance>::from_il_instance(
3047 <Self as ::unity::SystemObject>::as_instance(self),
3048 );
3049 {
3050 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3051 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
3052 panic!(
3053 "unity: virtual slot {}
3054 out of range (vtable len {}
3055) on the runtime class behind {}
3056 (method `{}
3057`)",
3058 30usize,
3059 __vt.len(),
3060 <UnitCalculator_EngageCountLimitCommand as ::unity::ClassIdentity>::NAME,
3061 "GetImpl",
3062 )
3063 });
3064 let __inner: extern "C" fn(UnitCalculator_EngageCountLimitCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
3065 ::core::mem::transmute(__vi.method_ptr);
3066 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3067 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
3068 }
3069 }
3070 }
3071 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
3072 fn get_impl_2(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
3073 unsafe {
3074 let __receiver = <UnitCalculator_EngageCountLimitCommand as ::unity::FromIlInstance>::from_il_instance(
3075 <Self as ::unity::SystemObject>::as_instance(self),
3076 );
3077 {
3078 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3079 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
3080 panic!(
3081 "unity: virtual slot {}
3082 out of range (vtable len {}
3083) on the runtime class behind {}
3084 (method `{}
3085`)",
3086 31usize,
3087 __vt.len(),
3088 <UnitCalculator_EngageCountLimitCommand as ::unity::ClassIdentity>::NAME,
3089 "GetImpl",
3090 )
3091 });
3092 let __inner: extern "C" fn(
3093 UnitCalculator_EngageCountLimitCommand,
3094 crate::app::battleinfoside::BattleInfoSide,
3095 ::unity::OptionalMethod,
3096 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
3097 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3098 __inner(__receiver, ::core::convert::Into::into(side), __mi)
3099 }
3100 }
3101 }
3102 #[doc = "`.ctor()` overload"]
3103 fn ctor(self) -> () {
3104 unsafe {
3105 let __receiver = <UnitCalculator_EngageCountLimitCommand as ::unity::FromIlInstance>::from_il_instance(
3106 <Self as ::unity::SystemObject>::as_instance(self),
3107 );
3108 ::unity::il2cpp_call!((::unity::module_base()+0x1b470b0usize)as*mut u8,();
3109(UnitCalculator_EngageCountLimitCommand)__receiver)
3110 }
3111 }
3112}
3113
3114#[cfg(feature = "app-unitcalculator")]
3115impl<__T: IUnitCalculator_EngageCountLimitCommand> IUnitCalculator_EngageCountLimitCommandMethods for __T {}
3116
3117#[cfg(feature = "app-unitcalculator")]
3118impl UnitCalculator_EngageCountLimitCommand {
3119 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3120 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
3121 }
3122
3123 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3124 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
3125 }
3126
3127 pub fn get_impl_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3128 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
3129 }
3130
3131 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3132 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
3133 }
3134}
3135
3136#[cfg(feature = "app-unitcalculator")]
3137impl UnitCalculator_EngageCountLimitCommand {
3138 #[doc = "Direct (non-virtual) call to `UnitCalculator_EngageCountLimitCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3139 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
3140 let __mi = Self::get_name_method_info();
3141 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
3142 __inner(this.into(), ::core::option::Option::None)
3143 }
3144
3145 #[doc = "Direct (non-virtual) call to `UnitCalculator_EngageCountLimitCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3146 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
3147 let __mi = Self::get_impl_method_info();
3148 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
3149 ::core::mem::transmute(__mi.method_ptr);
3150 __inner(this.into(), unit, ::core::option::Option::None)
3151 }
3152
3153 #[doc = "Direct (non-virtual) call to `UnitCalculator_EngageCountLimitCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3154 pub unsafe fn get_impl_2(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
3155 let __mi = Self::get_impl_2_method_info();
3156 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
3157 ::core::mem::transmute(__mi.method_ptr);
3158 __inner(this.into(), side, ::core::option::Option::None)
3159 }
3160}
3161
3162#[cfg(feature = "app-unitcalculator")]
3163impl UnitCalculator_EngageCountLimitCommand {
3164 #[doc = "`.ctor()` — no args"]
3165 pub fn new() -> Self {
3166 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
3167 panic!(
3168 "{}
3169::{}
3170 failed to instantiate",
3171 ::core::stringify!(UnitCalculator_EngageCountLimitCommand),
3172 ::core::stringify!(new),
3173 )
3174 });
3175 <Self as IUnitCalculator_EngageCountLimitCommandMethods>::ctor(this);
3176 this
3177 }
3178}
3179
3180#[cfg(feature = "app-unitcalculator")]
3181pub trait IUnitCalculator_PickupItemCommandMethods: IUnitCalculator_PickupItemCommand {
3182 #[doc = "`get_Name()` overload"]
3183 fn get_name(self) -> ::unity::Il2CppString {
3184 unsafe {
3185 let __receiver =
3186 <UnitCalculator_PickupItemCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3187 {
3188 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3189 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
3190 panic!(
3191 "unity: virtual slot {}
3192 out of range (vtable len {}
3193) on the runtime class behind {}
3194 (method `{}
3195`)",
3196 4usize,
3197 __vt.len(),
3198 <UnitCalculator_PickupItemCommand as ::unity::ClassIdentity>::NAME,
3199 "get_Name",
3200 )
3201 });
3202 let __inner: extern "C" fn(UnitCalculator_PickupItemCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
3203 ::core::mem::transmute(__vi.method_ptr);
3204 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3205 __inner(__receiver, __mi)
3206 }
3207 }
3208 }
3209 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
3210 fn get_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
3211 unsafe {
3212 let __receiver =
3213 <UnitCalculator_PickupItemCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3214 {
3215 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3216 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
3217 panic!(
3218 "unity: virtual slot {}
3219 out of range (vtable len {}
3220) on the runtime class behind {}
3221 (method `{}
3222`)",
3223 31usize,
3224 __vt.len(),
3225 <UnitCalculator_PickupItemCommand as ::unity::ClassIdentity>::NAME,
3226 "GetImpl",
3227 )
3228 });
3229 let __inner: extern "C" fn(
3230 UnitCalculator_PickupItemCommand,
3231 crate::app::battleinfoside::BattleInfoSide,
3232 ::unity::OptionalMethod,
3233 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
3234 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3235 __inner(__receiver, ::core::convert::Into::into(side), __mi)
3236 }
3237 }
3238 }
3239 #[doc = "`SetImpl(crate::app::battleinfoside::BattleInfoSide, f32)` overload"]
3240 fn set_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>, value: impl ::core::convert::Into<f32>) -> () {
3241 unsafe {
3242 let __receiver =
3243 <UnitCalculator_PickupItemCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3244 {
3245 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3246 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
3247 panic!(
3248 "unity: virtual slot {}
3249 out of range (vtable len {}
3250) on the runtime class behind {}
3251 (method `{}
3252`)",
3253 33usize,
3254 __vt.len(),
3255 <UnitCalculator_PickupItemCommand as ::unity::ClassIdentity>::NAME,
3256 "SetImpl",
3257 )
3258 });
3259 let __inner: extern "C" fn(
3260 UnitCalculator_PickupItemCommand,
3261 crate::app::battleinfoside::BattleInfoSide,
3262 f32,
3263 ::unity::OptionalMethod,
3264 ) -> () = ::core::mem::transmute(__vi.method_ptr);
3265 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3266 __inner(__receiver, ::core::convert::Into::into(side), ::core::convert::Into::into(value), __mi)
3267 }
3268 }
3269 }
3270 #[doc = "`.ctor()` overload"]
3271 fn ctor(self) -> () {
3272 unsafe {
3273 let __receiver =
3274 <UnitCalculator_PickupItemCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3275 ::unity::il2cpp_call!((::unity::module_base()+0x1b4aad0usize)as*mut u8,();
3276(UnitCalculator_PickupItemCommand)__receiver)
3277 }
3278 }
3279}
3280
3281#[cfg(feature = "app-unitcalculator")]
3282impl<__T: IUnitCalculator_PickupItemCommand> IUnitCalculator_PickupItemCommandMethods for __T {}
3283
3284#[cfg(feature = "app-unitcalculator")]
3285impl UnitCalculator_PickupItemCommand {
3286 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3287 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
3288 }
3289
3290 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3291 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
3292 }
3293
3294 pub fn set_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3295 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
3296 }
3297
3298 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3299 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
3300 }
3301}
3302
3303#[cfg(feature = "app-unitcalculator")]
3304impl UnitCalculator_PickupItemCommand {
3305 #[doc = "Direct (non-virtual) call to `UnitCalculator_PickupItemCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3306 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
3307 let __mi = Self::get_name_method_info();
3308 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
3309 __inner(this.into(), ::core::option::Option::None)
3310 }
3311
3312 #[doc = "Direct (non-virtual) call to `UnitCalculator_PickupItemCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3313 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
3314 let __mi = Self::get_impl_method_info();
3315 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
3316 ::core::mem::transmute(__mi.method_ptr);
3317 __inner(this.into(), side, ::core::option::Option::None)
3318 }
3319
3320 #[doc = "Direct (non-virtual) call to `UnitCalculator_PickupItemCommand`'s own `SetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3321 pub unsafe fn set_impl(
3322 this: impl ::core::convert::Into<::unity::IlInstance>,
3323 side: crate::app::battleinfoside::BattleInfoSide,
3324 value: f32,
3325 ) -> () {
3326 let __mi = Self::set_impl_method_info();
3327 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, f32, ::unity::OptionalMethod) -> () =
3328 ::core::mem::transmute(__mi.method_ptr);
3329 __inner(this.into(), side, value, ::core::option::Option::None)
3330 }
3331}
3332
3333#[cfg(feature = "app-unitcalculator")]
3334impl UnitCalculator_PickupItemCommand {
3335 #[doc = "`.ctor()` — no args"]
3336 pub fn new() -> Self {
3337 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
3338 panic!(
3339 "{}
3340::{}
3341 failed to instantiate",
3342 ::core::stringify!(UnitCalculator_PickupItemCommand),
3343 ::core::stringify!(new),
3344 )
3345 });
3346 <Self as IUnitCalculator_PickupItemCommandMethods>::ctor(this);
3347 this
3348 }
3349}
3350
3351#[cfg(feature = "app-unitcalculator")]
3352pub trait IUnitCalculator_BattleSceneResultCriticalCommandMethods: IUnitCalculator_BattleSceneResultCriticalCommand {
3353 #[doc = "`get_Name()` overload"]
3354 fn get_name(self) -> ::unity::Il2CppString {
3355 unsafe {
3356 let __receiver = <UnitCalculator_BattleSceneResultCriticalCommand as ::unity::FromIlInstance>::from_il_instance(
3357 <Self as ::unity::SystemObject>::as_instance(self),
3358 );
3359 {
3360 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3361 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
3362 panic!(
3363 "unity: virtual slot {}
3364 out of range (vtable len {}
3365) on the runtime class behind {}
3366 (method `{}
3367`)",
3368 4usize,
3369 __vt.len(),
3370 <UnitCalculator_BattleSceneResultCriticalCommand as ::unity::ClassIdentity>::NAME,
3371 "get_Name",
3372 )
3373 });
3374 let __inner: extern "C" fn(UnitCalculator_BattleSceneResultCriticalCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
3375 ::core::mem::transmute(__vi.method_ptr);
3376 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3377 __inner(__receiver, __mi)
3378 }
3379 }
3380 }
3381 #[doc = "`Get()` overload"]
3382 fn get(self) -> f32 {
3383 unsafe {
3384 let __receiver = <UnitCalculator_BattleSceneResultCriticalCommand as ::unity::FromIlInstance>::from_il_instance(
3385 <Self as ::unity::SystemObject>::as_instance(self),
3386 );
3387 {
3388 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3389 let __vi = *__vt.get(9usize).unwrap_or_else(|| {
3390 panic!(
3391 "unity: virtual slot {}
3392 out of range (vtable len {}
3393) on the runtime class behind {}
3394 (method `{}
3395`)",
3396 9usize,
3397 __vt.len(),
3398 <UnitCalculator_BattleSceneResultCriticalCommand as ::unity::ClassIdentity>::NAME,
3399 "Get",
3400 )
3401 });
3402 let __inner: extern "C" fn(UnitCalculator_BattleSceneResultCriticalCommand, ::unity::OptionalMethod) -> f32 =
3403 ::core::mem::transmute(__vi.method_ptr);
3404 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3405 __inner(__receiver, __mi)
3406 }
3407 }
3408 }
3409 #[doc = "`.ctor()` overload"]
3410 fn ctor(self) -> () {
3411 unsafe {
3412 let __receiver = <UnitCalculator_BattleSceneResultCriticalCommand as ::unity::FromIlInstance>::from_il_instance(
3413 <Self as ::unity::SystemObject>::as_instance(self),
3414 );
3415 ::unity::il2cpp_call!((::unity::module_base()+0x1b462c0usize)as*mut u8,();
3416(UnitCalculator_BattleSceneResultCriticalCommand)__receiver)
3417 }
3418 }
3419}
3420
3421#[cfg(feature = "app-unitcalculator")]
3422impl<__T: IUnitCalculator_BattleSceneResultCriticalCommand> IUnitCalculator_BattleSceneResultCriticalCommandMethods for __T {}
3423
3424#[cfg(feature = "app-unitcalculator")]
3425impl UnitCalculator_BattleSceneResultCriticalCommand {
3426 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3427 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
3428 }
3429
3430 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3431 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
3432 }
3433
3434 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3435 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
3436 }
3437}
3438
3439#[cfg(feature = "app-unitcalculator")]
3440impl UnitCalculator_BattleSceneResultCriticalCommand {
3441 #[doc = "Direct (non-virtual) call to `UnitCalculator_BattleSceneResultCriticalCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3442 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
3443 let __mi = Self::get_name_method_info();
3444 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
3445 __inner(this.into(), ::core::option::Option::None)
3446 }
3447
3448 #[doc = "Direct (non-virtual) call to `UnitCalculator_BattleSceneResultCriticalCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3449 pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
3450 let __mi = Self::get_method_info();
3451 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
3452 __inner(this.into(), ::core::option::Option::None)
3453 }
3454}
3455
3456#[cfg(feature = "app-unitcalculator")]
3457impl UnitCalculator_BattleSceneResultCriticalCommand {
3458 #[doc = "`.ctor()` — no args"]
3459 pub fn new() -> Self {
3460 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
3461 panic!(
3462 "{}
3463::{}
3464 failed to instantiate",
3465 ::core::stringify!(UnitCalculator_BattleSceneResultCriticalCommand),
3466 ::core::stringify!(new),
3467 )
3468 });
3469 <Self as IUnitCalculator_BattleSceneResultCriticalCommandMethods>::ctor(this);
3470 this
3471 }
3472}
3473
3474#[cfg(feature = "app-unitcalculator")]
3475pub trait IUnitCalculator_UnitDefenseCommandMethods: IUnitCalculator_UnitDefenseCommand {
3476 #[doc = "`get_Name()` overload"]
3477 fn get_name(self) -> ::unity::Il2CppString {
3478 unsafe {
3479 let __receiver =
3480 <UnitCalculator_UnitDefenseCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3481 {
3482 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3483 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
3484 panic!(
3485 "unity: virtual slot {}
3486 out of range (vtable len {}
3487) on the runtime class behind {}
3488 (method `{}
3489`)",
3490 4usize,
3491 __vt.len(),
3492 <UnitCalculator_UnitDefenseCommand as ::unity::ClassIdentity>::NAME,
3493 "get_Name",
3494 )
3495 });
3496 let __inner: extern "C" fn(UnitCalculator_UnitDefenseCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
3497 ::core::mem::transmute(__vi.method_ptr);
3498 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3499 __inner(__receiver, __mi)
3500 }
3501 }
3502 }
3503 #[doc = "`GetParam(crate::app::battleinfoside::BattleInfoSide)` overload"]
3504 fn get_param(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> crate::app::battleparam::BattleParam {
3505 unsafe {
3506 let __receiver =
3507 <UnitCalculator_UnitDefenseCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3508 {
3509 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3510 let __vi = *__vt.get(44usize).unwrap_or_else(|| {
3511 panic!(
3512 "unity: virtual slot {}
3513 out of range (vtable len {}
3514) on the runtime class behind {}
3515 (method `{}
3516`)",
3517 44usize,
3518 __vt.len(),
3519 <UnitCalculator_UnitDefenseCommand as ::unity::ClassIdentity>::NAME,
3520 "GetParam",
3521 )
3522 });
3523 let __inner: extern "C" fn(
3524 UnitCalculator_UnitDefenseCommand,
3525 crate::app::battleinfoside::BattleInfoSide,
3526 ::unity::OptionalMethod,
3527 ) -> crate::app::battleparam::BattleParam = ::core::mem::transmute(__vi.method_ptr);
3528 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3529 __inner(__receiver, ::core::convert::Into::into(side), __mi)
3530 }
3531 }
3532 }
3533 #[doc = "`.ctor()` overload"]
3534 fn ctor(self) -> () {
3535 unsafe {
3536 let __receiver =
3537 <UnitCalculator_UnitDefenseCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3538 ::unity::il2cpp_call!((::unity::module_base()+0x1b4d460usize)as*mut u8,();
3539(UnitCalculator_UnitDefenseCommand)__receiver)
3540 }
3541 }
3542}
3543
3544#[cfg(feature = "app-unitcalculator")]
3545impl<__T: IUnitCalculator_UnitDefenseCommand> IUnitCalculator_UnitDefenseCommandMethods for __T {}
3546
3547#[cfg(feature = "app-unitcalculator")]
3548impl UnitCalculator_UnitDefenseCommand {
3549 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3550 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
3551 }
3552
3553 pub fn get_param_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3554 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
3555 }
3556
3557 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3558 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
3559 }
3560}
3561
3562#[cfg(feature = "app-unitcalculator")]
3563impl UnitCalculator_UnitDefenseCommand {
3564 #[doc = "Direct (non-virtual) call to `UnitCalculator_UnitDefenseCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3565 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
3566 let __mi = Self::get_name_method_info();
3567 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
3568 __inner(this.into(), ::core::option::Option::None)
3569 }
3570
3571 #[doc = "Direct (non-virtual) call to `UnitCalculator_UnitDefenseCommand`'s own `GetParam`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3572 pub unsafe fn get_param(
3573 this: impl ::core::convert::Into<::unity::IlInstance>,
3574 side: crate::app::battleinfoside::BattleInfoSide,
3575 ) -> crate::app::battleparam::BattleParam {
3576 let __mi = Self::get_param_method_info();
3577 let __inner: extern "C" fn(
3578 ::unity::IlInstance,
3579 crate::app::battleinfoside::BattleInfoSide,
3580 ::unity::OptionalMethod,
3581 ) -> crate::app::battleparam::BattleParam = ::core::mem::transmute(__mi.method_ptr);
3582 __inner(this.into(), side, ::core::option::Option::None)
3583 }
3584}
3585
3586#[cfg(feature = "app-unitcalculator")]
3587impl UnitCalculator_UnitDefenseCommand {
3588 #[doc = "`.ctor()` — no args"]
3589 pub fn new() -> Self {
3590 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
3591 panic!(
3592 "{}
3593::{}
3594 failed to instantiate",
3595 ::core::stringify!(UnitCalculator_UnitDefenseCommand),
3596 ::core::stringify!(new),
3597 )
3598 });
3599 <Self as IUnitCalculator_UnitDefenseCommandMethods>::ctor(this);
3600 this
3601 }
3602}
3603
3604#[cfg(feature = "app-unitcalculator")]
3605pub trait IUnitCalculator_DefenseCommandMethods: IUnitCalculator_DefenseCommand {
3606 #[doc = "`get_Name()` overload"]
3607 fn get_name(self) -> ::unity::Il2CppString {
3608 unsafe {
3609 let __receiver =
3610 <UnitCalculator_DefenseCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3611 {
3612 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3613 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
3614 panic!(
3615 "unity: virtual slot {}
3616 out of range (vtable len {}
3617) on the runtime class behind {}
3618 (method `{}
3619`)",
3620 4usize,
3621 __vt.len(),
3622 <UnitCalculator_DefenseCommand as ::unity::ClassIdentity>::NAME,
3623 "get_Name",
3624 )
3625 });
3626 let __inner: extern "C" fn(UnitCalculator_DefenseCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
3627 ::core::mem::transmute(__vi.method_ptr);
3628 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3629 __inner(__receiver, __mi)
3630 }
3631 }
3632 }
3633 #[doc = "`GetParam(crate::app::battleinfoside::BattleInfoSide)` overload"]
3634 fn get_param(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> crate::app::battleparam::BattleParam {
3635 unsafe {
3636 let __receiver =
3637 <UnitCalculator_DefenseCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3638 {
3639 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3640 let __vi = *__vt.get(44usize).unwrap_or_else(|| {
3641 panic!(
3642 "unity: virtual slot {}
3643 out of range (vtable len {}
3644) on the runtime class behind {}
3645 (method `{}
3646`)",
3647 44usize,
3648 __vt.len(),
3649 <UnitCalculator_DefenseCommand as ::unity::ClassIdentity>::NAME,
3650 "GetParam",
3651 )
3652 });
3653 let __inner: extern "C" fn(
3654 UnitCalculator_DefenseCommand,
3655 crate::app::battleinfoside::BattleInfoSide,
3656 ::unity::OptionalMethod,
3657 ) -> crate::app::battleparam::BattleParam = ::core::mem::transmute(__vi.method_ptr);
3658 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3659 __inner(__receiver, ::core::convert::Into::into(side), __mi)
3660 }
3661 }
3662 }
3663 #[doc = "`IsVisible()` overload"]
3664 fn is_visible(self) -> bool {
3665 unsafe {
3666 let __receiver =
3667 <UnitCalculator_DefenseCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3668 {
3669 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3670 let __vi = *__vt.get(43usize).unwrap_or_else(|| {
3671 panic!(
3672 "unity: virtual slot {}
3673 out of range (vtable len {}
3674) on the runtime class behind {}
3675 (method `{}
3676`)",
3677 43usize,
3678 __vt.len(),
3679 <UnitCalculator_DefenseCommand as ::unity::ClassIdentity>::NAME,
3680 "IsVisible",
3681 )
3682 });
3683 let __inner: extern "C" fn(UnitCalculator_DefenseCommand, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
3684 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3685 __inner(__receiver, __mi)
3686 }
3687 }
3688 }
3689 #[doc = "`.ctor()` overload"]
3690 fn ctor(self) -> () {
3691 unsafe {
3692 let __receiver =
3693 <UnitCalculator_DefenseCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3694 ::unity::il2cpp_call!((::unity::module_base()+0x1b46e20usize)as*mut u8,();
3695(UnitCalculator_DefenseCommand)__receiver)
3696 }
3697 }
3698}
3699
3700#[cfg(feature = "app-unitcalculator")]
3701impl<__T: IUnitCalculator_DefenseCommand> IUnitCalculator_DefenseCommandMethods for __T {}
3702
3703#[cfg(feature = "app-unitcalculator")]
3704impl UnitCalculator_DefenseCommand {
3705 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3706 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
3707 }
3708
3709 pub fn get_param_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3710 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
3711 }
3712
3713 pub fn is_visible_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3714 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
3715 }
3716
3717 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3718 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
3719 }
3720}
3721
3722#[cfg(feature = "app-unitcalculator")]
3723impl UnitCalculator_DefenseCommand {
3724 #[doc = "Direct (non-virtual) call to `UnitCalculator_DefenseCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3725 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
3726 let __mi = Self::get_name_method_info();
3727 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
3728 __inner(this.into(), ::core::option::Option::None)
3729 }
3730
3731 #[doc = "Direct (non-virtual) call to `UnitCalculator_DefenseCommand`'s own `GetParam`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3732 pub unsafe fn get_param(
3733 this: impl ::core::convert::Into<::unity::IlInstance>,
3734 side: crate::app::battleinfoside::BattleInfoSide,
3735 ) -> crate::app::battleparam::BattleParam {
3736 let __mi = Self::get_param_method_info();
3737 let __inner: extern "C" fn(
3738 ::unity::IlInstance,
3739 crate::app::battleinfoside::BattleInfoSide,
3740 ::unity::OptionalMethod,
3741 ) -> crate::app::battleparam::BattleParam = ::core::mem::transmute(__mi.method_ptr);
3742 __inner(this.into(), side, ::core::option::Option::None)
3743 }
3744
3745 #[doc = "Direct (non-virtual) call to `UnitCalculator_DefenseCommand`'s own `IsVisible`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3746 pub unsafe fn is_visible(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
3747 let __mi = Self::is_visible_method_info();
3748 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
3749 __inner(this.into(), ::core::option::Option::None)
3750 }
3751}
3752
3753#[cfg(feature = "app-unitcalculator")]
3754impl UnitCalculator_DefenseCommand {
3755 #[doc = "`.ctor()` — no args"]
3756 pub fn new() -> Self {
3757 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
3758 panic!(
3759 "{}
3760::{}
3761 failed to instantiate",
3762 ::core::stringify!(UnitCalculator_DefenseCommand),
3763 ::core::stringify!(new),
3764 )
3765 });
3766 <Self as IUnitCalculator_DefenseCommandMethods>::ctor(this);
3767 this
3768 }
3769}
3770
3771#[cfg(feature = "app-unitcalculator")]
3772pub trait IUnitCalculator_JobRankCommandMethods: IUnitCalculator_JobRankCommand {
3773 #[doc = "`get_Name()` overload"]
3774 fn get_name(self) -> ::unity::Il2CppString {
3775 unsafe {
3776 let __receiver =
3777 <UnitCalculator_JobRankCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3778 {
3779 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3780 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
3781 panic!(
3782 "unity: virtual slot {}
3783 out of range (vtable len {}
3784) on the runtime class behind {}
3785 (method `{}
3786`)",
3787 4usize,
3788 __vt.len(),
3789 <UnitCalculator_JobRankCommand as ::unity::ClassIdentity>::NAME,
3790 "get_Name",
3791 )
3792 });
3793 let __inner: extern "C" fn(UnitCalculator_JobRankCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
3794 ::core::mem::transmute(__vi.method_ptr);
3795 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3796 __inner(__receiver, __mi)
3797 }
3798 }
3799 }
3800 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
3801 fn get_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
3802 unsafe {
3803 let __receiver =
3804 <UnitCalculator_JobRankCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3805 {
3806 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3807 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
3808 panic!(
3809 "unity: virtual slot {}
3810 out of range (vtable len {}
3811) on the runtime class behind {}
3812 (method `{}
3813`)",
3814 30usize,
3815 __vt.len(),
3816 <UnitCalculator_JobRankCommand as ::unity::ClassIdentity>::NAME,
3817 "GetImpl",
3818 )
3819 });
3820 let __inner: extern "C" fn(UnitCalculator_JobRankCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
3821 ::core::mem::transmute(__vi.method_ptr);
3822 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3823 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
3824 }
3825 }
3826 }
3827 #[doc = "`GetInvalid()` overload"]
3828 fn get_invalid(self) -> f32 {
3829 unsafe {
3830 let __receiver =
3831 <UnitCalculator_JobRankCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3832 {
3833 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3834 let __vi = *__vt.get(42usize).unwrap_or_else(|| {
3835 panic!(
3836 "unity: virtual slot {}
3837 out of range (vtable len {}
3838) on the runtime class behind {}
3839 (method `{}
3840`)",
3841 42usize,
3842 __vt.len(),
3843 <UnitCalculator_JobRankCommand as ::unity::ClassIdentity>::NAME,
3844 "GetInvalid",
3845 )
3846 });
3847 let __inner: extern "C" fn(UnitCalculator_JobRankCommand, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__vi.method_ptr);
3848 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3849 __inner(__receiver, __mi)
3850 }
3851 }
3852 }
3853 #[doc = "`.ctor()` overload"]
3854 fn ctor(self) -> () {
3855 unsafe {
3856 let __receiver =
3857 <UnitCalculator_JobRankCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3858 ::unity::il2cpp_call!((::unity::module_base()+0x1b486b0usize)as*mut u8,();
3859(UnitCalculator_JobRankCommand)__receiver)
3860 }
3861 }
3862}
3863
3864#[cfg(feature = "app-unitcalculator")]
3865impl<__T: IUnitCalculator_JobRankCommand> IUnitCalculator_JobRankCommandMethods for __T {}
3866
3867#[cfg(feature = "app-unitcalculator")]
3868impl UnitCalculator_JobRankCommand {
3869 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3870 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
3871 }
3872
3873 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3874 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
3875 }
3876
3877 pub fn get_invalid_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3878 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
3879 }
3880
3881 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3882 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
3883 }
3884}
3885
3886#[cfg(feature = "app-unitcalculator")]
3887impl UnitCalculator_JobRankCommand {
3888 #[doc = "Direct (non-virtual) call to `UnitCalculator_JobRankCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3889 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
3890 let __mi = Self::get_name_method_info();
3891 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
3892 __inner(this.into(), ::core::option::Option::None)
3893 }
3894
3895 #[doc = "Direct (non-virtual) call to `UnitCalculator_JobRankCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3896 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
3897 let __mi = Self::get_impl_method_info();
3898 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
3899 ::core::mem::transmute(__mi.method_ptr);
3900 __inner(this.into(), unit, ::core::option::Option::None)
3901 }
3902
3903 #[doc = "Direct (non-virtual) call to `UnitCalculator_JobRankCommand`'s own `GetInvalid`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3904 pub unsafe fn get_invalid(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
3905 let __mi = Self::get_invalid_method_info();
3906 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
3907 __inner(this.into(), ::core::option::Option::None)
3908 }
3909}
3910
3911#[cfg(feature = "app-unitcalculator")]
3912impl UnitCalculator_JobRankCommand {
3913 #[doc = "`.ctor()` — no args"]
3914 pub fn new() -> Self {
3915 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
3916 panic!(
3917 "{}
3918::{}
3919 failed to instantiate",
3920 ::core::stringify!(UnitCalculator_JobRankCommand),
3921 ::core::stringify!(new),
3922 )
3923 });
3924 <Self as IUnitCalculator_JobRankCommandMethods>::ctor(this);
3925 this
3926 }
3927}
3928
3929#[cfg(feature = "app-unitcalculator")]
3930pub trait IUnitCalculator_DefCommandMethods: IUnitCalculator_DefCommand {
3931 #[doc = "`get_Name()` overload"]
3932 fn get_name(self) -> ::unity::Il2CppString {
3933 unsafe {
3934 let __receiver =
3935 <UnitCalculator_DefCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3936 {
3937 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3938 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
3939 panic!(
3940 "unity: virtual slot {}
3941 out of range (vtable len {}
3942) on the runtime class behind {}
3943 (method `{}
3944`)",
3945 4usize,
3946 __vt.len(),
3947 <UnitCalculator_DefCommand as ::unity::ClassIdentity>::NAME,
3948 "get_Name",
3949 )
3950 });
3951 let __inner: extern "C" fn(UnitCalculator_DefCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
3952 ::core::mem::transmute(__vi.method_ptr);
3953 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3954 __inner(__receiver, __mi)
3955 }
3956 }
3957 }
3958 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
3959 fn get_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
3960 unsafe {
3961 let __receiver =
3962 <UnitCalculator_DefCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3963 {
3964 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3965 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
3966 panic!(
3967 "unity: virtual slot {}
3968 out of range (vtable len {}
3969) on the runtime class behind {}
3970 (method `{}
3971`)",
3972 30usize,
3973 __vt.len(),
3974 <UnitCalculator_DefCommand as ::unity::ClassIdentity>::NAME,
3975 "GetImpl",
3976 )
3977 });
3978 let __inner: extern "C" fn(UnitCalculator_DefCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
3979 ::core::mem::transmute(__vi.method_ptr);
3980 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3981 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
3982 }
3983 }
3984 }
3985 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
3986 fn get_impl_2(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
3987 unsafe {
3988 let __receiver =
3989 <UnitCalculator_DefCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3990 {
3991 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3992 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
3993 panic!(
3994 "unity: virtual slot {}
3995 out of range (vtable len {}
3996) on the runtime class behind {}
3997 (method `{}
3998`)",
3999 31usize,
4000 __vt.len(),
4001 <UnitCalculator_DefCommand as ::unity::ClassIdentity>::NAME,
4002 "GetImpl",
4003 )
4004 });
4005 let __inner: extern "C" fn(UnitCalculator_DefCommand, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
4006 ::core::mem::transmute(__vi.method_ptr);
4007 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4008 __inner(__receiver, ::core::convert::Into::into(side), __mi)
4009 }
4010 }
4011 }
4012 #[doc = "`SetImpl(crate::app::battleinfoside::BattleInfoSide, f32)` overload"]
4013 fn set_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>, value: impl ::core::convert::Into<f32>) -> () {
4014 unsafe {
4015 let __receiver =
4016 <UnitCalculator_DefCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4017 {
4018 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4019 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
4020 panic!(
4021 "unity: virtual slot {}
4022 out of range (vtable len {}
4023) on the runtime class behind {}
4024 (method `{}
4025`)",
4026 33usize,
4027 __vt.len(),
4028 <UnitCalculator_DefCommand as ::unity::ClassIdentity>::NAME,
4029 "SetImpl",
4030 )
4031 });
4032 let __inner: extern "C" fn(
4033 UnitCalculator_DefCommand,
4034 crate::app::battleinfoside::BattleInfoSide,
4035 f32,
4036 ::unity::OptionalMethod,
4037 ) -> () = ::core::mem::transmute(__vi.method_ptr);
4038 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4039 __inner(__receiver, ::core::convert::Into::into(side), ::core::convert::Into::into(value), __mi)
4040 }
4041 }
4042 }
4043 #[doc = "`.ctor()` overload"]
4044 fn ctor(self) -> () {
4045 unsafe {
4046 let __receiver =
4047 <UnitCalculator_DefCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4048 ::unity::il2cpp_call!((::unity::module_base()+0x1b46da0usize)as*mut u8,();
4049(UnitCalculator_DefCommand)__receiver)
4050 }
4051 }
4052}
4053
4054#[cfg(feature = "app-unitcalculator")]
4055impl<__T: IUnitCalculator_DefCommand> IUnitCalculator_DefCommandMethods for __T {}
4056
4057#[cfg(feature = "app-unitcalculator")]
4058impl UnitCalculator_DefCommand {
4059 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4060 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
4061 }
4062
4063 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4064 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
4065 }
4066
4067 pub fn get_impl_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4068 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
4069 }
4070
4071 pub fn set_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4072 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
4073 }
4074
4075 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4076 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
4077 }
4078}
4079
4080#[cfg(feature = "app-unitcalculator")]
4081impl UnitCalculator_DefCommand {
4082 #[doc = "Direct (non-virtual) call to `UnitCalculator_DefCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4083 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
4084 let __mi = Self::get_name_method_info();
4085 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
4086 __inner(this.into(), ::core::option::Option::None)
4087 }
4088
4089 #[doc = "Direct (non-virtual) call to `UnitCalculator_DefCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4090 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
4091 let __mi = Self::get_impl_method_info();
4092 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
4093 ::core::mem::transmute(__mi.method_ptr);
4094 __inner(this.into(), unit, ::core::option::Option::None)
4095 }
4096
4097 #[doc = "Direct (non-virtual) call to `UnitCalculator_DefCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4098 pub unsafe fn get_impl_2(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
4099 let __mi = Self::get_impl_2_method_info();
4100 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
4101 ::core::mem::transmute(__mi.method_ptr);
4102 __inner(this.into(), side, ::core::option::Option::None)
4103 }
4104
4105 #[doc = "Direct (non-virtual) call to `UnitCalculator_DefCommand`'s own `SetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4106 pub unsafe fn set_impl(
4107 this: impl ::core::convert::Into<::unity::IlInstance>,
4108 side: crate::app::battleinfoside::BattleInfoSide,
4109 value: f32,
4110 ) -> () {
4111 let __mi = Self::set_impl_method_info();
4112 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, f32, ::unity::OptionalMethod) -> () =
4113 ::core::mem::transmute(__mi.method_ptr);
4114 __inner(this.into(), side, value, ::core::option::Option::None)
4115 }
4116}
4117
4118#[cfg(feature = "app-unitcalculator")]
4119impl UnitCalculator_DefCommand {
4120 #[doc = "`.ctor()` — no args"]
4121 pub fn new() -> Self {
4122 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
4123 panic!(
4124 "{}
4125::{}
4126 failed to instantiate",
4127 ::core::stringify!(UnitCalculator_DefCommand),
4128 ::core::stringify!(new),
4129 )
4130 });
4131 <Self as IUnitCalculator_DefCommandMethods>::ctor(this);
4132 this
4133 }
4134}
4135
4136#[cfg(feature = "app-unitcalculator")]
4137pub trait IUnitCalculator_AroundGenderCountCommandMethods: IUnitCalculator_AroundGenderCountCommand {
4138 #[doc = "`get_Name()` overload"]
4139 fn get_name(self) -> ::unity::Il2CppString {
4140 unsafe {
4141 let __receiver = <UnitCalculator_AroundGenderCountCommand as ::unity::FromIlInstance>::from_il_instance(
4142 <Self as ::unity::SystemObject>::as_instance(self),
4143 );
4144 {
4145 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4146 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
4147 panic!(
4148 "unity: virtual slot {}
4149 out of range (vtable len {}
4150) on the runtime class behind {}
4151 (method `{}
4152`)",
4153 4usize,
4154 __vt.len(),
4155 <UnitCalculator_AroundGenderCountCommand as ::unity::ClassIdentity>::NAME,
4156 "get_Name",
4157 )
4158 });
4159 let __inner: extern "C" fn(UnitCalculator_AroundGenderCountCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
4160 ::core::mem::transmute(__vi.method_ptr);
4161 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4162 __inner(__receiver, __mi)
4163 }
4164 }
4165 }
4166 #[doc = "`FuncImpl(crate::app::unit::Unit, crate::system::collections::generic::list_1::List_1<f32>)` overload"]
4167 fn func_impl(
4168 self,
4169 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
4170 args: impl ::core::convert::Into<crate::system::collections::generic::list_1::List_1<f32>>,
4171 ) -> f32 {
4172 unsafe {
4173 let __receiver = <UnitCalculator_AroundGenderCountCommand as ::unity::FromIlInstance>::from_il_instance(
4174 <Self as ::unity::SystemObject>::as_instance(self),
4175 );
4176 {
4177 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4178 let __vi = *__vt.get(34usize).unwrap_or_else(|| {
4179 panic!(
4180 "unity: virtual slot {}
4181 out of range (vtable len {}
4182) on the runtime class behind {}
4183 (method `{}
4184`)",
4185 34usize,
4186 __vt.len(),
4187 <UnitCalculator_AroundGenderCountCommand as ::unity::ClassIdentity>::NAME,
4188 "FuncImpl",
4189 )
4190 });
4191 let __inner: extern "C" fn(
4192 UnitCalculator_AroundGenderCountCommand,
4193 crate::app::unit::Unit,
4194 crate::system::collections::generic::list_1::List_1<f32>,
4195 ::unity::OptionalMethod,
4196 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
4197 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4198 __inner(__receiver, ::core::convert::Into::into(unit), ::core::convert::Into::into(args), __mi)
4199 }
4200 }
4201 }
4202 #[doc = "`.ctor()` overload"]
4203 fn ctor(self) -> () {
4204 unsafe {
4205 let __receiver = <UnitCalculator_AroundGenderCountCommand as ::unity::FromIlInstance>::from_il_instance(
4206 <Self as ::unity::SystemObject>::as_instance(self),
4207 );
4208 ::unity::il2cpp_call!((::unity::module_base()+0x1b45340usize)as*mut u8,();
4209(UnitCalculator_AroundGenderCountCommand)__receiver)
4210 }
4211 }
4212}
4213
4214#[cfg(feature = "app-unitcalculator")]
4215impl<__T: IUnitCalculator_AroundGenderCountCommand> IUnitCalculator_AroundGenderCountCommandMethods for __T {}
4216
4217#[cfg(feature = "app-unitcalculator")]
4218impl UnitCalculator_AroundGenderCountCommand {
4219 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4220 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
4221 }
4222
4223 pub fn func_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4224 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
4225 }
4226
4227 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4228 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
4229 }
4230}
4231
4232#[cfg(feature = "app-unitcalculator")]
4233impl UnitCalculator_AroundGenderCountCommand {
4234 #[doc = "Direct (non-virtual) call to `UnitCalculator_AroundGenderCountCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4235 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
4236 let __mi = Self::get_name_method_info();
4237 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
4238 __inner(this.into(), ::core::option::Option::None)
4239 }
4240
4241 #[doc = "Direct (non-virtual) call to `UnitCalculator_AroundGenderCountCommand`'s own `FuncImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4242 pub unsafe fn func_impl(
4243 this: impl ::core::convert::Into<::unity::IlInstance>,
4244 unit: crate::app::unit::Unit,
4245 args: crate::system::collections::generic::list_1::List_1<f32>,
4246 ) -> f32 {
4247 let __mi = Self::func_impl_method_info();
4248 let __inner: extern "C" fn(
4249 ::unity::IlInstance,
4250 crate::app::unit::Unit,
4251 crate::system::collections::generic::list_1::List_1<f32>,
4252 ::unity::OptionalMethod,
4253 ) -> f32 = ::core::mem::transmute(__mi.method_ptr);
4254 __inner(this.into(), unit, args, ::core::option::Option::None)
4255 }
4256}
4257
4258#[cfg(feature = "app-unitcalculator")]
4259impl UnitCalculator_AroundGenderCountCommand {
4260 #[doc = "`.ctor()` — no args"]
4261 pub fn new() -> Self {
4262 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
4263 panic!(
4264 "{}
4265::{}
4266 failed to instantiate",
4267 ::core::stringify!(UnitCalculator_AroundGenderCountCommand),
4268 ::core::stringify!(new),
4269 )
4270 });
4271 <Self as IUnitCalculator_AroundGenderCountCommandMethods>::ctor(this);
4272 this
4273 }
4274}
4275
4276#[cfg(feature = "app-unitcalculator")]
4277pub trait IUnitCalculator_SimplePowerCommandMethods: IUnitCalculator_SimplePowerCommand {
4278 #[doc = "`get_Name()` overload"]
4279 fn get_name(self) -> ::unity::Il2CppString {
4280 unsafe {
4281 let __receiver =
4282 <UnitCalculator_SimplePowerCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4283 {
4284 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4285 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
4286 panic!(
4287 "unity: virtual slot {}
4288 out of range (vtable len {}
4289) on the runtime class behind {}
4290 (method `{}
4291`)",
4292 4usize,
4293 __vt.len(),
4294 <UnitCalculator_SimplePowerCommand as ::unity::ClassIdentity>::NAME,
4295 "get_Name",
4296 )
4297 });
4298 let __inner: extern "C" fn(UnitCalculator_SimplePowerCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
4299 ::core::mem::transmute(__vi.method_ptr);
4300 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4301 __inner(__receiver, __mi)
4302 }
4303 }
4304 }
4305 #[doc = "`GetParam(crate::app::battleinfoside::BattleInfoSide)` overload"]
4306 fn get_param(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> crate::app::battleparam::BattleParam {
4307 unsafe {
4308 let __receiver =
4309 <UnitCalculator_SimplePowerCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4310 {
4311 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4312 let __vi = *__vt.get(44usize).unwrap_or_else(|| {
4313 panic!(
4314 "unity: virtual slot {}
4315 out of range (vtable len {}
4316) on the runtime class behind {}
4317 (method `{}
4318`)",
4319 44usize,
4320 __vt.len(),
4321 <UnitCalculator_SimplePowerCommand as ::unity::ClassIdentity>::NAME,
4322 "GetParam",
4323 )
4324 });
4325 let __inner: extern "C" fn(
4326 UnitCalculator_SimplePowerCommand,
4327 crate::app::battleinfoside::BattleInfoSide,
4328 ::unity::OptionalMethod,
4329 ) -> crate::app::battleparam::BattleParam = ::core::mem::transmute(__vi.method_ptr);
4330 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4331 __inner(__receiver, ::core::convert::Into::into(side), __mi)
4332 }
4333 }
4334 }
4335 #[doc = "`IsVisible()` overload"]
4336 fn is_visible(self) -> bool {
4337 unsafe {
4338 let __receiver =
4339 <UnitCalculator_SimplePowerCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4340 {
4341 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4342 let __vi = *__vt.get(43usize).unwrap_or_else(|| {
4343 panic!(
4344 "unity: virtual slot {}
4345 out of range (vtable len {}
4346) on the runtime class behind {}
4347 (method `{}
4348`)",
4349 43usize,
4350 __vt.len(),
4351 <UnitCalculator_SimplePowerCommand as ::unity::ClassIdentity>::NAME,
4352 "IsVisible",
4353 )
4354 });
4355 let __inner: extern "C" fn(UnitCalculator_SimplePowerCommand, ::unity::OptionalMethod) -> bool =
4356 ::core::mem::transmute(__vi.method_ptr);
4357 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4358 __inner(__receiver, __mi)
4359 }
4360 }
4361 }
4362 #[doc = "`.ctor()` overload"]
4363 fn ctor(self) -> () {
4364 unsafe {
4365 let __receiver =
4366 <UnitCalculator_SimplePowerCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4367 ::unity::il2cpp_call!((::unity::module_base()+0x1b4be80usize)as*mut u8,();
4368(UnitCalculator_SimplePowerCommand)__receiver)
4369 }
4370 }
4371}
4372
4373#[cfg(feature = "app-unitcalculator")]
4374impl<__T: IUnitCalculator_SimplePowerCommand> IUnitCalculator_SimplePowerCommandMethods for __T {}
4375
4376#[cfg(feature = "app-unitcalculator")]
4377impl UnitCalculator_SimplePowerCommand {
4378 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4379 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
4380 }
4381
4382 pub fn get_param_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4383 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
4384 }
4385
4386 pub fn is_visible_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4387 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
4388 }
4389
4390 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4391 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
4392 }
4393}
4394
4395#[cfg(feature = "app-unitcalculator")]
4396impl UnitCalculator_SimplePowerCommand {
4397 #[doc = "Direct (non-virtual) call to `UnitCalculator_SimplePowerCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4398 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
4399 let __mi = Self::get_name_method_info();
4400 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
4401 __inner(this.into(), ::core::option::Option::None)
4402 }
4403
4404 #[doc = "Direct (non-virtual) call to `UnitCalculator_SimplePowerCommand`'s own `GetParam`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4405 pub unsafe fn get_param(
4406 this: impl ::core::convert::Into<::unity::IlInstance>,
4407 side: crate::app::battleinfoside::BattleInfoSide,
4408 ) -> crate::app::battleparam::BattleParam {
4409 let __mi = Self::get_param_method_info();
4410 let __inner: extern "C" fn(
4411 ::unity::IlInstance,
4412 crate::app::battleinfoside::BattleInfoSide,
4413 ::unity::OptionalMethod,
4414 ) -> crate::app::battleparam::BattleParam = ::core::mem::transmute(__mi.method_ptr);
4415 __inner(this.into(), side, ::core::option::Option::None)
4416 }
4417
4418 #[doc = "Direct (non-virtual) call to `UnitCalculator_SimplePowerCommand`'s own `IsVisible`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4419 pub unsafe fn is_visible(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
4420 let __mi = Self::is_visible_method_info();
4421 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
4422 __inner(this.into(), ::core::option::Option::None)
4423 }
4424}
4425
4426#[cfg(feature = "app-unitcalculator")]
4427impl UnitCalculator_SimplePowerCommand {
4428 #[doc = "`.ctor()` — no args"]
4429 pub fn new() -> Self {
4430 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
4431 panic!(
4432 "{}
4433::{}
4434 failed to instantiate",
4435 ::core::stringify!(UnitCalculator_SimplePowerCommand),
4436 ::core::stringify!(new),
4437 )
4438 });
4439 <Self as IUnitCalculator_SimplePowerCommandMethods>::ctor(this);
4440 this
4441 }
4442}
4443
4444#[cfg(feature = "app-unitcalculator")]
4445pub trait IUnitCalculator_GodLevelCommandMethods: IUnitCalculator_GodLevelCommand {
4446 #[doc = "`get_Name()` overload"]
4447 fn get_name(self) -> ::unity::Il2CppString {
4448 unsafe {
4449 let __receiver =
4450 <UnitCalculator_GodLevelCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4451 {
4452 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4453 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
4454 panic!(
4455 "unity: virtual slot {}
4456 out of range (vtable len {}
4457) on the runtime class behind {}
4458 (method `{}
4459`)",
4460 4usize,
4461 __vt.len(),
4462 <UnitCalculator_GodLevelCommand as ::unity::ClassIdentity>::NAME,
4463 "get_Name",
4464 )
4465 });
4466 let __inner: extern "C" fn(UnitCalculator_GodLevelCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
4467 ::core::mem::transmute(__vi.method_ptr);
4468 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4469 __inner(__receiver, __mi)
4470 }
4471 }
4472 }
4473 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
4474 fn get_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
4475 unsafe {
4476 let __receiver =
4477 <UnitCalculator_GodLevelCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4478 {
4479 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4480 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
4481 panic!(
4482 "unity: virtual slot {}
4483 out of range (vtable len {}
4484) on the runtime class behind {}
4485 (method `{}
4486`)",
4487 30usize,
4488 __vt.len(),
4489 <UnitCalculator_GodLevelCommand as ::unity::ClassIdentity>::NAME,
4490 "GetImpl",
4491 )
4492 });
4493 let __inner: extern "C" fn(UnitCalculator_GodLevelCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
4494 ::core::mem::transmute(__vi.method_ptr);
4495 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4496 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
4497 }
4498 }
4499 }
4500 #[doc = "`.ctor()` overload"]
4501 fn ctor(self) -> () {
4502 unsafe {
4503 let __receiver =
4504 <UnitCalculator_GodLevelCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4505 ::unity::il2cpp_call!((::unity::module_base()+0x1b480b0usize)as*mut u8,();
4506(UnitCalculator_GodLevelCommand)__receiver)
4507 }
4508 }
4509}
4510
4511#[cfg(feature = "app-unitcalculator")]
4512impl<__T: IUnitCalculator_GodLevelCommand> IUnitCalculator_GodLevelCommandMethods for __T {}
4513
4514#[cfg(feature = "app-unitcalculator")]
4515impl UnitCalculator_GodLevelCommand {
4516 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4517 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
4518 }
4519
4520 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4521 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
4522 }
4523
4524 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4525 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
4526 }
4527}
4528
4529#[cfg(feature = "app-unitcalculator")]
4530impl UnitCalculator_GodLevelCommand {
4531 #[doc = "Direct (non-virtual) call to `UnitCalculator_GodLevelCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4532 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
4533 let __mi = Self::get_name_method_info();
4534 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
4535 __inner(this.into(), ::core::option::Option::None)
4536 }
4537
4538 #[doc = "Direct (non-virtual) call to `UnitCalculator_GodLevelCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4539 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
4540 let __mi = Self::get_impl_method_info();
4541 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
4542 ::core::mem::transmute(__mi.method_ptr);
4543 __inner(this.into(), unit, ::core::option::Option::None)
4544 }
4545}
4546
4547#[cfg(feature = "app-unitcalculator")]
4548impl UnitCalculator_GodLevelCommand {
4549 #[doc = "`.ctor()` — no args"]
4550 pub fn new() -> Self {
4551 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
4552 panic!(
4553 "{}
4554::{}
4555 failed to instantiate",
4556 ::core::stringify!(UnitCalculator_GodLevelCommand),
4557 ::core::stringify!(new),
4558 )
4559 });
4560 <Self as IUnitCalculator_GodLevelCommandMethods>::ctor(this);
4561 this
4562 }
4563}
4564
4565#[cfg(feature = "app-unitcalculator")]
4566pub trait IUnitCalculator_SecureCommandMethods: IUnitCalculator_SecureCommand {
4567 #[doc = "`get_Name()` overload"]
4568 fn get_name(self) -> ::unity::Il2CppString {
4569 unsafe {
4570 let __receiver =
4571 <UnitCalculator_SecureCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4572 {
4573 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4574 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
4575 panic!(
4576 "unity: virtual slot {}
4577 out of range (vtable len {}
4578) on the runtime class behind {}
4579 (method `{}
4580`)",
4581 4usize,
4582 __vt.len(),
4583 <UnitCalculator_SecureCommand as ::unity::ClassIdentity>::NAME,
4584 "get_Name",
4585 )
4586 });
4587 let __inner: extern "C" fn(UnitCalculator_SecureCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
4588 ::core::mem::transmute(__vi.method_ptr);
4589 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4590 __inner(__receiver, __mi)
4591 }
4592 }
4593 }
4594 #[doc = "`GetParam(crate::app::battleinfoside::BattleInfoSide)` overload"]
4595 fn get_param(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> crate::app::battleparam::BattleParam {
4596 unsafe {
4597 let __receiver =
4598 <UnitCalculator_SecureCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4599 {
4600 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4601 let __vi = *__vt.get(44usize).unwrap_or_else(|| {
4602 panic!(
4603 "unity: virtual slot {}
4604 out of range (vtable len {}
4605) on the runtime class behind {}
4606 (method `{}
4607`)",
4608 44usize,
4609 __vt.len(),
4610 <UnitCalculator_SecureCommand as ::unity::ClassIdentity>::NAME,
4611 "GetParam",
4612 )
4613 });
4614 let __inner: extern "C" fn(
4615 UnitCalculator_SecureCommand,
4616 crate::app::battleinfoside::BattleInfoSide,
4617 ::unity::OptionalMethod,
4618 ) -> crate::app::battleparam::BattleParam = ::core::mem::transmute(__vi.method_ptr);
4619 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4620 __inner(__receiver, ::core::convert::Into::into(side), __mi)
4621 }
4622 }
4623 }
4624 #[doc = "`IsVisible()` overload"]
4625 fn is_visible(self) -> bool {
4626 unsafe {
4627 let __receiver =
4628 <UnitCalculator_SecureCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4629 {
4630 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4631 let __vi = *__vt.get(43usize).unwrap_or_else(|| {
4632 panic!(
4633 "unity: virtual slot {}
4634 out of range (vtable len {}
4635) on the runtime class behind {}
4636 (method `{}
4637`)",
4638 43usize,
4639 __vt.len(),
4640 <UnitCalculator_SecureCommand as ::unity::ClassIdentity>::NAME,
4641 "IsVisible",
4642 )
4643 });
4644 let __inner: extern "C" fn(UnitCalculator_SecureCommand, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
4645 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4646 __inner(__receiver, __mi)
4647 }
4648 }
4649 }
4650 #[doc = "`.ctor()` overload"]
4651 fn ctor(self) -> () {
4652 unsafe {
4653 let __receiver =
4654 <UnitCalculator_SecureCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4655 ::unity::il2cpp_call!((::unity::module_base()+0x1b4bd00usize)as*mut u8,();
4656(UnitCalculator_SecureCommand)__receiver)
4657 }
4658 }
4659}
4660
4661#[cfg(feature = "app-unitcalculator")]
4662impl<__T: IUnitCalculator_SecureCommand> IUnitCalculator_SecureCommandMethods for __T {}
4663
4664#[cfg(feature = "app-unitcalculator")]
4665impl UnitCalculator_SecureCommand {
4666 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4667 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
4668 }
4669
4670 pub fn get_param_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4671 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
4672 }
4673
4674 pub fn is_visible_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4675 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
4676 }
4677
4678 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4679 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
4680 }
4681}
4682
4683#[cfg(feature = "app-unitcalculator")]
4684impl UnitCalculator_SecureCommand {
4685 #[doc = "Direct (non-virtual) call to `UnitCalculator_SecureCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4686 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
4687 let __mi = Self::get_name_method_info();
4688 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
4689 __inner(this.into(), ::core::option::Option::None)
4690 }
4691
4692 #[doc = "Direct (non-virtual) call to `UnitCalculator_SecureCommand`'s own `GetParam`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4693 pub unsafe fn get_param(
4694 this: impl ::core::convert::Into<::unity::IlInstance>,
4695 side: crate::app::battleinfoside::BattleInfoSide,
4696 ) -> crate::app::battleparam::BattleParam {
4697 let __mi = Self::get_param_method_info();
4698 let __inner: extern "C" fn(
4699 ::unity::IlInstance,
4700 crate::app::battleinfoside::BattleInfoSide,
4701 ::unity::OptionalMethod,
4702 ) -> crate::app::battleparam::BattleParam = ::core::mem::transmute(__mi.method_ptr);
4703 __inner(this.into(), side, ::core::option::Option::None)
4704 }
4705
4706 #[doc = "Direct (non-virtual) call to `UnitCalculator_SecureCommand`'s own `IsVisible`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4707 pub unsafe fn is_visible(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
4708 let __mi = Self::is_visible_method_info();
4709 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
4710 __inner(this.into(), ::core::option::Option::None)
4711 }
4712}
4713
4714#[cfg(feature = "app-unitcalculator")]
4715impl UnitCalculator_SecureCommand {
4716 #[doc = "`.ctor()` — no args"]
4717 pub fn new() -> Self {
4718 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
4719 panic!(
4720 "{}
4721::{}
4722 failed to instantiate",
4723 ::core::stringify!(UnitCalculator_SecureCommand),
4724 ::core::stringify!(new),
4725 )
4726 });
4727 <Self as IUnitCalculator_SecureCommandMethods>::ctor(this);
4728 this
4729 }
4730}
4731
4732#[cfg(feature = "app-unitcalculator")]
4733pub trait IUnitCalculator_RangeFriendCountCommandMethods: IUnitCalculator_RangeFriendCountCommand {
4734 #[doc = "`get_Name()` overload"]
4735 fn get_name(self) -> ::unity::Il2CppString {
4736 unsafe {
4737 let __receiver = <UnitCalculator_RangeFriendCountCommand as ::unity::FromIlInstance>::from_il_instance(
4738 <Self as ::unity::SystemObject>::as_instance(self),
4739 );
4740 {
4741 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4742 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
4743 panic!(
4744 "unity: virtual slot {}
4745 out of range (vtable len {}
4746) on the runtime class behind {}
4747 (method `{}
4748`)",
4749 4usize,
4750 __vt.len(),
4751 <UnitCalculator_RangeFriendCountCommand as ::unity::ClassIdentity>::NAME,
4752 "get_Name",
4753 )
4754 });
4755 let __inner: extern "C" fn(UnitCalculator_RangeFriendCountCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
4756 ::core::mem::transmute(__vi.method_ptr);
4757 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4758 __inner(__receiver, __mi)
4759 }
4760 }
4761 }
4762 #[doc = "`FuncImpl(crate::app::unit::Unit, crate::system::collections::generic::list_1::List_1<f32>)` overload"]
4763 fn func_impl(
4764 self,
4765 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
4766 args: impl ::core::convert::Into<crate::system::collections::generic::list_1::List_1<f32>>,
4767 ) -> f32 {
4768 unsafe {
4769 let __receiver = <UnitCalculator_RangeFriendCountCommand as ::unity::FromIlInstance>::from_il_instance(
4770 <Self as ::unity::SystemObject>::as_instance(self),
4771 );
4772 {
4773 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4774 let __vi = *__vt.get(34usize).unwrap_or_else(|| {
4775 panic!(
4776 "unity: virtual slot {}
4777 out of range (vtable len {}
4778) on the runtime class behind {}
4779 (method `{}
4780`)",
4781 34usize,
4782 __vt.len(),
4783 <UnitCalculator_RangeFriendCountCommand as ::unity::ClassIdentity>::NAME,
4784 "FuncImpl",
4785 )
4786 });
4787 let __inner: extern "C" fn(
4788 UnitCalculator_RangeFriendCountCommand,
4789 crate::app::unit::Unit,
4790 crate::system::collections::generic::list_1::List_1<f32>,
4791 ::unity::OptionalMethod,
4792 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
4793 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4794 __inner(__receiver, ::core::convert::Into::into(unit), ::core::convert::Into::into(args), __mi)
4795 }
4796 }
4797 }
4798 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
4799 fn get_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
4800 unsafe {
4801 let __receiver = <UnitCalculator_RangeFriendCountCommand as ::unity::FromIlInstance>::from_il_instance(
4802 <Self as ::unity::SystemObject>::as_instance(self),
4803 );
4804 {
4805 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4806 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
4807 panic!(
4808 "unity: virtual slot {}
4809 out of range (vtable len {}
4810) on the runtime class behind {}
4811 (method `{}
4812`)",
4813 30usize,
4814 __vt.len(),
4815 <UnitCalculator_RangeFriendCountCommand as ::unity::ClassIdentity>::NAME,
4816 "GetImpl",
4817 )
4818 });
4819 let __inner: extern "C" fn(UnitCalculator_RangeFriendCountCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
4820 ::core::mem::transmute(__vi.method_ptr);
4821 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4822 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
4823 }
4824 }
4825 }
4826 #[doc = "`.ctor()` overload"]
4827 fn ctor(self) -> () {
4828 unsafe {
4829 let __receiver = <UnitCalculator_RangeFriendCountCommand as ::unity::FromIlInstance>::from_il_instance(
4830 <Self as ::unity::SystemObject>::as_instance(self),
4831 );
4832 ::unity::il2cpp_call!((::unity::module_base()+0x1b4b570usize)as*mut u8,();
4833(UnitCalculator_RangeFriendCountCommand)__receiver)
4834 }
4835 }
4836}
4837
4838#[cfg(feature = "app-unitcalculator")]
4839impl<__T: IUnitCalculator_RangeFriendCountCommand> IUnitCalculator_RangeFriendCountCommandMethods for __T {}
4840
4841#[cfg(feature = "app-unitcalculator")]
4842impl UnitCalculator_RangeFriendCountCommand {
4843 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4844 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
4845 }
4846
4847 pub fn func_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4848 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
4849 }
4850
4851 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4852 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
4853 }
4854
4855 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4856 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
4857 }
4858}
4859
4860#[cfg(feature = "app-unitcalculator")]
4861impl UnitCalculator_RangeFriendCountCommand {
4862 #[doc = "Direct (non-virtual) call to `UnitCalculator_RangeFriendCountCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4863 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
4864 let __mi = Self::get_name_method_info();
4865 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
4866 __inner(this.into(), ::core::option::Option::None)
4867 }
4868
4869 #[doc = "Direct (non-virtual) call to `UnitCalculator_RangeFriendCountCommand`'s own `FuncImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4870 pub unsafe fn func_impl(
4871 this: impl ::core::convert::Into<::unity::IlInstance>,
4872 unit: crate::app::unit::Unit,
4873 args: crate::system::collections::generic::list_1::List_1<f32>,
4874 ) -> f32 {
4875 let __mi = Self::func_impl_method_info();
4876 let __inner: extern "C" fn(
4877 ::unity::IlInstance,
4878 crate::app::unit::Unit,
4879 crate::system::collections::generic::list_1::List_1<f32>,
4880 ::unity::OptionalMethod,
4881 ) -> f32 = ::core::mem::transmute(__mi.method_ptr);
4882 __inner(this.into(), unit, args, ::core::option::Option::None)
4883 }
4884
4885 #[doc = "Direct (non-virtual) call to `UnitCalculator_RangeFriendCountCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4886 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
4887 let __mi = Self::get_impl_method_info();
4888 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
4889 ::core::mem::transmute(__mi.method_ptr);
4890 __inner(this.into(), unit, ::core::option::Option::None)
4891 }
4892}
4893
4894#[cfg(feature = "app-unitcalculator")]
4895impl UnitCalculator_RangeFriendCountCommand {
4896 #[doc = "`.ctor()` — no args"]
4897 pub fn new() -> Self {
4898 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
4899 panic!(
4900 "{}
4901::{}
4902 failed to instantiate",
4903 ::core::stringify!(UnitCalculator_RangeFriendCountCommand),
4904 ::core::stringify!(new),
4905 )
4906 });
4907 <Self as IUnitCalculator_RangeFriendCountCommandMethods>::ctor(this);
4908 this
4909 }
4910}
4911
4912#[cfg(feature = "app-unitcalculator")]
4913pub trait IUnitCalculator_LinkMagicCommandMethods: IUnitCalculator_LinkMagicCommand {
4914 #[doc = "`get_Name()` overload"]
4915 fn get_name(self) -> ::unity::Il2CppString {
4916 unsafe {
4917 let __receiver =
4918 <UnitCalculator_LinkMagicCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4919 {
4920 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4921 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
4922 panic!(
4923 "unity: virtual slot {}
4924 out of range (vtable len {}
4925) on the runtime class behind {}
4926 (method `{}
4927`)",
4928 4usize,
4929 __vt.len(),
4930 <UnitCalculator_LinkMagicCommand as ::unity::ClassIdentity>::NAME,
4931 "get_Name",
4932 )
4933 });
4934 let __inner: extern "C" fn(UnitCalculator_LinkMagicCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
4935 ::core::mem::transmute(__vi.method_ptr);
4936 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4937 __inner(__receiver, __mi)
4938 }
4939 }
4940 }
4941 #[doc = "`get_CapabilityType()` overload"]
4942 fn get_capability_type(self) -> crate::app::capabilitydefinition::CapabilityDefinition_Type {
4943 unsafe {
4944 let __receiver =
4945 <UnitCalculator_LinkMagicCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4946 {
4947 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4948 let __vi = *__vt.get(44usize).unwrap_or_else(|| {
4949 panic!(
4950 "unity: virtual slot {}
4951 out of range (vtable len {}
4952) on the runtime class behind {}
4953 (method `{}
4954`)",
4955 44usize,
4956 __vt.len(),
4957 <UnitCalculator_LinkMagicCommand as ::unity::ClassIdentity>::NAME,
4958 "get_CapabilityType",
4959 )
4960 });
4961 let __inner: extern "C" fn(
4962 UnitCalculator_LinkMagicCommand,
4963 ::unity::OptionalMethod,
4964 ) -> crate::app::capabilitydefinition::CapabilityDefinition_Type = ::core::mem::transmute(__vi.method_ptr);
4965 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4966 __inner(__receiver, __mi)
4967 }
4968 }
4969 }
4970 #[doc = "`.ctor()` overload"]
4971 fn ctor(self) -> () {
4972 unsafe {
4973 let __receiver =
4974 <UnitCalculator_LinkMagicCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4975 ::unity::il2cpp_call!((::unity::module_base()+0x1b48b10usize)as*mut u8,();
4976(UnitCalculator_LinkMagicCommand)__receiver)
4977 }
4978 }
4979}
4980
4981#[cfg(feature = "app-unitcalculator")]
4982impl<__T: IUnitCalculator_LinkMagicCommand> IUnitCalculator_LinkMagicCommandMethods for __T {}
4983
4984#[cfg(feature = "app-unitcalculator")]
4985impl UnitCalculator_LinkMagicCommand {
4986 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4987 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
4988 }
4989
4990 pub fn get_capability_type_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4991 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
4992 }
4993
4994 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4995 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
4996 }
4997}
4998
4999#[cfg(feature = "app-unitcalculator")]
5000impl UnitCalculator_LinkMagicCommand {
5001 #[doc = "Direct (non-virtual) call to `UnitCalculator_LinkMagicCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5002 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
5003 let __mi = Self::get_name_method_info();
5004 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
5005 __inner(this.into(), ::core::option::Option::None)
5006 }
5007
5008 #[doc = "Direct (non-virtual) call to `UnitCalculator_LinkMagicCommand`'s own `get_CapabilityType`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5009 pub unsafe fn get_capability_type(
5010 this: impl ::core::convert::Into<::unity::IlInstance>,
5011 ) -> crate::app::capabilitydefinition::CapabilityDefinition_Type {
5012 let __mi = Self::get_capability_type_method_info();
5013 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::capabilitydefinition::CapabilityDefinition_Type =
5014 ::core::mem::transmute(__mi.method_ptr);
5015 __inner(this.into(), ::core::option::Option::None)
5016 }
5017}
5018
5019#[cfg(feature = "app-unitcalculator")]
5020impl UnitCalculator_LinkMagicCommand {
5021 #[doc = "`.ctor()` — no args"]
5022 pub fn new() -> Self {
5023 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
5024 panic!(
5025 "{}
5026::{}
5027 failed to instantiate",
5028 ::core::stringify!(UnitCalculator_LinkMagicCommand),
5029 ::core::stringify!(new),
5030 )
5031 });
5032 <Self as IUnitCalculator_LinkMagicCommandMethods>::ctor(this);
5033 this
5034 }
5035}
5036
5037#[cfg(feature = "app-unitcalculator")]
5038pub trait IUnitCalculator_BattleSceneResultBreakCommandMethods: IUnitCalculator_BattleSceneResultBreakCommand {
5039 #[doc = "`get_Name()` overload"]
5040 fn get_name(self) -> ::unity::Il2CppString {
5041 unsafe {
5042 let __receiver = <UnitCalculator_BattleSceneResultBreakCommand as ::unity::FromIlInstance>::from_il_instance(
5043 <Self as ::unity::SystemObject>::as_instance(self),
5044 );
5045 {
5046 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5047 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
5048 panic!(
5049 "unity: virtual slot {}
5050 out of range (vtable len {}
5051) on the runtime class behind {}
5052 (method `{}
5053`)",
5054 4usize,
5055 __vt.len(),
5056 <UnitCalculator_BattleSceneResultBreakCommand as ::unity::ClassIdentity>::NAME,
5057 "get_Name",
5058 )
5059 });
5060 let __inner: extern "C" fn(UnitCalculator_BattleSceneResultBreakCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
5061 ::core::mem::transmute(__vi.method_ptr);
5062 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5063 __inner(__receiver, __mi)
5064 }
5065 }
5066 }
5067 #[doc = "`Get()` overload"]
5068 fn get(self) -> f32 {
5069 unsafe {
5070 let __receiver = <UnitCalculator_BattleSceneResultBreakCommand as ::unity::FromIlInstance>::from_il_instance(
5071 <Self as ::unity::SystemObject>::as_instance(self),
5072 );
5073 {
5074 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5075 let __vi = *__vt.get(9usize).unwrap_or_else(|| {
5076 panic!(
5077 "unity: virtual slot {}
5078 out of range (vtable len {}
5079) on the runtime class behind {}
5080 (method `{}
5081`)",
5082 9usize,
5083 __vt.len(),
5084 <UnitCalculator_BattleSceneResultBreakCommand as ::unity::ClassIdentity>::NAME,
5085 "Get",
5086 )
5087 });
5088 let __inner: extern "C" fn(UnitCalculator_BattleSceneResultBreakCommand, ::unity::OptionalMethod) -> f32 =
5089 ::core::mem::transmute(__vi.method_ptr);
5090 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5091 __inner(__receiver, __mi)
5092 }
5093 }
5094 }
5095 #[doc = "`.ctor()` overload"]
5096 fn ctor(self) -> () {
5097 unsafe {
5098 let __receiver = <UnitCalculator_BattleSceneResultBreakCommand as ::unity::FromIlInstance>::from_il_instance(
5099 <Self as ::unity::SystemObject>::as_instance(self),
5100 );
5101 ::unity::il2cpp_call!((::unity::module_base()+0x1b46030usize)as*mut u8,();
5102(UnitCalculator_BattleSceneResultBreakCommand)__receiver)
5103 }
5104 }
5105}
5106
5107#[cfg(feature = "app-unitcalculator")]
5108impl<__T: IUnitCalculator_BattleSceneResultBreakCommand> IUnitCalculator_BattleSceneResultBreakCommandMethods for __T {}
5109
5110#[cfg(feature = "app-unitcalculator")]
5111impl UnitCalculator_BattleSceneResultBreakCommand {
5112 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5113 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
5114 }
5115
5116 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5117 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
5118 }
5119
5120 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5121 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
5122 }
5123}
5124
5125#[cfg(feature = "app-unitcalculator")]
5126impl UnitCalculator_BattleSceneResultBreakCommand {
5127 #[doc = "Direct (non-virtual) call to `UnitCalculator_BattleSceneResultBreakCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5128 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
5129 let __mi = Self::get_name_method_info();
5130 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
5131 __inner(this.into(), ::core::option::Option::None)
5132 }
5133
5134 #[doc = "Direct (non-virtual) call to `UnitCalculator_BattleSceneResultBreakCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5135 pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
5136 let __mi = Self::get_method_info();
5137 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
5138 __inner(this.into(), ::core::option::Option::None)
5139 }
5140}
5141
5142#[cfg(feature = "app-unitcalculator")]
5143impl UnitCalculator_BattleSceneResultBreakCommand {
5144 #[doc = "`.ctor()` — no args"]
5145 pub fn new() -> Self {
5146 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
5147 panic!(
5148 "{}
5149::{}
5150 failed to instantiate",
5151 ::core::stringify!(UnitCalculator_BattleSceneResultBreakCommand),
5152 ::core::stringify!(new),
5153 )
5154 });
5155 <Self as IUnitCalculator_BattleSceneResultBreakCommandMethods>::ctor(this);
5156 this
5157 }
5158}
5159
5160#[cfg(feature = "app-unitcalculator")]
5161pub trait IUnitCalculator_BattleDeadCommandMethods: IUnitCalculator_BattleDeadCommand {
5162 #[doc = "`get_Name()` overload"]
5163 fn get_name(self) -> ::unity::Il2CppString {
5164 unsafe {
5165 let __receiver =
5166 <UnitCalculator_BattleDeadCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
5167 {
5168 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5169 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
5170 panic!(
5171 "unity: virtual slot {}
5172 out of range (vtable len {}
5173) on the runtime class behind {}
5174 (method `{}
5175`)",
5176 4usize,
5177 __vt.len(),
5178 <UnitCalculator_BattleDeadCommand as ::unity::ClassIdentity>::NAME,
5179 "get_Name",
5180 )
5181 });
5182 let __inner: extern "C" fn(UnitCalculator_BattleDeadCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
5183 ::core::mem::transmute(__vi.method_ptr);
5184 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5185 __inner(__receiver, __mi)
5186 }
5187 }
5188 }
5189 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
5190 fn get_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
5191 unsafe {
5192 let __receiver =
5193 <UnitCalculator_BattleDeadCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
5194 {
5195 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5196 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
5197 panic!(
5198 "unity: virtual slot {}
5199 out of range (vtable len {}
5200) on the runtime class behind {}
5201 (method `{}
5202`)",
5203 30usize,
5204 __vt.len(),
5205 <UnitCalculator_BattleDeadCommand as ::unity::ClassIdentity>::NAME,
5206 "GetImpl",
5207 )
5208 });
5209 let __inner: extern "C" fn(UnitCalculator_BattleDeadCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
5210 ::core::mem::transmute(__vi.method_ptr);
5211 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5212 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
5213 }
5214 }
5215 }
5216 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
5217 fn get_impl_2(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
5218 unsafe {
5219 let __receiver =
5220 <UnitCalculator_BattleDeadCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
5221 {
5222 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5223 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
5224 panic!(
5225 "unity: virtual slot {}
5226 out of range (vtable len {}
5227) on the runtime class behind {}
5228 (method `{}
5229`)",
5230 31usize,
5231 __vt.len(),
5232 <UnitCalculator_BattleDeadCommand as ::unity::ClassIdentity>::NAME,
5233 "GetImpl",
5234 )
5235 });
5236 let __inner: extern "C" fn(
5237 UnitCalculator_BattleDeadCommand,
5238 crate::app::battleinfoside::BattleInfoSide,
5239 ::unity::OptionalMethod,
5240 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
5241 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5242 __inner(__receiver, ::core::convert::Into::into(side), __mi)
5243 }
5244 }
5245 }
5246 #[doc = "`.ctor()` overload"]
5247 fn ctor(self) -> () {
5248 unsafe {
5249 let __receiver =
5250 <UnitCalculator_BattleDeadCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
5251 ::unity::il2cpp_call!((::unity::module_base()+0x1b459f0usize)as*mut u8,();
5252(UnitCalculator_BattleDeadCommand)__receiver)
5253 }
5254 }
5255}
5256
5257#[cfg(feature = "app-unitcalculator")]
5258impl<__T: IUnitCalculator_BattleDeadCommand> IUnitCalculator_BattleDeadCommandMethods for __T {}
5259
5260#[cfg(feature = "app-unitcalculator")]
5261impl UnitCalculator_BattleDeadCommand {
5262 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5263 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
5264 }
5265
5266 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5267 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
5268 }
5269
5270 pub fn get_impl_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5271 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
5272 }
5273
5274 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5275 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
5276 }
5277}
5278
5279#[cfg(feature = "app-unitcalculator")]
5280impl UnitCalculator_BattleDeadCommand {
5281 #[doc = "Direct (non-virtual) call to `UnitCalculator_BattleDeadCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5282 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
5283 let __mi = Self::get_name_method_info();
5284 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
5285 __inner(this.into(), ::core::option::Option::None)
5286 }
5287
5288 #[doc = "Direct (non-virtual) call to `UnitCalculator_BattleDeadCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5289 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
5290 let __mi = Self::get_impl_method_info();
5291 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
5292 ::core::mem::transmute(__mi.method_ptr);
5293 __inner(this.into(), unit, ::core::option::Option::None)
5294 }
5295
5296 #[doc = "Direct (non-virtual) call to `UnitCalculator_BattleDeadCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5297 pub unsafe fn get_impl_2(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
5298 let __mi = Self::get_impl_2_method_info();
5299 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
5300 ::core::mem::transmute(__mi.method_ptr);
5301 __inner(this.into(), side, ::core::option::Option::None)
5302 }
5303}
5304
5305#[cfg(feature = "app-unitcalculator")]
5306impl UnitCalculator_BattleDeadCommand {
5307 #[doc = "`.ctor()` — no args"]
5308 pub fn new() -> Self {
5309 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
5310 panic!(
5311 "{}
5312::{}
5313 failed to instantiate",
5314 ::core::stringify!(UnitCalculator_BattleDeadCommand),
5315 ::core::stringify!(new),
5316 )
5317 });
5318 <Self as IUnitCalculator_BattleDeadCommandMethods>::ctor(this);
5319 this
5320 }
5321}
5322
5323#[cfg(feature = "app-unitcalculator")]
5324pub trait IUnitCalculator_ProbabilitySkillCommandMethods: IUnitCalculator_ProbabilitySkillCommand {
5325 #[doc = "`get_Name()` overload"]
5326 fn get_name(self) -> ::unity::Il2CppString {
5327 unsafe {
5328 let __receiver = <UnitCalculator_ProbabilitySkillCommand as ::unity::FromIlInstance>::from_il_instance(
5329 <Self as ::unity::SystemObject>::as_instance(self),
5330 );
5331 {
5332 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5333 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
5334 panic!(
5335 "unity: virtual slot {}
5336 out of range (vtable len {}
5337) on the runtime class behind {}
5338 (method `{}
5339`)",
5340 4usize,
5341 __vt.len(),
5342 <UnitCalculator_ProbabilitySkillCommand as ::unity::ClassIdentity>::NAME,
5343 "get_Name",
5344 )
5345 });
5346 let __inner: extern "C" fn(UnitCalculator_ProbabilitySkillCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
5347 ::core::mem::transmute(__vi.method_ptr);
5348 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5349 __inner(__receiver, __mi)
5350 }
5351 }
5352 }
5353 #[doc = "`GetCorrect(crate::app::unit::Unit)` overload"]
5354 fn get_correct(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
5355 unsafe {
5356 let __receiver = <UnitCalculator_ProbabilitySkillCommand as ::unity::FromIlInstance>::from_il_instance(
5357 <Self as ::unity::SystemObject>::as_instance(self),
5358 );
5359 {
5360 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5361 let __vi = *__vt.get(44usize).unwrap_or_else(|| {
5362 panic!(
5363 "unity: virtual slot {}
5364 out of range (vtable len {}
5365) on the runtime class behind {}
5366 (method `{}
5367`)",
5368 44usize,
5369 __vt.len(),
5370 <UnitCalculator_ProbabilitySkillCommand as ::unity::ClassIdentity>::NAME,
5371 "GetCorrect",
5372 )
5373 });
5374 let __inner: extern "C" fn(UnitCalculator_ProbabilitySkillCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
5375 ::core::mem::transmute(__vi.method_ptr);
5376 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5377 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
5378 }
5379 }
5380 }
5381 #[doc = "`GetCorrect(crate::app::battleinfoside::BattleInfoSide)` overload"]
5382 fn get_correct_2(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
5383 unsafe {
5384 let __receiver = <UnitCalculator_ProbabilitySkillCommand as ::unity::FromIlInstance>::from_il_instance(
5385 <Self as ::unity::SystemObject>::as_instance(self),
5386 );
5387 {
5388 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5389 let __vi = *__vt.get(45usize).unwrap_or_else(|| {
5390 panic!(
5391 "unity: virtual slot {}
5392 out of range (vtable len {}
5393) on the runtime class behind {}
5394 (method `{}
5395`)",
5396 45usize,
5397 __vt.len(),
5398 <UnitCalculator_ProbabilitySkillCommand as ::unity::ClassIdentity>::NAME,
5399 "GetCorrect",
5400 )
5401 });
5402 let __inner: extern "C" fn(
5403 UnitCalculator_ProbabilitySkillCommand,
5404 crate::app::battleinfoside::BattleInfoSide,
5405 ::unity::OptionalMethod,
5406 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
5407 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5408 __inner(__receiver, ::core::convert::Into::into(side), __mi)
5409 }
5410 }
5411 }
5412 #[doc = "`.ctor()` overload"]
5413 fn ctor(self) -> () {
5414 unsafe {
5415 let __receiver = <UnitCalculator_ProbabilitySkillCommand as ::unity::FromIlInstance>::from_il_instance(
5416 <Self as ::unity::SystemObject>::as_instance(self),
5417 );
5418 ::unity::il2cpp_call!((::unity::module_base()+0x1b4b0e0usize)as*mut u8,();
5419(UnitCalculator_ProbabilitySkillCommand)__receiver)
5420 }
5421 }
5422}
5423
5424#[cfg(feature = "app-unitcalculator")]
5425impl<__T: IUnitCalculator_ProbabilitySkillCommand> IUnitCalculator_ProbabilitySkillCommandMethods for __T {}
5426
5427#[cfg(feature = "app-unitcalculator")]
5428impl UnitCalculator_ProbabilitySkillCommand {
5429 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5430 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
5431 }
5432
5433 pub fn get_correct_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5434 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
5435 }
5436
5437 pub fn get_correct_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5438 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
5439 }
5440
5441 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5442 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
5443 }
5444}
5445
5446#[cfg(feature = "app-unitcalculator")]
5447impl UnitCalculator_ProbabilitySkillCommand {
5448 #[doc = "Direct (non-virtual) call to `UnitCalculator_ProbabilitySkillCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5449 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
5450 let __mi = Self::get_name_method_info();
5451 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
5452 __inner(this.into(), ::core::option::Option::None)
5453 }
5454
5455 #[doc = "Direct (non-virtual) call to `UnitCalculator_ProbabilitySkillCommand`'s own `GetCorrect`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5456 pub unsafe fn get_correct(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
5457 let __mi = Self::get_correct_method_info();
5458 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
5459 ::core::mem::transmute(__mi.method_ptr);
5460 __inner(this.into(), unit, ::core::option::Option::None)
5461 }
5462
5463 #[doc = "Direct (non-virtual) call to `UnitCalculator_ProbabilitySkillCommand`'s own `GetCorrect`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5464 pub unsafe fn get_correct_2(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
5465 let __mi = Self::get_correct_2_method_info();
5466 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
5467 ::core::mem::transmute(__mi.method_ptr);
5468 __inner(this.into(), side, ::core::option::Option::None)
5469 }
5470}
5471
5472#[cfg(feature = "app-unitcalculator")]
5473impl UnitCalculator_ProbabilitySkillCommand {
5474 #[doc = "`.ctor()` — no args"]
5475 pub fn new() -> Self {
5476 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
5477 panic!(
5478 "{}
5479::{}
5480 failed to instantiate",
5481 ::core::stringify!(UnitCalculator_ProbabilitySkillCommand),
5482 ::core::stringify!(new),
5483 )
5484 });
5485 <Self as IUnitCalculator_ProbabilitySkillCommandMethods>::ctor(this);
5486 this
5487 }
5488}
5489
5490#[cfg(feature = "app-unitcalculator")]
5491pub trait IUnitCalculator_BattleEscortCommandMethods: IUnitCalculator_BattleEscortCommand {
5492 #[doc = "`get_Name()` overload"]
5493 fn get_name(self) -> ::unity::Il2CppString {
5494 unsafe {
5495 let __receiver =
5496 <UnitCalculator_BattleEscortCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
5497 {
5498 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5499 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
5500 panic!(
5501 "unity: virtual slot {}
5502 out of range (vtable len {}
5503) on the runtime class behind {}
5504 (method `{}
5505`)",
5506 4usize,
5507 __vt.len(),
5508 <UnitCalculator_BattleEscortCommand as ::unity::ClassIdentity>::NAME,
5509 "get_Name",
5510 )
5511 });
5512 let __inner: extern "C" fn(UnitCalculator_BattleEscortCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
5513 ::core::mem::transmute(__vi.method_ptr);
5514 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5515 __inner(__receiver, __mi)
5516 }
5517 }
5518 }
5519 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
5520 fn get_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
5521 unsafe {
5522 let __receiver =
5523 <UnitCalculator_BattleEscortCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
5524 {
5525 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5526 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
5527 panic!(
5528 "unity: virtual slot {}
5529 out of range (vtable len {}
5530) on the runtime class behind {}
5531 (method `{}
5532`)",
5533 31usize,
5534 __vt.len(),
5535 <UnitCalculator_BattleEscortCommand as ::unity::ClassIdentity>::NAME,
5536 "GetImpl",
5537 )
5538 });
5539 let __inner: extern "C" fn(
5540 UnitCalculator_BattleEscortCommand,
5541 crate::app::battleinfoside::BattleInfoSide,
5542 ::unity::OptionalMethod,
5543 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
5544 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5545 __inner(__receiver, ::core::convert::Into::into(side), __mi)
5546 }
5547 }
5548 }
5549 #[doc = "`.ctor()` overload"]
5550 fn ctor(self) -> () {
5551 unsafe {
5552 let __receiver =
5553 <UnitCalculator_BattleEscortCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
5554 ::unity::il2cpp_call!((::unity::module_base()+0x1b45b70usize)as*mut u8,();
5555(UnitCalculator_BattleEscortCommand)__receiver)
5556 }
5557 }
5558}
5559
5560#[cfg(feature = "app-unitcalculator")]
5561impl<__T: IUnitCalculator_BattleEscortCommand> IUnitCalculator_BattleEscortCommandMethods for __T {}
5562
5563#[cfg(feature = "app-unitcalculator")]
5564impl UnitCalculator_BattleEscortCommand {
5565 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5566 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
5567 }
5568
5569 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5570 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
5571 }
5572
5573 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5574 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
5575 }
5576}
5577
5578#[cfg(feature = "app-unitcalculator")]
5579impl UnitCalculator_BattleEscortCommand {
5580 #[doc = "Direct (non-virtual) call to `UnitCalculator_BattleEscortCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5581 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
5582 let __mi = Self::get_name_method_info();
5583 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
5584 __inner(this.into(), ::core::option::Option::None)
5585 }
5586
5587 #[doc = "Direct (non-virtual) call to `UnitCalculator_BattleEscortCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5588 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
5589 let __mi = Self::get_impl_method_info();
5590 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
5591 ::core::mem::transmute(__mi.method_ptr);
5592 __inner(this.into(), side, ::core::option::Option::None)
5593 }
5594}
5595
5596#[cfg(feature = "app-unitcalculator")]
5597impl UnitCalculator_BattleEscortCommand {
5598 #[doc = "`.ctor()` — no args"]
5599 pub fn new() -> Self {
5600 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
5601 panic!(
5602 "{}
5603::{}
5604 failed to instantiate",
5605 ::core::stringify!(UnitCalculator_BattleEscortCommand),
5606 ::core::stringify!(new),
5607 )
5608 });
5609 <Self as IUnitCalculator_BattleEscortCommandMethods>::ctor(this);
5610 this
5611 }
5612}
5613
5614#[cfg(feature = "app-unitcalculator")]
5615pub trait IUnitCalculator_HitCommandMethods: IUnitCalculator_HitCommand {
5616 #[doc = "`get_Name()` overload"]
5617 fn get_name(self) -> ::unity::Il2CppString {
5618 unsafe {
5619 let __receiver =
5620 <UnitCalculator_HitCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
5621 {
5622 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5623 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
5624 panic!(
5625 "unity: virtual slot {}
5626 out of range (vtable len {}
5627) on the runtime class behind {}
5628 (method `{}
5629`)",
5630 4usize,
5631 __vt.len(),
5632 <UnitCalculator_HitCommand as ::unity::ClassIdentity>::NAME,
5633 "get_Name",
5634 )
5635 });
5636 let __inner: extern "C" fn(UnitCalculator_HitCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
5637 ::core::mem::transmute(__vi.method_ptr);
5638 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5639 __inner(__receiver, __mi)
5640 }
5641 }
5642 }
5643 #[doc = "`GetParam(crate::app::battleinfoside::BattleInfoSide)` overload"]
5644 fn get_param(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> crate::app::battleparam::BattleParam {
5645 unsafe {
5646 let __receiver =
5647 <UnitCalculator_HitCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
5648 {
5649 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5650 let __vi = *__vt.get(44usize).unwrap_or_else(|| {
5651 panic!(
5652 "unity: virtual slot {}
5653 out of range (vtable len {}
5654) on the runtime class behind {}
5655 (method `{}
5656`)",
5657 44usize,
5658 __vt.len(),
5659 <UnitCalculator_HitCommand as ::unity::ClassIdentity>::NAME,
5660 "GetParam",
5661 )
5662 });
5663 let __inner: extern "C" fn(
5664 UnitCalculator_HitCommand,
5665 crate::app::battleinfoside::BattleInfoSide,
5666 ::unity::OptionalMethod,
5667 ) -> crate::app::battleparam::BattleParam = ::core::mem::transmute(__vi.method_ptr);
5668 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5669 __inner(__receiver, ::core::convert::Into::into(side), __mi)
5670 }
5671 }
5672 }
5673 #[doc = "`IsVisible()` overload"]
5674 fn is_visible(self) -> bool {
5675 unsafe {
5676 let __receiver =
5677 <UnitCalculator_HitCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
5678 {
5679 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5680 let __vi = *__vt.get(43usize).unwrap_or_else(|| {
5681 panic!(
5682 "unity: virtual slot {}
5683 out of range (vtable len {}
5684) on the runtime class behind {}
5685 (method `{}
5686`)",
5687 43usize,
5688 __vt.len(),
5689 <UnitCalculator_HitCommand as ::unity::ClassIdentity>::NAME,
5690 "IsVisible",
5691 )
5692 });
5693 let __inner: extern "C" fn(UnitCalculator_HitCommand, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
5694 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5695 __inner(__receiver, __mi)
5696 }
5697 }
5698 }
5699 #[doc = "`.ctor()` overload"]
5700 fn ctor(self) -> () {
5701 unsafe {
5702 let __receiver =
5703 <UnitCalculator_HitCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
5704 ::unity::il2cpp_call!((::unity::module_base()+0x1b48550usize)as*mut u8,();
5705(UnitCalculator_HitCommand)__receiver)
5706 }
5707 }
5708}
5709
5710#[cfg(feature = "app-unitcalculator")]
5711impl<__T: IUnitCalculator_HitCommand> IUnitCalculator_HitCommandMethods for __T {}
5712
5713#[cfg(feature = "app-unitcalculator")]
5714impl UnitCalculator_HitCommand {
5715 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5716 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
5717 }
5718
5719 pub fn get_param_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5720 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
5721 }
5722
5723 pub fn is_visible_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5724 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
5725 }
5726
5727 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5728 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
5729 }
5730}
5731
5732#[cfg(feature = "app-unitcalculator")]
5733impl UnitCalculator_HitCommand {
5734 #[doc = "Direct (non-virtual) call to `UnitCalculator_HitCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5735 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
5736 let __mi = Self::get_name_method_info();
5737 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
5738 __inner(this.into(), ::core::option::Option::None)
5739 }
5740
5741 #[doc = "Direct (non-virtual) call to `UnitCalculator_HitCommand`'s own `GetParam`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5742 pub unsafe fn get_param(
5743 this: impl ::core::convert::Into<::unity::IlInstance>,
5744 side: crate::app::battleinfoside::BattleInfoSide,
5745 ) -> crate::app::battleparam::BattleParam {
5746 let __mi = Self::get_param_method_info();
5747 let __inner: extern "C" fn(
5748 ::unity::IlInstance,
5749 crate::app::battleinfoside::BattleInfoSide,
5750 ::unity::OptionalMethod,
5751 ) -> crate::app::battleparam::BattleParam = ::core::mem::transmute(__mi.method_ptr);
5752 __inner(this.into(), side, ::core::option::Option::None)
5753 }
5754
5755 #[doc = "Direct (non-virtual) call to `UnitCalculator_HitCommand`'s own `IsVisible`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5756 pub unsafe fn is_visible(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
5757 let __mi = Self::is_visible_method_info();
5758 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
5759 __inner(this.into(), ::core::option::Option::None)
5760 }
5761}
5762
5763#[cfg(feature = "app-unitcalculator")]
5764impl UnitCalculator_HitCommand {
5765 #[doc = "`.ctor()` — no args"]
5766 pub fn new() -> Self {
5767 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
5768 panic!(
5769 "{}
5770::{}
5771 failed to instantiate",
5772 ::core::stringify!(UnitCalculator_HitCommand),
5773 ::core::stringify!(new),
5774 )
5775 });
5776 <Self as IUnitCalculator_HitCommandMethods>::ctor(this);
5777 this
5778 }
5779}
5780
5781#[cfg(feature = "app-unitcalculator")]
5782pub trait IUnitCalculator_GainExpCommandMethods: IUnitCalculator_GainExpCommand {
5783 #[doc = "`get_Name()` overload"]
5784 fn get_name(self) -> ::unity::Il2CppString {
5785 unsafe {
5786 let __receiver =
5787 <UnitCalculator_GainExpCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
5788 {
5789 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5790 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
5791 panic!(
5792 "unity: virtual slot {}
5793 out of range (vtable len {}
5794) on the runtime class behind {}
5795 (method `{}
5796`)",
5797 4usize,
5798 __vt.len(),
5799 <UnitCalculator_GainExpCommand as ::unity::ClassIdentity>::NAME,
5800 "get_Name",
5801 )
5802 });
5803 let __inner: extern "C" fn(UnitCalculator_GainExpCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
5804 ::core::mem::transmute(__vi.method_ptr);
5805 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5806 __inner(__receiver, __mi)
5807 }
5808 }
5809 }
5810 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
5811 fn get_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
5812 unsafe {
5813 let __receiver =
5814 <UnitCalculator_GainExpCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
5815 {
5816 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5817 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
5818 panic!(
5819 "unity: virtual slot {}
5820 out of range (vtable len {}
5821) on the runtime class behind {}
5822 (method `{}
5823`)",
5824 31usize,
5825 __vt.len(),
5826 <UnitCalculator_GainExpCommand as ::unity::ClassIdentity>::NAME,
5827 "GetImpl",
5828 )
5829 });
5830 let __inner: extern "C" fn(
5831 UnitCalculator_GainExpCommand,
5832 crate::app::battleinfoside::BattleInfoSide,
5833 ::unity::OptionalMethod,
5834 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
5835 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5836 __inner(__receiver, ::core::convert::Into::into(side), __mi)
5837 }
5838 }
5839 }
5840 #[doc = "`SetImpl(crate::app::battleinfoside::BattleInfoSide, f32)` overload"]
5841 fn set_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>, value: impl ::core::convert::Into<f32>) -> () {
5842 unsafe {
5843 let __receiver =
5844 <UnitCalculator_GainExpCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
5845 {
5846 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5847 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
5848 panic!(
5849 "unity: virtual slot {}
5850 out of range (vtable len {}
5851) on the runtime class behind {}
5852 (method `{}
5853`)",
5854 33usize,
5855 __vt.len(),
5856 <UnitCalculator_GainExpCommand as ::unity::ClassIdentity>::NAME,
5857 "SetImpl",
5858 )
5859 });
5860 let __inner: extern "C" fn(
5861 UnitCalculator_GainExpCommand,
5862 crate::app::battleinfoside::BattleInfoSide,
5863 f32,
5864 ::unity::OptionalMethod,
5865 ) -> () = ::core::mem::transmute(__vi.method_ptr);
5866 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5867 __inner(__receiver, ::core::convert::Into::into(side), ::core::convert::Into::into(value), __mi)
5868 }
5869 }
5870 }
5871 #[doc = "`.ctor()` overload"]
5872 fn ctor(self) -> () {
5873 unsafe {
5874 let __receiver =
5875 <UnitCalculator_GainExpCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
5876 ::unity::il2cpp_call!((::unity::module_base()+0x1b47980usize)as*mut u8,();
5877(UnitCalculator_GainExpCommand)__receiver)
5878 }
5879 }
5880}
5881
5882#[cfg(feature = "app-unitcalculator")]
5883impl<__T: IUnitCalculator_GainExpCommand> IUnitCalculator_GainExpCommandMethods for __T {}
5884
5885#[cfg(feature = "app-unitcalculator")]
5886impl UnitCalculator_GainExpCommand {
5887 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5888 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
5889 }
5890
5891 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5892 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
5893 }
5894
5895 pub fn set_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5896 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
5897 }
5898
5899 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5900 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
5901 }
5902}
5903
5904#[cfg(feature = "app-unitcalculator")]
5905impl UnitCalculator_GainExpCommand {
5906 #[doc = "Direct (non-virtual) call to `UnitCalculator_GainExpCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5907 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
5908 let __mi = Self::get_name_method_info();
5909 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
5910 __inner(this.into(), ::core::option::Option::None)
5911 }
5912
5913 #[doc = "Direct (non-virtual) call to `UnitCalculator_GainExpCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5914 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
5915 let __mi = Self::get_impl_method_info();
5916 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
5917 ::core::mem::transmute(__mi.method_ptr);
5918 __inner(this.into(), side, ::core::option::Option::None)
5919 }
5920
5921 #[doc = "Direct (non-virtual) call to `UnitCalculator_GainExpCommand`'s own `SetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5922 pub unsafe fn set_impl(
5923 this: impl ::core::convert::Into<::unity::IlInstance>,
5924 side: crate::app::battleinfoside::BattleInfoSide,
5925 value: f32,
5926 ) -> () {
5927 let __mi = Self::set_impl_method_info();
5928 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, f32, ::unity::OptionalMethod) -> () =
5929 ::core::mem::transmute(__mi.method_ptr);
5930 __inner(this.into(), side, value, ::core::option::Option::None)
5931 }
5932}
5933
5934#[cfg(feature = "app-unitcalculator")]
5935impl UnitCalculator_GainExpCommand {
5936 #[doc = "`.ctor()` — no args"]
5937 pub fn new() -> Self {
5938 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
5939 panic!(
5940 "{}
5941::{}
5942 failed to instantiate",
5943 ::core::stringify!(UnitCalculator_GainExpCommand),
5944 ::core::stringify!(new),
5945 )
5946 });
5947 <Self as IUnitCalculator_GainExpCommandMethods>::ctor(this);
5948 this
5949 }
5950}
5951
5952#[cfg(feature = "app-unitcalculator")]
5953pub trait IUnitCalculator_BattleSceneResultHitCommandMethods: IUnitCalculator_BattleSceneResultHitCommand {
5954 #[doc = "`get_Name()` overload"]
5955 fn get_name(self) -> ::unity::Il2CppString {
5956 unsafe {
5957 let __receiver = <UnitCalculator_BattleSceneResultHitCommand as ::unity::FromIlInstance>::from_il_instance(
5958 <Self as ::unity::SystemObject>::as_instance(self),
5959 );
5960 {
5961 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5962 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
5963 panic!(
5964 "unity: virtual slot {}
5965 out of range (vtable len {}
5966) on the runtime class behind {}
5967 (method `{}
5968`)",
5969 4usize,
5970 __vt.len(),
5971 <UnitCalculator_BattleSceneResultHitCommand as ::unity::ClassIdentity>::NAME,
5972 "get_Name",
5973 )
5974 });
5975 let __inner: extern "C" fn(UnitCalculator_BattleSceneResultHitCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
5976 ::core::mem::transmute(__vi.method_ptr);
5977 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5978 __inner(__receiver, __mi)
5979 }
5980 }
5981 }
5982 #[doc = "`Get()` overload"]
5983 fn get(self) -> f32 {
5984 unsafe {
5985 let __receiver = <UnitCalculator_BattleSceneResultHitCommand as ::unity::FromIlInstance>::from_il_instance(
5986 <Self as ::unity::SystemObject>::as_instance(self),
5987 );
5988 {
5989 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5990 let __vi = *__vt.get(9usize).unwrap_or_else(|| {
5991 panic!(
5992 "unity: virtual slot {}
5993 out of range (vtable len {}
5994) on the runtime class behind {}
5995 (method `{}
5996`)",
5997 9usize,
5998 __vt.len(),
5999 <UnitCalculator_BattleSceneResultHitCommand as ::unity::ClassIdentity>::NAME,
6000 "Get",
6001 )
6002 });
6003 let __inner: extern "C" fn(UnitCalculator_BattleSceneResultHitCommand, ::unity::OptionalMethod) -> f32 =
6004 ::core::mem::transmute(__vi.method_ptr);
6005 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
6006 __inner(__receiver, __mi)
6007 }
6008 }
6009 }
6010 #[doc = "`.ctor()` overload"]
6011 fn ctor(self) -> () {
6012 unsafe {
6013 let __receiver = <UnitCalculator_BattleSceneResultHitCommand as ::unity::FromIlInstance>::from_il_instance(
6014 <Self as ::unity::SystemObject>::as_instance(self),
6015 );
6016 ::unity::il2cpp_call!((::unity::module_base()+0x1b463a0usize)as*mut u8,();
6017(UnitCalculator_BattleSceneResultHitCommand)__receiver)
6018 }
6019 }
6020}
6021
6022#[cfg(feature = "app-unitcalculator")]
6023impl<__T: IUnitCalculator_BattleSceneResultHitCommand> IUnitCalculator_BattleSceneResultHitCommandMethods for __T {}
6024
6025#[cfg(feature = "app-unitcalculator")]
6026impl UnitCalculator_BattleSceneResultHitCommand {
6027 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6028 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
6029 }
6030
6031 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6032 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
6033 }
6034
6035 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6036 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
6037 }
6038}
6039
6040#[cfg(feature = "app-unitcalculator")]
6041impl UnitCalculator_BattleSceneResultHitCommand {
6042 #[doc = "Direct (non-virtual) call to `UnitCalculator_BattleSceneResultHitCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6043 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
6044 let __mi = Self::get_name_method_info();
6045 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
6046 __inner(this.into(), ::core::option::Option::None)
6047 }
6048
6049 #[doc = "Direct (non-virtual) call to `UnitCalculator_BattleSceneResultHitCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6050 pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
6051 let __mi = Self::get_method_info();
6052 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
6053 __inner(this.into(), ::core::option::Option::None)
6054 }
6055}
6056
6057#[cfg(feature = "app-unitcalculator")]
6058impl UnitCalculator_BattleSceneResultHitCommand {
6059 #[doc = "`.ctor()` — no args"]
6060 pub fn new() -> Self {
6061 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
6062 panic!(
6063 "{}
6064::{}
6065 failed to instantiate",
6066 ::core::stringify!(UnitCalculator_BattleSceneResultHitCommand),
6067 ::core::stringify!(new),
6068 )
6069 });
6070 <Self as IUnitCalculator_BattleSceneResultHitCommandMethods>::ctor(this);
6071 this
6072 }
6073}
6074
6075#[cfg(feature = "app-unitcalculator")]
6076pub trait IUnitCalculator_ForceCommandMethods: IUnitCalculator_ForceCommand {
6077 #[doc = "`get_Name()` overload"]
6078 fn get_name(self) -> ::unity::Il2CppString {
6079 unsafe {
6080 let __receiver =
6081 <UnitCalculator_ForceCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6082 {
6083 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
6084 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
6085 panic!(
6086 "unity: virtual slot {}
6087 out of range (vtable len {}
6088) on the runtime class behind {}
6089 (method `{}
6090`)",
6091 4usize,
6092 __vt.len(),
6093 <UnitCalculator_ForceCommand as ::unity::ClassIdentity>::NAME,
6094 "get_Name",
6095 )
6096 });
6097 let __inner: extern "C" fn(UnitCalculator_ForceCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
6098 ::core::mem::transmute(__vi.method_ptr);
6099 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
6100 __inner(__receiver, __mi)
6101 }
6102 }
6103 }
6104 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
6105 fn get_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
6106 unsafe {
6107 let __receiver =
6108 <UnitCalculator_ForceCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6109 {
6110 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
6111 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
6112 panic!(
6113 "unity: virtual slot {}
6114 out of range (vtable len {}
6115) on the runtime class behind {}
6116 (method `{}
6117`)",
6118 30usize,
6119 __vt.len(),
6120 <UnitCalculator_ForceCommand as ::unity::ClassIdentity>::NAME,
6121 "GetImpl",
6122 )
6123 });
6124 let __inner: extern "C" fn(UnitCalculator_ForceCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
6125 ::core::mem::transmute(__vi.method_ptr);
6126 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
6127 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
6128 }
6129 }
6130 }
6131 #[doc = "`GetInvalid()` overload"]
6132 fn get_invalid(self) -> f32 {
6133 unsafe {
6134 let __receiver =
6135 <UnitCalculator_ForceCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6136 {
6137 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
6138 let __vi = *__vt.get(42usize).unwrap_or_else(|| {
6139 panic!(
6140 "unity: virtual slot {}
6141 out of range (vtable len {}
6142) on the runtime class behind {}
6143 (method `{}
6144`)",
6145 42usize,
6146 __vt.len(),
6147 <UnitCalculator_ForceCommand as ::unity::ClassIdentity>::NAME,
6148 "GetInvalid",
6149 )
6150 });
6151 let __inner: extern "C" fn(UnitCalculator_ForceCommand, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__vi.method_ptr);
6152 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
6153 __inner(__receiver, __mi)
6154 }
6155 }
6156 }
6157 #[doc = "`.ctor()` overload"]
6158 fn ctor(self) -> () {
6159 unsafe {
6160 let __receiver =
6161 <UnitCalculator_ForceCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6162 ::unity::il2cpp_call!((::unity::module_base()+0x1b478e0usize)as*mut u8,();
6163(UnitCalculator_ForceCommand)__receiver)
6164 }
6165 }
6166}
6167
6168#[cfg(feature = "app-unitcalculator")]
6169impl<__T: IUnitCalculator_ForceCommand> IUnitCalculator_ForceCommandMethods for __T {}
6170
6171#[cfg(feature = "app-unitcalculator")]
6172impl UnitCalculator_ForceCommand {
6173 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6174 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
6175 }
6176
6177 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6178 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
6179 }
6180
6181 pub fn get_invalid_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6182 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
6183 }
6184
6185 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6186 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
6187 }
6188}
6189
6190#[cfg(feature = "app-unitcalculator")]
6191impl UnitCalculator_ForceCommand {
6192 #[doc = "Direct (non-virtual) call to `UnitCalculator_ForceCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6193 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
6194 let __mi = Self::get_name_method_info();
6195 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
6196 __inner(this.into(), ::core::option::Option::None)
6197 }
6198
6199 #[doc = "Direct (non-virtual) call to `UnitCalculator_ForceCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6200 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
6201 let __mi = Self::get_impl_method_info();
6202 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
6203 ::core::mem::transmute(__mi.method_ptr);
6204 __inner(this.into(), unit, ::core::option::Option::None)
6205 }
6206
6207 #[doc = "Direct (non-virtual) call to `UnitCalculator_ForceCommand`'s own `GetInvalid`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6208 pub unsafe fn get_invalid(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
6209 let __mi = Self::get_invalid_method_info();
6210 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
6211 __inner(this.into(), ::core::option::Option::None)
6212 }
6213}
6214
6215#[cfg(feature = "app-unitcalculator")]
6216impl UnitCalculator_ForceCommand {
6217 #[doc = "`.ctor()` — no args"]
6218 pub fn new() -> Self {
6219 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
6220 panic!(
6221 "{}
6222::{}
6223 failed to instantiate",
6224 ::core::stringify!(UnitCalculator_ForceCommand),
6225 ::core::stringify!(new),
6226 )
6227 });
6228 <Self as IUnitCalculator_ForceCommandMethods>::ctor(this);
6229 this
6230 }
6231}
6232
6233#[cfg(feature = "app-unitcalculator")]
6234pub trait IUnitCalculator_DamageCommandMethods: IUnitCalculator_DamageCommand {
6235 #[doc = "`get_Name()` overload"]
6236 fn get_name(self) -> ::unity::Il2CppString {
6237 unsafe {
6238 let __receiver =
6239 <UnitCalculator_DamageCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6240 {
6241 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
6242 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
6243 panic!(
6244 "unity: virtual slot {}
6245 out of range (vtable len {}
6246) on the runtime class behind {}
6247 (method `{}
6248`)",
6249 4usize,
6250 __vt.len(),
6251 <UnitCalculator_DamageCommand as ::unity::ClassIdentity>::NAME,
6252 "get_Name",
6253 )
6254 });
6255 let __inner: extern "C" fn(UnitCalculator_DamageCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
6256 ::core::mem::transmute(__vi.method_ptr);
6257 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
6258 __inner(__receiver, __mi)
6259 }
6260 }
6261 }
6262 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
6263 fn get_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
6264 unsafe {
6265 let __receiver =
6266 <UnitCalculator_DamageCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6267 {
6268 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
6269 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
6270 panic!(
6271 "unity: virtual slot {}
6272 out of range (vtable len {}
6273) on the runtime class behind {}
6274 (method `{}
6275`)",
6276 31usize,
6277 __vt.len(),
6278 <UnitCalculator_DamageCommand as ::unity::ClassIdentity>::NAME,
6279 "GetImpl",
6280 )
6281 });
6282 let __inner: extern "C" fn(UnitCalculator_DamageCommand, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
6283 ::core::mem::transmute(__vi.method_ptr);
6284 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
6285 __inner(__receiver, ::core::convert::Into::into(side), __mi)
6286 }
6287 }
6288 }
6289 #[doc = "`SetImpl(crate::app::battleinfoside::BattleInfoSide, f32)` overload"]
6290 fn set_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>, value: impl ::core::convert::Into<f32>) -> () {
6291 unsafe {
6292 let __receiver =
6293 <UnitCalculator_DamageCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6294 {
6295 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
6296 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
6297 panic!(
6298 "unity: virtual slot {}
6299 out of range (vtable len {}
6300) on the runtime class behind {}
6301 (method `{}
6302`)",
6303 33usize,
6304 __vt.len(),
6305 <UnitCalculator_DamageCommand as ::unity::ClassIdentity>::NAME,
6306 "SetImpl",
6307 )
6308 });
6309 let __inner: extern "C" fn(
6310 UnitCalculator_DamageCommand,
6311 crate::app::battleinfoside::BattleInfoSide,
6312 f32,
6313 ::unity::OptionalMethod,
6314 ) -> () = ::core::mem::transmute(__vi.method_ptr);
6315 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
6316 __inner(__receiver, ::core::convert::Into::into(side), ::core::convert::Into::into(value), __mi)
6317 }
6318 }
6319 }
6320 #[doc = "`.ctor()` overload"]
6321 fn ctor(self) -> () {
6322 unsafe {
6323 let __receiver =
6324 <UnitCalculator_DamageCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6325 ::unity::il2cpp_call!((::unity::module_base()+0x1b46ad0usize)as*mut u8,();
6326(UnitCalculator_DamageCommand)__receiver)
6327 }
6328 }
6329}
6330
6331#[cfg(feature = "app-unitcalculator")]
6332impl<__T: IUnitCalculator_DamageCommand> IUnitCalculator_DamageCommandMethods for __T {}
6333
6334#[cfg(feature = "app-unitcalculator")]
6335impl UnitCalculator_DamageCommand {
6336 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6337 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
6338 }
6339
6340 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6341 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
6342 }
6343
6344 pub fn set_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6345 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
6346 }
6347
6348 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6349 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
6350 }
6351}
6352
6353#[cfg(feature = "app-unitcalculator")]
6354impl UnitCalculator_DamageCommand {
6355 #[doc = "Direct (non-virtual) call to `UnitCalculator_DamageCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6356 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
6357 let __mi = Self::get_name_method_info();
6358 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
6359 __inner(this.into(), ::core::option::Option::None)
6360 }
6361
6362 #[doc = "Direct (non-virtual) call to `UnitCalculator_DamageCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6363 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
6364 let __mi = Self::get_impl_method_info();
6365 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
6366 ::core::mem::transmute(__mi.method_ptr);
6367 __inner(this.into(), side, ::core::option::Option::None)
6368 }
6369
6370 #[doc = "Direct (non-virtual) call to `UnitCalculator_DamageCommand`'s own `SetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6371 pub unsafe fn set_impl(
6372 this: impl ::core::convert::Into<::unity::IlInstance>,
6373 side: crate::app::battleinfoside::BattleInfoSide,
6374 value: f32,
6375 ) -> () {
6376 let __mi = Self::set_impl_method_info();
6377 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, f32, ::unity::OptionalMethod) -> () =
6378 ::core::mem::transmute(__mi.method_ptr);
6379 __inner(this.into(), side, value, ::core::option::Option::None)
6380 }
6381}
6382
6383#[cfg(feature = "app-unitcalculator")]
6384impl UnitCalculator_DamageCommand {
6385 #[doc = "`.ctor()` — no args"]
6386 pub fn new() -> Self {
6387 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
6388 panic!(
6389 "{}
6390::{}
6391 failed to instantiate",
6392 ::core::stringify!(UnitCalculator_DamageCommand),
6393 ::core::stringify!(new),
6394 )
6395 });
6396 <Self as IUnitCalculator_DamageCommandMethods>::ctor(this);
6397 this
6398 }
6399}
6400
6401#[cfg(feature = "app-unitcalculator")]
6402pub trait IUnitCalculator_BattleChainGuardCountCommandMethods: IUnitCalculator_BattleChainGuardCountCommand {
6403 #[doc = "`get_Name()` overload"]
6404 fn get_name(self) -> ::unity::Il2CppString {
6405 unsafe {
6406 let __receiver = <UnitCalculator_BattleChainGuardCountCommand as ::unity::FromIlInstance>::from_il_instance(
6407 <Self as ::unity::SystemObject>::as_instance(self),
6408 );
6409 {
6410 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
6411 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
6412 panic!(
6413 "unity: virtual slot {}
6414 out of range (vtable len {}
6415) on the runtime class behind {}
6416 (method `{}
6417`)",
6418 4usize,
6419 __vt.len(),
6420 <UnitCalculator_BattleChainGuardCountCommand as ::unity::ClassIdentity>::NAME,
6421 "get_Name",
6422 )
6423 });
6424 let __inner: extern "C" fn(UnitCalculator_BattleChainGuardCountCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
6425 ::core::mem::transmute(__vi.method_ptr);
6426 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
6427 __inner(__receiver, __mi)
6428 }
6429 }
6430 }
6431 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
6432 fn get_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
6433 unsafe {
6434 let __receiver = <UnitCalculator_BattleChainGuardCountCommand as ::unity::FromIlInstance>::from_il_instance(
6435 <Self as ::unity::SystemObject>::as_instance(self),
6436 );
6437 {
6438 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
6439 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
6440 panic!(
6441 "unity: virtual slot {}
6442 out of range (vtable len {}
6443) on the runtime class behind {}
6444 (method `{}
6445`)",
6446 31usize,
6447 __vt.len(),
6448 <UnitCalculator_BattleChainGuardCountCommand as ::unity::ClassIdentity>::NAME,
6449 "GetImpl",
6450 )
6451 });
6452 let __inner: extern "C" fn(
6453 UnitCalculator_BattleChainGuardCountCommand,
6454 crate::app::battleinfoside::BattleInfoSide,
6455 ::unity::OptionalMethod,
6456 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
6457 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
6458 __inner(__receiver, ::core::convert::Into::into(side), __mi)
6459 }
6460 }
6461 }
6462 #[doc = "`.ctor()` overload"]
6463 fn ctor(self) -> () {
6464 unsafe {
6465 let __receiver = <UnitCalculator_BattleChainGuardCountCommand as ::unity::FromIlInstance>::from_il_instance(
6466 <Self as ::unity::SystemObject>::as_instance(self),
6467 );
6468 ::unity::il2cpp_call!((::unity::module_base()+0x1b458b0usize)as*mut u8,();
6469(UnitCalculator_BattleChainGuardCountCommand)__receiver)
6470 }
6471 }
6472}
6473
6474#[cfg(feature = "app-unitcalculator")]
6475impl<__T: IUnitCalculator_BattleChainGuardCountCommand> IUnitCalculator_BattleChainGuardCountCommandMethods for __T {}
6476
6477#[cfg(feature = "app-unitcalculator")]
6478impl UnitCalculator_BattleChainGuardCountCommand {
6479 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6480 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
6481 }
6482
6483 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6484 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
6485 }
6486
6487 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6488 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
6489 }
6490}
6491
6492#[cfg(feature = "app-unitcalculator")]
6493impl UnitCalculator_BattleChainGuardCountCommand {
6494 #[doc = "Direct (non-virtual) call to `UnitCalculator_BattleChainGuardCountCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6495 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
6496 let __mi = Self::get_name_method_info();
6497 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
6498 __inner(this.into(), ::core::option::Option::None)
6499 }
6500
6501 #[doc = "Direct (non-virtual) call to `UnitCalculator_BattleChainGuardCountCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6502 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
6503 let __mi = Self::get_impl_method_info();
6504 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
6505 ::core::mem::transmute(__mi.method_ptr);
6506 __inner(this.into(), side, ::core::option::Option::None)
6507 }
6508}
6509
6510#[cfg(feature = "app-unitcalculator")]
6511impl UnitCalculator_BattleChainGuardCountCommand {
6512 #[doc = "`.ctor()` — no args"]
6513 pub fn new() -> Self {
6514 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
6515 panic!(
6516 "{}
6517::{}
6518 failed to instantiate",
6519 ::core::stringify!(UnitCalculator_BattleChainGuardCountCommand),
6520 ::core::stringify!(new),
6521 )
6522 });
6523 <Self as IUnitCalculator_BattleChainGuardCountCommandMethods>::ctor(this);
6524 this
6525 }
6526}
6527
6528#[cfg(feature = "app-unitcalculator")]
6529pub trait IUnitCalculator_ProbabilityGodSkillCommandMethods: IUnitCalculator_ProbabilityGodSkillCommand {
6530 #[doc = "`get_Name()` overload"]
6531 fn get_name(self) -> ::unity::Il2CppString {
6532 unsafe {
6533 let __receiver = <UnitCalculator_ProbabilityGodSkillCommand as ::unity::FromIlInstance>::from_il_instance(
6534 <Self as ::unity::SystemObject>::as_instance(self),
6535 );
6536 {
6537 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
6538 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
6539 panic!(
6540 "unity: virtual slot {}
6541 out of range (vtable len {}
6542) on the runtime class behind {}
6543 (method `{}
6544`)",
6545 4usize,
6546 __vt.len(),
6547 <UnitCalculator_ProbabilityGodSkillCommand as ::unity::ClassIdentity>::NAME,
6548 "get_Name",
6549 )
6550 });
6551 let __inner: extern "C" fn(UnitCalculator_ProbabilityGodSkillCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
6552 ::core::mem::transmute(__vi.method_ptr);
6553 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
6554 __inner(__receiver, __mi)
6555 }
6556 }
6557 }
6558 #[doc = "`GetCorrect(crate::app::unit::Unit)` overload"]
6559 fn get_correct(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
6560 unsafe {
6561 let __receiver = <UnitCalculator_ProbabilityGodSkillCommand as ::unity::FromIlInstance>::from_il_instance(
6562 <Self as ::unity::SystemObject>::as_instance(self),
6563 );
6564 {
6565 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
6566 let __vi = *__vt.get(44usize).unwrap_or_else(|| {
6567 panic!(
6568 "unity: virtual slot {}
6569 out of range (vtable len {}
6570) on the runtime class behind {}
6571 (method `{}
6572`)",
6573 44usize,
6574 __vt.len(),
6575 <UnitCalculator_ProbabilityGodSkillCommand as ::unity::ClassIdentity>::NAME,
6576 "GetCorrect",
6577 )
6578 });
6579 let __inner: extern "C" fn(UnitCalculator_ProbabilityGodSkillCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
6580 ::core::mem::transmute(__vi.method_ptr);
6581 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
6582 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
6583 }
6584 }
6585 }
6586 #[doc = "`GetCorrect(crate::app::battleinfoside::BattleInfoSide)` overload"]
6587 fn get_correct_2(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
6588 unsafe {
6589 let __receiver = <UnitCalculator_ProbabilityGodSkillCommand as ::unity::FromIlInstance>::from_il_instance(
6590 <Self as ::unity::SystemObject>::as_instance(self),
6591 );
6592 {
6593 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
6594 let __vi = *__vt.get(45usize).unwrap_or_else(|| {
6595 panic!(
6596 "unity: virtual slot {}
6597 out of range (vtable len {}
6598) on the runtime class behind {}
6599 (method `{}
6600`)",
6601 45usize,
6602 __vt.len(),
6603 <UnitCalculator_ProbabilityGodSkillCommand as ::unity::ClassIdentity>::NAME,
6604 "GetCorrect",
6605 )
6606 });
6607 let __inner: extern "C" fn(
6608 UnitCalculator_ProbabilityGodSkillCommand,
6609 crate::app::battleinfoside::BattleInfoSide,
6610 ::unity::OptionalMethod,
6611 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
6612 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
6613 __inner(__receiver, ::core::convert::Into::into(side), __mi)
6614 }
6615 }
6616 }
6617 #[doc = "`.ctor()` overload"]
6618 fn ctor(self) -> () {
6619 unsafe {
6620 let __receiver = <UnitCalculator_ProbabilityGodSkillCommand as ::unity::FromIlInstance>::from_il_instance(
6621 <Self as ::unity::SystemObject>::as_instance(self),
6622 );
6623 ::unity::il2cpp_call!((::unity::module_base()+0x1b4b050usize)as*mut u8,();
6624(UnitCalculator_ProbabilityGodSkillCommand)__receiver)
6625 }
6626 }
6627}
6628
6629#[cfg(feature = "app-unitcalculator")]
6630impl<__T: IUnitCalculator_ProbabilityGodSkillCommand> IUnitCalculator_ProbabilityGodSkillCommandMethods for __T {}
6631
6632#[cfg(feature = "app-unitcalculator")]
6633impl UnitCalculator_ProbabilityGodSkillCommand {
6634 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6635 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
6636 }
6637
6638 pub fn get_correct_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6639 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
6640 }
6641
6642 pub fn get_correct_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6643 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
6644 }
6645
6646 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6647 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
6648 }
6649}
6650
6651#[cfg(feature = "app-unitcalculator")]
6652impl UnitCalculator_ProbabilityGodSkillCommand {
6653 #[doc = "Direct (non-virtual) call to `UnitCalculator_ProbabilityGodSkillCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6654 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
6655 let __mi = Self::get_name_method_info();
6656 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
6657 __inner(this.into(), ::core::option::Option::None)
6658 }
6659
6660 #[doc = "Direct (non-virtual) call to `UnitCalculator_ProbabilityGodSkillCommand`'s own `GetCorrect`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6661 pub unsafe fn get_correct(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
6662 let __mi = Self::get_correct_method_info();
6663 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
6664 ::core::mem::transmute(__mi.method_ptr);
6665 __inner(this.into(), unit, ::core::option::Option::None)
6666 }
6667
6668 #[doc = "Direct (non-virtual) call to `UnitCalculator_ProbabilityGodSkillCommand`'s own `GetCorrect`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6669 pub unsafe fn get_correct_2(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
6670 let __mi = Self::get_correct_2_method_info();
6671 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
6672 ::core::mem::transmute(__mi.method_ptr);
6673 __inner(this.into(), side, ::core::option::Option::None)
6674 }
6675}
6676
6677#[cfg(feature = "app-unitcalculator")]
6678impl UnitCalculator_ProbabilityGodSkillCommand {
6679 #[doc = "`.ctor()` — no args"]
6680 pub fn new() -> Self {
6681 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
6682 panic!(
6683 "{}
6684::{}
6685 failed to instantiate",
6686 ::core::stringify!(UnitCalculator_ProbabilityGodSkillCommand),
6687 ::core::stringify!(new),
6688 )
6689 });
6690 <Self as IUnitCalculator_ProbabilityGodSkillCommandMethods>::ctor(this);
6691 this
6692 }
6693}
6694
6695#[cfg(feature = "app-unitcalculator")]
6696pub trait IUnitCalculator_LuukCommandMethods: IUnitCalculator_LuukCommand {
6697 #[doc = "`get_Name()` overload"]
6698 fn get_name(self) -> ::unity::Il2CppString {
6699 unsafe {
6700 let __receiver =
6701 <UnitCalculator_LuukCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6702 {
6703 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
6704 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
6705 panic!(
6706 "unity: virtual slot {}
6707 out of range (vtable len {}
6708) on the runtime class behind {}
6709 (method `{}
6710`)",
6711 4usize,
6712 __vt.len(),
6713 <UnitCalculator_LuukCommand as ::unity::ClassIdentity>::NAME,
6714 "get_Name",
6715 )
6716 });
6717 let __inner: extern "C" fn(UnitCalculator_LuukCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
6718 ::core::mem::transmute(__vi.method_ptr);
6719 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
6720 __inner(__receiver, __mi)
6721 }
6722 }
6723 }
6724 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
6725 fn get_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
6726 unsafe {
6727 let __receiver =
6728 <UnitCalculator_LuukCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6729 {
6730 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
6731 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
6732 panic!(
6733 "unity: virtual slot {}
6734 out of range (vtable len {}
6735) on the runtime class behind {}
6736 (method `{}
6737`)",
6738 30usize,
6739 __vt.len(),
6740 <UnitCalculator_LuukCommand as ::unity::ClassIdentity>::NAME,
6741 "GetImpl",
6742 )
6743 });
6744 let __inner: extern "C" fn(UnitCalculator_LuukCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
6745 ::core::mem::transmute(__vi.method_ptr);
6746 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
6747 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
6748 }
6749 }
6750 }
6751 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
6752 fn get_impl_2(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
6753 unsafe {
6754 let __receiver =
6755 <UnitCalculator_LuukCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6756 {
6757 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
6758 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
6759 panic!(
6760 "unity: virtual slot {}
6761 out of range (vtable len {}
6762) on the runtime class behind {}
6763 (method `{}
6764`)",
6765 31usize,
6766 __vt.len(),
6767 <UnitCalculator_LuukCommand as ::unity::ClassIdentity>::NAME,
6768 "GetImpl",
6769 )
6770 });
6771 let __inner: extern "C" fn(UnitCalculator_LuukCommand, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
6772 ::core::mem::transmute(__vi.method_ptr);
6773 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
6774 __inner(__receiver, ::core::convert::Into::into(side), __mi)
6775 }
6776 }
6777 }
6778 #[doc = "`SetImpl(crate::app::battleinfoside::BattleInfoSide, f32)` overload"]
6779 fn set_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>, value: impl ::core::convert::Into<f32>) -> () {
6780 unsafe {
6781 let __receiver =
6782 <UnitCalculator_LuukCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6783 {
6784 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
6785 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
6786 panic!(
6787 "unity: virtual slot {}
6788 out of range (vtable len {}
6789) on the runtime class behind {}
6790 (method `{}
6791`)",
6792 33usize,
6793 __vt.len(),
6794 <UnitCalculator_LuukCommand as ::unity::ClassIdentity>::NAME,
6795 "SetImpl",
6796 )
6797 });
6798 let __inner: extern "C" fn(
6799 UnitCalculator_LuukCommand,
6800 crate::app::battleinfoside::BattleInfoSide,
6801 f32,
6802 ::unity::OptionalMethod,
6803 ) -> () = ::core::mem::transmute(__vi.method_ptr);
6804 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
6805 __inner(__receiver, ::core::convert::Into::into(side), ::core::convert::Into::into(value), __mi)
6806 }
6807 }
6808 }
6809 #[doc = "`.ctor()` overload"]
6810 fn ctor(self) -> () {
6811 unsafe {
6812 let __receiver =
6813 <UnitCalculator_LuukCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6814 ::unity::il2cpp_call!((::unity::module_base()+0x1b49010usize)as*mut u8,();
6815(UnitCalculator_LuukCommand)__receiver)
6816 }
6817 }
6818}
6819
6820#[cfg(feature = "app-unitcalculator")]
6821impl<__T: IUnitCalculator_LuukCommand> IUnitCalculator_LuukCommandMethods for __T {}
6822
6823#[cfg(feature = "app-unitcalculator")]
6824impl UnitCalculator_LuukCommand {
6825 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6826 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
6827 }
6828
6829 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6830 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
6831 }
6832
6833 pub fn get_impl_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6834 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
6835 }
6836
6837 pub fn set_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6838 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
6839 }
6840
6841 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6842 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
6843 }
6844}
6845
6846#[cfg(feature = "app-unitcalculator")]
6847impl UnitCalculator_LuukCommand {
6848 #[doc = "Direct (non-virtual) call to `UnitCalculator_LuukCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6849 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
6850 let __mi = Self::get_name_method_info();
6851 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
6852 __inner(this.into(), ::core::option::Option::None)
6853 }
6854
6855 #[doc = "Direct (non-virtual) call to `UnitCalculator_LuukCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6856 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
6857 let __mi = Self::get_impl_method_info();
6858 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
6859 ::core::mem::transmute(__mi.method_ptr);
6860 __inner(this.into(), unit, ::core::option::Option::None)
6861 }
6862
6863 #[doc = "Direct (non-virtual) call to `UnitCalculator_LuukCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6864 pub unsafe fn get_impl_2(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
6865 let __mi = Self::get_impl_2_method_info();
6866 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
6867 ::core::mem::transmute(__mi.method_ptr);
6868 __inner(this.into(), side, ::core::option::Option::None)
6869 }
6870
6871 #[doc = "Direct (non-virtual) call to `UnitCalculator_LuukCommand`'s own `SetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6872 pub unsafe fn set_impl(
6873 this: impl ::core::convert::Into<::unity::IlInstance>,
6874 side: crate::app::battleinfoside::BattleInfoSide,
6875 value: f32,
6876 ) -> () {
6877 let __mi = Self::set_impl_method_info();
6878 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, f32, ::unity::OptionalMethod) -> () =
6879 ::core::mem::transmute(__mi.method_ptr);
6880 __inner(this.into(), side, value, ::core::option::Option::None)
6881 }
6882}
6883
6884#[cfg(feature = "app-unitcalculator")]
6885impl UnitCalculator_LuukCommand {
6886 #[doc = "`.ctor()` — no args"]
6887 pub fn new() -> Self {
6888 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
6889 panic!(
6890 "{}
6891::{}
6892 failed to instantiate",
6893 ::core::stringify!(UnitCalculator_LuukCommand),
6894 ::core::stringify!(new),
6895 )
6896 });
6897 <Self as IUnitCalculator_LuukCommandMethods>::ctor(this);
6898 this
6899 }
6900}
6901
6902#[cfg(feature = "app-unitcalculator")]
6903pub trait IUnitCalculator_ReciveAttackCountCommandMethods: IUnitCalculator_ReciveAttackCountCommand {
6904 #[doc = "`get_Name()` overload"]
6905 fn get_name(self) -> ::unity::Il2CppString {
6906 unsafe {
6907 let __receiver = <UnitCalculator_ReciveAttackCountCommand as ::unity::FromIlInstance>::from_il_instance(
6908 <Self as ::unity::SystemObject>::as_instance(self),
6909 );
6910 {
6911 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
6912 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
6913 panic!(
6914 "unity: virtual slot {}
6915 out of range (vtable len {}
6916) on the runtime class behind {}
6917 (method `{}
6918`)",
6919 4usize,
6920 __vt.len(),
6921 <UnitCalculator_ReciveAttackCountCommand as ::unity::ClassIdentity>::NAME,
6922 "get_Name",
6923 )
6924 });
6925 let __inner: extern "C" fn(UnitCalculator_ReciveAttackCountCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
6926 ::core::mem::transmute(__vi.method_ptr);
6927 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
6928 __inner(__receiver, __mi)
6929 }
6930 }
6931 }
6932 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
6933 fn get_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
6934 unsafe {
6935 let __receiver = <UnitCalculator_ReciveAttackCountCommand as ::unity::FromIlInstance>::from_il_instance(
6936 <Self as ::unity::SystemObject>::as_instance(self),
6937 );
6938 {
6939 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
6940 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
6941 panic!(
6942 "unity: virtual slot {}
6943 out of range (vtable len {}
6944) on the runtime class behind {}
6945 (method `{}
6946`)",
6947 30usize,
6948 __vt.len(),
6949 <UnitCalculator_ReciveAttackCountCommand as ::unity::ClassIdentity>::NAME,
6950 "GetImpl",
6951 )
6952 });
6953 let __inner: extern "C" fn(UnitCalculator_ReciveAttackCountCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
6954 ::core::mem::transmute(__vi.method_ptr);
6955 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
6956 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
6957 }
6958 }
6959 }
6960 #[doc = "`.ctor()` overload"]
6961 fn ctor(self) -> () {
6962 unsafe {
6963 let __receiver = <UnitCalculator_ReciveAttackCountCommand as ::unity::FromIlInstance>::from_il_instance(
6964 <Self as ::unity::SystemObject>::as_instance(self),
6965 );
6966 ::unity::il2cpp_call!((::unity::module_base()+0x1b4b800usize)as*mut u8,();
6967(UnitCalculator_ReciveAttackCountCommand)__receiver)
6968 }
6969 }
6970}
6971
6972#[cfg(feature = "app-unitcalculator")]
6973impl<__T: IUnitCalculator_ReciveAttackCountCommand> IUnitCalculator_ReciveAttackCountCommandMethods for __T {}
6974
6975#[cfg(feature = "app-unitcalculator")]
6976impl UnitCalculator_ReciveAttackCountCommand {
6977 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6978 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
6979 }
6980
6981 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6982 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
6983 }
6984
6985 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6986 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
6987 }
6988}
6989
6990#[cfg(feature = "app-unitcalculator")]
6991impl UnitCalculator_ReciveAttackCountCommand {
6992 #[doc = "Direct (non-virtual) call to `UnitCalculator_ReciveAttackCountCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6993 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
6994 let __mi = Self::get_name_method_info();
6995 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
6996 __inner(this.into(), ::core::option::Option::None)
6997 }
6998
6999 #[doc = "Direct (non-virtual) call to `UnitCalculator_ReciveAttackCountCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
7000 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
7001 let __mi = Self::get_impl_method_info();
7002 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
7003 ::core::mem::transmute(__mi.method_ptr);
7004 __inner(this.into(), unit, ::core::option::Option::None)
7005 }
7006}
7007
7008#[cfg(feature = "app-unitcalculator")]
7009impl UnitCalculator_ReciveAttackCountCommand {
7010 #[doc = "`.ctor()` — no args"]
7011 pub fn new() -> Self {
7012 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
7013 panic!(
7014 "{}
7015::{}
7016 failed to instantiate",
7017 ::core::stringify!(UnitCalculator_ReciveAttackCountCommand),
7018 ::core::stringify!(new),
7019 )
7020 });
7021 <Self as IUnitCalculator_ReciveAttackCountCommandMethods>::ctor(this);
7022 this
7023 }
7024}
7025
7026#[cfg(feature = "app-unitcalculator")]
7027pub trait IUnitCalculator_WeaponCriticalCommandMethods: IUnitCalculator_WeaponCriticalCommand {
7028 #[doc = "`get_Name()` overload"]
7029 fn get_name(self) -> ::unity::Il2CppString {
7030 unsafe {
7031 let __receiver = <UnitCalculator_WeaponCriticalCommand as ::unity::FromIlInstance>::from_il_instance(
7032 <Self as ::unity::SystemObject>::as_instance(self),
7033 );
7034 {
7035 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7036 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
7037 panic!(
7038 "unity: virtual slot {}
7039 out of range (vtable len {}
7040) on the runtime class behind {}
7041 (method `{}
7042`)",
7043 4usize,
7044 __vt.len(),
7045 <UnitCalculator_WeaponCriticalCommand as ::unity::ClassIdentity>::NAME,
7046 "get_Name",
7047 )
7048 });
7049 let __inner: extern "C" fn(UnitCalculator_WeaponCriticalCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
7050 ::core::mem::transmute(__vi.method_ptr);
7051 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7052 __inner(__receiver, __mi)
7053 }
7054 }
7055 }
7056 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
7057 fn get_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
7058 unsafe {
7059 let __receiver = <UnitCalculator_WeaponCriticalCommand as ::unity::FromIlInstance>::from_il_instance(
7060 <Self as ::unity::SystemObject>::as_instance(self),
7061 );
7062 {
7063 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7064 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
7065 panic!(
7066 "unity: virtual slot {}
7067 out of range (vtable len {}
7068) on the runtime class behind {}
7069 (method `{}
7070`)",
7071 31usize,
7072 __vt.len(),
7073 <UnitCalculator_WeaponCriticalCommand as ::unity::ClassIdentity>::NAME,
7074 "GetImpl",
7075 )
7076 });
7077 let __inner: extern "C" fn(
7078 UnitCalculator_WeaponCriticalCommand,
7079 crate::app::battleinfoside::BattleInfoSide,
7080 ::unity::OptionalMethod,
7081 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
7082 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7083 __inner(__receiver, ::core::convert::Into::into(side), __mi)
7084 }
7085 }
7086 }
7087 #[doc = "`SetImpl(crate::app::battleinfoside::BattleInfoSide, f32)` overload"]
7088 fn set_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>, value: impl ::core::convert::Into<f32>) -> () {
7089 unsafe {
7090 let __receiver = <UnitCalculator_WeaponCriticalCommand as ::unity::FromIlInstance>::from_il_instance(
7091 <Self as ::unity::SystemObject>::as_instance(self),
7092 );
7093 {
7094 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7095 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
7096 panic!(
7097 "unity: virtual slot {}
7098 out of range (vtable len {}
7099) on the runtime class behind {}
7100 (method `{}
7101`)",
7102 33usize,
7103 __vt.len(),
7104 <UnitCalculator_WeaponCriticalCommand as ::unity::ClassIdentity>::NAME,
7105 "SetImpl",
7106 )
7107 });
7108 let __inner: extern "C" fn(
7109 UnitCalculator_WeaponCriticalCommand,
7110 crate::app::battleinfoside::BattleInfoSide,
7111 f32,
7112 ::unity::OptionalMethod,
7113 ) -> () = ::core::mem::transmute(__vi.method_ptr);
7114 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7115 __inner(__receiver, ::core::convert::Into::into(side), ::core::convert::Into::into(value), __mi)
7116 }
7117 }
7118 }
7119 #[doc = "`IsVisible()` overload"]
7120 fn is_visible(self) -> bool {
7121 unsafe {
7122 let __receiver = <UnitCalculator_WeaponCriticalCommand as ::unity::FromIlInstance>::from_il_instance(
7123 <Self as ::unity::SystemObject>::as_instance(self),
7124 );
7125 {
7126 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7127 let __vi = *__vt.get(43usize).unwrap_or_else(|| {
7128 panic!(
7129 "unity: virtual slot {}
7130 out of range (vtable len {}
7131) on the runtime class behind {}
7132 (method `{}
7133`)",
7134 43usize,
7135 __vt.len(),
7136 <UnitCalculator_WeaponCriticalCommand as ::unity::ClassIdentity>::NAME,
7137 "IsVisible",
7138 )
7139 });
7140 let __inner: extern "C" fn(UnitCalculator_WeaponCriticalCommand, ::unity::OptionalMethod) -> bool =
7141 ::core::mem::transmute(__vi.method_ptr);
7142 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7143 __inner(__receiver, __mi)
7144 }
7145 }
7146 }
7147 #[doc = "`.ctor()` overload"]
7148 fn ctor(self) -> () {
7149 unsafe {
7150 let __receiver = <UnitCalculator_WeaponCriticalCommand as ::unity::FromIlInstance>::from_il_instance(
7151 <Self as ::unity::SystemObject>::as_instance(self),
7152 );
7153 ::unity::il2cpp_call!((::unity::module_base()+0x1b4dda0usize)as*mut u8,();
7154(UnitCalculator_WeaponCriticalCommand)__receiver)
7155 }
7156 }
7157}
7158
7159#[cfg(feature = "app-unitcalculator")]
7160impl<__T: IUnitCalculator_WeaponCriticalCommand> IUnitCalculator_WeaponCriticalCommandMethods for __T {}
7161
7162#[cfg(feature = "app-unitcalculator")]
7163impl UnitCalculator_WeaponCriticalCommand {
7164 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7165 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
7166 }
7167
7168 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7169 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
7170 }
7171
7172 pub fn set_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7173 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
7174 }
7175
7176 pub fn is_visible_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7177 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
7178 }
7179
7180 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7181 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
7182 }
7183}
7184
7185#[cfg(feature = "app-unitcalculator")]
7186impl UnitCalculator_WeaponCriticalCommand {
7187 #[doc = "Direct (non-virtual) call to `UnitCalculator_WeaponCriticalCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
7188 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
7189 let __mi = Self::get_name_method_info();
7190 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
7191 __inner(this.into(), ::core::option::Option::None)
7192 }
7193
7194 #[doc = "Direct (non-virtual) call to `UnitCalculator_WeaponCriticalCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
7195 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
7196 let __mi = Self::get_impl_method_info();
7197 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
7198 ::core::mem::transmute(__mi.method_ptr);
7199 __inner(this.into(), side, ::core::option::Option::None)
7200 }
7201
7202 #[doc = "Direct (non-virtual) call to `UnitCalculator_WeaponCriticalCommand`'s own `SetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
7203 pub unsafe fn set_impl(
7204 this: impl ::core::convert::Into<::unity::IlInstance>,
7205 side: crate::app::battleinfoside::BattleInfoSide,
7206 value: f32,
7207 ) -> () {
7208 let __mi = Self::set_impl_method_info();
7209 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, f32, ::unity::OptionalMethod) -> () =
7210 ::core::mem::transmute(__mi.method_ptr);
7211 __inner(this.into(), side, value, ::core::option::Option::None)
7212 }
7213
7214 #[doc = "Direct (non-virtual) call to `UnitCalculator_WeaponCriticalCommand`'s own `IsVisible`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
7215 pub unsafe fn is_visible(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
7216 let __mi = Self::is_visible_method_info();
7217 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
7218 __inner(this.into(), ::core::option::Option::None)
7219 }
7220}
7221
7222#[cfg(feature = "app-unitcalculator")]
7223impl UnitCalculator_WeaponCriticalCommand {
7224 #[doc = "`.ctor()` — no args"]
7225 pub fn new() -> Self {
7226 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
7227 panic!(
7228 "{}
7229::{}
7230 failed to instantiate",
7231 ::core::stringify!(UnitCalculator_WeaponCriticalCommand),
7232 ::core::stringify!(new),
7233 )
7234 });
7235 <Self as IUnitCalculator_WeaponCriticalCommandMethods>::ctor(this);
7236 this
7237 }
7238}
7239
7240#[cfg(feature = "app-unitcalculator")]
7241pub trait IUnitCalculator_GodEngagingCommandMethods: IUnitCalculator_GodEngagingCommand {
7242 #[doc = "`get_Name()` overload"]
7243 fn get_name(self) -> ::unity::Il2CppString {
7244 unsafe {
7245 let __receiver =
7246 <UnitCalculator_GodEngagingCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7247 {
7248 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7249 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
7250 panic!(
7251 "unity: virtual slot {}
7252 out of range (vtable len {}
7253) on the runtime class behind {}
7254 (method `{}
7255`)",
7256 4usize,
7257 __vt.len(),
7258 <UnitCalculator_GodEngagingCommand as ::unity::ClassIdentity>::NAME,
7259 "get_Name",
7260 )
7261 });
7262 let __inner: extern "C" fn(UnitCalculator_GodEngagingCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
7263 ::core::mem::transmute(__vi.method_ptr);
7264 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7265 __inner(__receiver, __mi)
7266 }
7267 }
7268 }
7269 #[doc = "`GetValue(crate::app::unit::Unit)` overload"]
7270 fn get_value(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> i32 {
7271 unsafe {
7272 let __receiver =
7273 <UnitCalculator_GodEngagingCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7274 ::unity::il2cpp_call!((::unity::module_base()+0x1b47c30usize)as*mut u8,i32;
7275(UnitCalculator_GodEngagingCommand)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(unit))
7276 }
7277 }
7278 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
7279 fn get_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
7280 unsafe {
7281 let __receiver =
7282 <UnitCalculator_GodEngagingCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7283 {
7284 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7285 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
7286 panic!(
7287 "unity: virtual slot {}
7288 out of range (vtable len {}
7289) on the runtime class behind {}
7290 (method `{}
7291`)",
7292 30usize,
7293 __vt.len(),
7294 <UnitCalculator_GodEngagingCommand as ::unity::ClassIdentity>::NAME,
7295 "GetImpl",
7296 )
7297 });
7298 let __inner: extern "C" fn(UnitCalculator_GodEngagingCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
7299 ::core::mem::transmute(__vi.method_ptr);
7300 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7301 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
7302 }
7303 }
7304 }
7305 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
7306 fn get_impl_2(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
7307 unsafe {
7308 let __receiver =
7309 <UnitCalculator_GodEngagingCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7310 {
7311 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7312 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
7313 panic!(
7314 "unity: virtual slot {}
7315 out of range (vtable len {}
7316) on the runtime class behind {}
7317 (method `{}
7318`)",
7319 31usize,
7320 __vt.len(),
7321 <UnitCalculator_GodEngagingCommand as ::unity::ClassIdentity>::NAME,
7322 "GetImpl",
7323 )
7324 });
7325 let __inner: extern "C" fn(
7326 UnitCalculator_GodEngagingCommand,
7327 crate::app::battleinfoside::BattleInfoSide,
7328 ::unity::OptionalMethod,
7329 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
7330 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7331 __inner(__receiver, ::core::convert::Into::into(side), __mi)
7332 }
7333 }
7334 }
7335 #[doc = "`.ctor()` overload"]
7336 fn ctor(self) -> () {
7337 unsafe {
7338 let __receiver =
7339 <UnitCalculator_GodEngagingCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7340 ::unity::il2cpp_call!((::unity::module_base()+0x1b47db0usize)as*mut u8,();
7341(UnitCalculator_GodEngagingCommand)__receiver)
7342 }
7343 }
7344}
7345
7346#[cfg(feature = "app-unitcalculator")]
7347impl<__T: IUnitCalculator_GodEngagingCommand> IUnitCalculator_GodEngagingCommandMethods for __T {}
7348
7349#[cfg(feature = "app-unitcalculator")]
7350impl UnitCalculator_GodEngagingCommand {
7351 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7352 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
7353 }
7354
7355 pub fn get_value_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7356 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
7357 }
7358
7359 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7360 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
7361 }
7362
7363 pub fn get_impl_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7364 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
7365 }
7366
7367 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7368 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
7369 }
7370}
7371
7372#[cfg(feature = "app-unitcalculator")]
7373impl UnitCalculator_GodEngagingCommand {
7374 #[doc = "Direct (non-virtual) call to `UnitCalculator_GodEngagingCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
7375 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
7376 let __mi = Self::get_name_method_info();
7377 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
7378 __inner(this.into(), ::core::option::Option::None)
7379 }
7380
7381 #[doc = "Direct (non-virtual) call to `UnitCalculator_GodEngagingCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
7382 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
7383 let __mi = Self::get_impl_method_info();
7384 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
7385 ::core::mem::transmute(__mi.method_ptr);
7386 __inner(this.into(), unit, ::core::option::Option::None)
7387 }
7388
7389 #[doc = "Direct (non-virtual) call to `UnitCalculator_GodEngagingCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
7390 pub unsafe fn get_impl_2(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
7391 let __mi = Self::get_impl_2_method_info();
7392 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
7393 ::core::mem::transmute(__mi.method_ptr);
7394 __inner(this.into(), side, ::core::option::Option::None)
7395 }
7396}
7397
7398#[cfg(feature = "app-unitcalculator")]
7399impl UnitCalculator_GodEngagingCommand {
7400 #[doc = "`.ctor()` — no args"]
7401 pub fn new() -> Self {
7402 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
7403 panic!(
7404 "{}
7405::{}
7406 failed to instantiate",
7407 ::core::stringify!(UnitCalculator_GodEngagingCommand),
7408 ::core::stringify!(new),
7409 )
7410 });
7411 <Self as IUnitCalculator_GodEngagingCommandMethods>::ctor(this);
7412 this
7413 }
7414}
7415
7416#[cfg(feature = "app-unitcalculator")]
7417pub trait IUnitCalculator_WeaponLevelCommandMethods: IUnitCalculator_WeaponLevelCommand {
7418 #[doc = "`get_Name()` overload"]
7419 fn get_name(self) -> ::unity::Il2CppString {
7420 unsafe {
7421 let __receiver =
7422 <UnitCalculator_WeaponLevelCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7423 {
7424 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7425 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
7426 panic!(
7427 "unity: virtual slot {}
7428 out of range (vtable len {}
7429) on the runtime class behind {}
7430 (method `{}
7431`)",
7432 4usize,
7433 __vt.len(),
7434 <UnitCalculator_WeaponLevelCommand as ::unity::ClassIdentity>::NAME,
7435 "get_Name",
7436 )
7437 });
7438 let __inner: extern "C" fn(UnitCalculator_WeaponLevelCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
7439 ::core::mem::transmute(__vi.method_ptr);
7440 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7441 __inner(__receiver, __mi)
7442 }
7443 }
7444 }
7445 #[doc = "`GetWeaponLevel(crate::app::itemdata::ItemData)` overload"]
7446 fn get_weapon_level(self, item: impl ::core::convert::Into<crate::app::itemdata::ItemData>) -> crate::app::weaponlevel::WeaponLevel_Kind {
7447 unsafe {
7448 let __receiver =
7449 <UnitCalculator_WeaponLevelCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7450 ::unity::il2cpp_call!((::unity::module_base()+0x1b4ea80usize)as*mut u8,crate::app::weaponlevel::WeaponLevel_Kind;
7451(UnitCalculator_WeaponLevelCommand)__receiver,(crate::app::itemdata::ItemData)::core::convert::Into::into(item))
7452 }
7453 }
7454 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
7455 fn get_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
7456 unsafe {
7457 let __receiver =
7458 <UnitCalculator_WeaponLevelCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7459 {
7460 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7461 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
7462 panic!(
7463 "unity: virtual slot {}
7464 out of range (vtable len {}
7465) on the runtime class behind {}
7466 (method `{}
7467`)",
7468 31usize,
7469 __vt.len(),
7470 <UnitCalculator_WeaponLevelCommand as ::unity::ClassIdentity>::NAME,
7471 "GetImpl",
7472 )
7473 });
7474 let __inner: extern "C" fn(
7475 UnitCalculator_WeaponLevelCommand,
7476 crate::app::battleinfoside::BattleInfoSide,
7477 ::unity::OptionalMethod,
7478 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
7479 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7480 __inner(__receiver, ::core::convert::Into::into(side), __mi)
7481 }
7482 }
7483 }
7484 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
7485 fn get_impl_2(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
7486 unsafe {
7487 let __receiver =
7488 <UnitCalculator_WeaponLevelCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7489 {
7490 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7491 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
7492 panic!(
7493 "unity: virtual slot {}
7494 out of range (vtable len {}
7495) on the runtime class behind {}
7496 (method `{}
7497`)",
7498 30usize,
7499 __vt.len(),
7500 <UnitCalculator_WeaponLevelCommand as ::unity::ClassIdentity>::NAME,
7501 "GetImpl",
7502 )
7503 });
7504 let __inner: extern "C" fn(UnitCalculator_WeaponLevelCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
7505 ::core::mem::transmute(__vi.method_ptr);
7506 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7507 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
7508 }
7509 }
7510 }
7511 #[doc = "`IsVisible()` overload"]
7512 fn is_visible(self) -> bool {
7513 unsafe {
7514 let __receiver =
7515 <UnitCalculator_WeaponLevelCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7516 {
7517 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7518 let __vi = *__vt.get(43usize).unwrap_or_else(|| {
7519 panic!(
7520 "unity: virtual slot {}
7521 out of range (vtable len {}
7522) on the runtime class behind {}
7523 (method `{}
7524`)",
7525 43usize,
7526 __vt.len(),
7527 <UnitCalculator_WeaponLevelCommand as ::unity::ClassIdentity>::NAME,
7528 "IsVisible",
7529 )
7530 });
7531 let __inner: extern "C" fn(UnitCalculator_WeaponLevelCommand, ::unity::OptionalMethod) -> bool =
7532 ::core::mem::transmute(__vi.method_ptr);
7533 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7534 __inner(__receiver, __mi)
7535 }
7536 }
7537 }
7538 #[doc = "`.ctor()` overload"]
7539 fn ctor(self) -> () {
7540 unsafe {
7541 let __receiver =
7542 <UnitCalculator_WeaponLevelCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7543 ::unity::il2cpp_call!((::unity::module_base()+0x1b4ec90usize)as*mut u8,();
7544(UnitCalculator_WeaponLevelCommand)__receiver)
7545 }
7546 }
7547}
7548
7549#[cfg(feature = "app-unitcalculator")]
7550impl<__T: IUnitCalculator_WeaponLevelCommand> IUnitCalculator_WeaponLevelCommandMethods for __T {}
7551
7552#[cfg(feature = "app-unitcalculator")]
7553impl UnitCalculator_WeaponLevelCommand {
7554 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7555 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
7556 }
7557
7558 pub fn get_weapon_level_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7559 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
7560 }
7561
7562 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7563 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
7564 }
7565
7566 pub fn get_impl_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7567 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
7568 }
7569
7570 pub fn is_visible_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7571 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
7572 }
7573
7574 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7575 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
7576 }
7577}
7578
7579#[cfg(feature = "app-unitcalculator")]
7580impl UnitCalculator_WeaponLevelCommand {
7581 #[doc = "Direct (non-virtual) call to `UnitCalculator_WeaponLevelCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
7582 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
7583 let __mi = Self::get_name_method_info();
7584 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
7585 __inner(this.into(), ::core::option::Option::None)
7586 }
7587
7588 #[doc = "Direct (non-virtual) call to `UnitCalculator_WeaponLevelCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
7589 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
7590 let __mi = Self::get_impl_method_info();
7591 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
7592 ::core::mem::transmute(__mi.method_ptr);
7593 __inner(this.into(), side, ::core::option::Option::None)
7594 }
7595
7596 #[doc = "Direct (non-virtual) call to `UnitCalculator_WeaponLevelCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
7597 pub unsafe fn get_impl_2(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
7598 let __mi = Self::get_impl_2_method_info();
7599 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
7600 ::core::mem::transmute(__mi.method_ptr);
7601 __inner(this.into(), unit, ::core::option::Option::None)
7602 }
7603
7604 #[doc = "Direct (non-virtual) call to `UnitCalculator_WeaponLevelCommand`'s own `IsVisible`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
7605 pub unsafe fn is_visible(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
7606 let __mi = Self::is_visible_method_info();
7607 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
7608 __inner(this.into(), ::core::option::Option::None)
7609 }
7610}
7611
7612#[cfg(feature = "app-unitcalculator")]
7613impl UnitCalculator_WeaponLevelCommand {
7614 #[doc = "`.ctor()` — no args"]
7615 pub fn new() -> Self {
7616 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
7617 panic!(
7618 "{}
7619::{}
7620 failed to instantiate",
7621 ::core::stringify!(UnitCalculator_WeaponLevelCommand),
7622 ::core::stringify!(new),
7623 )
7624 });
7625 <Self as IUnitCalculator_WeaponLevelCommandMethods>::ctor(this);
7626 this
7627 }
7628}
7629
7630#[cfg(feature = "app-unitcalculator")]
7631pub trait IUnitCalculator_FixedEnemyCountCommandMethods: IUnitCalculator_FixedEnemyCountCommand {
7632 #[doc = "`get_Name()` overload"]
7633 fn get_name(self) -> ::unity::Il2CppString {
7634 unsafe {
7635 let __receiver = <UnitCalculator_FixedEnemyCountCommand as ::unity::FromIlInstance>::from_il_instance(
7636 <Self as ::unity::SystemObject>::as_instance(self),
7637 );
7638 {
7639 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7640 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
7641 panic!(
7642 "unity: virtual slot {}
7643 out of range (vtable len {}
7644) on the runtime class behind {}
7645 (method `{}
7646`)",
7647 4usize,
7648 __vt.len(),
7649 <UnitCalculator_FixedEnemyCountCommand as ::unity::ClassIdentity>::NAME,
7650 "get_Name",
7651 )
7652 });
7653 let __inner: extern "C" fn(UnitCalculator_FixedEnemyCountCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
7654 ::core::mem::transmute(__vi.method_ptr);
7655 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7656 __inner(__receiver, __mi)
7657 }
7658 }
7659 }
7660 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
7661 fn get_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
7662 unsafe {
7663 let __receiver = <UnitCalculator_FixedEnemyCountCommand as ::unity::FromIlInstance>::from_il_instance(
7664 <Self as ::unity::SystemObject>::as_instance(self),
7665 );
7666 {
7667 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7668 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
7669 panic!(
7670 "unity: virtual slot {}
7671 out of range (vtable len {}
7672) on the runtime class behind {}
7673 (method `{}
7674`)",
7675 30usize,
7676 __vt.len(),
7677 <UnitCalculator_FixedEnemyCountCommand as ::unity::ClassIdentity>::NAME,
7678 "GetImpl",
7679 )
7680 });
7681 let __inner: extern "C" fn(UnitCalculator_FixedEnemyCountCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
7682 ::core::mem::transmute(__vi.method_ptr);
7683 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7684 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
7685 }
7686 }
7687 }
7688 #[doc = "`.ctor()` overload"]
7689 fn ctor(self) -> () {
7690 unsafe {
7691 let __receiver = <UnitCalculator_FixedEnemyCountCommand as ::unity::FromIlInstance>::from_il_instance(
7692 <Self as ::unity::SystemObject>::as_instance(self),
7693 );
7694 ::unity::il2cpp_call!((::unity::module_base()+0x1b477d0usize)as*mut u8,();
7695(UnitCalculator_FixedEnemyCountCommand)__receiver)
7696 }
7697 }
7698}
7699
7700#[cfg(feature = "app-unitcalculator")]
7701impl<__T: IUnitCalculator_FixedEnemyCountCommand> IUnitCalculator_FixedEnemyCountCommandMethods for __T {}
7702
7703#[cfg(feature = "app-unitcalculator")]
7704impl UnitCalculator_FixedEnemyCountCommand {
7705 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7706 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
7707 }
7708
7709 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7710 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
7711 }
7712
7713 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7714 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
7715 }
7716}
7717
7718#[cfg(feature = "app-unitcalculator")]
7719impl UnitCalculator_FixedEnemyCountCommand {
7720 #[doc = "Direct (non-virtual) call to `UnitCalculator_FixedEnemyCountCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
7721 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
7722 let __mi = Self::get_name_method_info();
7723 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
7724 __inner(this.into(), ::core::option::Option::None)
7725 }
7726
7727 #[doc = "Direct (non-virtual) call to `UnitCalculator_FixedEnemyCountCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
7728 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
7729 let __mi = Self::get_impl_method_info();
7730 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
7731 ::core::mem::transmute(__mi.method_ptr);
7732 __inner(this.into(), unit, ::core::option::Option::None)
7733 }
7734}
7735
7736#[cfg(feature = "app-unitcalculator")]
7737impl UnitCalculator_FixedEnemyCountCommand {
7738 #[doc = "`.ctor()` — no args"]
7739 pub fn new() -> Self {
7740 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
7741 panic!(
7742 "{}
7743::{}
7744 failed to instantiate",
7745 ::core::stringify!(UnitCalculator_FixedEnemyCountCommand),
7746 ::core::stringify!(new),
7747 )
7748 });
7749 <Self as IUnitCalculator_FixedEnemyCountCommandMethods>::ctor(this);
7750 this
7751 }
7752}
7753
7754#[cfg(feature = "app-unitcalculator")]
7755pub trait IUnitCalculator_MagicCommandMethods: IUnitCalculator_MagicCommand {
7756 #[doc = "`get_Name()` overload"]
7757 fn get_name(self) -> ::unity::Il2CppString {
7758 unsafe {
7759 let __receiver =
7760 <UnitCalculator_MagicCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7761 {
7762 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7763 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
7764 panic!(
7765 "unity: virtual slot {}
7766 out of range (vtable len {}
7767) on the runtime class behind {}
7768 (method `{}
7769`)",
7770 4usize,
7771 __vt.len(),
7772 <UnitCalculator_MagicCommand as ::unity::ClassIdentity>::NAME,
7773 "get_Name",
7774 )
7775 });
7776 let __inner: extern "C" fn(UnitCalculator_MagicCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
7777 ::core::mem::transmute(__vi.method_ptr);
7778 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7779 __inner(__receiver, __mi)
7780 }
7781 }
7782 }
7783 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
7784 fn get_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
7785 unsafe {
7786 let __receiver =
7787 <UnitCalculator_MagicCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7788 {
7789 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7790 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
7791 panic!(
7792 "unity: virtual slot {}
7793 out of range (vtable len {}
7794) on the runtime class behind {}
7795 (method `{}
7796`)",
7797 30usize,
7798 __vt.len(),
7799 <UnitCalculator_MagicCommand as ::unity::ClassIdentity>::NAME,
7800 "GetImpl",
7801 )
7802 });
7803 let __inner: extern "C" fn(UnitCalculator_MagicCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
7804 ::core::mem::transmute(__vi.method_ptr);
7805 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7806 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
7807 }
7808 }
7809 }
7810 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
7811 fn get_impl_2(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
7812 unsafe {
7813 let __receiver =
7814 <UnitCalculator_MagicCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7815 {
7816 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7817 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
7818 panic!(
7819 "unity: virtual slot {}
7820 out of range (vtable len {}
7821) on the runtime class behind {}
7822 (method `{}
7823`)",
7824 31usize,
7825 __vt.len(),
7826 <UnitCalculator_MagicCommand as ::unity::ClassIdentity>::NAME,
7827 "GetImpl",
7828 )
7829 });
7830 let __inner: extern "C" fn(UnitCalculator_MagicCommand, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
7831 ::core::mem::transmute(__vi.method_ptr);
7832 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7833 __inner(__receiver, ::core::convert::Into::into(side), __mi)
7834 }
7835 }
7836 }
7837 #[doc = "`SetImpl(crate::app::battleinfoside::BattleInfoSide, f32)` overload"]
7838 fn set_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>, value: impl ::core::convert::Into<f32>) -> () {
7839 unsafe {
7840 let __receiver =
7841 <UnitCalculator_MagicCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7842 {
7843 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7844 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
7845 panic!(
7846 "unity: virtual slot {}
7847 out of range (vtable len {}
7848) on the runtime class behind {}
7849 (method `{}
7850`)",
7851 33usize,
7852 __vt.len(),
7853 <UnitCalculator_MagicCommand as ::unity::ClassIdentity>::NAME,
7854 "SetImpl",
7855 )
7856 });
7857 let __inner: extern "C" fn(
7858 UnitCalculator_MagicCommand,
7859 crate::app::battleinfoside::BattleInfoSide,
7860 f32,
7861 ::unity::OptionalMethod,
7862 ) -> () = ::core::mem::transmute(__vi.method_ptr);
7863 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7864 __inner(__receiver, ::core::convert::Into::into(side), ::core::convert::Into::into(value), __mi)
7865 }
7866 }
7867 }
7868 #[doc = "`.ctor()` overload"]
7869 fn ctor(self) -> () {
7870 unsafe {
7871 let __receiver =
7872 <UnitCalculator_MagicCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7873 ::unity::il2cpp_call!((::unity::module_base()+0x1b492f0usize)as*mut u8,();
7874(UnitCalculator_MagicCommand)__receiver)
7875 }
7876 }
7877}
7878
7879#[cfg(feature = "app-unitcalculator")]
7880impl<__T: IUnitCalculator_MagicCommand> IUnitCalculator_MagicCommandMethods for __T {}
7881
7882#[cfg(feature = "app-unitcalculator")]
7883impl UnitCalculator_MagicCommand {
7884 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7885 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
7886 }
7887
7888 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7889 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
7890 }
7891
7892 pub fn get_impl_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7893 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
7894 }
7895
7896 pub fn set_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7897 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
7898 }
7899
7900 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7901 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
7902 }
7903}
7904
7905#[cfg(feature = "app-unitcalculator")]
7906impl UnitCalculator_MagicCommand {
7907 #[doc = "Direct (non-virtual) call to `UnitCalculator_MagicCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
7908 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
7909 let __mi = Self::get_name_method_info();
7910 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
7911 __inner(this.into(), ::core::option::Option::None)
7912 }
7913
7914 #[doc = "Direct (non-virtual) call to `UnitCalculator_MagicCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
7915 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
7916 let __mi = Self::get_impl_method_info();
7917 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
7918 ::core::mem::transmute(__mi.method_ptr);
7919 __inner(this.into(), unit, ::core::option::Option::None)
7920 }
7921
7922 #[doc = "Direct (non-virtual) call to `UnitCalculator_MagicCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
7923 pub unsafe fn get_impl_2(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
7924 let __mi = Self::get_impl_2_method_info();
7925 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
7926 ::core::mem::transmute(__mi.method_ptr);
7927 __inner(this.into(), side, ::core::option::Option::None)
7928 }
7929
7930 #[doc = "Direct (non-virtual) call to `UnitCalculator_MagicCommand`'s own `SetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
7931 pub unsafe fn set_impl(
7932 this: impl ::core::convert::Into<::unity::IlInstance>,
7933 side: crate::app::battleinfoside::BattleInfoSide,
7934 value: f32,
7935 ) -> () {
7936 let __mi = Self::set_impl_method_info();
7937 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, f32, ::unity::OptionalMethod) -> () =
7938 ::core::mem::transmute(__mi.method_ptr);
7939 __inner(this.into(), side, value, ::core::option::Option::None)
7940 }
7941}
7942
7943#[cfg(feature = "app-unitcalculator")]
7944impl UnitCalculator_MagicCommand {
7945 #[doc = "`.ctor()` — no args"]
7946 pub fn new() -> Self {
7947 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
7948 panic!(
7949 "{}
7950::{}
7951 failed to instantiate",
7952 ::core::stringify!(UnitCalculator_MagicCommand),
7953 ::core::stringify!(new),
7954 )
7955 });
7956 <Self as IUnitCalculator_MagicCommandMethods>::ctor(this);
7957 this
7958 }
7959}
7960
7961#[cfg(feature = "app-unitcalculator")]
7962pub trait IUnitCalculator_TotalOrderCommandMethods: IUnitCalculator_TotalOrderCommand {
7963 #[doc = "`get_Name()` overload"]
7964 fn get_name(self) -> ::unity::Il2CppString {
7965 unsafe {
7966 let __receiver =
7967 <UnitCalculator_TotalOrderCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7968 {
7969 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7970 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
7971 panic!(
7972 "unity: virtual slot {}
7973 out of range (vtable len {}
7974) on the runtime class behind {}
7975 (method `{}
7976`)",
7977 4usize,
7978 __vt.len(),
7979 <UnitCalculator_TotalOrderCommand as ::unity::ClassIdentity>::NAME,
7980 "get_Name",
7981 )
7982 });
7983 let __inner: extern "C" fn(UnitCalculator_TotalOrderCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
7984 ::core::mem::transmute(__vi.method_ptr);
7985 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7986 __inner(__receiver, __mi)
7987 }
7988 }
7989 }
7990 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
7991 fn get_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
7992 unsafe {
7993 let __receiver =
7994 <UnitCalculator_TotalOrderCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7995 {
7996 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7997 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
7998 panic!(
7999 "unity: virtual slot {}
8000 out of range (vtable len {}
8001) on the runtime class behind {}
8002 (method `{}
8003`)",
8004 31usize,
8005 __vt.len(),
8006 <UnitCalculator_TotalOrderCommand as ::unity::ClassIdentity>::NAME,
8007 "GetImpl",
8008 )
8009 });
8010 let __inner: extern "C" fn(
8011 UnitCalculator_TotalOrderCommand,
8012 crate::app::battleinfoside::BattleInfoSide,
8013 ::unity::OptionalMethod,
8014 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
8015 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
8016 __inner(__receiver, ::core::convert::Into::into(side), __mi)
8017 }
8018 }
8019 }
8020 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
8021 fn get_impl_2(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
8022 unsafe {
8023 let __receiver =
8024 <UnitCalculator_TotalOrderCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8025 {
8026 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
8027 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
8028 panic!(
8029 "unity: virtual slot {}
8030 out of range (vtable len {}
8031) on the runtime class behind {}
8032 (method `{}
8033`)",
8034 30usize,
8035 __vt.len(),
8036 <UnitCalculator_TotalOrderCommand as ::unity::ClassIdentity>::NAME,
8037 "GetImpl",
8038 )
8039 });
8040 let __inner: extern "C" fn(UnitCalculator_TotalOrderCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
8041 ::core::mem::transmute(__vi.method_ptr);
8042 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
8043 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
8044 }
8045 }
8046 }
8047 #[doc = "`.ctor()` overload"]
8048 fn ctor(self) -> () {
8049 unsafe {
8050 let __receiver =
8051 <UnitCalculator_TotalOrderCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8052 ::unity::il2cpp_call!((::unity::module_base()+0x1b4cd50usize)as*mut u8,();
8053(UnitCalculator_TotalOrderCommand)__receiver)
8054 }
8055 }
8056}
8057
8058#[cfg(feature = "app-unitcalculator")]
8059impl<__T: IUnitCalculator_TotalOrderCommand> IUnitCalculator_TotalOrderCommandMethods for __T {}
8060
8061#[cfg(feature = "app-unitcalculator")]
8062impl UnitCalculator_TotalOrderCommand {
8063 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8064 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
8065 }
8066
8067 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8068 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
8069 }
8070
8071 pub fn get_impl_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8072 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
8073 }
8074
8075 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8076 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
8077 }
8078}
8079
8080#[cfg(feature = "app-unitcalculator")]
8081impl UnitCalculator_TotalOrderCommand {
8082 #[doc = "Direct (non-virtual) call to `UnitCalculator_TotalOrderCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
8083 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
8084 let __mi = Self::get_name_method_info();
8085 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
8086 __inner(this.into(), ::core::option::Option::None)
8087 }
8088
8089 #[doc = "Direct (non-virtual) call to `UnitCalculator_TotalOrderCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
8090 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
8091 let __mi = Self::get_impl_method_info();
8092 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
8093 ::core::mem::transmute(__mi.method_ptr);
8094 __inner(this.into(), side, ::core::option::Option::None)
8095 }
8096
8097 #[doc = "Direct (non-virtual) call to `UnitCalculator_TotalOrderCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
8098 pub unsafe fn get_impl_2(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
8099 let __mi = Self::get_impl_2_method_info();
8100 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
8101 ::core::mem::transmute(__mi.method_ptr);
8102 __inner(this.into(), unit, ::core::option::Option::None)
8103 }
8104}
8105
8106#[cfg(feature = "app-unitcalculator")]
8107impl UnitCalculator_TotalOrderCommand {
8108 #[doc = "`.ctor()` — no args"]
8109 pub fn new() -> Self {
8110 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
8111 panic!(
8112 "{}
8113::{}
8114 failed to instantiate",
8115 ::core::stringify!(UnitCalculator_TotalOrderCommand),
8116 ::core::stringify!(new),
8117 )
8118 });
8119 <Self as IUnitCalculator_TotalOrderCommandMethods>::ctor(this);
8120 this
8121 }
8122}
8123
8124#[cfg(feature = "app-unitcalculator")]
8125pub trait IUnitCalculator_ExpInterferenceCountCommandMethods: IUnitCalculator_ExpInterferenceCountCommand {
8126 #[doc = "`get_Name()` overload"]
8127 fn get_name(self) -> ::unity::Il2CppString {
8128 unsafe {
8129 let __receiver = <UnitCalculator_ExpInterferenceCountCommand as ::unity::FromIlInstance>::from_il_instance(
8130 <Self as ::unity::SystemObject>::as_instance(self),
8131 );
8132 {
8133 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
8134 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
8135 panic!(
8136 "unity: virtual slot {}
8137 out of range (vtable len {}
8138) on the runtime class behind {}
8139 (method `{}
8140`)",
8141 4usize,
8142 __vt.len(),
8143 <UnitCalculator_ExpInterferenceCountCommand as ::unity::ClassIdentity>::NAME,
8144 "get_Name",
8145 )
8146 });
8147 let __inner: extern "C" fn(UnitCalculator_ExpInterferenceCountCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
8148 ::core::mem::transmute(__vi.method_ptr);
8149 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
8150 __inner(__receiver, __mi)
8151 }
8152 }
8153 }
8154 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
8155 fn get_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
8156 unsafe {
8157 let __receiver = <UnitCalculator_ExpInterferenceCountCommand as ::unity::FromIlInstance>::from_il_instance(
8158 <Self as ::unity::SystemObject>::as_instance(self),
8159 );
8160 {
8161 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
8162 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
8163 panic!(
8164 "unity: virtual slot {}
8165 out of range (vtable len {}
8166) on the runtime class behind {}
8167 (method `{}
8168`)",
8169 30usize,
8170 __vt.len(),
8171 <UnitCalculator_ExpInterferenceCountCommand as ::unity::ClassIdentity>::NAME,
8172 "GetImpl",
8173 )
8174 });
8175 let __inner: extern "C" fn(UnitCalculator_ExpInterferenceCountCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
8176 ::core::mem::transmute(__vi.method_ptr);
8177 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
8178 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
8179 }
8180 }
8181 }
8182 #[doc = "`.ctor()` overload"]
8183 fn ctor(self) -> () {
8184 unsafe {
8185 let __receiver = <UnitCalculator_ExpInterferenceCountCommand as ::unity::FromIlInstance>::from_il_instance(
8186 <Self as ::unity::SystemObject>::as_instance(self),
8187 );
8188 ::unity::il2cpp_call!((::unity::module_base()+0x1b47360usize)as*mut u8,();
8189(UnitCalculator_ExpInterferenceCountCommand)__receiver)
8190 }
8191 }
8192}
8193
8194#[cfg(feature = "app-unitcalculator")]
8195impl<__T: IUnitCalculator_ExpInterferenceCountCommand> IUnitCalculator_ExpInterferenceCountCommandMethods for __T {}
8196
8197#[cfg(feature = "app-unitcalculator")]
8198impl UnitCalculator_ExpInterferenceCountCommand {
8199 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8200 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
8201 }
8202
8203 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8204 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
8205 }
8206
8207 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8208 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
8209 }
8210}
8211
8212#[cfg(feature = "app-unitcalculator")]
8213impl UnitCalculator_ExpInterferenceCountCommand {
8214 #[doc = "Direct (non-virtual) call to `UnitCalculator_ExpInterferenceCountCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
8215 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
8216 let __mi = Self::get_name_method_info();
8217 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
8218 __inner(this.into(), ::core::option::Option::None)
8219 }
8220
8221 #[doc = "Direct (non-virtual) call to `UnitCalculator_ExpInterferenceCountCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
8222 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
8223 let __mi = Self::get_impl_method_info();
8224 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
8225 ::core::mem::transmute(__mi.method_ptr);
8226 __inner(this.into(), unit, ::core::option::Option::None)
8227 }
8228}
8229
8230#[cfg(feature = "app-unitcalculator")]
8231impl UnitCalculator_ExpInterferenceCountCommand {
8232 #[doc = "`.ctor()` — no args"]
8233 pub fn new() -> Self {
8234 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
8235 panic!(
8236 "{}
8237::{}
8238 failed to instantiate",
8239 ::core::stringify!(UnitCalculator_ExpInterferenceCountCommand),
8240 ::core::stringify!(new),
8241 )
8242 });
8243 <Self as IUnitCalculator_ExpInterferenceCountCommandMethods>::ctor(this);
8244 this
8245 }
8246}
8247
8248#[cfg(feature = "app-unitcalculator")]
8249pub trait IUnitCalculator_RangeGenderCountCommandMethods: IUnitCalculator_RangeGenderCountCommand {
8250 #[doc = "`get_Name()` overload"]
8251 fn get_name(self) -> ::unity::Il2CppString {
8252 unsafe {
8253 let __receiver = <UnitCalculator_RangeGenderCountCommand as ::unity::FromIlInstance>::from_il_instance(
8254 <Self as ::unity::SystemObject>::as_instance(self),
8255 );
8256 {
8257 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
8258 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
8259 panic!(
8260 "unity: virtual slot {}
8261 out of range (vtable len {}
8262) on the runtime class behind {}
8263 (method `{}
8264`)",
8265 4usize,
8266 __vt.len(),
8267 <UnitCalculator_RangeGenderCountCommand as ::unity::ClassIdentity>::NAME,
8268 "get_Name",
8269 )
8270 });
8271 let __inner: extern "C" fn(UnitCalculator_RangeGenderCountCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
8272 ::core::mem::transmute(__vi.method_ptr);
8273 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
8274 __inner(__receiver, __mi)
8275 }
8276 }
8277 }
8278 #[doc = "`FuncImpl(crate::app::unit::Unit, crate::system::collections::generic::list_1::List_1<f32>)` overload"]
8279 fn func_impl(
8280 self,
8281 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
8282 args: impl ::core::convert::Into<crate::system::collections::generic::list_1::List_1<f32>>,
8283 ) -> f32 {
8284 unsafe {
8285 let __receiver = <UnitCalculator_RangeGenderCountCommand as ::unity::FromIlInstance>::from_il_instance(
8286 <Self as ::unity::SystemObject>::as_instance(self),
8287 );
8288 {
8289 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
8290 let __vi = *__vt.get(34usize).unwrap_or_else(|| {
8291 panic!(
8292 "unity: virtual slot {}
8293 out of range (vtable len {}
8294) on the runtime class behind {}
8295 (method `{}
8296`)",
8297 34usize,
8298 __vt.len(),
8299 <UnitCalculator_RangeGenderCountCommand as ::unity::ClassIdentity>::NAME,
8300 "FuncImpl",
8301 )
8302 });
8303 let __inner: extern "C" fn(
8304 UnitCalculator_RangeGenderCountCommand,
8305 crate::app::unit::Unit,
8306 crate::system::collections::generic::list_1::List_1<f32>,
8307 ::unity::OptionalMethod,
8308 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
8309 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
8310 __inner(__receiver, ::core::convert::Into::into(unit), ::core::convert::Into::into(args), __mi)
8311 }
8312 }
8313 }
8314 #[doc = "`.ctor()` overload"]
8315 fn ctor(self) -> () {
8316 unsafe {
8317 let __receiver = <UnitCalculator_RangeGenderCountCommand as ::unity::FromIlInstance>::from_il_instance(
8318 <Self as ::unity::SystemObject>::as_instance(self),
8319 );
8320 ::unity::il2cpp_call!((::unity::module_base()+0x1b4b690usize)as*mut u8,();
8321(UnitCalculator_RangeGenderCountCommand)__receiver)
8322 }
8323 }
8324}
8325
8326#[cfg(feature = "app-unitcalculator")]
8327impl<__T: IUnitCalculator_RangeGenderCountCommand> IUnitCalculator_RangeGenderCountCommandMethods for __T {}
8328
8329#[cfg(feature = "app-unitcalculator")]
8330impl UnitCalculator_RangeGenderCountCommand {
8331 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8332 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
8333 }
8334
8335 pub fn func_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8336 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
8337 }
8338
8339 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8340 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
8341 }
8342}
8343
8344#[cfg(feature = "app-unitcalculator")]
8345impl UnitCalculator_RangeGenderCountCommand {
8346 #[doc = "Direct (non-virtual) call to `UnitCalculator_RangeGenderCountCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
8347 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
8348 let __mi = Self::get_name_method_info();
8349 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
8350 __inner(this.into(), ::core::option::Option::None)
8351 }
8352
8353 #[doc = "Direct (non-virtual) call to `UnitCalculator_RangeGenderCountCommand`'s own `FuncImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
8354 pub unsafe fn func_impl(
8355 this: impl ::core::convert::Into<::unity::IlInstance>,
8356 unit: crate::app::unit::Unit,
8357 args: crate::system::collections::generic::list_1::List_1<f32>,
8358 ) -> f32 {
8359 let __mi = Self::func_impl_method_info();
8360 let __inner: extern "C" fn(
8361 ::unity::IlInstance,
8362 crate::app::unit::Unit,
8363 crate::system::collections::generic::list_1::List_1<f32>,
8364 ::unity::OptionalMethod,
8365 ) -> f32 = ::core::mem::transmute(__mi.method_ptr);
8366 __inner(this.into(), unit, args, ::core::option::Option::None)
8367 }
8368}
8369
8370#[cfg(feature = "app-unitcalculator")]
8371impl UnitCalculator_RangeGenderCountCommand {
8372 #[doc = "`.ctor()` — no args"]
8373 pub fn new() -> Self {
8374 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
8375 panic!(
8376 "{}
8377::{}
8378 failed to instantiate",
8379 ::core::stringify!(UnitCalculator_RangeGenderCountCommand),
8380 ::core::stringify!(new),
8381 )
8382 });
8383 <Self as IUnitCalculator_RangeGenderCountCommandMethods>::ctor(this);
8384 this
8385 }
8386}
8387
8388#[cfg(feature = "app-unitcalculator")]
8389pub trait IUnitCalculator_ExpRodCountCommandMethods: IUnitCalculator_ExpRodCountCommand {
8390 #[doc = "`get_Name()` overload"]
8391 fn get_name(self) -> ::unity::Il2CppString {
8392 unsafe {
8393 let __receiver =
8394 <UnitCalculator_ExpRodCountCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8395 {
8396 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
8397 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
8398 panic!(
8399 "unity: virtual slot {}
8400 out of range (vtable len {}
8401) on the runtime class behind {}
8402 (method `{}
8403`)",
8404 4usize,
8405 __vt.len(),
8406 <UnitCalculator_ExpRodCountCommand as ::unity::ClassIdentity>::NAME,
8407 "get_Name",
8408 )
8409 });
8410 let __inner: extern "C" fn(UnitCalculator_ExpRodCountCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
8411 ::core::mem::transmute(__vi.method_ptr);
8412 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
8413 __inner(__receiver, __mi)
8414 }
8415 }
8416 }
8417 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
8418 fn get_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
8419 unsafe {
8420 let __receiver =
8421 <UnitCalculator_ExpRodCountCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8422 {
8423 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
8424 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
8425 panic!(
8426 "unity: virtual slot {}
8427 out of range (vtable len {}
8428) on the runtime class behind {}
8429 (method `{}
8430`)",
8431 30usize,
8432 __vt.len(),
8433 <UnitCalculator_ExpRodCountCommand as ::unity::ClassIdentity>::NAME,
8434 "GetImpl",
8435 )
8436 });
8437 let __inner: extern "C" fn(UnitCalculator_ExpRodCountCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
8438 ::core::mem::transmute(__vi.method_ptr);
8439 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
8440 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
8441 }
8442 }
8443 }
8444 #[doc = "`.ctor()` overload"]
8445 fn ctor(self) -> () {
8446 unsafe {
8447 let __receiver =
8448 <UnitCalculator_ExpRodCountCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8449 ::unity::il2cpp_call!((::unity::module_base()+0x1b473f0usize)as*mut u8,();
8450(UnitCalculator_ExpRodCountCommand)__receiver)
8451 }
8452 }
8453}
8454
8455#[cfg(feature = "app-unitcalculator")]
8456impl<__T: IUnitCalculator_ExpRodCountCommand> IUnitCalculator_ExpRodCountCommandMethods for __T {}
8457
8458#[cfg(feature = "app-unitcalculator")]
8459impl UnitCalculator_ExpRodCountCommand {
8460 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8461 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
8462 }
8463
8464 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8465 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
8466 }
8467
8468 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8469 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
8470 }
8471}
8472
8473#[cfg(feature = "app-unitcalculator")]
8474impl UnitCalculator_ExpRodCountCommand {
8475 #[doc = "Direct (non-virtual) call to `UnitCalculator_ExpRodCountCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
8476 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
8477 let __mi = Self::get_name_method_info();
8478 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
8479 __inner(this.into(), ::core::option::Option::None)
8480 }
8481
8482 #[doc = "Direct (non-virtual) call to `UnitCalculator_ExpRodCountCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
8483 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
8484 let __mi = Self::get_impl_method_info();
8485 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
8486 ::core::mem::transmute(__mi.method_ptr);
8487 __inner(this.into(), unit, ::core::option::Option::None)
8488 }
8489}
8490
8491#[cfg(feature = "app-unitcalculator")]
8492impl UnitCalculator_ExpRodCountCommand {
8493 #[doc = "`.ctor()` — no args"]
8494 pub fn new() -> Self {
8495 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
8496 panic!(
8497 "{}
8498::{}
8499 failed to instantiate",
8500 ::core::stringify!(UnitCalculator_ExpRodCountCommand),
8501 ::core::stringify!(new),
8502 )
8503 });
8504 <Self as IUnitCalculator_ExpRodCountCommandMethods>::ctor(this);
8505 this
8506 }
8507}
8508
8509#[cfg(feature = "app-unitcalculator")]
8510pub trait IUnitCalculator_SupportHitCommandMethods: IUnitCalculator_SupportHitCommand {
8511 #[doc = "`get_Name()` overload"]
8512 fn get_name(self) -> ::unity::Il2CppString {
8513 unsafe {
8514 let __receiver =
8515 <UnitCalculator_SupportHitCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8516 {
8517 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
8518 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
8519 panic!(
8520 "unity: virtual slot {}
8521 out of range (vtable len {}
8522) on the runtime class behind {}
8523 (method `{}
8524`)",
8525 4usize,
8526 __vt.len(),
8527 <UnitCalculator_SupportHitCommand as ::unity::ClassIdentity>::NAME,
8528 "get_Name",
8529 )
8530 });
8531 let __inner: extern "C" fn(UnitCalculator_SupportHitCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
8532 ::core::mem::transmute(__vi.method_ptr);
8533 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
8534 __inner(__receiver, __mi)
8535 }
8536 }
8537 }
8538 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
8539 fn get_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
8540 unsafe {
8541 let __receiver =
8542 <UnitCalculator_SupportHitCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8543 {
8544 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
8545 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
8546 panic!(
8547 "unity: virtual slot {}
8548 out of range (vtable len {}
8549) on the runtime class behind {}
8550 (method `{}
8551`)",
8552 31usize,
8553 __vt.len(),
8554 <UnitCalculator_SupportHitCommand as ::unity::ClassIdentity>::NAME,
8555 "GetImpl",
8556 )
8557 });
8558 let __inner: extern "C" fn(
8559 UnitCalculator_SupportHitCommand,
8560 crate::app::battleinfoside::BattleInfoSide,
8561 ::unity::OptionalMethod,
8562 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
8563 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
8564 __inner(__receiver, ::core::convert::Into::into(side), __mi)
8565 }
8566 }
8567 }
8568 #[doc = "`SetImpl(crate::app::battleinfoside::BattleInfoSide, f32)` overload"]
8569 fn set_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>, value: impl ::core::convert::Into<f32>) -> () {
8570 unsafe {
8571 let __receiver =
8572 <UnitCalculator_SupportHitCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8573 {
8574 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
8575 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
8576 panic!(
8577 "unity: virtual slot {}
8578 out of range (vtable len {}
8579) on the runtime class behind {}
8580 (method `{}
8581`)",
8582 33usize,
8583 __vt.len(),
8584 <UnitCalculator_SupportHitCommand as ::unity::ClassIdentity>::NAME,
8585 "SetImpl",
8586 )
8587 });
8588 let __inner: extern "C" fn(
8589 UnitCalculator_SupportHitCommand,
8590 crate::app::battleinfoside::BattleInfoSide,
8591 f32,
8592 ::unity::OptionalMethod,
8593 ) -> () = ::core::mem::transmute(__vi.method_ptr);
8594 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
8595 __inner(__receiver, ::core::convert::Into::into(side), ::core::convert::Into::into(value), __mi)
8596 }
8597 }
8598 }
8599 #[doc = "`IsVisible()` overload"]
8600 fn is_visible(self) -> bool {
8601 unsafe {
8602 let __receiver =
8603 <UnitCalculator_SupportHitCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8604 {
8605 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
8606 let __vi = *__vt.get(43usize).unwrap_or_else(|| {
8607 panic!(
8608 "unity: virtual slot {}
8609 out of range (vtable len {}
8610) on the runtime class behind {}
8611 (method `{}
8612`)",
8613 43usize,
8614 __vt.len(),
8615 <UnitCalculator_SupportHitCommand as ::unity::ClassIdentity>::NAME,
8616 "IsVisible",
8617 )
8618 });
8619 let __inner: extern "C" fn(UnitCalculator_SupportHitCommand, ::unity::OptionalMethod) -> bool =
8620 ::core::mem::transmute(__vi.method_ptr);
8621 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
8622 __inner(__receiver, __mi)
8623 }
8624 }
8625 }
8626 #[doc = "`.ctor()` overload"]
8627 fn ctor(self) -> () {
8628 unsafe {
8629 let __receiver =
8630 <UnitCalculator_SupportHitCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8631 ::unity::il2cpp_call!((::unity::module_base()+0x1b4c440usize)as*mut u8,();
8632(UnitCalculator_SupportHitCommand)__receiver)
8633 }
8634 }
8635}
8636
8637#[cfg(feature = "app-unitcalculator")]
8638impl<__T: IUnitCalculator_SupportHitCommand> IUnitCalculator_SupportHitCommandMethods for __T {}
8639
8640#[cfg(feature = "app-unitcalculator")]
8641impl UnitCalculator_SupportHitCommand {
8642 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8643 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
8644 }
8645
8646 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8647 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
8648 }
8649
8650 pub fn set_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8651 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
8652 }
8653
8654 pub fn is_visible_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8655 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
8656 }
8657
8658 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8659 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
8660 }
8661}
8662
8663#[cfg(feature = "app-unitcalculator")]
8664impl UnitCalculator_SupportHitCommand {
8665 #[doc = "Direct (non-virtual) call to `UnitCalculator_SupportHitCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
8666 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
8667 let __mi = Self::get_name_method_info();
8668 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
8669 __inner(this.into(), ::core::option::Option::None)
8670 }
8671
8672 #[doc = "Direct (non-virtual) call to `UnitCalculator_SupportHitCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
8673 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
8674 let __mi = Self::get_impl_method_info();
8675 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
8676 ::core::mem::transmute(__mi.method_ptr);
8677 __inner(this.into(), side, ::core::option::Option::None)
8678 }
8679
8680 #[doc = "Direct (non-virtual) call to `UnitCalculator_SupportHitCommand`'s own `SetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
8681 pub unsafe fn set_impl(
8682 this: impl ::core::convert::Into<::unity::IlInstance>,
8683 side: crate::app::battleinfoside::BattleInfoSide,
8684 value: f32,
8685 ) -> () {
8686 let __mi = Self::set_impl_method_info();
8687 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, f32, ::unity::OptionalMethod) -> () =
8688 ::core::mem::transmute(__mi.method_ptr);
8689 __inner(this.into(), side, value, ::core::option::Option::None)
8690 }
8691
8692 #[doc = "Direct (non-virtual) call to `UnitCalculator_SupportHitCommand`'s own `IsVisible`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
8693 pub unsafe fn is_visible(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
8694 let __mi = Self::is_visible_method_info();
8695 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
8696 __inner(this.into(), ::core::option::Option::None)
8697 }
8698}
8699
8700#[cfg(feature = "app-unitcalculator")]
8701impl UnitCalculator_SupportHitCommand {
8702 #[doc = "`.ctor()` — no args"]
8703 pub fn new() -> Self {
8704 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
8705 panic!(
8706 "{}
8707::{}
8708 failed to instantiate",
8709 ::core::stringify!(UnitCalculator_SupportHitCommand),
8710 ::core::stringify!(new),
8711 )
8712 });
8713 <Self as IUnitCalculator_SupportHitCommandMethods>::ctor(this);
8714 this
8715 }
8716}
8717
8718#[cfg(feature = "app-unitcalculator")]
8719pub trait IUnitCalculator_UnitIdentCommandMethods: IUnitCalculator_UnitIdentCommand {
8720 #[doc = "`get_Name()` overload"]
8721 fn get_name(self) -> ::unity::Il2CppString {
8722 unsafe {
8723 let __receiver =
8724 <UnitCalculator_UnitIdentCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8725 {
8726 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
8727 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
8728 panic!(
8729 "unity: virtual slot {}
8730 out of range (vtable len {}
8731) on the runtime class behind {}
8732 (method `{}
8733`)",
8734 4usize,
8735 __vt.len(),
8736 <UnitCalculator_UnitIdentCommand as ::unity::ClassIdentity>::NAME,
8737 "get_Name",
8738 )
8739 });
8740 let __inner: extern "C" fn(UnitCalculator_UnitIdentCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
8741 ::core::mem::transmute(__vi.method_ptr);
8742 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
8743 __inner(__receiver, __mi)
8744 }
8745 }
8746 }
8747 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
8748 fn get_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
8749 unsafe {
8750 let __receiver =
8751 <UnitCalculator_UnitIdentCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8752 {
8753 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
8754 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
8755 panic!(
8756 "unity: virtual slot {}
8757 out of range (vtable len {}
8758) on the runtime class behind {}
8759 (method `{}
8760`)",
8761 30usize,
8762 __vt.len(),
8763 <UnitCalculator_UnitIdentCommand as ::unity::ClassIdentity>::NAME,
8764 "GetImpl",
8765 )
8766 });
8767 let __inner: extern "C" fn(UnitCalculator_UnitIdentCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
8768 ::core::mem::transmute(__vi.method_ptr);
8769 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
8770 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
8771 }
8772 }
8773 }
8774 #[doc = "`.ctor()` overload"]
8775 fn ctor(self) -> () {
8776 unsafe {
8777 let __receiver =
8778 <UnitCalculator_UnitIdentCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8779 ::unity::il2cpp_call!((::unity::module_base()+0x1b4d5f0usize)as*mut u8,();
8780(UnitCalculator_UnitIdentCommand)__receiver)
8781 }
8782 }
8783}
8784
8785#[cfg(feature = "app-unitcalculator")]
8786impl<__T: IUnitCalculator_UnitIdentCommand> IUnitCalculator_UnitIdentCommandMethods for __T {}
8787
8788#[cfg(feature = "app-unitcalculator")]
8789impl UnitCalculator_UnitIdentCommand {
8790 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8791 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
8792 }
8793
8794 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8795 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
8796 }
8797
8798 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8799 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
8800 }
8801}
8802
8803#[cfg(feature = "app-unitcalculator")]
8804impl UnitCalculator_UnitIdentCommand {
8805 #[doc = "Direct (non-virtual) call to `UnitCalculator_UnitIdentCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
8806 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
8807 let __mi = Self::get_name_method_info();
8808 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
8809 __inner(this.into(), ::core::option::Option::None)
8810 }
8811
8812 #[doc = "Direct (non-virtual) call to `UnitCalculator_UnitIdentCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
8813 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
8814 let __mi = Self::get_impl_method_info();
8815 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
8816 ::core::mem::transmute(__mi.method_ptr);
8817 __inner(this.into(), unit, ::core::option::Option::None)
8818 }
8819}
8820
8821#[cfg(feature = "app-unitcalculator")]
8822impl UnitCalculator_UnitIdentCommand {
8823 #[doc = "`.ctor()` — no args"]
8824 pub fn new() -> Self {
8825 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
8826 panic!(
8827 "{}
8828::{}
8829 failed to instantiate",
8830 ::core::stringify!(UnitCalculator_UnitIdentCommand),
8831 ::core::stringify!(new),
8832 )
8833 });
8834 <Self as IUnitCalculator_UnitIdentCommandMethods>::ctor(this);
8835 this
8836 }
8837}
8838
8839#[cfg(feature = "app-unitcalculator")]
8840pub trait IUnitCalculator_BattleParamCommandMethods: IUnitCalculator_BattleParamCommand {
8841 #[doc = "`.ctor()` overload"]
8842 fn ctor(self) -> () {
8843 unsafe {
8844 let __receiver =
8845 <UnitCalculator_BattleParamCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8846 ::unity::il2cpp_call!((::unity::module_base()+0x1b45480usize)as*mut u8,();
8847(UnitCalculator_BattleParamCommand)__receiver)
8848 }
8849 }
8850 #[doc = "`GetParam(crate::app::battleinfoside::BattleInfoSide)` overload"]
8851 fn get_param(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> crate::app::battleparam::BattleParam {
8852 unsafe {
8853 let __receiver =
8854 <UnitCalculator_BattleParamCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8855 {
8856 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
8857 let __vi = *__vt.get(44usize).unwrap_or_else(|| {
8858 panic!(
8859 "unity: virtual slot {}
8860 out of range (vtable len {}
8861) on the runtime class behind {}
8862 (method `{}
8863`)",
8864 44usize,
8865 __vt.len(),
8866 <UnitCalculator_BattleParamCommand as ::unity::ClassIdentity>::NAME,
8867 "GetParam",
8868 )
8869 });
8870 let __inner: extern "C" fn(
8871 UnitCalculator_BattleParamCommand,
8872 crate::app::battleinfoside::BattleInfoSide,
8873 ::unity::OptionalMethod,
8874 ) -> crate::app::battleparam::BattleParam = ::core::mem::transmute(__vi.method_ptr);
8875 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
8876 __inner(__receiver, ::core::convert::Into::into(side), __mi)
8877 }
8878 }
8879 }
8880 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
8881 fn get_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
8882 unsafe {
8883 let __receiver =
8884 <UnitCalculator_BattleParamCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8885 {
8886 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
8887 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
8888 panic!(
8889 "unity: virtual slot {}
8890 out of range (vtable len {}
8891) on the runtime class behind {}
8892 (method `{}
8893`)",
8894 31usize,
8895 __vt.len(),
8896 <UnitCalculator_BattleParamCommand as ::unity::ClassIdentity>::NAME,
8897 "GetImpl",
8898 )
8899 });
8900 let __inner: extern "C" fn(
8901 UnitCalculator_BattleParamCommand,
8902 crate::app::battleinfoside::BattleInfoSide,
8903 ::unity::OptionalMethod,
8904 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
8905 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
8906 __inner(__receiver, ::core::convert::Into::into(side), __mi)
8907 }
8908 }
8909 }
8910 #[doc = "`AddImpl(crate::app::battleinfoside::BattleInfoSide, f32)` overload"]
8911 fn add_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>, value: impl ::core::convert::Into<f32>) -> () {
8912 unsafe {
8913 let __receiver =
8914 <UnitCalculator_BattleParamCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8915 {
8916 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
8917 let __vi = *__vt.get(39usize).unwrap_or_else(|| {
8918 panic!(
8919 "unity: virtual slot {}
8920 out of range (vtable len {}
8921) on the runtime class behind {}
8922 (method `{}
8923`)",
8924 39usize,
8925 __vt.len(),
8926 <UnitCalculator_BattleParamCommand as ::unity::ClassIdentity>::NAME,
8927 "AddImpl",
8928 )
8929 });
8930 let __inner: extern "C" fn(
8931 UnitCalculator_BattleParamCommand,
8932 crate::app::battleinfoside::BattleInfoSide,
8933 f32,
8934 ::unity::OptionalMethod,
8935 ) -> () = ::core::mem::transmute(__vi.method_ptr);
8936 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
8937 __inner(__receiver, ::core::convert::Into::into(side), ::core::convert::Into::into(value), __mi)
8938 }
8939 }
8940 }
8941 #[doc = "`ScaleImpl(crate::app::battleinfoside::BattleInfoSide, f32)` overload"]
8942 fn scale_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>, value: impl ::core::convert::Into<f32>) -> () {
8943 unsafe {
8944 let __receiver =
8945 <UnitCalculator_BattleParamCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8946 {
8947 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
8948 let __vi = *__vt.get(41usize).unwrap_or_else(|| {
8949 panic!(
8950 "unity: virtual slot {}
8951 out of range (vtable len {}
8952) on the runtime class behind {}
8953 (method `{}
8954`)",
8955 41usize,
8956 __vt.len(),
8957 <UnitCalculator_BattleParamCommand as ::unity::ClassIdentity>::NAME,
8958 "ScaleImpl",
8959 )
8960 });
8961 let __inner: extern "C" fn(
8962 UnitCalculator_BattleParamCommand,
8963 crate::app::battleinfoside::BattleInfoSide,
8964 f32,
8965 ::unity::OptionalMethod,
8966 ) -> () = ::core::mem::transmute(__vi.method_ptr);
8967 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
8968 __inner(__receiver, ::core::convert::Into::into(side), ::core::convert::Into::into(value), __mi)
8969 }
8970 }
8971 }
8972 #[doc = "`SetImpl(crate::app::battleinfoside::BattleInfoSide, f32)` overload"]
8973 fn set_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>, value: impl ::core::convert::Into<f32>) -> () {
8974 unsafe {
8975 let __receiver =
8976 <UnitCalculator_BattleParamCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8977 {
8978 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
8979 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
8980 panic!(
8981 "unity: virtual slot {}
8982 out of range (vtable len {}
8983) on the runtime class behind {}
8984 (method `{}
8985`)",
8986 33usize,
8987 __vt.len(),
8988 <UnitCalculator_BattleParamCommand as ::unity::ClassIdentity>::NAME,
8989 "SetImpl",
8990 )
8991 });
8992 let __inner: extern "C" fn(
8993 UnitCalculator_BattleParamCommand,
8994 crate::app::battleinfoside::BattleInfoSide,
8995 f32,
8996 ::unity::OptionalMethod,
8997 ) -> () = ::core::mem::transmute(__vi.method_ptr);
8998 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
8999 __inner(__receiver, ::core::convert::Into::into(side), ::core::convert::Into::into(value), __mi)
9000 }
9001 }
9002 }
9003}
9004
9005#[cfg(feature = "app-unitcalculator")]
9006impl<__T: IUnitCalculator_BattleParamCommand> IUnitCalculator_BattleParamCommandMethods for __T {}
9007
9008#[cfg(feature = "app-unitcalculator")]
9009impl UnitCalculator_BattleParamCommand {
9010 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
9011 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
9012 }
9013
9014 pub fn get_param_method_info() -> &'static ::unity::il2cpp::MethodInfo {
9015 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
9016 }
9017
9018 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
9019 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
9020 }
9021
9022 pub fn add_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
9023 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
9024 }
9025
9026 pub fn scale_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
9027 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
9028 }
9029
9030 pub fn set_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
9031 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
9032 }
9033}
9034
9035#[cfg(feature = "app-unitcalculator")]
9036impl UnitCalculator_BattleParamCommand {
9037 #[doc = "Direct (non-virtual) call to `UnitCalculator_BattleParamCommand`'s own `GetParam`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
9038 pub unsafe fn get_param(
9039 this: impl ::core::convert::Into<::unity::IlInstance>,
9040 side: crate::app::battleinfoside::BattleInfoSide,
9041 ) -> crate::app::battleparam::BattleParam {
9042 let __mi = Self::get_param_method_info();
9043 let __inner: extern "C" fn(
9044 ::unity::IlInstance,
9045 crate::app::battleinfoside::BattleInfoSide,
9046 ::unity::OptionalMethod,
9047 ) -> crate::app::battleparam::BattleParam = ::core::mem::transmute(__mi.method_ptr);
9048 __inner(this.into(), side, ::core::option::Option::None)
9049 }
9050
9051 #[doc = "Direct (non-virtual) call to `UnitCalculator_BattleParamCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
9052 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
9053 let __mi = Self::get_impl_method_info();
9054 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
9055 ::core::mem::transmute(__mi.method_ptr);
9056 __inner(this.into(), side, ::core::option::Option::None)
9057 }
9058
9059 #[doc = "Direct (non-virtual) call to `UnitCalculator_BattleParamCommand`'s own `AddImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
9060 pub unsafe fn add_impl(
9061 this: impl ::core::convert::Into<::unity::IlInstance>,
9062 side: crate::app::battleinfoside::BattleInfoSide,
9063 value: f32,
9064 ) -> () {
9065 let __mi = Self::add_impl_method_info();
9066 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, f32, ::unity::OptionalMethod) -> () =
9067 ::core::mem::transmute(__mi.method_ptr);
9068 __inner(this.into(), side, value, ::core::option::Option::None)
9069 }
9070
9071 #[doc = "Direct (non-virtual) call to `UnitCalculator_BattleParamCommand`'s own `ScaleImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
9072 pub unsafe fn scale_impl(
9073 this: impl ::core::convert::Into<::unity::IlInstance>,
9074 side: crate::app::battleinfoside::BattleInfoSide,
9075 value: f32,
9076 ) -> () {
9077 let __mi = Self::scale_impl_method_info();
9078 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, f32, ::unity::OptionalMethod) -> () =
9079 ::core::mem::transmute(__mi.method_ptr);
9080 __inner(this.into(), side, value, ::core::option::Option::None)
9081 }
9082
9083 #[doc = "Direct (non-virtual) call to `UnitCalculator_BattleParamCommand`'s own `SetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
9084 pub unsafe fn set_impl(
9085 this: impl ::core::convert::Into<::unity::IlInstance>,
9086 side: crate::app::battleinfoside::BattleInfoSide,
9087 value: f32,
9088 ) -> () {
9089 let __mi = Self::set_impl_method_info();
9090 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, f32, ::unity::OptionalMethod) -> () =
9091 ::core::mem::transmute(__mi.method_ptr);
9092 __inner(this.into(), side, value, ::core::option::Option::None)
9093 }
9094}
9095
9096#[cfg(feature = "app-unitcalculator")]
9097impl UnitCalculator_BattleParamCommand {
9098 #[doc = "`.ctor()` — no args"]
9099 pub fn new() -> Self {
9100 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
9101 panic!(
9102 "{}
9103::{}
9104 failed to instantiate",
9105 ::core::stringify!(UnitCalculator_BattleParamCommand),
9106 ::core::stringify!(new),
9107 )
9108 });
9109 <Self as IUnitCalculator_BattleParamCommandMethods>::ctor(this);
9110 this
9111 }
9112}
9113
9114#[cfg(feature = "app-unitcalculator")]
9115pub trait IUnitCalculator_LinkTechCommandMethods: IUnitCalculator_LinkTechCommand {
9116 #[doc = "`get_Name()` overload"]
9117 fn get_name(self) -> ::unity::Il2CppString {
9118 unsafe {
9119 let __receiver =
9120 <UnitCalculator_LinkTechCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9121 {
9122 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
9123 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
9124 panic!(
9125 "unity: virtual slot {}
9126 out of range (vtable len {}
9127) on the runtime class behind {}
9128 (method `{}
9129`)",
9130 4usize,
9131 __vt.len(),
9132 <UnitCalculator_LinkTechCommand as ::unity::ClassIdentity>::NAME,
9133 "get_Name",
9134 )
9135 });
9136 let __inner: extern "C" fn(UnitCalculator_LinkTechCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
9137 ::core::mem::transmute(__vi.method_ptr);
9138 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
9139 __inner(__receiver, __mi)
9140 }
9141 }
9142 }
9143 #[doc = "`get_CapabilityType()` overload"]
9144 fn get_capability_type(self) -> crate::app::capabilitydefinition::CapabilityDefinition_Type {
9145 unsafe {
9146 let __receiver =
9147 <UnitCalculator_LinkTechCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9148 {
9149 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
9150 let __vi = *__vt.get(44usize).unwrap_or_else(|| {
9151 panic!(
9152 "unity: virtual slot {}
9153 out of range (vtable len {}
9154) on the runtime class behind {}
9155 (method `{}
9156`)",
9157 44usize,
9158 __vt.len(),
9159 <UnitCalculator_LinkTechCommand as ::unity::ClassIdentity>::NAME,
9160 "get_CapabilityType",
9161 )
9162 });
9163 let __inner: extern "C" fn(
9164 UnitCalculator_LinkTechCommand,
9165 ::unity::OptionalMethod,
9166 ) -> crate::app::capabilitydefinition::CapabilityDefinition_Type = ::core::mem::transmute(__vi.method_ptr);
9167 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
9168 __inner(__receiver, __mi)
9169 }
9170 }
9171 }
9172 #[doc = "`.ctor()` overload"]
9173 fn ctor(self) -> () {
9174 unsafe {
9175 let __receiver =
9176 <UnitCalculator_LinkTechCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9177 ::unity::il2cpp_call!((::unity::module_base()+0x1b48d40usize)as*mut u8,();
9178(UnitCalculator_LinkTechCommand)__receiver)
9179 }
9180 }
9181}
9182
9183#[cfg(feature = "app-unitcalculator")]
9184impl<__T: IUnitCalculator_LinkTechCommand> IUnitCalculator_LinkTechCommandMethods for __T {}
9185
9186#[cfg(feature = "app-unitcalculator")]
9187impl UnitCalculator_LinkTechCommand {
9188 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
9189 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
9190 }
9191
9192 pub fn get_capability_type_method_info() -> &'static ::unity::il2cpp::MethodInfo {
9193 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
9194 }
9195
9196 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
9197 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
9198 }
9199}
9200
9201#[cfg(feature = "app-unitcalculator")]
9202impl UnitCalculator_LinkTechCommand {
9203 #[doc = "Direct (non-virtual) call to `UnitCalculator_LinkTechCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
9204 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
9205 let __mi = Self::get_name_method_info();
9206 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
9207 __inner(this.into(), ::core::option::Option::None)
9208 }
9209
9210 #[doc = "Direct (non-virtual) call to `UnitCalculator_LinkTechCommand`'s own `get_CapabilityType`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
9211 pub unsafe fn get_capability_type(
9212 this: impl ::core::convert::Into<::unity::IlInstance>,
9213 ) -> crate::app::capabilitydefinition::CapabilityDefinition_Type {
9214 let __mi = Self::get_capability_type_method_info();
9215 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::capabilitydefinition::CapabilityDefinition_Type =
9216 ::core::mem::transmute(__mi.method_ptr);
9217 __inner(this.into(), ::core::option::Option::None)
9218 }
9219}
9220
9221#[cfg(feature = "app-unitcalculator")]
9222impl UnitCalculator_LinkTechCommand {
9223 #[doc = "`.ctor()` — no args"]
9224 pub fn new() -> Self {
9225 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
9226 panic!(
9227 "{}
9228::{}
9229 failed to instantiate",
9230 ::core::stringify!(UnitCalculator_LinkTechCommand),
9231 ::core::stringify!(new),
9232 )
9233 });
9234 <Self as IUnitCalculator_LinkTechCommandMethods>::ctor(this);
9235 this
9236 }
9237}
9238
9239#[cfg(feature = "app-unitcalculator")]
9240pub trait IUnitCalculator_MoveTypeCommandMethods: IUnitCalculator_MoveTypeCommand {
9241 #[doc = "`get_Name()` overload"]
9242 fn get_name(self) -> ::unity::Il2CppString {
9243 unsafe {
9244 let __receiver =
9245 <UnitCalculator_MoveTypeCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9246 {
9247 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
9248 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
9249 panic!(
9250 "unity: virtual slot {}
9251 out of range (vtable len {}
9252) on the runtime class behind {}
9253 (method `{}
9254`)",
9255 4usize,
9256 __vt.len(),
9257 <UnitCalculator_MoveTypeCommand as ::unity::ClassIdentity>::NAME,
9258 "get_Name",
9259 )
9260 });
9261 let __inner: extern "C" fn(UnitCalculator_MoveTypeCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
9262 ::core::mem::transmute(__vi.method_ptr);
9263 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
9264 __inner(__receiver, __mi)
9265 }
9266 }
9267 }
9268 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
9269 fn get_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
9270 unsafe {
9271 let __receiver =
9272 <UnitCalculator_MoveTypeCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9273 {
9274 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
9275 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
9276 panic!(
9277 "unity: virtual slot {}
9278 out of range (vtable len {}
9279) on the runtime class behind {}
9280 (method `{}
9281`)",
9282 30usize,
9283 __vt.len(),
9284 <UnitCalculator_MoveTypeCommand as ::unity::ClassIdentity>::NAME,
9285 "GetImpl",
9286 )
9287 });
9288 let __inner: extern "C" fn(UnitCalculator_MoveTypeCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
9289 ::core::mem::transmute(__vi.method_ptr);
9290 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
9291 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
9292 }
9293 }
9294 }
9295 #[doc = "`GetInvalid()` overload"]
9296 fn get_invalid(self) -> f32 {
9297 unsafe {
9298 let __receiver =
9299 <UnitCalculator_MoveTypeCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9300 {
9301 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
9302 let __vi = *__vt.get(42usize).unwrap_or_else(|| {
9303 panic!(
9304 "unity: virtual slot {}
9305 out of range (vtable len {}
9306) on the runtime class behind {}
9307 (method `{}
9308`)",
9309 42usize,
9310 __vt.len(),
9311 <UnitCalculator_MoveTypeCommand as ::unity::ClassIdentity>::NAME,
9312 "GetInvalid",
9313 )
9314 });
9315 let __inner: extern "C" fn(UnitCalculator_MoveTypeCommand, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__vi.method_ptr);
9316 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
9317 __inner(__receiver, __mi)
9318 }
9319 }
9320 }
9321 #[doc = "`.ctor()` overload"]
9322 fn ctor(self) -> () {
9323 unsafe {
9324 let __receiver =
9325 <UnitCalculator_MoveTypeCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9326 ::unity::il2cpp_call!((::unity::module_base()+0x1b4a6b0usize)as*mut u8,();
9327(UnitCalculator_MoveTypeCommand)__receiver)
9328 }
9329 }
9330}
9331
9332#[cfg(feature = "app-unitcalculator")]
9333impl<__T: IUnitCalculator_MoveTypeCommand> IUnitCalculator_MoveTypeCommandMethods for __T {}
9334
9335#[cfg(feature = "app-unitcalculator")]
9336impl UnitCalculator_MoveTypeCommand {
9337 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
9338 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
9339 }
9340
9341 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
9342 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
9343 }
9344
9345 pub fn get_invalid_method_info() -> &'static ::unity::il2cpp::MethodInfo {
9346 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
9347 }
9348
9349 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
9350 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
9351 }
9352}
9353
9354#[cfg(feature = "app-unitcalculator")]
9355impl UnitCalculator_MoveTypeCommand {
9356 #[doc = "Direct (non-virtual) call to `UnitCalculator_MoveTypeCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
9357 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
9358 let __mi = Self::get_name_method_info();
9359 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
9360 __inner(this.into(), ::core::option::Option::None)
9361 }
9362
9363 #[doc = "Direct (non-virtual) call to `UnitCalculator_MoveTypeCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
9364 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
9365 let __mi = Self::get_impl_method_info();
9366 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
9367 ::core::mem::transmute(__mi.method_ptr);
9368 __inner(this.into(), unit, ::core::option::Option::None)
9369 }
9370
9371 #[doc = "Direct (non-virtual) call to `UnitCalculator_MoveTypeCommand`'s own `GetInvalid`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
9372 pub unsafe fn get_invalid(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
9373 let __mi = Self::get_invalid_method_info();
9374 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
9375 __inner(this.into(), ::core::option::Option::None)
9376 }
9377}
9378
9379#[cfg(feature = "app-unitcalculator")]
9380impl UnitCalculator_MoveTypeCommand {
9381 #[doc = "`.ctor()` — no args"]
9382 pub fn new() -> Self {
9383 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
9384 panic!(
9385 "{}
9386::{}
9387 failed to instantiate",
9388 ::core::stringify!(UnitCalculator_MoveTypeCommand),
9389 ::core::stringify!(new),
9390 )
9391 });
9392 <Self as IUnitCalculator_MoveTypeCommandMethods>::ctor(this);
9393 this
9394 }
9395}
9396
9397#[cfg(feature = "app-unitcalculator")]
9398pub trait IUnitCalculator_BattleSceneResultCommandMethods: IUnitCalculator_BattleSceneResultCommand {
9399 #[doc = "`get_Name()` overload"]
9400 fn get_name(self) -> ::unity::Il2CppString {
9401 unsafe {
9402 let __receiver = <UnitCalculator_BattleSceneResultCommand as ::unity::FromIlInstance>::from_il_instance(
9403 <Self as ::unity::SystemObject>::as_instance(self),
9404 );
9405 {
9406 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
9407 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
9408 panic!(
9409 "unity: virtual slot {}
9410 out of range (vtable len {}
9411) on the runtime class behind {}
9412 (method `{}
9413`)",
9414 4usize,
9415 __vt.len(),
9416 <UnitCalculator_BattleSceneResultCommand as ::unity::ClassIdentity>::NAME,
9417 "get_Name",
9418 )
9419 });
9420 let __inner: extern "C" fn(UnitCalculator_BattleSceneResultCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
9421 ::core::mem::transmute(__vi.method_ptr);
9422 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
9423 __inner(__receiver, __mi)
9424 }
9425 }
9426 }
9427 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
9428 fn get_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
9429 unsafe {
9430 let __receiver = <UnitCalculator_BattleSceneResultCommand as ::unity::FromIlInstance>::from_il_instance(
9431 <Self as ::unity::SystemObject>::as_instance(self),
9432 );
9433 {
9434 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
9435 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
9436 panic!(
9437 "unity: virtual slot {}
9438 out of range (vtable len {}
9439) on the runtime class behind {}
9440 (method `{}
9441`)",
9442 31usize,
9443 __vt.len(),
9444 <UnitCalculator_BattleSceneResultCommand as ::unity::ClassIdentity>::NAME,
9445 "GetImpl",
9446 )
9447 });
9448 let __inner: extern "C" fn(
9449 UnitCalculator_BattleSceneResultCommand,
9450 crate::app::battleinfoside::BattleInfoSide,
9451 ::unity::OptionalMethod,
9452 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
9453 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
9454 __inner(__receiver, ::core::convert::Into::into(side), __mi)
9455 }
9456 }
9457 }
9458 #[doc = "`SetImpl(crate::app::battleinfoside::BattleInfoSide, f32)` overload"]
9459 fn set_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>, value: impl ::core::convert::Into<f32>) -> () {
9460 unsafe {
9461 let __receiver = <UnitCalculator_BattleSceneResultCommand as ::unity::FromIlInstance>::from_il_instance(
9462 <Self as ::unity::SystemObject>::as_instance(self),
9463 );
9464 {
9465 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
9466 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
9467 panic!(
9468 "unity: virtual slot {}
9469 out of range (vtable len {}
9470) on the runtime class behind {}
9471 (method `{}
9472`)",
9473 33usize,
9474 __vt.len(),
9475 <UnitCalculator_BattleSceneResultCommand as ::unity::ClassIdentity>::NAME,
9476 "SetImpl",
9477 )
9478 });
9479 let __inner: extern "C" fn(
9480 UnitCalculator_BattleSceneResultCommand,
9481 crate::app::battleinfoside::BattleInfoSide,
9482 f32,
9483 ::unity::OptionalMethod,
9484 ) -> () = ::core::mem::transmute(__vi.method_ptr);
9485 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
9486 __inner(__receiver, ::core::convert::Into::into(side), ::core::convert::Into::into(value), __mi)
9487 }
9488 }
9489 }
9490 #[doc = "`FuncImpl(crate::app::battleinfoside::BattleInfoSide, crate::system::collections::generic::list_1::List_1<f32>)` overload"]
9491 fn func_impl(
9492 self,
9493 side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
9494 args: impl ::core::convert::Into<crate::system::collections::generic::list_1::List_1<f32>>,
9495 ) -> f32 {
9496 unsafe {
9497 let __receiver = <UnitCalculator_BattleSceneResultCommand as ::unity::FromIlInstance>::from_il_instance(
9498 <Self as ::unity::SystemObject>::as_instance(self),
9499 );
9500 {
9501 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
9502 let __vi = *__vt.get(35usize).unwrap_or_else(|| {
9503 panic!(
9504 "unity: virtual slot {}
9505 out of range (vtable len {}
9506) on the runtime class behind {}
9507 (method `{}
9508`)",
9509 35usize,
9510 __vt.len(),
9511 <UnitCalculator_BattleSceneResultCommand as ::unity::ClassIdentity>::NAME,
9512 "FuncImpl",
9513 )
9514 });
9515 let __inner: extern "C" fn(
9516 UnitCalculator_BattleSceneResultCommand,
9517 crate::app::battleinfoside::BattleInfoSide,
9518 crate::system::collections::generic::list_1::List_1<f32>,
9519 ::unity::OptionalMethod,
9520 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
9521 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
9522 __inner(__receiver, ::core::convert::Into::into(side), ::core::convert::Into::into(args), __mi)
9523 }
9524 }
9525 }
9526 #[doc = "`.ctor()` overload"]
9527 fn ctor(self) -> () {
9528 unsafe {
9529 let __receiver = <UnitCalculator_BattleSceneResultCommand as ::unity::FromIlInstance>::from_il_instance(
9530 <Self as ::unity::SystemObject>::as_instance(self),
9531 );
9532 ::unity::il2cpp_call!((::unity::module_base()+0x1b46240usize)as*mut u8,();
9533(UnitCalculator_BattleSceneResultCommand)__receiver)
9534 }
9535 }
9536}
9537
9538#[cfg(feature = "app-unitcalculator")]
9539impl<__T: IUnitCalculator_BattleSceneResultCommand> IUnitCalculator_BattleSceneResultCommandMethods for __T {}
9540
9541#[cfg(feature = "app-unitcalculator")]
9542impl UnitCalculator_BattleSceneResultCommand {
9543 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
9544 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
9545 }
9546
9547 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
9548 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
9549 }
9550
9551 pub fn set_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
9552 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
9553 }
9554
9555 pub fn func_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
9556 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
9557 }
9558
9559 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
9560 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
9561 }
9562}
9563
9564#[cfg(feature = "app-unitcalculator")]
9565impl UnitCalculator_BattleSceneResultCommand {
9566 #[doc = "Direct (non-virtual) call to `UnitCalculator_BattleSceneResultCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
9567 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
9568 let __mi = Self::get_name_method_info();
9569 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
9570 __inner(this.into(), ::core::option::Option::None)
9571 }
9572
9573 #[doc = "Direct (non-virtual) call to `UnitCalculator_BattleSceneResultCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
9574 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
9575 let __mi = Self::get_impl_method_info();
9576 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
9577 ::core::mem::transmute(__mi.method_ptr);
9578 __inner(this.into(), side, ::core::option::Option::None)
9579 }
9580
9581 #[doc = "Direct (non-virtual) call to `UnitCalculator_BattleSceneResultCommand`'s own `SetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
9582 pub unsafe fn set_impl(
9583 this: impl ::core::convert::Into<::unity::IlInstance>,
9584 side: crate::app::battleinfoside::BattleInfoSide,
9585 value: f32,
9586 ) -> () {
9587 let __mi = Self::set_impl_method_info();
9588 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, f32, ::unity::OptionalMethod) -> () =
9589 ::core::mem::transmute(__mi.method_ptr);
9590 __inner(this.into(), side, value, ::core::option::Option::None)
9591 }
9592
9593 #[doc = "Direct (non-virtual) call to `UnitCalculator_BattleSceneResultCommand`'s own `FuncImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
9594 pub unsafe fn func_impl(
9595 this: impl ::core::convert::Into<::unity::IlInstance>,
9596 side: crate::app::battleinfoside::BattleInfoSide,
9597 args: crate::system::collections::generic::list_1::List_1<f32>,
9598 ) -> f32 {
9599 let __mi = Self::func_impl_method_info();
9600 let __inner: extern "C" fn(
9601 ::unity::IlInstance,
9602 crate::app::battleinfoside::BattleInfoSide,
9603 crate::system::collections::generic::list_1::List_1<f32>,
9604 ::unity::OptionalMethod,
9605 ) -> f32 = ::core::mem::transmute(__mi.method_ptr);
9606 __inner(this.into(), side, args, ::core::option::Option::None)
9607 }
9608}
9609
9610#[cfg(feature = "app-unitcalculator")]
9611impl UnitCalculator_BattleSceneResultCommand {
9612 #[doc = "`.ctor()` — no args"]
9613 pub fn new() -> Self {
9614 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
9615 panic!(
9616 "{}
9617::{}
9618 failed to instantiate",
9619 ::core::stringify!(UnitCalculator_BattleSceneResultCommand),
9620 ::core::stringify!(new),
9621 )
9622 });
9623 <Self as IUnitCalculator_BattleSceneResultCommandMethods>::ctor(this);
9624 this
9625 }
9626}
9627
9628#[cfg(feature = "app-unitcalculator")]
9629pub trait IUnitCalculator_LinkMdefCommandMethods: IUnitCalculator_LinkMdefCommand {
9630 #[doc = "`get_Name()` overload"]
9631 fn get_name(self) -> ::unity::Il2CppString {
9632 unsafe {
9633 let __receiver =
9634 <UnitCalculator_LinkMdefCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9635 {
9636 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
9637 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
9638 panic!(
9639 "unity: virtual slot {}
9640 out of range (vtable len {}
9641) on the runtime class behind {}
9642 (method `{}
9643`)",
9644 4usize,
9645 __vt.len(),
9646 <UnitCalculator_LinkMdefCommand as ::unity::ClassIdentity>::NAME,
9647 "get_Name",
9648 )
9649 });
9650 let __inner: extern "C" fn(UnitCalculator_LinkMdefCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
9651 ::core::mem::transmute(__vi.method_ptr);
9652 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
9653 __inner(__receiver, __mi)
9654 }
9655 }
9656 }
9657 #[doc = "`get_CapabilityType()` overload"]
9658 fn get_capability_type(self) -> crate::app::capabilitydefinition::CapabilityDefinition_Type {
9659 unsafe {
9660 let __receiver =
9661 <UnitCalculator_LinkMdefCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9662 {
9663 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
9664 let __vi = *__vt.get(44usize).unwrap_or_else(|| {
9665 panic!(
9666 "unity: virtual slot {}
9667 out of range (vtable len {}
9668) on the runtime class behind {}
9669 (method `{}
9670`)",
9671 44usize,
9672 __vt.len(),
9673 <UnitCalculator_LinkMdefCommand as ::unity::ClassIdentity>::NAME,
9674 "get_CapabilityType",
9675 )
9676 });
9677 let __inner: extern "C" fn(
9678 UnitCalculator_LinkMdefCommand,
9679 ::unity::OptionalMethod,
9680 ) -> crate::app::capabilitydefinition::CapabilityDefinition_Type = ::core::mem::transmute(__vi.method_ptr);
9681 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
9682 __inner(__receiver, __mi)
9683 }
9684 }
9685 }
9686 #[doc = "`.ctor()` overload"]
9687 fn ctor(self) -> () {
9688 unsafe {
9689 let __receiver =
9690 <UnitCalculator_LinkMdefCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9691 ::unity::il2cpp_call!((::unity::module_base()+0x1b48b80usize)as*mut u8,();
9692(UnitCalculator_LinkMdefCommand)__receiver)
9693 }
9694 }
9695}
9696
9697#[cfg(feature = "app-unitcalculator")]
9698impl<__T: IUnitCalculator_LinkMdefCommand> IUnitCalculator_LinkMdefCommandMethods for __T {}
9699
9700#[cfg(feature = "app-unitcalculator")]
9701impl UnitCalculator_LinkMdefCommand {
9702 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
9703 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
9704 }
9705
9706 pub fn get_capability_type_method_info() -> &'static ::unity::il2cpp::MethodInfo {
9707 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
9708 }
9709
9710 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
9711 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
9712 }
9713}
9714
9715#[cfg(feature = "app-unitcalculator")]
9716impl UnitCalculator_LinkMdefCommand {
9717 #[doc = "Direct (non-virtual) call to `UnitCalculator_LinkMdefCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
9718 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
9719 let __mi = Self::get_name_method_info();
9720 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
9721 __inner(this.into(), ::core::option::Option::None)
9722 }
9723
9724 #[doc = "Direct (non-virtual) call to `UnitCalculator_LinkMdefCommand`'s own `get_CapabilityType`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
9725 pub unsafe fn get_capability_type(
9726 this: impl ::core::convert::Into<::unity::IlInstance>,
9727 ) -> crate::app::capabilitydefinition::CapabilityDefinition_Type {
9728 let __mi = Self::get_capability_type_method_info();
9729 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::capabilitydefinition::CapabilityDefinition_Type =
9730 ::core::mem::transmute(__mi.method_ptr);
9731 __inner(this.into(), ::core::option::Option::None)
9732 }
9733}
9734
9735#[cfg(feature = "app-unitcalculator")]
9736impl UnitCalculator_LinkMdefCommand {
9737 #[doc = "`.ctor()` — no args"]
9738 pub fn new() -> Self {
9739 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
9740 panic!(
9741 "{}
9742::{}
9743 failed to instantiate",
9744 ::core::stringify!(UnitCalculator_LinkMdefCommand),
9745 ::core::stringify!(new),
9746 )
9747 });
9748 <Self as IUnitCalculator_LinkMdefCommandMethods>::ctor(this);
9749 this
9750 }
9751}
9752
9753#[cfg(feature = "app-unitcalculator")]
9754pub trait IUnitCalculator_BattleDistanceCommandMethods: IUnitCalculator_BattleDistanceCommand {
9755 #[doc = "`get_Name()` overload"]
9756 fn get_name(self) -> ::unity::Il2CppString {
9757 unsafe {
9758 let __receiver = <UnitCalculator_BattleDistanceCommand as ::unity::FromIlInstance>::from_il_instance(
9759 <Self as ::unity::SystemObject>::as_instance(self),
9760 );
9761 {
9762 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
9763 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
9764 panic!(
9765 "unity: virtual slot {}
9766 out of range (vtable len {}
9767) on the runtime class behind {}
9768 (method `{}
9769`)",
9770 4usize,
9771 __vt.len(),
9772 <UnitCalculator_BattleDistanceCommand as ::unity::ClassIdentity>::NAME,
9773 "get_Name",
9774 )
9775 });
9776 let __inner: extern "C" fn(UnitCalculator_BattleDistanceCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
9777 ::core::mem::transmute(__vi.method_ptr);
9778 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
9779 __inner(__receiver, __mi)
9780 }
9781 }
9782 }
9783 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
9784 fn get_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
9785 unsafe {
9786 let __receiver = <UnitCalculator_BattleDistanceCommand as ::unity::FromIlInstance>::from_il_instance(
9787 <Self as ::unity::SystemObject>::as_instance(self),
9788 );
9789 {
9790 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
9791 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
9792 panic!(
9793 "unity: virtual slot {}
9794 out of range (vtable len {}
9795) on the runtime class behind {}
9796 (method `{}
9797`)",
9798 31usize,
9799 __vt.len(),
9800 <UnitCalculator_BattleDistanceCommand as ::unity::ClassIdentity>::NAME,
9801 "GetImpl",
9802 )
9803 });
9804 let __inner: extern "C" fn(
9805 UnitCalculator_BattleDistanceCommand,
9806 crate::app::battleinfoside::BattleInfoSide,
9807 ::unity::OptionalMethod,
9808 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
9809 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
9810 __inner(__receiver, ::core::convert::Into::into(side), __mi)
9811 }
9812 }
9813 }
9814 #[doc = "`.ctor()` overload"]
9815 fn ctor(self) -> () {
9816 unsafe {
9817 let __receiver = <UnitCalculator_BattleDistanceCommand as ::unity::FromIlInstance>::from_il_instance(
9818 <Self as ::unity::SystemObject>::as_instance(self),
9819 );
9820 ::unity::il2cpp_call!((::unity::module_base()+0x1b45a60usize)as*mut u8,();
9821(UnitCalculator_BattleDistanceCommand)__receiver)
9822 }
9823 }
9824}
9825
9826#[cfg(feature = "app-unitcalculator")]
9827impl<__T: IUnitCalculator_BattleDistanceCommand> IUnitCalculator_BattleDistanceCommandMethods for __T {}
9828
9829#[cfg(feature = "app-unitcalculator")]
9830impl UnitCalculator_BattleDistanceCommand {
9831 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
9832 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
9833 }
9834
9835 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
9836 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
9837 }
9838
9839 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
9840 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
9841 }
9842}
9843
9844#[cfg(feature = "app-unitcalculator")]
9845impl UnitCalculator_BattleDistanceCommand {
9846 #[doc = "Direct (non-virtual) call to `UnitCalculator_BattleDistanceCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
9847 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
9848 let __mi = Self::get_name_method_info();
9849 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
9850 __inner(this.into(), ::core::option::Option::None)
9851 }
9852
9853 #[doc = "Direct (non-virtual) call to `UnitCalculator_BattleDistanceCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
9854 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
9855 let __mi = Self::get_impl_method_info();
9856 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
9857 ::core::mem::transmute(__mi.method_ptr);
9858 __inner(this.into(), side, ::core::option::Option::None)
9859 }
9860}
9861
9862#[cfg(feature = "app-unitcalculator")]
9863impl UnitCalculator_BattleDistanceCommand {
9864 #[doc = "`.ctor()` — no args"]
9865 pub fn new() -> Self {
9866 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
9867 panic!(
9868 "{}
9869::{}
9870 failed to instantiate",
9871 ::core::stringify!(UnitCalculator_BattleDistanceCommand),
9872 ::core::stringify!(new),
9873 )
9874 });
9875 <Self as IUnitCalculator_BattleDistanceCommandMethods>::ctor(this);
9876 this
9877 }
9878}
9879
9880#[cfg(feature = "app-unitcalculator")]
9881pub trait IUnitCalculator_MdefCommandMethods: IUnitCalculator_MdefCommand {
9882 #[doc = "`get_Name()` overload"]
9883 fn get_name(self) -> ::unity::Il2CppString {
9884 unsafe {
9885 let __receiver =
9886 <UnitCalculator_MdefCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9887 {
9888 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
9889 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
9890 panic!(
9891 "unity: virtual slot {}
9892 out of range (vtable len {}
9893) on the runtime class behind {}
9894 (method `{}
9895`)",
9896 4usize,
9897 __vt.len(),
9898 <UnitCalculator_MdefCommand as ::unity::ClassIdentity>::NAME,
9899 "get_Name",
9900 )
9901 });
9902 let __inner: extern "C" fn(UnitCalculator_MdefCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
9903 ::core::mem::transmute(__vi.method_ptr);
9904 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
9905 __inner(__receiver, __mi)
9906 }
9907 }
9908 }
9909 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
9910 fn get_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
9911 unsafe {
9912 let __receiver =
9913 <UnitCalculator_MdefCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9914 {
9915 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
9916 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
9917 panic!(
9918 "unity: virtual slot {}
9919 out of range (vtable len {}
9920) on the runtime class behind {}
9921 (method `{}
9922`)",
9923 30usize,
9924 __vt.len(),
9925 <UnitCalculator_MdefCommand as ::unity::ClassIdentity>::NAME,
9926 "GetImpl",
9927 )
9928 });
9929 let __inner: extern "C" fn(UnitCalculator_MdefCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
9930 ::core::mem::transmute(__vi.method_ptr);
9931 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
9932 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
9933 }
9934 }
9935 }
9936 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
9937 fn get_impl_2(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
9938 unsafe {
9939 let __receiver =
9940 <UnitCalculator_MdefCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9941 {
9942 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
9943 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
9944 panic!(
9945 "unity: virtual slot {}
9946 out of range (vtable len {}
9947) on the runtime class behind {}
9948 (method `{}
9949`)",
9950 31usize,
9951 __vt.len(),
9952 <UnitCalculator_MdefCommand as ::unity::ClassIdentity>::NAME,
9953 "GetImpl",
9954 )
9955 });
9956 let __inner: extern "C" fn(UnitCalculator_MdefCommand, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
9957 ::core::mem::transmute(__vi.method_ptr);
9958 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
9959 __inner(__receiver, ::core::convert::Into::into(side), __mi)
9960 }
9961 }
9962 }
9963 #[doc = "`SetImpl(crate::app::battleinfoside::BattleInfoSide, f32)` overload"]
9964 fn set_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>, value: impl ::core::convert::Into<f32>) -> () {
9965 unsafe {
9966 let __receiver =
9967 <UnitCalculator_MdefCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9968 {
9969 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
9970 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
9971 panic!(
9972 "unity: virtual slot {}
9973 out of range (vtable len {}
9974) on the runtime class behind {}
9975 (method `{}
9976`)",
9977 33usize,
9978 __vt.len(),
9979 <UnitCalculator_MdefCommand as ::unity::ClassIdentity>::NAME,
9980 "SetImpl",
9981 )
9982 });
9983 let __inner: extern "C" fn(
9984 UnitCalculator_MdefCommand,
9985 crate::app::battleinfoside::BattleInfoSide,
9986 f32,
9987 ::unity::OptionalMethod,
9988 ) -> () = ::core::mem::transmute(__vi.method_ptr);
9989 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
9990 __inner(__receiver, ::core::convert::Into::into(side), ::core::convert::Into::into(value), __mi)
9991 }
9992 }
9993 }
9994 #[doc = "`.ctor()` overload"]
9995 fn ctor(self) -> () {
9996 unsafe {
9997 let __receiver =
9998 <UnitCalculator_MdefCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
9999 ::unity::il2cpp_call!((::unity::module_base()+0x1b4a590usize)as*mut u8,();
10000(UnitCalculator_MdefCommand)__receiver)
10001 }
10002 }
10003}
10004
10005#[cfg(feature = "app-unitcalculator")]
10006impl<__T: IUnitCalculator_MdefCommand> IUnitCalculator_MdefCommandMethods for __T {}
10007
10008#[cfg(feature = "app-unitcalculator")]
10009impl UnitCalculator_MdefCommand {
10010 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10011 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
10012 }
10013
10014 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10015 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
10016 }
10017
10018 pub fn get_impl_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10019 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
10020 }
10021
10022 pub fn set_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10023 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
10024 }
10025
10026 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10027 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
10028 }
10029}
10030
10031#[cfg(feature = "app-unitcalculator")]
10032impl UnitCalculator_MdefCommand {
10033 #[doc = "Direct (non-virtual) call to `UnitCalculator_MdefCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
10034 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
10035 let __mi = Self::get_name_method_info();
10036 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
10037 __inner(this.into(), ::core::option::Option::None)
10038 }
10039
10040 #[doc = "Direct (non-virtual) call to `UnitCalculator_MdefCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
10041 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
10042 let __mi = Self::get_impl_method_info();
10043 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
10044 ::core::mem::transmute(__mi.method_ptr);
10045 __inner(this.into(), unit, ::core::option::Option::None)
10046 }
10047
10048 #[doc = "Direct (non-virtual) call to `UnitCalculator_MdefCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
10049 pub unsafe fn get_impl_2(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
10050 let __mi = Self::get_impl_2_method_info();
10051 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
10052 ::core::mem::transmute(__mi.method_ptr);
10053 __inner(this.into(), side, ::core::option::Option::None)
10054 }
10055
10056 #[doc = "Direct (non-virtual) call to `UnitCalculator_MdefCommand`'s own `SetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
10057 pub unsafe fn set_impl(
10058 this: impl ::core::convert::Into<::unity::IlInstance>,
10059 side: crate::app::battleinfoside::BattleInfoSide,
10060 value: f32,
10061 ) -> () {
10062 let __mi = Self::set_impl_method_info();
10063 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, f32, ::unity::OptionalMethod) -> () =
10064 ::core::mem::transmute(__mi.method_ptr);
10065 __inner(this.into(), side, value, ::core::option::Option::None)
10066 }
10067}
10068
10069#[cfg(feature = "app-unitcalculator")]
10070impl UnitCalculator_MdefCommand {
10071 #[doc = "`.ctor()` — no args"]
10072 pub fn new() -> Self {
10073 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
10074 panic!(
10075 "{}
10076::{}
10077 failed to instantiate",
10078 ::core::stringify!(UnitCalculator_MdefCommand),
10079 ::core::stringify!(new),
10080 )
10081 });
10082 <Self as IUnitCalculator_MdefCommandMethods>::ctor(this);
10083 this
10084 }
10085}
10086
10087#[cfg(feature = "app-unitcalculator")]
10088pub trait IUnitCalculator_StrCommandMethods: IUnitCalculator_StrCommand {
10089 #[doc = "`get_Name()` overload"]
10090 fn get_name(self) -> ::unity::Il2CppString {
10091 unsafe {
10092 let __receiver =
10093 <UnitCalculator_StrCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
10094 {
10095 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
10096 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
10097 panic!(
10098 "unity: virtual slot {}
10099 out of range (vtable len {}
10100) on the runtime class behind {}
10101 (method `{}
10102`)",
10103 4usize,
10104 __vt.len(),
10105 <UnitCalculator_StrCommand as ::unity::ClassIdentity>::NAME,
10106 "get_Name",
10107 )
10108 });
10109 let __inner: extern "C" fn(UnitCalculator_StrCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
10110 ::core::mem::transmute(__vi.method_ptr);
10111 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
10112 __inner(__receiver, __mi)
10113 }
10114 }
10115 }
10116 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
10117 fn get_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
10118 unsafe {
10119 let __receiver =
10120 <UnitCalculator_StrCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
10121 {
10122 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
10123 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
10124 panic!(
10125 "unity: virtual slot {}
10126 out of range (vtable len {}
10127) on the runtime class behind {}
10128 (method `{}
10129`)",
10130 30usize,
10131 __vt.len(),
10132 <UnitCalculator_StrCommand as ::unity::ClassIdentity>::NAME,
10133 "GetImpl",
10134 )
10135 });
10136 let __inner: extern "C" fn(UnitCalculator_StrCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
10137 ::core::mem::transmute(__vi.method_ptr);
10138 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
10139 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
10140 }
10141 }
10142 }
10143 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
10144 fn get_impl_2(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
10145 unsafe {
10146 let __receiver =
10147 <UnitCalculator_StrCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
10148 {
10149 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
10150 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
10151 panic!(
10152 "unity: virtual slot {}
10153 out of range (vtable len {}
10154) on the runtime class behind {}
10155 (method `{}
10156`)",
10157 31usize,
10158 __vt.len(),
10159 <UnitCalculator_StrCommand as ::unity::ClassIdentity>::NAME,
10160 "GetImpl",
10161 )
10162 });
10163 let __inner: extern "C" fn(UnitCalculator_StrCommand, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
10164 ::core::mem::transmute(__vi.method_ptr);
10165 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
10166 __inner(__receiver, ::core::convert::Into::into(side), __mi)
10167 }
10168 }
10169 }
10170 #[doc = "`SetImpl(crate::app::battleinfoside::BattleInfoSide, f32)` overload"]
10171 fn set_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>, value: impl ::core::convert::Into<f32>) -> () {
10172 unsafe {
10173 let __receiver =
10174 <UnitCalculator_StrCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
10175 {
10176 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
10177 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
10178 panic!(
10179 "unity: virtual slot {}
10180 out of range (vtable len {}
10181) on the runtime class behind {}
10182 (method `{}
10183`)",
10184 33usize,
10185 __vt.len(),
10186 <UnitCalculator_StrCommand as ::unity::ClassIdentity>::NAME,
10187 "SetImpl",
10188 )
10189 });
10190 let __inner: extern "C" fn(
10191 UnitCalculator_StrCommand,
10192 crate::app::battleinfoside::BattleInfoSide,
10193 f32,
10194 ::unity::OptionalMethod,
10195 ) -> () = ::core::mem::transmute(__vi.method_ptr);
10196 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
10197 __inner(__receiver, ::core::convert::Into::into(side), ::core::convert::Into::into(value), __mi)
10198 }
10199 }
10200 }
10201 #[doc = "`.ctor()` overload"]
10202 fn ctor(self) -> () {
10203 unsafe {
10204 let __receiver =
10205 <UnitCalculator_StrCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
10206 ::unity::il2cpp_call!((::unity::module_base()+0x1b4c200usize)as*mut u8,();
10207(UnitCalculator_StrCommand)__receiver)
10208 }
10209 }
10210}
10211
10212#[cfg(feature = "app-unitcalculator")]
10213impl<__T: IUnitCalculator_StrCommand> IUnitCalculator_StrCommandMethods for __T {}
10214
10215#[cfg(feature = "app-unitcalculator")]
10216impl UnitCalculator_StrCommand {
10217 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10218 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
10219 }
10220
10221 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10222 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
10223 }
10224
10225 pub fn get_impl_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10226 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
10227 }
10228
10229 pub fn set_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10230 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
10231 }
10232
10233 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10234 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
10235 }
10236}
10237
10238#[cfg(feature = "app-unitcalculator")]
10239impl UnitCalculator_StrCommand {
10240 #[doc = "Direct (non-virtual) call to `UnitCalculator_StrCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
10241 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
10242 let __mi = Self::get_name_method_info();
10243 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
10244 __inner(this.into(), ::core::option::Option::None)
10245 }
10246
10247 #[doc = "Direct (non-virtual) call to `UnitCalculator_StrCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
10248 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
10249 let __mi = Self::get_impl_method_info();
10250 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
10251 ::core::mem::transmute(__mi.method_ptr);
10252 __inner(this.into(), unit, ::core::option::Option::None)
10253 }
10254
10255 #[doc = "Direct (non-virtual) call to `UnitCalculator_StrCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
10256 pub unsafe fn get_impl_2(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
10257 let __mi = Self::get_impl_2_method_info();
10258 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
10259 ::core::mem::transmute(__mi.method_ptr);
10260 __inner(this.into(), side, ::core::option::Option::None)
10261 }
10262
10263 #[doc = "Direct (non-virtual) call to `UnitCalculator_StrCommand`'s own `SetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
10264 pub unsafe fn set_impl(
10265 this: impl ::core::convert::Into<::unity::IlInstance>,
10266 side: crate::app::battleinfoside::BattleInfoSide,
10267 value: f32,
10268 ) -> () {
10269 let __mi = Self::set_impl_method_info();
10270 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, f32, ::unity::OptionalMethod) -> () =
10271 ::core::mem::transmute(__mi.method_ptr);
10272 __inner(this.into(), side, value, ::core::option::Option::None)
10273 }
10274}
10275
10276#[cfg(feature = "app-unitcalculator")]
10277impl UnitCalculator_StrCommand {
10278 #[doc = "`.ctor()` — no args"]
10279 pub fn new() -> Self {
10280 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
10281 panic!(
10282 "{}
10283::{}
10284 failed to instantiate",
10285 ::core::stringify!(UnitCalculator_StrCommand),
10286 ::core::stringify!(new),
10287 )
10288 });
10289 <Self as IUnitCalculator_StrCommandMethods>::ctor(this);
10290 this
10291 }
10292}
10293
10294#[cfg(feature = "app-unitcalculator")]
10295pub trait IUnitCalculator_ContinuousCommandMethods: IUnitCalculator_ContinuousCommand {
10296 #[doc = "`get_Name()` overload"]
10297 fn get_name(self) -> ::unity::Il2CppString {
10298 unsafe {
10299 let __receiver =
10300 <UnitCalculator_ContinuousCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
10301 {
10302 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
10303 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
10304 panic!(
10305 "unity: virtual slot {}
10306 out of range (vtable len {}
10307) on the runtime class behind {}
10308 (method `{}
10309`)",
10310 4usize,
10311 __vt.len(),
10312 <UnitCalculator_ContinuousCommand as ::unity::ClassIdentity>::NAME,
10313 "get_Name",
10314 )
10315 });
10316 let __inner: extern "C" fn(UnitCalculator_ContinuousCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
10317 ::core::mem::transmute(__vi.method_ptr);
10318 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
10319 __inner(__receiver, __mi)
10320 }
10321 }
10322 }
10323 #[doc = "`GetParam(crate::app::battleinfoside::BattleInfoSide)` overload"]
10324 fn get_param(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> crate::app::battleparam::BattleParam {
10325 unsafe {
10326 let __receiver =
10327 <UnitCalculator_ContinuousCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
10328 {
10329 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
10330 let __vi = *__vt.get(44usize).unwrap_or_else(|| {
10331 panic!(
10332 "unity: virtual slot {}
10333 out of range (vtable len {}
10334) on the runtime class behind {}
10335 (method `{}
10336`)",
10337 44usize,
10338 __vt.len(),
10339 <UnitCalculator_ContinuousCommand as ::unity::ClassIdentity>::NAME,
10340 "GetParam",
10341 )
10342 });
10343 let __inner: extern "C" fn(
10344 UnitCalculator_ContinuousCommand,
10345 crate::app::battleinfoside::BattleInfoSide,
10346 ::unity::OptionalMethod,
10347 ) -> crate::app::battleparam::BattleParam = ::core::mem::transmute(__vi.method_ptr);
10348 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
10349 __inner(__receiver, ::core::convert::Into::into(side), __mi)
10350 }
10351 }
10352 }
10353 #[doc = "`IsVisible()` overload"]
10354 fn is_visible(self) -> bool {
10355 unsafe {
10356 let __receiver =
10357 <UnitCalculator_ContinuousCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
10358 {
10359 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
10360 let __vi = *__vt.get(43usize).unwrap_or_else(|| {
10361 panic!(
10362 "unity: virtual slot {}
10363 out of range (vtable len {}
10364) on the runtime class behind {}
10365 (method `{}
10366`)",
10367 43usize,
10368 __vt.len(),
10369 <UnitCalculator_ContinuousCommand as ::unity::ClassIdentity>::NAME,
10370 "IsVisible",
10371 )
10372 });
10373 let __inner: extern "C" fn(UnitCalculator_ContinuousCommand, ::unity::OptionalMethod) -> bool =
10374 ::core::mem::transmute(__vi.method_ptr);
10375 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
10376 __inner(__receiver, __mi)
10377 }
10378 }
10379 }
10380 #[doc = "`.ctor()` overload"]
10381 fn ctor(self) -> () {
10382 unsafe {
10383 let __receiver =
10384 <UnitCalculator_ContinuousCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
10385 ::unity::il2cpp_call!((::unity::module_base()+0x1b469b0usize)as*mut u8,();
10386(UnitCalculator_ContinuousCommand)__receiver)
10387 }
10388 }
10389}
10390
10391#[cfg(feature = "app-unitcalculator")]
10392impl<__T: IUnitCalculator_ContinuousCommand> IUnitCalculator_ContinuousCommandMethods for __T {}
10393
10394#[cfg(feature = "app-unitcalculator")]
10395impl UnitCalculator_ContinuousCommand {
10396 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10397 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
10398 }
10399
10400 pub fn get_param_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10401 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
10402 }
10403
10404 pub fn is_visible_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10405 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
10406 }
10407
10408 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10409 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
10410 }
10411}
10412
10413#[cfg(feature = "app-unitcalculator")]
10414impl UnitCalculator_ContinuousCommand {
10415 #[doc = "Direct (non-virtual) call to `UnitCalculator_ContinuousCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
10416 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
10417 let __mi = Self::get_name_method_info();
10418 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
10419 __inner(this.into(), ::core::option::Option::None)
10420 }
10421
10422 #[doc = "Direct (non-virtual) call to `UnitCalculator_ContinuousCommand`'s own `GetParam`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
10423 pub unsafe fn get_param(
10424 this: impl ::core::convert::Into<::unity::IlInstance>,
10425 side: crate::app::battleinfoside::BattleInfoSide,
10426 ) -> crate::app::battleparam::BattleParam {
10427 let __mi = Self::get_param_method_info();
10428 let __inner: extern "C" fn(
10429 ::unity::IlInstance,
10430 crate::app::battleinfoside::BattleInfoSide,
10431 ::unity::OptionalMethod,
10432 ) -> crate::app::battleparam::BattleParam = ::core::mem::transmute(__mi.method_ptr);
10433 __inner(this.into(), side, ::core::option::Option::None)
10434 }
10435
10436 #[doc = "Direct (non-virtual) call to `UnitCalculator_ContinuousCommand`'s own `IsVisible`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
10437 pub unsafe fn is_visible(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
10438 let __mi = Self::is_visible_method_info();
10439 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
10440 __inner(this.into(), ::core::option::Option::None)
10441 }
10442}
10443
10444#[cfg(feature = "app-unitcalculator")]
10445impl UnitCalculator_ContinuousCommand {
10446 #[doc = "`.ctor()` — no args"]
10447 pub fn new() -> Self {
10448 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
10449 panic!(
10450 "{}
10451::{}
10452 failed to instantiate",
10453 ::core::stringify!(UnitCalculator_ContinuousCommand),
10454 ::core::stringify!(new),
10455 )
10456 });
10457 <Self as IUnitCalculator_ContinuousCommandMethods>::ctor(this);
10458 this
10459 }
10460}
10461
10462#[cfg(feature = "app-unitcalculator")]
10463pub trait IUnitCalculator_UnitPersonCommandMethods: IUnitCalculator_UnitPersonCommand {
10464 #[doc = "`get_Name()` overload"]
10465 fn get_name(self) -> ::unity::Il2CppString {
10466 unsafe {
10467 let __receiver =
10468 <UnitCalculator_UnitPersonCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
10469 {
10470 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
10471 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
10472 panic!(
10473 "unity: virtual slot {}
10474 out of range (vtable len {}
10475) on the runtime class behind {}
10476 (method `{}
10477`)",
10478 4usize,
10479 __vt.len(),
10480 <UnitCalculator_UnitPersonCommand as ::unity::ClassIdentity>::NAME,
10481 "get_Name",
10482 )
10483 });
10484 let __inner: extern "C" fn(UnitCalculator_UnitPersonCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
10485 ::core::mem::transmute(__vi.method_ptr);
10486 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
10487 __inner(__receiver, __mi)
10488 }
10489 }
10490 }
10491 #[doc = "`FuncImpl(crate::app::unit::Unit, ::unity::Il2CppString)` overload"]
10492 fn func_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>, arg: impl ::core::convert::Into<::unity::Il2CppString>) -> f32 {
10493 unsafe {
10494 let __receiver =
10495 <UnitCalculator_UnitPersonCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
10496 {
10497 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
10498 let __vi = *__vt.get(36usize).unwrap_or_else(|| {
10499 panic!(
10500 "unity: virtual slot {}
10501 out of range (vtable len {}
10502) on the runtime class behind {}
10503 (method `{}
10504`)",
10505 36usize,
10506 __vt.len(),
10507 <UnitCalculator_UnitPersonCommand as ::unity::ClassIdentity>::NAME,
10508 "FuncImpl",
10509 )
10510 });
10511 let __inner: extern "C" fn(
10512 UnitCalculator_UnitPersonCommand,
10513 crate::app::unit::Unit,
10514 ::unity::Il2CppString,
10515 ::unity::OptionalMethod,
10516 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
10517 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
10518 __inner(__receiver, ::core::convert::Into::into(unit), ::core::convert::Into::into(arg), __mi)
10519 }
10520 }
10521 }
10522 #[doc = "`.ctor()` overload"]
10523 fn ctor(self) -> () {
10524 unsafe {
10525 let __receiver =
10526 <UnitCalculator_UnitPersonCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
10527 ::unity::il2cpp_call!((::unity::module_base()+0x1b4d7c0usize)as*mut u8,();
10528(UnitCalculator_UnitPersonCommand)__receiver)
10529 }
10530 }
10531}
10532
10533#[cfg(feature = "app-unitcalculator")]
10534impl<__T: IUnitCalculator_UnitPersonCommand> IUnitCalculator_UnitPersonCommandMethods for __T {}
10535
10536#[cfg(feature = "app-unitcalculator")]
10537impl UnitCalculator_UnitPersonCommand {
10538 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10539 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
10540 }
10541
10542 pub fn func_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10543 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
10544 }
10545
10546 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10547 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
10548 }
10549}
10550
10551#[cfg(feature = "app-unitcalculator")]
10552impl UnitCalculator_UnitPersonCommand {
10553 #[doc = "Direct (non-virtual) call to `UnitCalculator_UnitPersonCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
10554 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
10555 let __mi = Self::get_name_method_info();
10556 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
10557 __inner(this.into(), ::core::option::Option::None)
10558 }
10559
10560 #[doc = "Direct (non-virtual) call to `UnitCalculator_UnitPersonCommand`'s own `FuncImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
10561 pub unsafe fn func_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit, arg: ::unity::Il2CppString) -> f32 {
10562 let __mi = Self::func_impl_method_info();
10563 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::Il2CppString, ::unity::OptionalMethod) -> f32 =
10564 ::core::mem::transmute(__mi.method_ptr);
10565 __inner(this.into(), unit, arg, ::core::option::Option::None)
10566 }
10567}
10568
10569#[cfg(feature = "app-unitcalculator")]
10570impl UnitCalculator_UnitPersonCommand {
10571 #[doc = "`.ctor()` — no args"]
10572 pub fn new() -> Self {
10573 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
10574 panic!(
10575 "{}
10576::{}
10577 failed to instantiate",
10578 ::core::stringify!(UnitCalculator_UnitPersonCommand),
10579 ::core::stringify!(new),
10580 )
10581 });
10582 <Self as IUnitCalculator_UnitPersonCommandMethods>::ctor(this);
10583 this
10584 }
10585}
10586
10587#[cfg(feature = "app-unitcalculator")]
10588pub trait IUnitCalculator_BattleAliveCommandMethods: IUnitCalculator_BattleAliveCommand {
10589 #[doc = "`get_Name()` overload"]
10590 fn get_name(self) -> ::unity::Il2CppString {
10591 unsafe {
10592 let __receiver =
10593 <UnitCalculator_BattleAliveCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
10594 {
10595 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
10596 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
10597 panic!(
10598 "unity: virtual slot {}
10599 out of range (vtable len {}
10600) on the runtime class behind {}
10601 (method `{}
10602`)",
10603 4usize,
10604 __vt.len(),
10605 <UnitCalculator_BattleAliveCommand as ::unity::ClassIdentity>::NAME,
10606 "get_Name",
10607 )
10608 });
10609 let __inner: extern "C" fn(UnitCalculator_BattleAliveCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
10610 ::core::mem::transmute(__vi.method_ptr);
10611 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
10612 __inner(__receiver, __mi)
10613 }
10614 }
10615 }
10616 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
10617 fn get_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
10618 unsafe {
10619 let __receiver =
10620 <UnitCalculator_BattleAliveCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
10621 {
10622 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
10623 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
10624 panic!(
10625 "unity: virtual slot {}
10626 out of range (vtable len {}
10627) on the runtime class behind {}
10628 (method `{}
10629`)",
10630 30usize,
10631 __vt.len(),
10632 <UnitCalculator_BattleAliveCommand as ::unity::ClassIdentity>::NAME,
10633 "GetImpl",
10634 )
10635 });
10636 let __inner: extern "C" fn(UnitCalculator_BattleAliveCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
10637 ::core::mem::transmute(__vi.method_ptr);
10638 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
10639 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
10640 }
10641 }
10642 }
10643 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
10644 fn get_impl_2(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
10645 unsafe {
10646 let __receiver =
10647 <UnitCalculator_BattleAliveCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
10648 {
10649 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
10650 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
10651 panic!(
10652 "unity: virtual slot {}
10653 out of range (vtable len {}
10654) on the runtime class behind {}
10655 (method `{}
10656`)",
10657 31usize,
10658 __vt.len(),
10659 <UnitCalculator_BattleAliveCommand as ::unity::ClassIdentity>::NAME,
10660 "GetImpl",
10661 )
10662 });
10663 let __inner: extern "C" fn(
10664 UnitCalculator_BattleAliveCommand,
10665 crate::app::battleinfoside::BattleInfoSide,
10666 ::unity::OptionalMethod,
10667 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
10668 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
10669 __inner(__receiver, ::core::convert::Into::into(side), __mi)
10670 }
10671 }
10672 }
10673 #[doc = "`.ctor()` overload"]
10674 fn ctor(self) -> () {
10675 unsafe {
10676 let __receiver =
10677 <UnitCalculator_BattleAliveCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
10678 ::unity::il2cpp_call!((::unity::module_base()+0x1b45690usize)as*mut u8,();
10679(UnitCalculator_BattleAliveCommand)__receiver)
10680 }
10681 }
10682}
10683
10684#[cfg(feature = "app-unitcalculator")]
10685impl<__T: IUnitCalculator_BattleAliveCommand> IUnitCalculator_BattleAliveCommandMethods for __T {}
10686
10687#[cfg(feature = "app-unitcalculator")]
10688impl UnitCalculator_BattleAliveCommand {
10689 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10690 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
10691 }
10692
10693 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10694 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
10695 }
10696
10697 pub fn get_impl_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10698 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
10699 }
10700
10701 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10702 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
10703 }
10704}
10705
10706#[cfg(feature = "app-unitcalculator")]
10707impl UnitCalculator_BattleAliveCommand {
10708 #[doc = "Direct (non-virtual) call to `UnitCalculator_BattleAliveCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
10709 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
10710 let __mi = Self::get_name_method_info();
10711 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
10712 __inner(this.into(), ::core::option::Option::None)
10713 }
10714
10715 #[doc = "Direct (non-virtual) call to `UnitCalculator_BattleAliveCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
10716 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
10717 let __mi = Self::get_impl_method_info();
10718 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
10719 ::core::mem::transmute(__mi.method_ptr);
10720 __inner(this.into(), unit, ::core::option::Option::None)
10721 }
10722
10723 #[doc = "Direct (non-virtual) call to `UnitCalculator_BattleAliveCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
10724 pub unsafe fn get_impl_2(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
10725 let __mi = Self::get_impl_2_method_info();
10726 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
10727 ::core::mem::transmute(__mi.method_ptr);
10728 __inner(this.into(), side, ::core::option::Option::None)
10729 }
10730}
10731
10732#[cfg(feature = "app-unitcalculator")]
10733impl UnitCalculator_BattleAliveCommand {
10734 #[doc = "`.ctor()` — no args"]
10735 pub fn new() -> Self {
10736 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
10737 panic!(
10738 "{}
10739::{}
10740 failed to instantiate",
10741 ::core::stringify!(UnitCalculator_BattleAliveCommand),
10742 ::core::stringify!(new),
10743 )
10744 });
10745 <Self as IUnitCalculator_BattleAliveCommandMethods>::ctor(this);
10746 this
10747 }
10748}
10749
10750#[cfg(feature = "app-unitcalculator")]
10751pub trait IUnitCalculator_WeaponAvoidCommandMethods: IUnitCalculator_WeaponAvoidCommand {
10752 #[doc = "`get_Name()` overload"]
10753 fn get_name(self) -> ::unity::Il2CppString {
10754 unsafe {
10755 let __receiver =
10756 <UnitCalculator_WeaponAvoidCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
10757 {
10758 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
10759 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
10760 panic!(
10761 "unity: virtual slot {}
10762 out of range (vtable len {}
10763) on the runtime class behind {}
10764 (method `{}
10765`)",
10766 4usize,
10767 __vt.len(),
10768 <UnitCalculator_WeaponAvoidCommand as ::unity::ClassIdentity>::NAME,
10769 "get_Name",
10770 )
10771 });
10772 let __inner: extern "C" fn(UnitCalculator_WeaponAvoidCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
10773 ::core::mem::transmute(__vi.method_ptr);
10774 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
10775 __inner(__receiver, __mi)
10776 }
10777 }
10778 }
10779 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
10780 fn get_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
10781 unsafe {
10782 let __receiver =
10783 <UnitCalculator_WeaponAvoidCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
10784 {
10785 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
10786 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
10787 panic!(
10788 "unity: virtual slot {}
10789 out of range (vtable len {}
10790) on the runtime class behind {}
10791 (method `{}
10792`)",
10793 31usize,
10794 __vt.len(),
10795 <UnitCalculator_WeaponAvoidCommand as ::unity::ClassIdentity>::NAME,
10796 "GetImpl",
10797 )
10798 });
10799 let __inner: extern "C" fn(
10800 UnitCalculator_WeaponAvoidCommand,
10801 crate::app::battleinfoside::BattleInfoSide,
10802 ::unity::OptionalMethod,
10803 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
10804 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
10805 __inner(__receiver, ::core::convert::Into::into(side), __mi)
10806 }
10807 }
10808 }
10809 #[doc = "`SetImpl(crate::app::battleinfoside::BattleInfoSide, f32)` overload"]
10810 fn set_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>, value: impl ::core::convert::Into<f32>) -> () {
10811 unsafe {
10812 let __receiver =
10813 <UnitCalculator_WeaponAvoidCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
10814 {
10815 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
10816 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
10817 panic!(
10818 "unity: virtual slot {}
10819 out of range (vtable len {}
10820) on the runtime class behind {}
10821 (method `{}
10822`)",
10823 33usize,
10824 __vt.len(),
10825 <UnitCalculator_WeaponAvoidCommand as ::unity::ClassIdentity>::NAME,
10826 "SetImpl",
10827 )
10828 });
10829 let __inner: extern "C" fn(
10830 UnitCalculator_WeaponAvoidCommand,
10831 crate::app::battleinfoside::BattleInfoSide,
10832 f32,
10833 ::unity::OptionalMethod,
10834 ) -> () = ::core::mem::transmute(__vi.method_ptr);
10835 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
10836 __inner(__receiver, ::core::convert::Into::into(side), ::core::convert::Into::into(value), __mi)
10837 }
10838 }
10839 }
10840 #[doc = "`IsVisible()` overload"]
10841 fn is_visible(self) -> bool {
10842 unsafe {
10843 let __receiver =
10844 <UnitCalculator_WeaponAvoidCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
10845 {
10846 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
10847 let __vi = *__vt.get(43usize).unwrap_or_else(|| {
10848 panic!(
10849 "unity: virtual slot {}
10850 out of range (vtable len {}
10851) on the runtime class behind {}
10852 (method `{}
10853`)",
10854 43usize,
10855 __vt.len(),
10856 <UnitCalculator_WeaponAvoidCommand as ::unity::ClassIdentity>::NAME,
10857 "IsVisible",
10858 )
10859 });
10860 let __inner: extern "C" fn(UnitCalculator_WeaponAvoidCommand, ::unity::OptionalMethod) -> bool =
10861 ::core::mem::transmute(__vi.method_ptr);
10862 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
10863 __inner(__receiver, __mi)
10864 }
10865 }
10866 }
10867 #[doc = "`.ctor()` overload"]
10868 fn ctor(self) -> () {
10869 unsafe {
10870 let __receiver =
10871 <UnitCalculator_WeaponAvoidCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
10872 ::unity::il2cpp_call!((::unity::module_base()+0x1b4dce0usize)as*mut u8,();
10873(UnitCalculator_WeaponAvoidCommand)__receiver)
10874 }
10875 }
10876}
10877
10878#[cfg(feature = "app-unitcalculator")]
10879impl<__T: IUnitCalculator_WeaponAvoidCommand> IUnitCalculator_WeaponAvoidCommandMethods for __T {}
10880
10881#[cfg(feature = "app-unitcalculator")]
10882impl UnitCalculator_WeaponAvoidCommand {
10883 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10884 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
10885 }
10886
10887 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10888 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
10889 }
10890
10891 pub fn set_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10892 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
10893 }
10894
10895 pub fn is_visible_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10896 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
10897 }
10898
10899 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
10900 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
10901 }
10902}
10903
10904#[cfg(feature = "app-unitcalculator")]
10905impl UnitCalculator_WeaponAvoidCommand {
10906 #[doc = "Direct (non-virtual) call to `UnitCalculator_WeaponAvoidCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
10907 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
10908 let __mi = Self::get_name_method_info();
10909 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
10910 __inner(this.into(), ::core::option::Option::None)
10911 }
10912
10913 #[doc = "Direct (non-virtual) call to `UnitCalculator_WeaponAvoidCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
10914 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
10915 let __mi = Self::get_impl_method_info();
10916 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
10917 ::core::mem::transmute(__mi.method_ptr);
10918 __inner(this.into(), side, ::core::option::Option::None)
10919 }
10920
10921 #[doc = "Direct (non-virtual) call to `UnitCalculator_WeaponAvoidCommand`'s own `SetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
10922 pub unsafe fn set_impl(
10923 this: impl ::core::convert::Into<::unity::IlInstance>,
10924 side: crate::app::battleinfoside::BattleInfoSide,
10925 value: f32,
10926 ) -> () {
10927 let __mi = Self::set_impl_method_info();
10928 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, f32, ::unity::OptionalMethod) -> () =
10929 ::core::mem::transmute(__mi.method_ptr);
10930 __inner(this.into(), side, value, ::core::option::Option::None)
10931 }
10932
10933 #[doc = "Direct (non-virtual) call to `UnitCalculator_WeaponAvoidCommand`'s own `IsVisible`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
10934 pub unsafe fn is_visible(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
10935 let __mi = Self::is_visible_method_info();
10936 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
10937 __inner(this.into(), ::core::option::Option::None)
10938 }
10939}
10940
10941#[cfg(feature = "app-unitcalculator")]
10942impl UnitCalculator_WeaponAvoidCommand {
10943 #[doc = "`.ctor()` — no args"]
10944 pub fn new() -> Self {
10945 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
10946 panic!(
10947 "{}
10948::{}
10949 failed to instantiate",
10950 ::core::stringify!(UnitCalculator_WeaponAvoidCommand),
10951 ::core::stringify!(new),
10952 )
10953 });
10954 <Self as IUnitCalculator_WeaponAvoidCommandMethods>::ctor(this);
10955 this
10956 }
10957}
10958
10959#[cfg(feature = "app-unitcalculator")]
10960pub trait IUnitCalculator_InternalLevelCommandMethods: IUnitCalculator_InternalLevelCommand {
10961 #[doc = "`get_Name()` overload"]
10962 fn get_name(self) -> ::unity::Il2CppString {
10963 unsafe {
10964 let __receiver = <UnitCalculator_InternalLevelCommand as ::unity::FromIlInstance>::from_il_instance(
10965 <Self as ::unity::SystemObject>::as_instance(self),
10966 );
10967 {
10968 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
10969 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
10970 panic!(
10971 "unity: virtual slot {}
10972 out of range (vtable len {}
10973) on the runtime class behind {}
10974 (method `{}
10975`)",
10976 4usize,
10977 __vt.len(),
10978 <UnitCalculator_InternalLevelCommand as ::unity::ClassIdentity>::NAME,
10979 "get_Name",
10980 )
10981 });
10982 let __inner: extern "C" fn(UnitCalculator_InternalLevelCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
10983 ::core::mem::transmute(__vi.method_ptr);
10984 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
10985 __inner(__receiver, __mi)
10986 }
10987 }
10988 }
10989 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
10990 fn get_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
10991 unsafe {
10992 let __receiver = <UnitCalculator_InternalLevelCommand as ::unity::FromIlInstance>::from_il_instance(
10993 <Self as ::unity::SystemObject>::as_instance(self),
10994 );
10995 {
10996 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
10997 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
10998 panic!(
10999 "unity: virtual slot {}
11000 out of range (vtable len {}
11001) on the runtime class behind {}
11002 (method `{}
11003`)",
11004 30usize,
11005 __vt.len(),
11006 <UnitCalculator_InternalLevelCommand as ::unity::ClassIdentity>::NAME,
11007 "GetImpl",
11008 )
11009 });
11010 let __inner: extern "C" fn(UnitCalculator_InternalLevelCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
11011 ::core::mem::transmute(__vi.method_ptr);
11012 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
11013 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
11014 }
11015 }
11016 }
11017 #[doc = "`.ctor()` overload"]
11018 fn ctor(self) -> () {
11019 unsafe {
11020 let __receiver = <UnitCalculator_InternalLevelCommand as ::unity::FromIlInstance>::from_il_instance(
11021 <Self as ::unity::SystemObject>::as_instance(self),
11022 );
11023 ::unity::il2cpp_call!((::unity::module_base()+0x1b485c0usize)as*mut u8,();
11024(UnitCalculator_InternalLevelCommand)__receiver)
11025 }
11026 }
11027}
11028
11029#[cfg(feature = "app-unitcalculator")]
11030impl<__T: IUnitCalculator_InternalLevelCommand> IUnitCalculator_InternalLevelCommandMethods for __T {}
11031
11032#[cfg(feature = "app-unitcalculator")]
11033impl UnitCalculator_InternalLevelCommand {
11034 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11035 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
11036 }
11037
11038 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11039 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
11040 }
11041
11042 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11043 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
11044 }
11045}
11046
11047#[cfg(feature = "app-unitcalculator")]
11048impl UnitCalculator_InternalLevelCommand {
11049 #[doc = "Direct (non-virtual) call to `UnitCalculator_InternalLevelCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
11050 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
11051 let __mi = Self::get_name_method_info();
11052 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
11053 __inner(this.into(), ::core::option::Option::None)
11054 }
11055
11056 #[doc = "Direct (non-virtual) call to `UnitCalculator_InternalLevelCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
11057 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
11058 let __mi = Self::get_impl_method_info();
11059 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
11060 ::core::mem::transmute(__mi.method_ptr);
11061 __inner(this.into(), unit, ::core::option::Option::None)
11062 }
11063}
11064
11065#[cfg(feature = "app-unitcalculator")]
11066impl UnitCalculator_InternalLevelCommand {
11067 #[doc = "`.ctor()` — no args"]
11068 pub fn new() -> Self {
11069 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
11070 panic!(
11071 "{}
11072::{}
11073 failed to instantiate",
11074 ::core::stringify!(UnitCalculator_InternalLevelCommand),
11075 ::core::stringify!(new),
11076 )
11077 });
11078 <Self as IUnitCalculator_InternalLevelCommandMethods>::ctor(this);
11079 this
11080 }
11081}
11082
11083#[cfg(feature = "app-unitcalculator")]
11084pub trait IUnitCalculator_LinkQuickCommandMethods: IUnitCalculator_LinkQuickCommand {
11085 #[doc = "`get_Name()` overload"]
11086 fn get_name(self) -> ::unity::Il2CppString {
11087 unsafe {
11088 let __receiver =
11089 <UnitCalculator_LinkQuickCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
11090 {
11091 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
11092 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
11093 panic!(
11094 "unity: virtual slot {}
11095 out of range (vtable len {}
11096) on the runtime class behind {}
11097 (method `{}
11098`)",
11099 4usize,
11100 __vt.len(),
11101 <UnitCalculator_LinkQuickCommand as ::unity::ClassIdentity>::NAME,
11102 "get_Name",
11103 )
11104 });
11105 let __inner: extern "C" fn(UnitCalculator_LinkQuickCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
11106 ::core::mem::transmute(__vi.method_ptr);
11107 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
11108 __inner(__receiver, __mi)
11109 }
11110 }
11111 }
11112 #[doc = "`get_CapabilityType()` overload"]
11113 fn get_capability_type(self) -> crate::app::capabilitydefinition::CapabilityDefinition_Type {
11114 unsafe {
11115 let __receiver =
11116 <UnitCalculator_LinkQuickCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
11117 {
11118 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
11119 let __vi = *__vt.get(44usize).unwrap_or_else(|| {
11120 panic!(
11121 "unity: virtual slot {}
11122 out of range (vtable len {}
11123) on the runtime class behind {}
11124 (method `{}
11125`)",
11126 44usize,
11127 __vt.len(),
11128 <UnitCalculator_LinkQuickCommand as ::unity::ClassIdentity>::NAME,
11129 "get_CapabilityType",
11130 )
11131 });
11132 let __inner: extern "C" fn(
11133 UnitCalculator_LinkQuickCommand,
11134 ::unity::OptionalMethod,
11135 ) -> crate::app::capabilitydefinition::CapabilityDefinition_Type = ::core::mem::transmute(__vi.method_ptr);
11136 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
11137 __inner(__receiver, __mi)
11138 }
11139 }
11140 }
11141 #[doc = "`.ctor()` overload"]
11142 fn ctor(self) -> () {
11143 unsafe {
11144 let __receiver =
11145 <UnitCalculator_LinkQuickCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
11146 ::unity::il2cpp_call!((::unity::module_base()+0x1b48c60usize)as*mut u8,();
11147(UnitCalculator_LinkQuickCommand)__receiver)
11148 }
11149 }
11150}
11151
11152#[cfg(feature = "app-unitcalculator")]
11153impl<__T: IUnitCalculator_LinkQuickCommand> IUnitCalculator_LinkQuickCommandMethods for __T {}
11154
11155#[cfg(feature = "app-unitcalculator")]
11156impl UnitCalculator_LinkQuickCommand {
11157 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11158 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
11159 }
11160
11161 pub fn get_capability_type_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11162 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
11163 }
11164
11165 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11166 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
11167 }
11168}
11169
11170#[cfg(feature = "app-unitcalculator")]
11171impl UnitCalculator_LinkQuickCommand {
11172 #[doc = "Direct (non-virtual) call to `UnitCalculator_LinkQuickCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
11173 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
11174 let __mi = Self::get_name_method_info();
11175 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
11176 __inner(this.into(), ::core::option::Option::None)
11177 }
11178
11179 #[doc = "Direct (non-virtual) call to `UnitCalculator_LinkQuickCommand`'s own `get_CapabilityType`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
11180 pub unsafe fn get_capability_type(
11181 this: impl ::core::convert::Into<::unity::IlInstance>,
11182 ) -> crate::app::capabilitydefinition::CapabilityDefinition_Type {
11183 let __mi = Self::get_capability_type_method_info();
11184 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::capabilitydefinition::CapabilityDefinition_Type =
11185 ::core::mem::transmute(__mi.method_ptr);
11186 __inner(this.into(), ::core::option::Option::None)
11187 }
11188}
11189
11190#[cfg(feature = "app-unitcalculator")]
11191impl UnitCalculator_LinkQuickCommand {
11192 #[doc = "`.ctor()` — no args"]
11193 pub fn new() -> Self {
11194 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
11195 panic!(
11196 "{}
11197::{}
11198 failed to instantiate",
11199 ::core::stringify!(UnitCalculator_LinkQuickCommand),
11200 ::core::stringify!(new),
11201 )
11202 });
11203 <Self as IUnitCalculator_LinkQuickCommandMethods>::ctor(this);
11204 this
11205 }
11206}
11207
11208#[cfg(feature = "app-unitcalculator")]
11209pub trait IUnitCalculator_UnitAttackCommandMethods: IUnitCalculator_UnitAttackCommand {
11210 #[doc = "`get_Name()` overload"]
11211 fn get_name(self) -> ::unity::Il2CppString {
11212 unsafe {
11213 let __receiver =
11214 <UnitCalculator_UnitAttackCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
11215 {
11216 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
11217 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
11218 panic!(
11219 "unity: virtual slot {}
11220 out of range (vtable len {}
11221) on the runtime class behind {}
11222 (method `{}
11223`)",
11224 4usize,
11225 __vt.len(),
11226 <UnitCalculator_UnitAttackCommand as ::unity::ClassIdentity>::NAME,
11227 "get_Name",
11228 )
11229 });
11230 let __inner: extern "C" fn(UnitCalculator_UnitAttackCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
11231 ::core::mem::transmute(__vi.method_ptr);
11232 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
11233 __inner(__receiver, __mi)
11234 }
11235 }
11236 }
11237 #[doc = "`GetParam(crate::app::battleinfoside::BattleInfoSide)` overload"]
11238 fn get_param(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> crate::app::battleparam::BattleParam {
11239 unsafe {
11240 let __receiver =
11241 <UnitCalculator_UnitAttackCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
11242 {
11243 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
11244 let __vi = *__vt.get(44usize).unwrap_or_else(|| {
11245 panic!(
11246 "unity: virtual slot {}
11247 out of range (vtable len {}
11248) on the runtime class behind {}
11249 (method `{}
11250`)",
11251 44usize,
11252 __vt.len(),
11253 <UnitCalculator_UnitAttackCommand as ::unity::ClassIdentity>::NAME,
11254 "GetParam",
11255 )
11256 });
11257 let __inner: extern "C" fn(
11258 UnitCalculator_UnitAttackCommand,
11259 crate::app::battleinfoside::BattleInfoSide,
11260 ::unity::OptionalMethod,
11261 ) -> crate::app::battleparam::BattleParam = ::core::mem::transmute(__vi.method_ptr);
11262 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
11263 __inner(__receiver, ::core::convert::Into::into(side), __mi)
11264 }
11265 }
11266 }
11267 #[doc = "`.ctor()` overload"]
11268 fn ctor(self) -> () {
11269 unsafe {
11270 let __receiver =
11271 <UnitCalculator_UnitAttackCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
11272 ::unity::il2cpp_call!((::unity::module_base()+0x1b4d270usize)as*mut u8,();
11273(UnitCalculator_UnitAttackCommand)__receiver)
11274 }
11275 }
11276}
11277
11278#[cfg(feature = "app-unitcalculator")]
11279impl<__T: IUnitCalculator_UnitAttackCommand> IUnitCalculator_UnitAttackCommandMethods for __T {}
11280
11281#[cfg(feature = "app-unitcalculator")]
11282impl UnitCalculator_UnitAttackCommand {
11283 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11284 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
11285 }
11286
11287 pub fn get_param_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11288 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
11289 }
11290
11291 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11292 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
11293 }
11294}
11295
11296#[cfg(feature = "app-unitcalculator")]
11297impl UnitCalculator_UnitAttackCommand {
11298 #[doc = "Direct (non-virtual) call to `UnitCalculator_UnitAttackCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
11299 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
11300 let __mi = Self::get_name_method_info();
11301 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
11302 __inner(this.into(), ::core::option::Option::None)
11303 }
11304
11305 #[doc = "Direct (non-virtual) call to `UnitCalculator_UnitAttackCommand`'s own `GetParam`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
11306 pub unsafe fn get_param(
11307 this: impl ::core::convert::Into<::unity::IlInstance>,
11308 side: crate::app::battleinfoside::BattleInfoSide,
11309 ) -> crate::app::battleparam::BattleParam {
11310 let __mi = Self::get_param_method_info();
11311 let __inner: extern "C" fn(
11312 ::unity::IlInstance,
11313 crate::app::battleinfoside::BattleInfoSide,
11314 ::unity::OptionalMethod,
11315 ) -> crate::app::battleparam::BattleParam = ::core::mem::transmute(__mi.method_ptr);
11316 __inner(this.into(), side, ::core::option::Option::None)
11317 }
11318}
11319
11320#[cfg(feature = "app-unitcalculator")]
11321impl UnitCalculator_UnitAttackCommand {
11322 #[doc = "`.ctor()` — no args"]
11323 pub fn new() -> Self {
11324 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
11325 panic!(
11326 "{}
11327::{}
11328 failed to instantiate",
11329 ::core::stringify!(UnitCalculator_UnitAttackCommand),
11330 ::core::stringify!(new),
11331 )
11332 });
11333 <Self as IUnitCalculator_UnitAttackCommandMethods>::ctor(this);
11334 this
11335 }
11336}
11337
11338#[cfg(feature = "app-unitcalculator")]
11339pub trait IUnitCalculator_UnitJobCommandMethods: IUnitCalculator_UnitJobCommand {
11340 #[doc = "`get_Name()` overload"]
11341 fn get_name(self) -> ::unity::Il2CppString {
11342 unsafe {
11343 let __receiver =
11344 <UnitCalculator_UnitJobCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
11345 {
11346 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
11347 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
11348 panic!(
11349 "unity: virtual slot {}
11350 out of range (vtable len {}
11351) on the runtime class behind {}
11352 (method `{}
11353`)",
11354 4usize,
11355 __vt.len(),
11356 <UnitCalculator_UnitJobCommand as ::unity::ClassIdentity>::NAME,
11357 "get_Name",
11358 )
11359 });
11360 let __inner: extern "C" fn(UnitCalculator_UnitJobCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
11361 ::core::mem::transmute(__vi.method_ptr);
11362 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
11363 __inner(__receiver, __mi)
11364 }
11365 }
11366 }
11367 #[doc = "`FuncImpl(crate::app::unit::Unit, ::unity::Il2CppString)` overload"]
11368 fn func_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>, arg: impl ::core::convert::Into<::unity::Il2CppString>) -> f32 {
11369 unsafe {
11370 let __receiver =
11371 <UnitCalculator_UnitJobCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
11372 {
11373 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
11374 let __vi = *__vt.get(36usize).unwrap_or_else(|| {
11375 panic!(
11376 "unity: virtual slot {}
11377 out of range (vtable len {}
11378) on the runtime class behind {}
11379 (method `{}
11380`)",
11381 36usize,
11382 __vt.len(),
11383 <UnitCalculator_UnitJobCommand as ::unity::ClassIdentity>::NAME,
11384 "FuncImpl",
11385 )
11386 });
11387 let __inner: extern "C" fn(
11388 UnitCalculator_UnitJobCommand,
11389 crate::app::unit::Unit,
11390 ::unity::Il2CppString,
11391 ::unity::OptionalMethod,
11392 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
11393 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
11394 __inner(__receiver, ::core::convert::Into::into(unit), ::core::convert::Into::into(arg), __mi)
11395 }
11396 }
11397 }
11398 #[doc = "`.ctor()` overload"]
11399 fn ctor(self) -> () {
11400 unsafe {
11401 let __receiver =
11402 <UnitCalculator_UnitJobCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
11403 ::unity::il2cpp_call!((::unity::module_base()+0x1b4d710usize)as*mut u8,();
11404(UnitCalculator_UnitJobCommand)__receiver)
11405 }
11406 }
11407}
11408
11409#[cfg(feature = "app-unitcalculator")]
11410impl<__T: IUnitCalculator_UnitJobCommand> IUnitCalculator_UnitJobCommandMethods for __T {}
11411
11412#[cfg(feature = "app-unitcalculator")]
11413impl UnitCalculator_UnitJobCommand {
11414 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11415 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
11416 }
11417
11418 pub fn func_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11419 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
11420 }
11421
11422 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11423 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
11424 }
11425}
11426
11427#[cfg(feature = "app-unitcalculator")]
11428impl UnitCalculator_UnitJobCommand {
11429 #[doc = "Direct (non-virtual) call to `UnitCalculator_UnitJobCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
11430 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
11431 let __mi = Self::get_name_method_info();
11432 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
11433 __inner(this.into(), ::core::option::Option::None)
11434 }
11435
11436 #[doc = "Direct (non-virtual) call to `UnitCalculator_UnitJobCommand`'s own `FuncImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
11437 pub unsafe fn func_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit, arg: ::unity::Il2CppString) -> f32 {
11438 let __mi = Self::func_impl_method_info();
11439 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::Il2CppString, ::unity::OptionalMethod) -> f32 =
11440 ::core::mem::transmute(__mi.method_ptr);
11441 __inner(this.into(), unit, arg, ::core::option::Option::None)
11442 }
11443}
11444
11445#[cfg(feature = "app-unitcalculator")]
11446impl UnitCalculator_UnitJobCommand {
11447 #[doc = "`.ctor()` — no args"]
11448 pub fn new() -> Self {
11449 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
11450 panic!(
11451 "{}
11452::{}
11453 failed to instantiate",
11454 ::core::stringify!(UnitCalculator_UnitJobCommand),
11455 ::core::stringify!(new),
11456 )
11457 });
11458 <Self as IUnitCalculator_UnitJobCommandMethods>::ctor(this);
11459 this
11460 }
11461}
11462
11463#[cfg(feature = "app-unitcalculator")]
11464pub trait IUnitCalculator_GodGoodWeaponCommandMethods: IUnitCalculator_GodGoodWeaponCommand {
11465 #[doc = "`get_Name()` overload"]
11466 fn get_name(self) -> ::unity::Il2CppString {
11467 unsafe {
11468 let __receiver = <UnitCalculator_GodGoodWeaponCommand as ::unity::FromIlInstance>::from_il_instance(
11469 <Self as ::unity::SystemObject>::as_instance(self),
11470 );
11471 {
11472 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
11473 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
11474 panic!(
11475 "unity: virtual slot {}
11476 out of range (vtable len {}
11477) on the runtime class behind {}
11478 (method `{}
11479`)",
11480 4usize,
11481 __vt.len(),
11482 <UnitCalculator_GodGoodWeaponCommand as ::unity::ClassIdentity>::NAME,
11483 "get_Name",
11484 )
11485 });
11486 let __inner: extern "C" fn(UnitCalculator_GodGoodWeaponCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
11487 ::core::mem::transmute(__vi.method_ptr);
11488 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
11489 __inner(__receiver, __mi)
11490 }
11491 }
11492 }
11493 #[doc = "`GetValue(crate::app::unit::Unit)` overload"]
11494 fn get_value(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> i32 {
11495 unsafe {
11496 let __receiver = <UnitCalculator_GodGoodWeaponCommand as ::unity::FromIlInstance>::from_il_instance(
11497 <Self as ::unity::SystemObject>::as_instance(self),
11498 );
11499 ::unity::il2cpp_call!((::unity::module_base()+0x1b47e10usize)as*mut u8,i32;
11500(UnitCalculator_GodGoodWeaponCommand)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(unit))
11501 }
11502 }
11503 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
11504 fn get_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
11505 unsafe {
11506 let __receiver = <UnitCalculator_GodGoodWeaponCommand as ::unity::FromIlInstance>::from_il_instance(
11507 <Self as ::unity::SystemObject>::as_instance(self),
11508 );
11509 {
11510 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
11511 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
11512 panic!(
11513 "unity: virtual slot {}
11514 out of range (vtable len {}
11515) on the runtime class behind {}
11516 (method `{}
11517`)",
11518 30usize,
11519 __vt.len(),
11520 <UnitCalculator_GodGoodWeaponCommand as ::unity::ClassIdentity>::NAME,
11521 "GetImpl",
11522 )
11523 });
11524 let __inner: extern "C" fn(UnitCalculator_GodGoodWeaponCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
11525 ::core::mem::transmute(__vi.method_ptr);
11526 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
11527 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
11528 }
11529 }
11530 }
11531 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
11532 fn get_impl_2(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
11533 unsafe {
11534 let __receiver = <UnitCalculator_GodGoodWeaponCommand as ::unity::FromIlInstance>::from_il_instance(
11535 <Self as ::unity::SystemObject>::as_instance(self),
11536 );
11537 {
11538 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
11539 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
11540 panic!(
11541 "unity: virtual slot {}
11542 out of range (vtable len {}
11543) on the runtime class behind {}
11544 (method `{}
11545`)",
11546 31usize,
11547 __vt.len(),
11548 <UnitCalculator_GodGoodWeaponCommand as ::unity::ClassIdentity>::NAME,
11549 "GetImpl",
11550 )
11551 });
11552 let __inner: extern "C" fn(
11553 UnitCalculator_GodGoodWeaponCommand,
11554 crate::app::battleinfoside::BattleInfoSide,
11555 ::unity::OptionalMethod,
11556 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
11557 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
11558 __inner(__receiver, ::core::convert::Into::into(side), __mi)
11559 }
11560 }
11561 }
11562 #[doc = "`.ctor()` overload"]
11563 fn ctor(self) -> () {
11564 unsafe {
11565 let __receiver = <UnitCalculator_GodGoodWeaponCommand as ::unity::FromIlInstance>::from_il_instance(
11566 <Self as ::unity::SystemObject>::as_instance(self),
11567 );
11568 ::unity::il2cpp_call!((::unity::module_base()+0x1b48010usize)as*mut u8,();
11569(UnitCalculator_GodGoodWeaponCommand)__receiver)
11570 }
11571 }
11572}
11573
11574#[cfg(feature = "app-unitcalculator")]
11575impl<__T: IUnitCalculator_GodGoodWeaponCommand> IUnitCalculator_GodGoodWeaponCommandMethods for __T {}
11576
11577#[cfg(feature = "app-unitcalculator")]
11578impl UnitCalculator_GodGoodWeaponCommand {
11579 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11580 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
11581 }
11582
11583 pub fn get_value_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11584 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
11585 }
11586
11587 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11588 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
11589 }
11590
11591 pub fn get_impl_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11592 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
11593 }
11594
11595 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11596 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
11597 }
11598}
11599
11600#[cfg(feature = "app-unitcalculator")]
11601impl UnitCalculator_GodGoodWeaponCommand {
11602 #[doc = "Direct (non-virtual) call to `UnitCalculator_GodGoodWeaponCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
11603 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
11604 let __mi = Self::get_name_method_info();
11605 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
11606 __inner(this.into(), ::core::option::Option::None)
11607 }
11608
11609 #[doc = "Direct (non-virtual) call to `UnitCalculator_GodGoodWeaponCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
11610 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
11611 let __mi = Self::get_impl_method_info();
11612 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
11613 ::core::mem::transmute(__mi.method_ptr);
11614 __inner(this.into(), unit, ::core::option::Option::None)
11615 }
11616
11617 #[doc = "Direct (non-virtual) call to `UnitCalculator_GodGoodWeaponCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
11618 pub unsafe fn get_impl_2(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
11619 let __mi = Self::get_impl_2_method_info();
11620 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
11621 ::core::mem::transmute(__mi.method_ptr);
11622 __inner(this.into(), side, ::core::option::Option::None)
11623 }
11624}
11625
11626#[cfg(feature = "app-unitcalculator")]
11627impl UnitCalculator_GodGoodWeaponCommand {
11628 #[doc = "`.ctor()` — no args"]
11629 pub fn new() -> Self {
11630 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
11631 panic!(
11632 "{}
11633::{}
11634 failed to instantiate",
11635 ::core::stringify!(UnitCalculator_GodGoodWeaponCommand),
11636 ::core::stringify!(new),
11637 )
11638 });
11639 <Self as IUnitCalculator_GodGoodWeaponCommandMethods>::ctor(this);
11640 this
11641 }
11642}
11643
11644#[cfg(feature = "app-unitcalculator")]
11645pub trait IUnitCalculator_ProbabilityCommandMethods: IUnitCalculator_ProbabilityCommand {
11646 #[doc = "`GetResult(crate::app::battleside::BattleSide_Type, i32)` overload"]
11647 fn get_result(self, side: impl ::core::convert::Into<crate::app::battleside::BattleSide_Type>, percent: impl ::core::convert::Into<i32>) -> f32 {
11648 unsafe {
11649 let __receiver =
11650 <UnitCalculator_ProbabilityCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
11651 ::unity::il2cpp_call!((::unity::module_base()+0x1b4acc0usize)as*mut u8,f32;
11652(UnitCalculator_ProbabilityCommand)__receiver,(crate::app::battleside::BattleSide_Type)::core::convert::Into::into(side),(i32)::core::convert::Into::into(percent))
11653 }
11654 }
11655 #[doc = "`FuncImpl(crate::app::unit::Unit, crate::system::collections::generic::list_1::List_1<f32>)` overload"]
11656 fn func_impl(
11657 self,
11658 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
11659 args: impl ::core::convert::Into<crate::system::collections::generic::list_1::List_1<f32>>,
11660 ) -> f32 {
11661 unsafe {
11662 let __receiver =
11663 <UnitCalculator_ProbabilityCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
11664 {
11665 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
11666 let __vi = *__vt.get(34usize).unwrap_or_else(|| {
11667 panic!(
11668 "unity: virtual slot {}
11669 out of range (vtable len {}
11670) on the runtime class behind {}
11671 (method `{}
11672`)",
11673 34usize,
11674 __vt.len(),
11675 <UnitCalculator_ProbabilityCommand as ::unity::ClassIdentity>::NAME,
11676 "FuncImpl",
11677 )
11678 });
11679 let __inner: extern "C" fn(
11680 UnitCalculator_ProbabilityCommand,
11681 crate::app::unit::Unit,
11682 crate::system::collections::generic::list_1::List_1<f32>,
11683 ::unity::OptionalMethod,
11684 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
11685 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
11686 __inner(__receiver, ::core::convert::Into::into(unit), ::core::convert::Into::into(args), __mi)
11687 }
11688 }
11689 }
11690 #[doc = "`FuncImpl(crate::app::battleinfoside::BattleInfoSide, crate::system::collections::generic::list_1::List_1<f32>)` overload"]
11691 fn func_impl_2(
11692 self,
11693 side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
11694 args: impl ::core::convert::Into<crate::system::collections::generic::list_1::List_1<f32>>,
11695 ) -> f32 {
11696 unsafe {
11697 let __receiver =
11698 <UnitCalculator_ProbabilityCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
11699 {
11700 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
11701 let __vi = *__vt.get(35usize).unwrap_or_else(|| {
11702 panic!(
11703 "unity: virtual slot {}
11704 out of range (vtable len {}
11705) on the runtime class behind {}
11706 (method `{}
11707`)",
11708 35usize,
11709 __vt.len(),
11710 <UnitCalculator_ProbabilityCommand as ::unity::ClassIdentity>::NAME,
11711 "FuncImpl",
11712 )
11713 });
11714 let __inner: extern "C" fn(
11715 UnitCalculator_ProbabilityCommand,
11716 crate::app::battleinfoside::BattleInfoSide,
11717 crate::system::collections::generic::list_1::List_1<f32>,
11718 ::unity::OptionalMethod,
11719 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
11720 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
11721 __inner(__receiver, ::core::convert::Into::into(side), ::core::convert::Into::into(args), __mi)
11722 }
11723 }
11724 }
11725 #[doc = "`GetCorrect(crate::app::unit::Unit)` overload"]
11726 fn get_correct(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
11727 unsafe {
11728 let __receiver =
11729 <UnitCalculator_ProbabilityCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
11730 {
11731 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
11732 let __vi = *__vt.get(44usize).unwrap_or_else(|| {
11733 panic!(
11734 "unity: virtual slot {}
11735 out of range (vtable len {}
11736) on the runtime class behind {}
11737 (method `{}
11738`)",
11739 44usize,
11740 __vt.len(),
11741 <UnitCalculator_ProbabilityCommand as ::unity::ClassIdentity>::NAME,
11742 "GetCorrect",
11743 )
11744 });
11745 let __inner: extern "C" fn(UnitCalculator_ProbabilityCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
11746 ::core::mem::transmute(__vi.method_ptr);
11747 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
11748 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
11749 }
11750 }
11751 }
11752 #[doc = "`GetCorrect(crate::app::battleinfoside::BattleInfoSide)` overload"]
11753 fn get_correct_2(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
11754 unsafe {
11755 let __receiver =
11756 <UnitCalculator_ProbabilityCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
11757 {
11758 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
11759 let __vi = *__vt.get(45usize).unwrap_or_else(|| {
11760 panic!(
11761 "unity: virtual slot {}
11762 out of range (vtable len {}
11763) on the runtime class behind {}
11764 (method `{}
11765`)",
11766 45usize,
11767 __vt.len(),
11768 <UnitCalculator_ProbabilityCommand as ::unity::ClassIdentity>::NAME,
11769 "GetCorrect",
11770 )
11771 });
11772 let __inner: extern "C" fn(
11773 UnitCalculator_ProbabilityCommand,
11774 crate::app::battleinfoside::BattleInfoSide,
11775 ::unity::OptionalMethod,
11776 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
11777 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
11778 __inner(__receiver, ::core::convert::Into::into(side), __mi)
11779 }
11780 }
11781 }
11782 #[doc = "`.ctor()` overload"]
11783 fn ctor(self) -> () {
11784 unsafe {
11785 let __receiver =
11786 <UnitCalculator_ProbabilityCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
11787 ::unity::il2cpp_call!((::unity::module_base()+0x1b4afa0usize)as*mut u8,();
11788(UnitCalculator_ProbabilityCommand)__receiver)
11789 }
11790 }
11791}
11792
11793#[cfg(feature = "app-unitcalculator")]
11794impl<__T: IUnitCalculator_ProbabilityCommand> IUnitCalculator_ProbabilityCommandMethods for __T {}
11795
11796#[cfg(feature = "app-unitcalculator")]
11797impl UnitCalculator_ProbabilityCommand {
11798 pub fn get_result_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11799 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
11800 }
11801
11802 pub fn func_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11803 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
11804 }
11805
11806 pub fn func_impl_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11807 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
11808 }
11809
11810 pub fn get_correct_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11811 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
11812 }
11813
11814 pub fn get_correct_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11815 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
11816 }
11817
11818 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11819 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
11820 }
11821}
11822
11823#[cfg(feature = "app-unitcalculator")]
11824impl UnitCalculator_ProbabilityCommand {
11825 #[doc = "Direct (non-virtual) call to `UnitCalculator_ProbabilityCommand`'s own `FuncImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
11826 pub unsafe fn func_impl(
11827 this: impl ::core::convert::Into<::unity::IlInstance>,
11828 unit: crate::app::unit::Unit,
11829 args: crate::system::collections::generic::list_1::List_1<f32>,
11830 ) -> f32 {
11831 let __mi = Self::func_impl_method_info();
11832 let __inner: extern "C" fn(
11833 ::unity::IlInstance,
11834 crate::app::unit::Unit,
11835 crate::system::collections::generic::list_1::List_1<f32>,
11836 ::unity::OptionalMethod,
11837 ) -> f32 = ::core::mem::transmute(__mi.method_ptr);
11838 __inner(this.into(), unit, args, ::core::option::Option::None)
11839 }
11840
11841 #[doc = "Direct (non-virtual) call to `UnitCalculator_ProbabilityCommand`'s own `FuncImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
11842 pub unsafe fn func_impl_2(
11843 this: impl ::core::convert::Into<::unity::IlInstance>,
11844 side: crate::app::battleinfoside::BattleInfoSide,
11845 args: crate::system::collections::generic::list_1::List_1<f32>,
11846 ) -> f32 {
11847 let __mi = Self::func_impl_2_method_info();
11848 let __inner: extern "C" fn(
11849 ::unity::IlInstance,
11850 crate::app::battleinfoside::BattleInfoSide,
11851 crate::system::collections::generic::list_1::List_1<f32>,
11852 ::unity::OptionalMethod,
11853 ) -> f32 = ::core::mem::transmute(__mi.method_ptr);
11854 __inner(this.into(), side, args, ::core::option::Option::None)
11855 }
11856
11857 #[doc = "Direct (non-virtual) call to `UnitCalculator_ProbabilityCommand`'s own `GetCorrect`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
11858 pub unsafe fn get_correct(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
11859 let __mi = Self::get_correct_method_info();
11860 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
11861 ::core::mem::transmute(__mi.method_ptr);
11862 __inner(this.into(), unit, ::core::option::Option::None)
11863 }
11864
11865 #[doc = "Direct (non-virtual) call to `UnitCalculator_ProbabilityCommand`'s own `GetCorrect`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
11866 pub unsafe fn get_correct_2(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
11867 let __mi = Self::get_correct_2_method_info();
11868 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
11869 ::core::mem::transmute(__mi.method_ptr);
11870 __inner(this.into(), side, ::core::option::Option::None)
11871 }
11872}
11873
11874#[cfg(feature = "app-unitcalculator")]
11875impl UnitCalculator_ProbabilityCommand {
11876 #[doc = "`.ctor()` — no args"]
11877 pub fn new() -> Self {
11878 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
11879 panic!(
11880 "{}
11881::{}
11882 failed to instantiate",
11883 ::core::stringify!(UnitCalculator_ProbabilityCommand),
11884 ::core::stringify!(new),
11885 )
11886 });
11887 <Self as IUnitCalculator_ProbabilityCommandMethods>::ctor(this);
11888 this
11889 }
11890}
11891
11892#[cfg(feature = "app-unitcalculator")]
11893pub trait IUnitCalculator_BattleReviveCommandMethods: IUnitCalculator_BattleReviveCommand {
11894 #[doc = "`get_Name()` overload"]
11895 fn get_name(self) -> ::unity::Il2CppString {
11896 unsafe {
11897 let __receiver =
11898 <UnitCalculator_BattleReviveCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
11899 {
11900 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
11901 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
11902 panic!(
11903 "unity: virtual slot {}
11904 out of range (vtable len {}
11905) on the runtime class behind {}
11906 (method `{}
11907`)",
11908 4usize,
11909 __vt.len(),
11910 <UnitCalculator_BattleReviveCommand as ::unity::ClassIdentity>::NAME,
11911 "get_Name",
11912 )
11913 });
11914 let __inner: extern "C" fn(UnitCalculator_BattleReviveCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
11915 ::core::mem::transmute(__vi.method_ptr);
11916 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
11917 __inner(__receiver, __mi)
11918 }
11919 }
11920 }
11921 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
11922 fn get_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
11923 unsafe {
11924 let __receiver =
11925 <UnitCalculator_BattleReviveCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
11926 {
11927 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
11928 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
11929 panic!(
11930 "unity: virtual slot {}
11931 out of range (vtable len {}
11932) on the runtime class behind {}
11933 (method `{}
11934`)",
11935 30usize,
11936 __vt.len(),
11937 <UnitCalculator_BattleReviveCommand as ::unity::ClassIdentity>::NAME,
11938 "GetImpl",
11939 )
11940 });
11941 let __inner: extern "C" fn(UnitCalculator_BattleReviveCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
11942 ::core::mem::transmute(__vi.method_ptr);
11943 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
11944 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
11945 }
11946 }
11947 }
11948 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
11949 fn get_impl_2(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
11950 unsafe {
11951 let __receiver =
11952 <UnitCalculator_BattleReviveCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
11953 {
11954 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
11955 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
11956 panic!(
11957 "unity: virtual slot {}
11958 out of range (vtable len {}
11959) on the runtime class behind {}
11960 (method `{}
11961`)",
11962 31usize,
11963 __vt.len(),
11964 <UnitCalculator_BattleReviveCommand as ::unity::ClassIdentity>::NAME,
11965 "GetImpl",
11966 )
11967 });
11968 let __inner: extern "C" fn(
11969 UnitCalculator_BattleReviveCommand,
11970 crate::app::battleinfoside::BattleInfoSide,
11971 ::unity::OptionalMethod,
11972 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
11973 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
11974 __inner(__receiver, ::core::convert::Into::into(side), __mi)
11975 }
11976 }
11977 }
11978 #[doc = "`.ctor()` overload"]
11979 fn ctor(self) -> () {
11980 unsafe {
11981 let __receiver =
11982 <UnitCalculator_BattleReviveCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
11983 ::unity::il2cpp_call!((::unity::module_base()+0x1b45fc0usize)as*mut u8,();
11984(UnitCalculator_BattleReviveCommand)__receiver)
11985 }
11986 }
11987}
11988
11989#[cfg(feature = "app-unitcalculator")]
11990impl<__T: IUnitCalculator_BattleReviveCommand> IUnitCalculator_BattleReviveCommandMethods for __T {}
11991
11992#[cfg(feature = "app-unitcalculator")]
11993impl UnitCalculator_BattleReviveCommand {
11994 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11995 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
11996 }
11997
11998 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
11999 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
12000 }
12001
12002 pub fn get_impl_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
12003 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
12004 }
12005
12006 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
12007 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
12008 }
12009}
12010
12011#[cfg(feature = "app-unitcalculator")]
12012impl UnitCalculator_BattleReviveCommand {
12013 #[doc = "Direct (non-virtual) call to `UnitCalculator_BattleReviveCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
12014 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
12015 let __mi = Self::get_name_method_info();
12016 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
12017 __inner(this.into(), ::core::option::Option::None)
12018 }
12019
12020 #[doc = "Direct (non-virtual) call to `UnitCalculator_BattleReviveCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
12021 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
12022 let __mi = Self::get_impl_method_info();
12023 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
12024 ::core::mem::transmute(__mi.method_ptr);
12025 __inner(this.into(), unit, ::core::option::Option::None)
12026 }
12027
12028 #[doc = "Direct (non-virtual) call to `UnitCalculator_BattleReviveCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
12029 pub unsafe fn get_impl_2(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
12030 let __mi = Self::get_impl_2_method_info();
12031 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
12032 ::core::mem::transmute(__mi.method_ptr);
12033 __inner(this.into(), side, ::core::option::Option::None)
12034 }
12035}
12036
12037#[cfg(feature = "app-unitcalculator")]
12038impl UnitCalculator_BattleReviveCommand {
12039 #[doc = "`.ctor()` — no args"]
12040 pub fn new() -> Self {
12041 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
12042 panic!(
12043 "{}
12044::{}
12045 failed to instantiate",
12046 ::core::stringify!(UnitCalculator_BattleReviveCommand),
12047 ::core::stringify!(new),
12048 )
12049 });
12050 <Self as IUnitCalculator_BattleReviveCommandMethods>::ctor(this);
12051 this
12052 }
12053}
12054
12055#[cfg(feature = "app-unitcalculator")]
12056pub trait IUnitCalculator_EngageCountCommandMethods: IUnitCalculator_EngageCountCommand {
12057 #[doc = "`get_Name()` overload"]
12058 fn get_name(self) -> ::unity::Il2CppString {
12059 unsafe {
12060 let __receiver =
12061 <UnitCalculator_EngageCountCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
12062 {
12063 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
12064 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
12065 panic!(
12066 "unity: virtual slot {}
12067 out of range (vtable len {}
12068) on the runtime class behind {}
12069 (method `{}
12070`)",
12071 4usize,
12072 __vt.len(),
12073 <UnitCalculator_EngageCountCommand as ::unity::ClassIdentity>::NAME,
12074 "get_Name",
12075 )
12076 });
12077 let __inner: extern "C" fn(UnitCalculator_EngageCountCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
12078 ::core::mem::transmute(__vi.method_ptr);
12079 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
12080 __inner(__receiver, __mi)
12081 }
12082 }
12083 }
12084 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
12085 fn get_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
12086 unsafe {
12087 let __receiver =
12088 <UnitCalculator_EngageCountCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
12089 {
12090 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
12091 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
12092 panic!(
12093 "unity: virtual slot {}
12094 out of range (vtable len {}
12095) on the runtime class behind {}
12096 (method `{}
12097`)",
12098 30usize,
12099 __vt.len(),
12100 <UnitCalculator_EngageCountCommand as ::unity::ClassIdentity>::NAME,
12101 "GetImpl",
12102 )
12103 });
12104 let __inner: extern "C" fn(UnitCalculator_EngageCountCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
12105 ::core::mem::transmute(__vi.method_ptr);
12106 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
12107 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
12108 }
12109 }
12110 }
12111 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
12112 fn get_impl_2(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
12113 unsafe {
12114 let __receiver =
12115 <UnitCalculator_EngageCountCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
12116 {
12117 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
12118 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
12119 panic!(
12120 "unity: virtual slot {}
12121 out of range (vtable len {}
12122) on the runtime class behind {}
12123 (method `{}
12124`)",
12125 31usize,
12126 __vt.len(),
12127 <UnitCalculator_EngageCountCommand as ::unity::ClassIdentity>::NAME,
12128 "GetImpl",
12129 )
12130 });
12131 let __inner: extern "C" fn(
12132 UnitCalculator_EngageCountCommand,
12133 crate::app::battleinfoside::BattleInfoSide,
12134 ::unity::OptionalMethod,
12135 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
12136 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
12137 __inner(__receiver, ::core::convert::Into::into(side), __mi)
12138 }
12139 }
12140 }
12141 #[doc = "`SetImpl(crate::app::unit::Unit, f32)` overload"]
12142 fn set_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>, value: impl ::core::convert::Into<f32>) -> () {
12143 unsafe {
12144 let __receiver =
12145 <UnitCalculator_EngageCountCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
12146 {
12147 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
12148 let __vi = *__vt.get(32usize).unwrap_or_else(|| {
12149 panic!(
12150 "unity: virtual slot {}
12151 out of range (vtable len {}
12152) on the runtime class behind {}
12153 (method `{}
12154`)",
12155 32usize,
12156 __vt.len(),
12157 <UnitCalculator_EngageCountCommand as ::unity::ClassIdentity>::NAME,
12158 "SetImpl",
12159 )
12160 });
12161 let __inner: extern "C" fn(UnitCalculator_EngageCountCommand, crate::app::unit::Unit, f32, ::unity::OptionalMethod) -> () =
12162 ::core::mem::transmute(__vi.method_ptr);
12163 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
12164 __inner(__receiver, ::core::convert::Into::into(unit), ::core::convert::Into::into(value), __mi)
12165 }
12166 }
12167 }
12168 #[doc = "`SetImpl(crate::app::battleinfoside::BattleInfoSide, f32)` overload"]
12169 fn set_impl_2(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>, value: impl ::core::convert::Into<f32>) -> () {
12170 unsafe {
12171 let __receiver =
12172 <UnitCalculator_EngageCountCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
12173 {
12174 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
12175 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
12176 panic!(
12177 "unity: virtual slot {}
12178 out of range (vtable len {}
12179) on the runtime class behind {}
12180 (method `{}
12181`)",
12182 33usize,
12183 __vt.len(),
12184 <UnitCalculator_EngageCountCommand as ::unity::ClassIdentity>::NAME,
12185 "SetImpl",
12186 )
12187 });
12188 let __inner: extern "C" fn(
12189 UnitCalculator_EngageCountCommand,
12190 crate::app::battleinfoside::BattleInfoSide,
12191 f32,
12192 ::unity::OptionalMethod,
12193 ) -> () = ::core::mem::transmute(__vi.method_ptr);
12194 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
12195 __inner(__receiver, ::core::convert::Into::into(side), ::core::convert::Into::into(value), __mi)
12196 }
12197 }
12198 }
12199 #[doc = "`.ctor()` overload"]
12200 fn ctor(self) -> () {
12201 unsafe {
12202 let __receiver =
12203 <UnitCalculator_EngageCountCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
12204 ::unity::il2cpp_call!((::unity::module_base()+0x1b46f80usize)as*mut u8,();
12205(UnitCalculator_EngageCountCommand)__receiver)
12206 }
12207 }
12208}
12209
12210#[cfg(feature = "app-unitcalculator")]
12211impl<__T: IUnitCalculator_EngageCountCommand> IUnitCalculator_EngageCountCommandMethods for __T {}
12212
12213#[cfg(feature = "app-unitcalculator")]
12214impl UnitCalculator_EngageCountCommand {
12215 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
12216 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
12217 }
12218
12219 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
12220 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
12221 }
12222
12223 pub fn get_impl_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
12224 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
12225 }
12226
12227 pub fn set_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
12228 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
12229 }
12230
12231 pub fn set_impl_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
12232 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
12233 }
12234
12235 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
12236 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
12237 }
12238}
12239
12240#[cfg(feature = "app-unitcalculator")]
12241impl UnitCalculator_EngageCountCommand {
12242 #[doc = "Direct (non-virtual) call to `UnitCalculator_EngageCountCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
12243 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
12244 let __mi = Self::get_name_method_info();
12245 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
12246 __inner(this.into(), ::core::option::Option::None)
12247 }
12248
12249 #[doc = "Direct (non-virtual) call to `UnitCalculator_EngageCountCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
12250 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
12251 let __mi = Self::get_impl_method_info();
12252 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
12253 ::core::mem::transmute(__mi.method_ptr);
12254 __inner(this.into(), unit, ::core::option::Option::None)
12255 }
12256
12257 #[doc = "Direct (non-virtual) call to `UnitCalculator_EngageCountCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
12258 pub unsafe fn get_impl_2(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
12259 let __mi = Self::get_impl_2_method_info();
12260 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
12261 ::core::mem::transmute(__mi.method_ptr);
12262 __inner(this.into(), side, ::core::option::Option::None)
12263 }
12264
12265 #[doc = "Direct (non-virtual) call to `UnitCalculator_EngageCountCommand`'s own `SetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
12266 pub unsafe fn set_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit, value: f32) -> () {
12267 let __mi = Self::set_impl_method_info();
12268 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, f32, ::unity::OptionalMethod) -> () =
12269 ::core::mem::transmute(__mi.method_ptr);
12270 __inner(this.into(), unit, value, ::core::option::Option::None)
12271 }
12272
12273 #[doc = "Direct (non-virtual) call to `UnitCalculator_EngageCountCommand`'s own `SetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
12274 pub unsafe fn set_impl_2(
12275 this: impl ::core::convert::Into<::unity::IlInstance>,
12276 side: crate::app::battleinfoside::BattleInfoSide,
12277 value: f32,
12278 ) -> () {
12279 let __mi = Self::set_impl_2_method_info();
12280 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, f32, ::unity::OptionalMethod) -> () =
12281 ::core::mem::transmute(__mi.method_ptr);
12282 __inner(this.into(), side, value, ::core::option::Option::None)
12283 }
12284}
12285
12286#[cfg(feature = "app-unitcalculator")]
12287impl UnitCalculator_EngageCountCommand {
12288 #[doc = "`.ctor()` — no args"]
12289 pub fn new() -> Self {
12290 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
12291 panic!(
12292 "{}
12293::{}
12294 failed to instantiate",
12295 ::core::stringify!(UnitCalculator_EngageCountCommand),
12296 ::core::stringify!(new),
12297 )
12298 });
12299 <Self as IUnitCalculator_EngageCountCommandMethods>::ctor(this);
12300 this
12301 }
12302}
12303
12304#[cfg(feature = "app-unitcalculator")]
12305pub trait IUnitCalculator_SimpleCriticalCommandMethods: IUnitCalculator_SimpleCriticalCommand {
12306 #[doc = "`get_Name()` overload"]
12307 fn get_name(self) -> ::unity::Il2CppString {
12308 unsafe {
12309 let __receiver = <UnitCalculator_SimpleCriticalCommand as ::unity::FromIlInstance>::from_il_instance(
12310 <Self as ::unity::SystemObject>::as_instance(self),
12311 );
12312 {
12313 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
12314 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
12315 panic!(
12316 "unity: virtual slot {}
12317 out of range (vtable len {}
12318) on the runtime class behind {}
12319 (method `{}
12320`)",
12321 4usize,
12322 __vt.len(),
12323 <UnitCalculator_SimpleCriticalCommand as ::unity::ClassIdentity>::NAME,
12324 "get_Name",
12325 )
12326 });
12327 let __inner: extern "C" fn(UnitCalculator_SimpleCriticalCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
12328 ::core::mem::transmute(__vi.method_ptr);
12329 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
12330 __inner(__receiver, __mi)
12331 }
12332 }
12333 }
12334 #[doc = "`GetParam(crate::app::battleinfoside::BattleInfoSide)` overload"]
12335 fn get_param(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> crate::app::battleparam::BattleParam {
12336 unsafe {
12337 let __receiver = <UnitCalculator_SimpleCriticalCommand as ::unity::FromIlInstance>::from_il_instance(
12338 <Self as ::unity::SystemObject>::as_instance(self),
12339 );
12340 {
12341 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
12342 let __vi = *__vt.get(44usize).unwrap_or_else(|| {
12343 panic!(
12344 "unity: virtual slot {}
12345 out of range (vtable len {}
12346) on the runtime class behind {}
12347 (method `{}
12348`)",
12349 44usize,
12350 __vt.len(),
12351 <UnitCalculator_SimpleCriticalCommand as ::unity::ClassIdentity>::NAME,
12352 "GetParam",
12353 )
12354 });
12355 let __inner: extern "C" fn(
12356 UnitCalculator_SimpleCriticalCommand,
12357 crate::app::battleinfoside::BattleInfoSide,
12358 ::unity::OptionalMethod,
12359 ) -> crate::app::battleparam::BattleParam = ::core::mem::transmute(__vi.method_ptr);
12360 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
12361 __inner(__receiver, ::core::convert::Into::into(side), __mi)
12362 }
12363 }
12364 }
12365 #[doc = "`IsVisible()` overload"]
12366 fn is_visible(self) -> bool {
12367 unsafe {
12368 let __receiver = <UnitCalculator_SimpleCriticalCommand as ::unity::FromIlInstance>::from_il_instance(
12369 <Self as ::unity::SystemObject>::as_instance(self),
12370 );
12371 {
12372 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
12373 let __vi = *__vt.get(43usize).unwrap_or_else(|| {
12374 panic!(
12375 "unity: virtual slot {}
12376 out of range (vtable len {}
12377) on the runtime class behind {}
12378 (method `{}
12379`)",
12380 43usize,
12381 __vt.len(),
12382 <UnitCalculator_SimpleCriticalCommand as ::unity::ClassIdentity>::NAME,
12383 "IsVisible",
12384 )
12385 });
12386 let __inner: extern "C" fn(UnitCalculator_SimpleCriticalCommand, ::unity::OptionalMethod) -> bool =
12387 ::core::mem::transmute(__vi.method_ptr);
12388 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
12389 __inner(__receiver, __mi)
12390 }
12391 }
12392 }
12393 #[doc = "`.ctor()` overload"]
12394 fn ctor(self) -> () {
12395 unsafe {
12396 let __receiver = <UnitCalculator_SimpleCriticalCommand as ::unity::FromIlInstance>::from_il_instance(
12397 <Self as ::unity::SystemObject>::as_instance(self),
12398 );
12399 ::unity::il2cpp_call!((::unity::module_base()+0x1b4bd80usize)as*mut u8,();
12400(UnitCalculator_SimpleCriticalCommand)__receiver)
12401 }
12402 }
12403}
12404
12405#[cfg(feature = "app-unitcalculator")]
12406impl<__T: IUnitCalculator_SimpleCriticalCommand> IUnitCalculator_SimpleCriticalCommandMethods for __T {}
12407
12408#[cfg(feature = "app-unitcalculator")]
12409impl UnitCalculator_SimpleCriticalCommand {
12410 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
12411 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
12412 }
12413
12414 pub fn get_param_method_info() -> &'static ::unity::il2cpp::MethodInfo {
12415 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
12416 }
12417
12418 pub fn is_visible_method_info() -> &'static ::unity::il2cpp::MethodInfo {
12419 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
12420 }
12421
12422 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
12423 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
12424 }
12425}
12426
12427#[cfg(feature = "app-unitcalculator")]
12428impl UnitCalculator_SimpleCriticalCommand {
12429 #[doc = "Direct (non-virtual) call to `UnitCalculator_SimpleCriticalCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
12430 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
12431 let __mi = Self::get_name_method_info();
12432 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
12433 __inner(this.into(), ::core::option::Option::None)
12434 }
12435
12436 #[doc = "Direct (non-virtual) call to `UnitCalculator_SimpleCriticalCommand`'s own `GetParam`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
12437 pub unsafe fn get_param(
12438 this: impl ::core::convert::Into<::unity::IlInstance>,
12439 side: crate::app::battleinfoside::BattleInfoSide,
12440 ) -> crate::app::battleparam::BattleParam {
12441 let __mi = Self::get_param_method_info();
12442 let __inner: extern "C" fn(
12443 ::unity::IlInstance,
12444 crate::app::battleinfoside::BattleInfoSide,
12445 ::unity::OptionalMethod,
12446 ) -> crate::app::battleparam::BattleParam = ::core::mem::transmute(__mi.method_ptr);
12447 __inner(this.into(), side, ::core::option::Option::None)
12448 }
12449
12450 #[doc = "Direct (non-virtual) call to `UnitCalculator_SimpleCriticalCommand`'s own `IsVisible`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
12451 pub unsafe fn is_visible(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
12452 let __mi = Self::is_visible_method_info();
12453 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
12454 __inner(this.into(), ::core::option::Option::None)
12455 }
12456}
12457
12458#[cfg(feature = "app-unitcalculator")]
12459impl UnitCalculator_SimpleCriticalCommand {
12460 #[doc = "`.ctor()` — no args"]
12461 pub fn new() -> Self {
12462 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
12463 panic!(
12464 "{}
12465::{}
12466 failed to instantiate",
12467 ::core::stringify!(UnitCalculator_SimpleCriticalCommand),
12468 ::core::stringify!(new),
12469 )
12470 });
12471 <Self as IUnitCalculator_SimpleCriticalCommandMethods>::ctor(this);
12472 this
12473 }
12474}
12475
12476#[cfg(feature = "app-unitcalculator")]
12477pub trait IUnitCalculator_DropItemRatioCommandMethods: IUnitCalculator_DropItemRatioCommand {
12478 #[doc = "`get_Name()` overload"]
12479 fn get_name(self) -> ::unity::Il2CppString {
12480 unsafe {
12481 let __receiver = <UnitCalculator_DropItemRatioCommand as ::unity::FromIlInstance>::from_il_instance(
12482 <Self as ::unity::SystemObject>::as_instance(self),
12483 );
12484 {
12485 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
12486 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
12487 panic!(
12488 "unity: virtual slot {}
12489 out of range (vtable len {}
12490) on the runtime class behind {}
12491 (method `{}
12492`)",
12493 4usize,
12494 __vt.len(),
12495 <UnitCalculator_DropItemRatioCommand as ::unity::ClassIdentity>::NAME,
12496 "get_Name",
12497 )
12498 });
12499 let __inner: extern "C" fn(UnitCalculator_DropItemRatioCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
12500 ::core::mem::transmute(__vi.method_ptr);
12501 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
12502 __inner(__receiver, __mi)
12503 }
12504 }
12505 }
12506 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
12507 fn get_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
12508 unsafe {
12509 let __receiver = <UnitCalculator_DropItemRatioCommand as ::unity::FromIlInstance>::from_il_instance(
12510 <Self as ::unity::SystemObject>::as_instance(self),
12511 );
12512 {
12513 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
12514 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
12515 panic!(
12516 "unity: virtual slot {}
12517 out of range (vtable len {}
12518) on the runtime class behind {}
12519 (method `{}
12520`)",
12521 31usize,
12522 __vt.len(),
12523 <UnitCalculator_DropItemRatioCommand as ::unity::ClassIdentity>::NAME,
12524 "GetImpl",
12525 )
12526 });
12527 let __inner: extern "C" fn(
12528 UnitCalculator_DropItemRatioCommand,
12529 crate::app::battleinfoside::BattleInfoSide,
12530 ::unity::OptionalMethod,
12531 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
12532 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
12533 __inner(__receiver, ::core::convert::Into::into(side), __mi)
12534 }
12535 }
12536 }
12537 #[doc = "`SetImpl(crate::app::battleinfoside::BattleInfoSide, f32)` overload"]
12538 fn set_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>, value: impl ::core::convert::Into<f32>) -> () {
12539 unsafe {
12540 let __receiver = <UnitCalculator_DropItemRatioCommand as ::unity::FromIlInstance>::from_il_instance(
12541 <Self as ::unity::SystemObject>::as_instance(self),
12542 );
12543 {
12544 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
12545 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
12546 panic!(
12547 "unity: virtual slot {}
12548 out of range (vtable len {}
12549) on the runtime class behind {}
12550 (method `{}
12551`)",
12552 33usize,
12553 __vt.len(),
12554 <UnitCalculator_DropItemRatioCommand as ::unity::ClassIdentity>::NAME,
12555 "SetImpl",
12556 )
12557 });
12558 let __inner: extern "C" fn(
12559 UnitCalculator_DropItemRatioCommand,
12560 crate::app::battleinfoside::BattleInfoSide,
12561 f32,
12562 ::unity::OptionalMethod,
12563 ) -> () = ::core::mem::transmute(__vi.method_ptr);
12564 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
12565 __inner(__receiver, ::core::convert::Into::into(side), ::core::convert::Into::into(value), __mi)
12566 }
12567 }
12568 }
12569 #[doc = "`.ctor()` overload"]
12570 fn ctor(self) -> () {
12571 unsafe {
12572 let __receiver = <UnitCalculator_DropItemRatioCommand as ::unity::FromIlInstance>::from_il_instance(
12573 <Self as ::unity::SystemObject>::as_instance(self),
12574 );
12575 ::unity::il2cpp_call!((::unity::module_base()+0x1b46ea0usize)as*mut u8,();
12576(UnitCalculator_DropItemRatioCommand)__receiver)
12577 }
12578 }
12579}
12580
12581#[cfg(feature = "app-unitcalculator")]
12582impl<__T: IUnitCalculator_DropItemRatioCommand> IUnitCalculator_DropItemRatioCommandMethods for __T {}
12583
12584#[cfg(feature = "app-unitcalculator")]
12585impl UnitCalculator_DropItemRatioCommand {
12586 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
12587 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
12588 }
12589
12590 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
12591 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
12592 }
12593
12594 pub fn set_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
12595 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
12596 }
12597
12598 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
12599 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
12600 }
12601}
12602
12603#[cfg(feature = "app-unitcalculator")]
12604impl UnitCalculator_DropItemRatioCommand {
12605 #[doc = "Direct (non-virtual) call to `UnitCalculator_DropItemRatioCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
12606 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
12607 let __mi = Self::get_name_method_info();
12608 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
12609 __inner(this.into(), ::core::option::Option::None)
12610 }
12611
12612 #[doc = "Direct (non-virtual) call to `UnitCalculator_DropItemRatioCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
12613 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
12614 let __mi = Self::get_impl_method_info();
12615 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
12616 ::core::mem::transmute(__mi.method_ptr);
12617 __inner(this.into(), side, ::core::option::Option::None)
12618 }
12619
12620 #[doc = "Direct (non-virtual) call to `UnitCalculator_DropItemRatioCommand`'s own `SetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
12621 pub unsafe fn set_impl(
12622 this: impl ::core::convert::Into<::unity::IlInstance>,
12623 side: crate::app::battleinfoside::BattleInfoSide,
12624 value: f32,
12625 ) -> () {
12626 let __mi = Self::set_impl_method_info();
12627 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, f32, ::unity::OptionalMethod) -> () =
12628 ::core::mem::transmute(__mi.method_ptr);
12629 __inner(this.into(), side, value, ::core::option::Option::None)
12630 }
12631}
12632
12633#[cfg(feature = "app-unitcalculator")]
12634impl UnitCalculator_DropItemRatioCommand {
12635 #[doc = "`.ctor()` — no args"]
12636 pub fn new() -> Self {
12637 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
12638 panic!(
12639 "{}
12640::{}
12641 failed to instantiate",
12642 ::core::stringify!(UnitCalculator_DropItemRatioCommand),
12643 ::core::stringify!(new),
12644 )
12645 });
12646 <Self as IUnitCalculator_DropItemRatioCommandMethods>::ctor(this);
12647 this
12648 }
12649}
12650
12651#[cfg(feature = "app-unitcalculator")]
12652pub trait IUnitCalculator_MapPhaseCommandMethods: IUnitCalculator_MapPhaseCommand {
12653 #[doc = "`get_Name()` overload"]
12654 fn get_name(self) -> ::unity::Il2CppString {
12655 unsafe {
12656 let __receiver =
12657 <UnitCalculator_MapPhaseCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
12658 {
12659 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
12660 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
12661 panic!(
12662 "unity: virtual slot {}
12663 out of range (vtable len {}
12664) on the runtime class behind {}
12665 (method `{}
12666`)",
12667 4usize,
12668 __vt.len(),
12669 <UnitCalculator_MapPhaseCommand as ::unity::ClassIdentity>::NAME,
12670 "get_Name",
12671 )
12672 });
12673 let __inner: extern "C" fn(UnitCalculator_MapPhaseCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
12674 ::core::mem::transmute(__vi.method_ptr);
12675 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
12676 __inner(__receiver, __mi)
12677 }
12678 }
12679 }
12680 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
12681 fn get_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
12682 unsafe {
12683 let __receiver =
12684 <UnitCalculator_MapPhaseCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
12685 {
12686 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
12687 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
12688 panic!(
12689 "unity: virtual slot {}
12690 out of range (vtable len {}
12691) on the runtime class behind {}
12692 (method `{}
12693`)",
12694 30usize,
12695 __vt.len(),
12696 <UnitCalculator_MapPhaseCommand as ::unity::ClassIdentity>::NAME,
12697 "GetImpl",
12698 )
12699 });
12700 let __inner: extern "C" fn(UnitCalculator_MapPhaseCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
12701 ::core::mem::transmute(__vi.method_ptr);
12702 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
12703 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
12704 }
12705 }
12706 }
12707 #[doc = "`GetInvalid()` overload"]
12708 fn get_invalid(self) -> f32 {
12709 unsafe {
12710 let __receiver =
12711 <UnitCalculator_MapPhaseCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
12712 {
12713 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
12714 let __vi = *__vt.get(42usize).unwrap_or_else(|| {
12715 panic!(
12716 "unity: virtual slot {}
12717 out of range (vtable len {}
12718) on the runtime class behind {}
12719 (method `{}
12720`)",
12721 42usize,
12722 __vt.len(),
12723 <UnitCalculator_MapPhaseCommand as ::unity::ClassIdentity>::NAME,
12724 "GetInvalid",
12725 )
12726 });
12727 let __inner: extern "C" fn(UnitCalculator_MapPhaseCommand, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__vi.method_ptr);
12728 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
12729 __inner(__receiver, __mi)
12730 }
12731 }
12732 }
12733 #[doc = "`.ctor()` overload"]
12734 fn ctor(self) -> () {
12735 unsafe {
12736 let __receiver =
12737 <UnitCalculator_MapPhaseCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
12738 ::unity::il2cpp_call!((::unity::module_base()+0x1b49470usize)as*mut u8,();
12739(UnitCalculator_MapPhaseCommand)__receiver)
12740 }
12741 }
12742}
12743
12744#[cfg(feature = "app-unitcalculator")]
12745impl<__T: IUnitCalculator_MapPhaseCommand> IUnitCalculator_MapPhaseCommandMethods for __T {}
12746
12747#[cfg(feature = "app-unitcalculator")]
12748impl UnitCalculator_MapPhaseCommand {
12749 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
12750 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
12751 }
12752
12753 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
12754 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
12755 }
12756
12757 pub fn get_invalid_method_info() -> &'static ::unity::il2cpp::MethodInfo {
12758 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
12759 }
12760
12761 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
12762 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
12763 }
12764}
12765
12766#[cfg(feature = "app-unitcalculator")]
12767impl UnitCalculator_MapPhaseCommand {
12768 #[doc = "Direct (non-virtual) call to `UnitCalculator_MapPhaseCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
12769 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
12770 let __mi = Self::get_name_method_info();
12771 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
12772 __inner(this.into(), ::core::option::Option::None)
12773 }
12774
12775 #[doc = "Direct (non-virtual) call to `UnitCalculator_MapPhaseCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
12776 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
12777 let __mi = Self::get_impl_method_info();
12778 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
12779 ::core::mem::transmute(__mi.method_ptr);
12780 __inner(this.into(), unit, ::core::option::Option::None)
12781 }
12782
12783 #[doc = "Direct (non-virtual) call to `UnitCalculator_MapPhaseCommand`'s own `GetInvalid`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
12784 pub unsafe fn get_invalid(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
12785 let __mi = Self::get_invalid_method_info();
12786 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
12787 __inner(this.into(), ::core::option::Option::None)
12788 }
12789}
12790
12791#[cfg(feature = "app-unitcalculator")]
12792impl UnitCalculator_MapPhaseCommand {
12793 #[doc = "`.ctor()` — no args"]
12794 pub fn new() -> Self {
12795 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
12796 panic!(
12797 "{}
12798::{}
12799 failed to instantiate",
12800 ::core::stringify!(UnitCalculator_MapPhaseCommand),
12801 ::core::stringify!(new),
12802 )
12803 });
12804 <Self as IUnitCalculator_MapPhaseCommandMethods>::ctor(this);
12805 this
12806 }
12807}
12808
12809#[cfg(feature = "app-unitcalculator")]
12810pub trait IUnitCalculator_SkillCorrectCommandMethods: IUnitCalculator_SkillCorrectCommand {
12811 #[doc = "`get_Name()` overload"]
12812 fn get_name(self) -> ::unity::Il2CppString {
12813 unsafe {
12814 let __receiver =
12815 <UnitCalculator_SkillCorrectCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
12816 {
12817 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
12818 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
12819 panic!(
12820 "unity: virtual slot {}
12821 out of range (vtable len {}
12822) on the runtime class behind {}
12823 (method `{}
12824`)",
12825 4usize,
12826 __vt.len(),
12827 <UnitCalculator_SkillCorrectCommand as ::unity::ClassIdentity>::NAME,
12828 "get_Name",
12829 )
12830 });
12831 let __inner: extern "C" fn(UnitCalculator_SkillCorrectCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
12832 ::core::mem::transmute(__vi.method_ptr);
12833 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
12834 __inner(__receiver, __mi)
12835 }
12836 }
12837 }
12838 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
12839 fn get_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
12840 unsafe {
12841 let __receiver =
12842 <UnitCalculator_SkillCorrectCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
12843 {
12844 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
12845 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
12846 panic!(
12847 "unity: virtual slot {}
12848 out of range (vtable len {}
12849) on the runtime class behind {}
12850 (method `{}
12851`)",
12852 31usize,
12853 __vt.len(),
12854 <UnitCalculator_SkillCorrectCommand as ::unity::ClassIdentity>::NAME,
12855 "GetImpl",
12856 )
12857 });
12858 let __inner: extern "C" fn(
12859 UnitCalculator_SkillCorrectCommand,
12860 crate::app::battleinfoside::BattleInfoSide,
12861 ::unity::OptionalMethod,
12862 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
12863 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
12864 __inner(__receiver, ::core::convert::Into::into(side), __mi)
12865 }
12866 }
12867 }
12868 #[doc = "`SetImpl(crate::app::battleinfoside::BattleInfoSide, f32)` overload"]
12869 fn set_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>, value: impl ::core::convert::Into<f32>) -> () {
12870 unsafe {
12871 let __receiver =
12872 <UnitCalculator_SkillCorrectCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
12873 {
12874 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
12875 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
12876 panic!(
12877 "unity: virtual slot {}
12878 out of range (vtable len {}
12879) on the runtime class behind {}
12880 (method `{}
12881`)",
12882 33usize,
12883 __vt.len(),
12884 <UnitCalculator_SkillCorrectCommand as ::unity::ClassIdentity>::NAME,
12885 "SetImpl",
12886 )
12887 });
12888 let __inner: extern "C" fn(
12889 UnitCalculator_SkillCorrectCommand,
12890 crate::app::battleinfoside::BattleInfoSide,
12891 f32,
12892 ::unity::OptionalMethod,
12893 ) -> () = ::core::mem::transmute(__vi.method_ptr);
12894 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
12895 __inner(__receiver, ::core::convert::Into::into(side), ::core::convert::Into::into(value), __mi)
12896 }
12897 }
12898 }
12899 #[doc = "`.ctor()` overload"]
12900 fn ctor(self) -> () {
12901 unsafe {
12902 let __receiver =
12903 <UnitCalculator_SkillCorrectCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
12904 ::unity::il2cpp_call!((::unity::module_base()+0x1b4bf30usize)as*mut u8,();
12905(UnitCalculator_SkillCorrectCommand)__receiver)
12906 }
12907 }
12908}
12909
12910#[cfg(feature = "app-unitcalculator")]
12911impl<__T: IUnitCalculator_SkillCorrectCommand> IUnitCalculator_SkillCorrectCommandMethods for __T {}
12912
12913#[cfg(feature = "app-unitcalculator")]
12914impl UnitCalculator_SkillCorrectCommand {
12915 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
12916 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
12917 }
12918
12919 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
12920 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
12921 }
12922
12923 pub fn set_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
12924 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
12925 }
12926
12927 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
12928 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
12929 }
12930}
12931
12932#[cfg(feature = "app-unitcalculator")]
12933impl UnitCalculator_SkillCorrectCommand {
12934 #[doc = "Direct (non-virtual) call to `UnitCalculator_SkillCorrectCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
12935 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
12936 let __mi = Self::get_name_method_info();
12937 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
12938 __inner(this.into(), ::core::option::Option::None)
12939 }
12940
12941 #[doc = "Direct (non-virtual) call to `UnitCalculator_SkillCorrectCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
12942 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
12943 let __mi = Self::get_impl_method_info();
12944 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
12945 ::core::mem::transmute(__mi.method_ptr);
12946 __inner(this.into(), side, ::core::option::Option::None)
12947 }
12948
12949 #[doc = "Direct (non-virtual) call to `UnitCalculator_SkillCorrectCommand`'s own `SetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
12950 pub unsafe fn set_impl(
12951 this: impl ::core::convert::Into<::unity::IlInstance>,
12952 side: crate::app::battleinfoside::BattleInfoSide,
12953 value: f32,
12954 ) -> () {
12955 let __mi = Self::set_impl_method_info();
12956 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, f32, ::unity::OptionalMethod) -> () =
12957 ::core::mem::transmute(__mi.method_ptr);
12958 __inner(this.into(), side, value, ::core::option::Option::None)
12959 }
12960}
12961
12962#[cfg(feature = "app-unitcalculator")]
12963impl UnitCalculator_SkillCorrectCommand {
12964 #[doc = "`.ctor()` — no args"]
12965 pub fn new() -> Self {
12966 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
12967 panic!(
12968 "{}
12969::{}
12970 failed to instantiate",
12971 ::core::stringify!(UnitCalculator_SkillCorrectCommand),
12972 ::core::stringify!(new),
12973 )
12974 });
12975 <Self as IUnitCalculator_SkillCorrectCommandMethods>::ctor(this);
12976 this
12977 }
12978}
12979
12980#[cfg(feature = "app-unitcalculator")]
12981pub trait IUnitCalculator_GodSkillCorrectCommandMethods: IUnitCalculator_GodSkillCorrectCommand {
12982 #[doc = "`get_Name()` overload"]
12983 fn get_name(self) -> ::unity::Il2CppString {
12984 unsafe {
12985 let __receiver = <UnitCalculator_GodSkillCorrectCommand as ::unity::FromIlInstance>::from_il_instance(
12986 <Self as ::unity::SystemObject>::as_instance(self),
12987 );
12988 {
12989 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
12990 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
12991 panic!(
12992 "unity: virtual slot {}
12993 out of range (vtable len {}
12994) on the runtime class behind {}
12995 (method `{}
12996`)",
12997 4usize,
12998 __vt.len(),
12999 <UnitCalculator_GodSkillCorrectCommand as ::unity::ClassIdentity>::NAME,
13000 "get_Name",
13001 )
13002 });
13003 let __inner: extern "C" fn(UnitCalculator_GodSkillCorrectCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
13004 ::core::mem::transmute(__vi.method_ptr);
13005 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
13006 __inner(__receiver, __mi)
13007 }
13008 }
13009 }
13010 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
13011 fn get_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
13012 unsafe {
13013 let __receiver = <UnitCalculator_GodSkillCorrectCommand as ::unity::FromIlInstance>::from_il_instance(
13014 <Self as ::unity::SystemObject>::as_instance(self),
13015 );
13016 {
13017 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
13018 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
13019 panic!(
13020 "unity: virtual slot {}
13021 out of range (vtable len {}
13022) on the runtime class behind {}
13023 (method `{}
13024`)",
13025 31usize,
13026 __vt.len(),
13027 <UnitCalculator_GodSkillCorrectCommand as ::unity::ClassIdentity>::NAME,
13028 "GetImpl",
13029 )
13030 });
13031 let __inner: extern "C" fn(
13032 UnitCalculator_GodSkillCorrectCommand,
13033 crate::app::battleinfoside::BattleInfoSide,
13034 ::unity::OptionalMethod,
13035 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
13036 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
13037 __inner(__receiver, ::core::convert::Into::into(side), __mi)
13038 }
13039 }
13040 }
13041 #[doc = "`SetImpl(crate::app::battleinfoside::BattleInfoSide, f32)` overload"]
13042 fn set_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>, value: impl ::core::convert::Into<f32>) -> () {
13043 unsafe {
13044 let __receiver = <UnitCalculator_GodSkillCorrectCommand as ::unity::FromIlInstance>::from_il_instance(
13045 <Self as ::unity::SystemObject>::as_instance(self),
13046 );
13047 {
13048 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
13049 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
13050 panic!(
13051 "unity: virtual slot {}
13052 out of range (vtable len {}
13053) on the runtime class behind {}
13054 (method `{}
13055`)",
13056 33usize,
13057 __vt.len(),
13058 <UnitCalculator_GodSkillCorrectCommand as ::unity::ClassIdentity>::NAME,
13059 "SetImpl",
13060 )
13061 });
13062 let __inner: extern "C" fn(
13063 UnitCalculator_GodSkillCorrectCommand,
13064 crate::app::battleinfoside::BattleInfoSide,
13065 f32,
13066 ::unity::OptionalMethod,
13067 ) -> () = ::core::mem::transmute(__vi.method_ptr);
13068 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
13069 __inner(__receiver, ::core::convert::Into::into(side), ::core::convert::Into::into(value), __mi)
13070 }
13071 }
13072 }
13073 #[doc = "`.ctor()` overload"]
13074 fn ctor(self) -> () {
13075 unsafe {
13076 let __receiver = <UnitCalculator_GodSkillCorrectCommand as ::unity::FromIlInstance>::from_il_instance(
13077 <Self as ::unity::SystemObject>::as_instance(self),
13078 );
13079 ::unity::il2cpp_call!((::unity::module_base()+0x1b48160usize)as*mut u8,();
13080(UnitCalculator_GodSkillCorrectCommand)__receiver)
13081 }
13082 }
13083}
13084
13085#[cfg(feature = "app-unitcalculator")]
13086impl<__T: IUnitCalculator_GodSkillCorrectCommand> IUnitCalculator_GodSkillCorrectCommandMethods for __T {}
13087
13088#[cfg(feature = "app-unitcalculator")]
13089impl UnitCalculator_GodSkillCorrectCommand {
13090 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
13091 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
13092 }
13093
13094 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
13095 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
13096 }
13097
13098 pub fn set_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
13099 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
13100 }
13101
13102 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
13103 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
13104 }
13105}
13106
13107#[cfg(feature = "app-unitcalculator")]
13108impl UnitCalculator_GodSkillCorrectCommand {
13109 #[doc = "Direct (non-virtual) call to `UnitCalculator_GodSkillCorrectCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
13110 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
13111 let __mi = Self::get_name_method_info();
13112 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
13113 __inner(this.into(), ::core::option::Option::None)
13114 }
13115
13116 #[doc = "Direct (non-virtual) call to `UnitCalculator_GodSkillCorrectCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
13117 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
13118 let __mi = Self::get_impl_method_info();
13119 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
13120 ::core::mem::transmute(__mi.method_ptr);
13121 __inner(this.into(), side, ::core::option::Option::None)
13122 }
13123
13124 #[doc = "Direct (non-virtual) call to `UnitCalculator_GodSkillCorrectCommand`'s own `SetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
13125 pub unsafe fn set_impl(
13126 this: impl ::core::convert::Into<::unity::IlInstance>,
13127 side: crate::app::battleinfoside::BattleInfoSide,
13128 value: f32,
13129 ) -> () {
13130 let __mi = Self::set_impl_method_info();
13131 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, f32, ::unity::OptionalMethod) -> () =
13132 ::core::mem::transmute(__mi.method_ptr);
13133 __inner(this.into(), side, value, ::core::option::Option::None)
13134 }
13135}
13136
13137#[cfg(feature = "app-unitcalculator")]
13138impl UnitCalculator_GodSkillCorrectCommand {
13139 #[doc = "`.ctor()` — no args"]
13140 pub fn new() -> Self {
13141 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
13142 panic!(
13143 "{}
13144::{}
13145 failed to instantiate",
13146 ::core::stringify!(UnitCalculator_GodSkillCorrectCommand),
13147 ::core::stringify!(new),
13148 )
13149 });
13150 <Self as IUnitCalculator_GodSkillCorrectCommandMethods>::ctor(this);
13151 this
13152 }
13153}
13154
13155#[cfg(feature = "app-unitcalculator")]
13156pub trait IUnitCalculator_LevelCommandMethods: IUnitCalculator_LevelCommand {
13157 #[doc = "`get_Name()` overload"]
13158 fn get_name(self) -> ::unity::Il2CppString {
13159 unsafe {
13160 let __receiver =
13161 <UnitCalculator_LevelCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
13162 {
13163 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
13164 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
13165 panic!(
13166 "unity: virtual slot {}
13167 out of range (vtable len {}
13168) on the runtime class behind {}
13169 (method `{}
13170`)",
13171 4usize,
13172 __vt.len(),
13173 <UnitCalculator_LevelCommand as ::unity::ClassIdentity>::NAME,
13174 "get_Name",
13175 )
13176 });
13177 let __inner: extern "C" fn(UnitCalculator_LevelCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
13178 ::core::mem::transmute(__vi.method_ptr);
13179 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
13180 __inner(__receiver, __mi)
13181 }
13182 }
13183 }
13184 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
13185 fn get_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
13186 unsafe {
13187 let __receiver =
13188 <UnitCalculator_LevelCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
13189 {
13190 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
13191 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
13192 panic!(
13193 "unity: virtual slot {}
13194 out of range (vtable len {}
13195) on the runtime class behind {}
13196 (method `{}
13197`)",
13198 30usize,
13199 __vt.len(),
13200 <UnitCalculator_LevelCommand as ::unity::ClassIdentity>::NAME,
13201 "GetImpl",
13202 )
13203 });
13204 let __inner: extern "C" fn(UnitCalculator_LevelCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
13205 ::core::mem::transmute(__vi.method_ptr);
13206 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
13207 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
13208 }
13209 }
13210 }
13211 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
13212 fn get_impl_2(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
13213 unsafe {
13214 let __receiver =
13215 <UnitCalculator_LevelCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
13216 {
13217 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
13218 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
13219 panic!(
13220 "unity: virtual slot {}
13221 out of range (vtable len {}
13222) on the runtime class behind {}
13223 (method `{}
13224`)",
13225 31usize,
13226 __vt.len(),
13227 <UnitCalculator_LevelCommand as ::unity::ClassIdentity>::NAME,
13228 "GetImpl",
13229 )
13230 });
13231 let __inner: extern "C" fn(UnitCalculator_LevelCommand, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
13232 ::core::mem::transmute(__vi.method_ptr);
13233 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
13234 __inner(__receiver, ::core::convert::Into::into(side), __mi)
13235 }
13236 }
13237 }
13238 #[doc = "`.ctor()` overload"]
13239 fn ctor(self) -> () {
13240 unsafe {
13241 let __receiver =
13242 <UnitCalculator_LevelCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
13243 ::unity::il2cpp_call!((::unity::module_base()+0x1b48730usize)as*mut u8,();
13244(UnitCalculator_LevelCommand)__receiver)
13245 }
13246 }
13247}
13248
13249#[cfg(feature = "app-unitcalculator")]
13250impl<__T: IUnitCalculator_LevelCommand> IUnitCalculator_LevelCommandMethods for __T {}
13251
13252#[cfg(feature = "app-unitcalculator")]
13253impl UnitCalculator_LevelCommand {
13254 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
13255 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
13256 }
13257
13258 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
13259 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
13260 }
13261
13262 pub fn get_impl_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
13263 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
13264 }
13265
13266 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
13267 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
13268 }
13269}
13270
13271#[cfg(feature = "app-unitcalculator")]
13272impl UnitCalculator_LevelCommand {
13273 #[doc = "Direct (non-virtual) call to `UnitCalculator_LevelCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
13274 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
13275 let __mi = Self::get_name_method_info();
13276 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
13277 __inner(this.into(), ::core::option::Option::None)
13278 }
13279
13280 #[doc = "Direct (non-virtual) call to `UnitCalculator_LevelCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
13281 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
13282 let __mi = Self::get_impl_method_info();
13283 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
13284 ::core::mem::transmute(__mi.method_ptr);
13285 __inner(this.into(), unit, ::core::option::Option::None)
13286 }
13287
13288 #[doc = "Direct (non-virtual) call to `UnitCalculator_LevelCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
13289 pub unsafe fn get_impl_2(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
13290 let __mi = Self::get_impl_2_method_info();
13291 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
13292 ::core::mem::transmute(__mi.method_ptr);
13293 __inner(this.into(), side, ::core::option::Option::None)
13294 }
13295}
13296
13297#[cfg(feature = "app-unitcalculator")]
13298impl UnitCalculator_LevelCommand {
13299 #[doc = "`.ctor()` — no args"]
13300 pub fn new() -> Self {
13301 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
13302 panic!(
13303 "{}
13304::{}
13305 failed to instantiate",
13306 ::core::stringify!(UnitCalculator_LevelCommand),
13307 ::core::stringify!(new),
13308 )
13309 });
13310 <Self as IUnitCalculator_LevelCommandMethods>::ctor(this);
13311 this
13312 }
13313}
13314
13315#[cfg(feature = "app-unitcalculator")]
13316impl UnitCalculator_WeaponEnduranceCommand {
13317 #[doc = "`GetEndurance(crate::app::unititem::UnitItem)` overload"]
13318 pub fn get_endurance(unit_item: impl ::core::convert::Into<crate::app::unititem::UnitItem>) -> i32 {
13319 unsafe {
13320 ::unity::il2cpp_call!((::unity::module_base()+0x1b4dec0usize)as*mut u8,i32;
13321(crate::app::unititem::UnitItem)::core::convert::Into::into(unit_item))
13322 }
13323 }
13324}
13325
13326#[cfg(feature = "app-unitcalculator")]
13327pub trait IUnitCalculator_WeaponEnduranceCommandMethods: IUnitCalculator_WeaponEnduranceCommand {
13328 #[doc = "`get_Name()` overload"]
13329 fn get_name(self) -> ::unity::Il2CppString {
13330 unsafe {
13331 let __receiver = <UnitCalculator_WeaponEnduranceCommand as ::unity::FromIlInstance>::from_il_instance(
13332 <Self as ::unity::SystemObject>::as_instance(self),
13333 );
13334 {
13335 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
13336 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
13337 panic!(
13338 "unity: virtual slot {}
13339 out of range (vtable len {}
13340) on the runtime class behind {}
13341 (method `{}
13342`)",
13343 4usize,
13344 __vt.len(),
13345 <UnitCalculator_WeaponEnduranceCommand as ::unity::ClassIdentity>::NAME,
13346 "get_Name",
13347 )
13348 });
13349 let __inner: extern "C" fn(UnitCalculator_WeaponEnduranceCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
13350 ::core::mem::transmute(__vi.method_ptr);
13351 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
13352 __inner(__receiver, __mi)
13353 }
13354 }
13355 }
13356 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
13357 fn get_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
13358 unsafe {
13359 let __receiver = <UnitCalculator_WeaponEnduranceCommand as ::unity::FromIlInstance>::from_il_instance(
13360 <Self as ::unity::SystemObject>::as_instance(self),
13361 );
13362 {
13363 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
13364 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
13365 panic!(
13366 "unity: virtual slot {}
13367 out of range (vtable len {}
13368) on the runtime class behind {}
13369 (method `{}
13370`)",
13371 31usize,
13372 __vt.len(),
13373 <UnitCalculator_WeaponEnduranceCommand as ::unity::ClassIdentity>::NAME,
13374 "GetImpl",
13375 )
13376 });
13377 let __inner: extern "C" fn(
13378 UnitCalculator_WeaponEnduranceCommand,
13379 crate::app::battleinfoside::BattleInfoSide,
13380 ::unity::OptionalMethod,
13381 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
13382 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
13383 __inner(__receiver, ::core::convert::Into::into(side), __mi)
13384 }
13385 }
13386 }
13387 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
13388 fn get_impl_2(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
13389 unsafe {
13390 let __receiver = <UnitCalculator_WeaponEnduranceCommand as ::unity::FromIlInstance>::from_il_instance(
13391 <Self as ::unity::SystemObject>::as_instance(self),
13392 );
13393 {
13394 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
13395 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
13396 panic!(
13397 "unity: virtual slot {}
13398 out of range (vtable len {}
13399) on the runtime class behind {}
13400 (method `{}
13401`)",
13402 30usize,
13403 __vt.len(),
13404 <UnitCalculator_WeaponEnduranceCommand as ::unity::ClassIdentity>::NAME,
13405 "GetImpl",
13406 )
13407 });
13408 let __inner: extern "C" fn(UnitCalculator_WeaponEnduranceCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
13409 ::core::mem::transmute(__vi.method_ptr);
13410 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
13411 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
13412 }
13413 }
13414 }
13415 #[doc = "`.ctor()` overload"]
13416 fn ctor(self) -> () {
13417 unsafe {
13418 let __receiver = <UnitCalculator_WeaponEnduranceCommand as ::unity::FromIlInstance>::from_il_instance(
13419 <Self as ::unity::SystemObject>::as_instance(self),
13420 );
13421 ::unity::il2cpp_call!((::unity::module_base()+0x1b4e100usize)as*mut u8,();
13422(UnitCalculator_WeaponEnduranceCommand)__receiver)
13423 }
13424 }
13425}
13426
13427#[cfg(feature = "app-unitcalculator")]
13428impl<__T: IUnitCalculator_WeaponEnduranceCommand> IUnitCalculator_WeaponEnduranceCommandMethods for __T {}
13429
13430#[cfg(feature = "app-unitcalculator")]
13431impl UnitCalculator_WeaponEnduranceCommand {
13432 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
13433 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
13434 }
13435
13436 pub fn get_endurance_method_info() -> &'static ::unity::il2cpp::MethodInfo {
13437 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
13438 }
13439
13440 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
13441 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
13442 }
13443
13444 pub fn get_impl_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
13445 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
13446 }
13447
13448 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
13449 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
13450 }
13451}
13452
13453#[cfg(feature = "app-unitcalculator")]
13454impl UnitCalculator_WeaponEnduranceCommand {
13455 #[doc = "Direct (non-virtual) call to `UnitCalculator_WeaponEnduranceCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
13456 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
13457 let __mi = Self::get_name_method_info();
13458 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
13459 __inner(this.into(), ::core::option::Option::None)
13460 }
13461
13462 #[doc = "Direct (non-virtual) call to `UnitCalculator_WeaponEnduranceCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
13463 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
13464 let __mi = Self::get_impl_method_info();
13465 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
13466 ::core::mem::transmute(__mi.method_ptr);
13467 __inner(this.into(), side, ::core::option::Option::None)
13468 }
13469
13470 #[doc = "Direct (non-virtual) call to `UnitCalculator_WeaponEnduranceCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
13471 pub unsafe fn get_impl_2(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
13472 let __mi = Self::get_impl_2_method_info();
13473 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
13474 ::core::mem::transmute(__mi.method_ptr);
13475 __inner(this.into(), unit, ::core::option::Option::None)
13476 }
13477}
13478
13479#[cfg(feature = "app-unitcalculator")]
13480impl UnitCalculator_WeaponEnduranceCommand {
13481 #[doc = "`.ctor()` — no args"]
13482 pub fn new() -> Self {
13483 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
13484 panic!(
13485 "{}
13486::{}
13487 failed to instantiate",
13488 ::core::stringify!(UnitCalculator_WeaponEnduranceCommand),
13489 ::core::stringify!(new),
13490 )
13491 });
13492 <Self as IUnitCalculator_WeaponEnduranceCommandMethods>::ctor(this);
13493 this
13494 }
13495}
13496
13497#[cfg(feature = "app-unitcalculator")]
13498pub trait IUnitCalculator_WeaponSecureCommandMethods: IUnitCalculator_WeaponSecureCommand {
13499 #[doc = "`get_Name()` overload"]
13500 fn get_name(self) -> ::unity::Il2CppString {
13501 unsafe {
13502 let __receiver =
13503 <UnitCalculator_WeaponSecureCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
13504 {
13505 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
13506 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
13507 panic!(
13508 "unity: virtual slot {}
13509 out of range (vtable len {}
13510) on the runtime class behind {}
13511 (method `{}
13512`)",
13513 4usize,
13514 __vt.len(),
13515 <UnitCalculator_WeaponSecureCommand as ::unity::ClassIdentity>::NAME,
13516 "get_Name",
13517 )
13518 });
13519 let __inner: extern "C" fn(UnitCalculator_WeaponSecureCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
13520 ::core::mem::transmute(__vi.method_ptr);
13521 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
13522 __inner(__receiver, __mi)
13523 }
13524 }
13525 }
13526 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
13527 fn get_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
13528 unsafe {
13529 let __receiver =
13530 <UnitCalculator_WeaponSecureCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
13531 {
13532 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
13533 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
13534 panic!(
13535 "unity: virtual slot {}
13536 out of range (vtable len {}
13537) on the runtime class behind {}
13538 (method `{}
13539`)",
13540 31usize,
13541 __vt.len(),
13542 <UnitCalculator_WeaponSecureCommand as ::unity::ClassIdentity>::NAME,
13543 "GetImpl",
13544 )
13545 });
13546 let __inner: extern "C" fn(
13547 UnitCalculator_WeaponSecureCommand,
13548 crate::app::battleinfoside::BattleInfoSide,
13549 ::unity::OptionalMethod,
13550 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
13551 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
13552 __inner(__receiver, ::core::convert::Into::into(side), __mi)
13553 }
13554 }
13555 }
13556 #[doc = "`SetImpl(crate::app::battleinfoside::BattleInfoSide, f32)` overload"]
13557 fn set_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>, value: impl ::core::convert::Into<f32>) -> () {
13558 unsafe {
13559 let __receiver =
13560 <UnitCalculator_WeaponSecureCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
13561 {
13562 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
13563 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
13564 panic!(
13565 "unity: virtual slot {}
13566 out of range (vtable len {}
13567) on the runtime class behind {}
13568 (method `{}
13569`)",
13570 33usize,
13571 __vt.len(),
13572 <UnitCalculator_WeaponSecureCommand as ::unity::ClassIdentity>::NAME,
13573 "SetImpl",
13574 )
13575 });
13576 let __inner: extern "C" fn(
13577 UnitCalculator_WeaponSecureCommand,
13578 crate::app::battleinfoside::BattleInfoSide,
13579 f32,
13580 ::unity::OptionalMethod,
13581 ) -> () = ::core::mem::transmute(__vi.method_ptr);
13582 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
13583 __inner(__receiver, ::core::convert::Into::into(side), ::core::convert::Into::into(value), __mi)
13584 }
13585 }
13586 }
13587 #[doc = "`IsVisible()` overload"]
13588 fn is_visible(self) -> bool {
13589 unsafe {
13590 let __receiver =
13591 <UnitCalculator_WeaponSecureCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
13592 {
13593 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
13594 let __vi = *__vt.get(43usize).unwrap_or_else(|| {
13595 panic!(
13596 "unity: virtual slot {}
13597 out of range (vtable len {}
13598) on the runtime class behind {}
13599 (method `{}
13600`)",
13601 43usize,
13602 __vt.len(),
13603 <UnitCalculator_WeaponSecureCommand as ::unity::ClassIdentity>::NAME,
13604 "IsVisible",
13605 )
13606 });
13607 let __inner: extern "C" fn(UnitCalculator_WeaponSecureCommand, ::unity::OptionalMethod) -> bool =
13608 ::core::mem::transmute(__vi.method_ptr);
13609 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
13610 __inner(__receiver, __mi)
13611 }
13612 }
13613 }
13614 #[doc = "`.ctor()` overload"]
13615 fn ctor(self) -> () {
13616 unsafe {
13617 let __receiver =
13618 <UnitCalculator_WeaponSecureCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
13619 ::unity::il2cpp_call!((::unity::module_base()+0x1b4ed50usize)as*mut u8,();
13620(UnitCalculator_WeaponSecureCommand)__receiver)
13621 }
13622 }
13623}
13624
13625#[cfg(feature = "app-unitcalculator")]
13626impl<__T: IUnitCalculator_WeaponSecureCommand> IUnitCalculator_WeaponSecureCommandMethods for __T {}
13627
13628#[cfg(feature = "app-unitcalculator")]
13629impl UnitCalculator_WeaponSecureCommand {
13630 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
13631 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
13632 }
13633
13634 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
13635 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
13636 }
13637
13638 pub fn set_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
13639 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
13640 }
13641
13642 pub fn is_visible_method_info() -> &'static ::unity::il2cpp::MethodInfo {
13643 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
13644 }
13645
13646 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
13647 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
13648 }
13649}
13650
13651#[cfg(feature = "app-unitcalculator")]
13652impl UnitCalculator_WeaponSecureCommand {
13653 #[doc = "Direct (non-virtual) call to `UnitCalculator_WeaponSecureCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
13654 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
13655 let __mi = Self::get_name_method_info();
13656 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
13657 __inner(this.into(), ::core::option::Option::None)
13658 }
13659
13660 #[doc = "Direct (non-virtual) call to `UnitCalculator_WeaponSecureCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
13661 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
13662 let __mi = Self::get_impl_method_info();
13663 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
13664 ::core::mem::transmute(__mi.method_ptr);
13665 __inner(this.into(), side, ::core::option::Option::None)
13666 }
13667
13668 #[doc = "Direct (non-virtual) call to `UnitCalculator_WeaponSecureCommand`'s own `SetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
13669 pub unsafe fn set_impl(
13670 this: impl ::core::convert::Into<::unity::IlInstance>,
13671 side: crate::app::battleinfoside::BattleInfoSide,
13672 value: f32,
13673 ) -> () {
13674 let __mi = Self::set_impl_method_info();
13675 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, f32, ::unity::OptionalMethod) -> () =
13676 ::core::mem::transmute(__mi.method_ptr);
13677 __inner(this.into(), side, value, ::core::option::Option::None)
13678 }
13679
13680 #[doc = "Direct (non-virtual) call to `UnitCalculator_WeaponSecureCommand`'s own `IsVisible`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
13681 pub unsafe fn is_visible(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
13682 let __mi = Self::is_visible_method_info();
13683 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
13684 __inner(this.into(), ::core::option::Option::None)
13685 }
13686}
13687
13688#[cfg(feature = "app-unitcalculator")]
13689impl UnitCalculator_WeaponSecureCommand {
13690 #[doc = "`.ctor()` — no args"]
13691 pub fn new() -> Self {
13692 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
13693 panic!(
13694 "{}
13695::{}
13696 failed to instantiate",
13697 ::core::stringify!(UnitCalculator_WeaponSecureCommand),
13698 ::core::stringify!(new),
13699 )
13700 });
13701 <Self as IUnitCalculator_WeaponSecureCommandMethods>::ctor(this);
13702 this
13703 }
13704}
13705
13706#[cfg(feature = "app-unitcalculator")]
13707pub trait IUnitCalculator_BattleTimesCommandMethods: IUnitCalculator_BattleTimesCommand {
13708 #[doc = "`get_Name()` overload"]
13709 fn get_name(self) -> ::unity::Il2CppString {
13710 unsafe {
13711 let __receiver =
13712 <UnitCalculator_BattleTimesCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
13713 {
13714 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
13715 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
13716 panic!(
13717 "unity: virtual slot {}
13718 out of range (vtable len {}
13719) on the runtime class behind {}
13720 (method `{}
13721`)",
13722 4usize,
13723 __vt.len(),
13724 <UnitCalculator_BattleTimesCommand as ::unity::ClassIdentity>::NAME,
13725 "get_Name",
13726 )
13727 });
13728 let __inner: extern "C" fn(UnitCalculator_BattleTimesCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
13729 ::core::mem::transmute(__vi.method_ptr);
13730 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
13731 __inner(__receiver, __mi)
13732 }
13733 }
13734 }
13735 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
13736 fn get_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
13737 unsafe {
13738 let __receiver =
13739 <UnitCalculator_BattleTimesCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
13740 {
13741 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
13742 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
13743 panic!(
13744 "unity: virtual slot {}
13745 out of range (vtable len {}
13746) on the runtime class behind {}
13747 (method `{}
13748`)",
13749 31usize,
13750 __vt.len(),
13751 <UnitCalculator_BattleTimesCommand as ::unity::ClassIdentity>::NAME,
13752 "GetImpl",
13753 )
13754 });
13755 let __inner: extern "C" fn(
13756 UnitCalculator_BattleTimesCommand,
13757 crate::app::battleinfoside::BattleInfoSide,
13758 ::unity::OptionalMethod,
13759 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
13760 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
13761 __inner(__receiver, ::core::convert::Into::into(side), __mi)
13762 }
13763 }
13764 }
13765 #[doc = "`SetImpl(crate::app::battleinfoside::BattleInfoSide, f32)` overload"]
13766 fn set_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>, value: impl ::core::convert::Into<f32>) -> () {
13767 unsafe {
13768 let __receiver =
13769 <UnitCalculator_BattleTimesCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
13770 {
13771 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
13772 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
13773 panic!(
13774 "unity: virtual slot {}
13775 out of range (vtable len {}
13776) on the runtime class behind {}
13777 (method `{}
13778`)",
13779 33usize,
13780 __vt.len(),
13781 <UnitCalculator_BattleTimesCommand as ::unity::ClassIdentity>::NAME,
13782 "SetImpl",
13783 )
13784 });
13785 let __inner: extern "C" fn(
13786 UnitCalculator_BattleTimesCommand,
13787 crate::app::battleinfoside::BattleInfoSide,
13788 f32,
13789 ::unity::OptionalMethod,
13790 ) -> () = ::core::mem::transmute(__vi.method_ptr);
13791 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
13792 __inner(__receiver, ::core::convert::Into::into(side), ::core::convert::Into::into(value), __mi)
13793 }
13794 }
13795 }
13796 #[doc = "`.ctor()` overload"]
13797 fn ctor(self) -> () {
13798 unsafe {
13799 let __receiver =
13800 <UnitCalculator_BattleTimesCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
13801 ::unity::il2cpp_call!((::unity::module_base()+0x1b467d0usize)as*mut u8,();
13802(UnitCalculator_BattleTimesCommand)__receiver)
13803 }
13804 }
13805}
13806
13807#[cfg(feature = "app-unitcalculator")]
13808impl<__T: IUnitCalculator_BattleTimesCommand> IUnitCalculator_BattleTimesCommandMethods for __T {}
13809
13810#[cfg(feature = "app-unitcalculator")]
13811impl UnitCalculator_BattleTimesCommand {
13812 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
13813 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
13814 }
13815
13816 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
13817 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
13818 }
13819
13820 pub fn set_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
13821 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
13822 }
13823
13824 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
13825 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
13826 }
13827}
13828
13829#[cfg(feature = "app-unitcalculator")]
13830impl UnitCalculator_BattleTimesCommand {
13831 #[doc = "Direct (non-virtual) call to `UnitCalculator_BattleTimesCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
13832 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
13833 let __mi = Self::get_name_method_info();
13834 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
13835 __inner(this.into(), ::core::option::Option::None)
13836 }
13837
13838 #[doc = "Direct (non-virtual) call to `UnitCalculator_BattleTimesCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
13839 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
13840 let __mi = Self::get_impl_method_info();
13841 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
13842 ::core::mem::transmute(__mi.method_ptr);
13843 __inner(this.into(), side, ::core::option::Option::None)
13844 }
13845
13846 #[doc = "Direct (non-virtual) call to `UnitCalculator_BattleTimesCommand`'s own `SetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
13847 pub unsafe fn set_impl(
13848 this: impl ::core::convert::Into<::unity::IlInstance>,
13849 side: crate::app::battleinfoside::BattleInfoSide,
13850 value: f32,
13851 ) -> () {
13852 let __mi = Self::set_impl_method_info();
13853 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, f32, ::unity::OptionalMethod) -> () =
13854 ::core::mem::transmute(__mi.method_ptr);
13855 __inner(this.into(), side, value, ::core::option::Option::None)
13856 }
13857}
13858
13859#[cfg(feature = "app-unitcalculator")]
13860impl UnitCalculator_BattleTimesCommand {
13861 #[doc = "`.ctor()` — no args"]
13862 pub fn new() -> Self {
13863 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
13864 panic!(
13865 "{}
13866::{}
13867 failed to instantiate",
13868 ::core::stringify!(UnitCalculator_BattleTimesCommand),
13869 ::core::stringify!(new),
13870 )
13871 });
13872 <Self as IUnitCalculator_BattleTimesCommandMethods>::ctor(this);
13873 this
13874 }
13875}
13876
13877#[cfg(feature = "app-unitcalculator")]
13878pub trait IUnitCalculator_TotalAttackCommandMethods: IUnitCalculator_TotalAttackCommand {
13879 #[doc = "`get_Name()` overload"]
13880 fn get_name(self) -> ::unity::Il2CppString {
13881 unsafe {
13882 let __receiver =
13883 <UnitCalculator_TotalAttackCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
13884 {
13885 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
13886 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
13887 panic!(
13888 "unity: virtual slot {}
13889 out of range (vtable len {}
13890) on the runtime class behind {}
13891 (method `{}
13892`)",
13893 4usize,
13894 __vt.len(),
13895 <UnitCalculator_TotalAttackCommand as ::unity::ClassIdentity>::NAME,
13896 "get_Name",
13897 )
13898 });
13899 let __inner: extern "C" fn(UnitCalculator_TotalAttackCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
13900 ::core::mem::transmute(__vi.method_ptr);
13901 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
13902 __inner(__receiver, __mi)
13903 }
13904 }
13905 }
13906 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
13907 fn get_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
13908 unsafe {
13909 let __receiver =
13910 <UnitCalculator_TotalAttackCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
13911 {
13912 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
13913 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
13914 panic!(
13915 "unity: virtual slot {}
13916 out of range (vtable len {}
13917) on the runtime class behind {}
13918 (method `{}
13919`)",
13920 31usize,
13921 __vt.len(),
13922 <UnitCalculator_TotalAttackCommand as ::unity::ClassIdentity>::NAME,
13923 "GetImpl",
13924 )
13925 });
13926 let __inner: extern "C" fn(
13927 UnitCalculator_TotalAttackCommand,
13928 crate::app::battleinfoside::BattleInfoSide,
13929 ::unity::OptionalMethod,
13930 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
13931 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
13932 __inner(__receiver, ::core::convert::Into::into(side), __mi)
13933 }
13934 }
13935 }
13936 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
13937 fn get_impl_2(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
13938 unsafe {
13939 let __receiver =
13940 <UnitCalculator_TotalAttackCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
13941 {
13942 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
13943 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
13944 panic!(
13945 "unity: virtual slot {}
13946 out of range (vtable len {}
13947) on the runtime class behind {}
13948 (method `{}
13949`)",
13950 30usize,
13951 __vt.len(),
13952 <UnitCalculator_TotalAttackCommand as ::unity::ClassIdentity>::NAME,
13953 "GetImpl",
13954 )
13955 });
13956 let __inner: extern "C" fn(UnitCalculator_TotalAttackCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
13957 ::core::mem::transmute(__vi.method_ptr);
13958 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
13959 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
13960 }
13961 }
13962 }
13963 #[doc = "`.ctor()` overload"]
13964 fn ctor(self) -> () {
13965 unsafe {
13966 let __receiver =
13967 <UnitCalculator_TotalAttackCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
13968 ::unity::il2cpp_call!((::unity::module_base()+0x1b4cbe0usize)as*mut u8,();
13969(UnitCalculator_TotalAttackCommand)__receiver)
13970 }
13971 }
13972}
13973
13974#[cfg(feature = "app-unitcalculator")]
13975impl<__T: IUnitCalculator_TotalAttackCommand> IUnitCalculator_TotalAttackCommandMethods for __T {}
13976
13977#[cfg(feature = "app-unitcalculator")]
13978impl UnitCalculator_TotalAttackCommand {
13979 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
13980 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
13981 }
13982
13983 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
13984 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
13985 }
13986
13987 pub fn get_impl_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
13988 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
13989 }
13990
13991 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
13992 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
13993 }
13994}
13995
13996#[cfg(feature = "app-unitcalculator")]
13997impl UnitCalculator_TotalAttackCommand {
13998 #[doc = "Direct (non-virtual) call to `UnitCalculator_TotalAttackCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
13999 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
14000 let __mi = Self::get_name_method_info();
14001 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
14002 __inner(this.into(), ::core::option::Option::None)
14003 }
14004
14005 #[doc = "Direct (non-virtual) call to `UnitCalculator_TotalAttackCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
14006 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
14007 let __mi = Self::get_impl_method_info();
14008 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
14009 ::core::mem::transmute(__mi.method_ptr);
14010 __inner(this.into(), side, ::core::option::Option::None)
14011 }
14012
14013 #[doc = "Direct (non-virtual) call to `UnitCalculator_TotalAttackCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
14014 pub unsafe fn get_impl_2(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
14015 let __mi = Self::get_impl_2_method_info();
14016 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
14017 ::core::mem::transmute(__mi.method_ptr);
14018 __inner(this.into(), unit, ::core::option::Option::None)
14019 }
14020}
14021
14022#[cfg(feature = "app-unitcalculator")]
14023impl UnitCalculator_TotalAttackCommand {
14024 #[doc = "`.ctor()` — no args"]
14025 pub fn new() -> Self {
14026 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
14027 panic!(
14028 "{}
14029::{}
14030 failed to instantiate",
14031 ::core::stringify!(UnitCalculator_TotalAttackCommand),
14032 ::core::stringify!(new),
14033 )
14034 });
14035 <Self as IUnitCalculator_TotalAttackCommandMethods>::ctor(this);
14036 this
14037 }
14038}
14039
14040#[cfg(feature = "app-unitcalculator")]
14041pub trait IUnitCalculator_ExpBattleGiveCountCommandMethods: IUnitCalculator_ExpBattleGiveCountCommand {
14042 #[doc = "`get_Name()` overload"]
14043 fn get_name(self) -> ::unity::Il2CppString {
14044 unsafe {
14045 let __receiver = <UnitCalculator_ExpBattleGiveCountCommand as ::unity::FromIlInstance>::from_il_instance(
14046 <Self as ::unity::SystemObject>::as_instance(self),
14047 );
14048 {
14049 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
14050 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
14051 panic!(
14052 "unity: virtual slot {}
14053 out of range (vtable len {}
14054) on the runtime class behind {}
14055 (method `{}
14056`)",
14057 4usize,
14058 __vt.len(),
14059 <UnitCalculator_ExpBattleGiveCountCommand as ::unity::ClassIdentity>::NAME,
14060 "get_Name",
14061 )
14062 });
14063 let __inner: extern "C" fn(UnitCalculator_ExpBattleGiveCountCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
14064 ::core::mem::transmute(__vi.method_ptr);
14065 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
14066 __inner(__receiver, __mi)
14067 }
14068 }
14069 }
14070 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
14071 fn get_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
14072 unsafe {
14073 let __receiver = <UnitCalculator_ExpBattleGiveCountCommand as ::unity::FromIlInstance>::from_il_instance(
14074 <Self as ::unity::SystemObject>::as_instance(self),
14075 );
14076 {
14077 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
14078 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
14079 panic!(
14080 "unity: virtual slot {}
14081 out of range (vtable len {}
14082) on the runtime class behind {}
14083 (method `{}
14084`)",
14085 30usize,
14086 __vt.len(),
14087 <UnitCalculator_ExpBattleGiveCountCommand as ::unity::ClassIdentity>::NAME,
14088 "GetImpl",
14089 )
14090 });
14091 let __inner: extern "C" fn(UnitCalculator_ExpBattleGiveCountCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
14092 ::core::mem::transmute(__vi.method_ptr);
14093 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
14094 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
14095 }
14096 }
14097 }
14098 #[doc = "`.ctor()` overload"]
14099 fn ctor(self) -> () {
14100 unsafe {
14101 let __receiver = <UnitCalculator_ExpBattleGiveCountCommand as ::unity::FromIlInstance>::from_il_instance(
14102 <Self as ::unity::SystemObject>::as_instance(self),
14103 );
14104 ::unity::il2cpp_call!((::unity::module_base()+0x1b47140usize)as*mut u8,();
14105(UnitCalculator_ExpBattleGiveCountCommand)__receiver)
14106 }
14107 }
14108}
14109
14110#[cfg(feature = "app-unitcalculator")]
14111impl<__T: IUnitCalculator_ExpBattleGiveCountCommand> IUnitCalculator_ExpBattleGiveCountCommandMethods for __T {}
14112
14113#[cfg(feature = "app-unitcalculator")]
14114impl UnitCalculator_ExpBattleGiveCountCommand {
14115 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
14116 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
14117 }
14118
14119 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
14120 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
14121 }
14122
14123 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
14124 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
14125 }
14126}
14127
14128#[cfg(feature = "app-unitcalculator")]
14129impl UnitCalculator_ExpBattleGiveCountCommand {
14130 #[doc = "Direct (non-virtual) call to `UnitCalculator_ExpBattleGiveCountCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
14131 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
14132 let __mi = Self::get_name_method_info();
14133 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
14134 __inner(this.into(), ::core::option::Option::None)
14135 }
14136
14137 #[doc = "Direct (non-virtual) call to `UnitCalculator_ExpBattleGiveCountCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
14138 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
14139 let __mi = Self::get_impl_method_info();
14140 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
14141 ::core::mem::transmute(__mi.method_ptr);
14142 __inner(this.into(), unit, ::core::option::Option::None)
14143 }
14144}
14145
14146#[cfg(feature = "app-unitcalculator")]
14147impl UnitCalculator_ExpBattleGiveCountCommand {
14148 #[doc = "`.ctor()` — no args"]
14149 pub fn new() -> Self {
14150 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
14151 panic!(
14152 "{}
14153::{}
14154 failed to instantiate",
14155 ::core::stringify!(UnitCalculator_ExpBattleGiveCountCommand),
14156 ::core::stringify!(new),
14157 )
14158 });
14159 <Self as IUnitCalculator_ExpBattleGiveCountCommandMethods>::ctor(this);
14160 this
14161 }
14162}
14163
14164#[cfg(feature = "app-unitcalculator")]
14165pub trait IUnitCalculator_PosLowXCommandMethods: IUnitCalculator_PosLowXCommand {
14166 #[doc = "`get_Name()` overload"]
14167 fn get_name(self) -> ::unity::Il2CppString {
14168 unsafe {
14169 let __receiver =
14170 <UnitCalculator_PosLowXCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
14171 {
14172 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
14173 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
14174 panic!(
14175 "unity: virtual slot {}
14176 out of range (vtable len {}
14177) on the runtime class behind {}
14178 (method `{}
14179`)",
14180 4usize,
14181 __vt.len(),
14182 <UnitCalculator_PosLowXCommand as ::unity::ClassIdentity>::NAME,
14183 "get_Name",
14184 )
14185 });
14186 let __inner: extern "C" fn(UnitCalculator_PosLowXCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
14187 ::core::mem::transmute(__vi.method_ptr);
14188 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
14189 __inner(__receiver, __mi)
14190 }
14191 }
14192 }
14193 #[doc = "`.ctor()` overload"]
14194 fn ctor(self) -> () {
14195 unsafe {
14196 let __receiver =
14197 <UnitCalculator_PosLowXCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
14198 ::unity::il2cpp_call!((::unity::module_base()+0x1b4ab30usize)as*mut u8,();
14199(UnitCalculator_PosLowXCommand)__receiver)
14200 }
14201 }
14202}
14203
14204#[cfg(feature = "app-unitcalculator")]
14205impl<__T: IUnitCalculator_PosLowXCommand> IUnitCalculator_PosLowXCommandMethods for __T {}
14206
14207#[cfg(feature = "app-unitcalculator")]
14208impl UnitCalculator_PosLowXCommand {
14209 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
14210 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
14211 }
14212
14213 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
14214 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
14215 }
14216}
14217
14218#[cfg(feature = "app-unitcalculator")]
14219impl UnitCalculator_PosLowXCommand {
14220 #[doc = "Direct (non-virtual) call to `UnitCalculator_PosLowXCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
14221 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
14222 let __mi = Self::get_name_method_info();
14223 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
14224 __inner(this.into(), ::core::option::Option::None)
14225 }
14226}
14227
14228#[cfg(feature = "app-unitcalculator")]
14229impl UnitCalculator_PosLowXCommand {
14230 #[doc = "`.ctor()` — no args"]
14231 pub fn new() -> Self {
14232 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
14233 panic!(
14234 "{}
14235::{}
14236 failed to instantiate",
14237 ::core::stringify!(UnitCalculator_PosLowXCommand),
14238 ::core::stringify!(new),
14239 )
14240 });
14241 <Self as IUnitCalculator_PosLowXCommandMethods>::ctor(this);
14242 this
14243 }
14244}
14245
14246#[cfg(feature = "app-unitcalculator")]
14247pub trait IUnitCalculator_BattleLastTargetCommandMethods: IUnitCalculator_BattleLastTargetCommand {
14248 #[doc = "`get_Name()` overload"]
14249 fn get_name(self) -> ::unity::Il2CppString {
14250 unsafe {
14251 let __receiver = <UnitCalculator_BattleLastTargetCommand as ::unity::FromIlInstance>::from_il_instance(
14252 <Self as ::unity::SystemObject>::as_instance(self),
14253 );
14254 {
14255 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
14256 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
14257 panic!(
14258 "unity: virtual slot {}
14259 out of range (vtable len {}
14260) on the runtime class behind {}
14261 (method `{}
14262`)",
14263 4usize,
14264 __vt.len(),
14265 <UnitCalculator_BattleLastTargetCommand as ::unity::ClassIdentity>::NAME,
14266 "get_Name",
14267 )
14268 });
14269 let __inner: extern "C" fn(UnitCalculator_BattleLastTargetCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
14270 ::core::mem::transmute(__vi.method_ptr);
14271 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
14272 __inner(__receiver, __mi)
14273 }
14274 }
14275 }
14276 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
14277 fn get_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
14278 unsafe {
14279 let __receiver = <UnitCalculator_BattleLastTargetCommand as ::unity::FromIlInstance>::from_il_instance(
14280 <Self as ::unity::SystemObject>::as_instance(self),
14281 );
14282 {
14283 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
14284 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
14285 panic!(
14286 "unity: virtual slot {}
14287 out of range (vtable len {}
14288) on the runtime class behind {}
14289 (method `{}
14290`)",
14291 30usize,
14292 __vt.len(),
14293 <UnitCalculator_BattleLastTargetCommand as ::unity::ClassIdentity>::NAME,
14294 "GetImpl",
14295 )
14296 });
14297 let __inner: extern "C" fn(UnitCalculator_BattleLastTargetCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
14298 ::core::mem::transmute(__vi.method_ptr);
14299 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
14300 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
14301 }
14302 }
14303 }
14304 #[doc = "`.ctor()` overload"]
14305 fn ctor(self) -> () {
14306 unsafe {
14307 let __receiver = <UnitCalculator_BattleLastTargetCommand as ::unity::FromIlInstance>::from_il_instance(
14308 <Self as ::unity::SystemObject>::as_instance(self),
14309 );
14310 ::unity::il2cpp_call!((::unity::module_base()+0x1b45c00usize)as*mut u8,();
14311(UnitCalculator_BattleLastTargetCommand)__receiver)
14312 }
14313 }
14314}
14315
14316#[cfg(feature = "app-unitcalculator")]
14317impl<__T: IUnitCalculator_BattleLastTargetCommand> IUnitCalculator_BattleLastTargetCommandMethods for __T {}
14318
14319#[cfg(feature = "app-unitcalculator")]
14320impl UnitCalculator_BattleLastTargetCommand {
14321 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
14322 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
14323 }
14324
14325 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
14326 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
14327 }
14328
14329 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
14330 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
14331 }
14332}
14333
14334#[cfg(feature = "app-unitcalculator")]
14335impl UnitCalculator_BattleLastTargetCommand {
14336 #[doc = "Direct (non-virtual) call to `UnitCalculator_BattleLastTargetCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
14337 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
14338 let __mi = Self::get_name_method_info();
14339 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
14340 __inner(this.into(), ::core::option::Option::None)
14341 }
14342
14343 #[doc = "Direct (non-virtual) call to `UnitCalculator_BattleLastTargetCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
14344 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
14345 let __mi = Self::get_impl_method_info();
14346 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
14347 ::core::mem::transmute(__mi.method_ptr);
14348 __inner(this.into(), unit, ::core::option::Option::None)
14349 }
14350}
14351
14352#[cfg(feature = "app-unitcalculator")]
14353impl UnitCalculator_BattleLastTargetCommand {
14354 #[doc = "`.ctor()` — no args"]
14355 pub fn new() -> Self {
14356 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
14357 panic!(
14358 "{}
14359::{}
14360 failed to instantiate",
14361 ::core::stringify!(UnitCalculator_BattleLastTargetCommand),
14362 ::core::stringify!(new),
14363 )
14364 });
14365 <Self as IUnitCalculator_BattleLastTargetCommandMethods>::ctor(this);
14366 this
14367 }
14368}
14369
14370#[cfg(feature = "app-unitcalculator")]
14371pub trait IUnitCalculator_BattleSceneResultMissCommandMethods: IUnitCalculator_BattleSceneResultMissCommand {
14372 #[doc = "`get_Name()` overload"]
14373 fn get_name(self) -> ::unity::Il2CppString {
14374 unsafe {
14375 let __receiver = <UnitCalculator_BattleSceneResultMissCommand as ::unity::FromIlInstance>::from_il_instance(
14376 <Self as ::unity::SystemObject>::as_instance(self),
14377 );
14378 {
14379 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
14380 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
14381 panic!(
14382 "unity: virtual slot {}
14383 out of range (vtable len {}
14384) on the runtime class behind {}
14385 (method `{}
14386`)",
14387 4usize,
14388 __vt.len(),
14389 <UnitCalculator_BattleSceneResultMissCommand as ::unity::ClassIdentity>::NAME,
14390 "get_Name",
14391 )
14392 });
14393 let __inner: extern "C" fn(UnitCalculator_BattleSceneResultMissCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
14394 ::core::mem::transmute(__vi.method_ptr);
14395 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
14396 __inner(__receiver, __mi)
14397 }
14398 }
14399 }
14400 #[doc = "`Get()` overload"]
14401 fn get(self) -> f32 {
14402 unsafe {
14403 let __receiver = <UnitCalculator_BattleSceneResultMissCommand as ::unity::FromIlInstance>::from_il_instance(
14404 <Self as ::unity::SystemObject>::as_instance(self),
14405 );
14406 {
14407 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
14408 let __vi = *__vt.get(9usize).unwrap_or_else(|| {
14409 panic!(
14410 "unity: virtual slot {}
14411 out of range (vtable len {}
14412) on the runtime class behind {}
14413 (method `{}
14414`)",
14415 9usize,
14416 __vt.len(),
14417 <UnitCalculator_BattleSceneResultMissCommand as ::unity::ClassIdentity>::NAME,
14418 "Get",
14419 )
14420 });
14421 let __inner: extern "C" fn(UnitCalculator_BattleSceneResultMissCommand, ::unity::OptionalMethod) -> f32 =
14422 ::core::mem::transmute(__vi.method_ptr);
14423 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
14424 __inner(__receiver, __mi)
14425 }
14426 }
14427 }
14428 #[doc = "`.ctor()` overload"]
14429 fn ctor(self) -> () {
14430 unsafe {
14431 let __receiver = <UnitCalculator_BattleSceneResultMissCommand as ::unity::FromIlInstance>::from_il_instance(
14432 <Self as ::unity::SystemObject>::as_instance(self),
14433 );
14434 ::unity::il2cpp_call!((::unity::module_base()+0x1b46410usize)as*mut u8,();
14435(UnitCalculator_BattleSceneResultMissCommand)__receiver)
14436 }
14437 }
14438}
14439
14440#[cfg(feature = "app-unitcalculator")]
14441impl<__T: IUnitCalculator_BattleSceneResultMissCommand> IUnitCalculator_BattleSceneResultMissCommandMethods for __T {}
14442
14443#[cfg(feature = "app-unitcalculator")]
14444impl UnitCalculator_BattleSceneResultMissCommand {
14445 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
14446 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
14447 }
14448
14449 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
14450 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
14451 }
14452
14453 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
14454 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
14455 }
14456}
14457
14458#[cfg(feature = "app-unitcalculator")]
14459impl UnitCalculator_BattleSceneResultMissCommand {
14460 #[doc = "Direct (non-virtual) call to `UnitCalculator_BattleSceneResultMissCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
14461 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
14462 let __mi = Self::get_name_method_info();
14463 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
14464 __inner(this.into(), ::core::option::Option::None)
14465 }
14466
14467 #[doc = "Direct (non-virtual) call to `UnitCalculator_BattleSceneResultMissCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
14468 pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
14469 let __mi = Self::get_method_info();
14470 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
14471 __inner(this.into(), ::core::option::Option::None)
14472 }
14473}
14474
14475#[cfg(feature = "app-unitcalculator")]
14476impl UnitCalculator_BattleSceneResultMissCommand {
14477 #[doc = "`.ctor()` — no args"]
14478 pub fn new() -> Self {
14479 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
14480 panic!(
14481 "{}
14482::{}
14483 failed to instantiate",
14484 ::core::stringify!(UnitCalculator_BattleSceneResultMissCommand),
14485 ::core::stringify!(new),
14486 )
14487 });
14488 <Self as IUnitCalculator_BattleSceneResultMissCommandMethods>::ctor(this);
14489 this
14490 }
14491}
14492
14493#[cfg(feature = "app-unitcalculator")]
14494pub trait IUnitCalculator_WeaponAttackCommandMethods: IUnitCalculator_WeaponAttackCommand {
14495 #[doc = "`get_Name()` overload"]
14496 fn get_name(self) -> ::unity::Il2CppString {
14497 unsafe {
14498 let __receiver =
14499 <UnitCalculator_WeaponAttackCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
14500 {
14501 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
14502 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
14503 panic!(
14504 "unity: virtual slot {}
14505 out of range (vtable len {}
14506) on the runtime class behind {}
14507 (method `{}
14508`)",
14509 4usize,
14510 __vt.len(),
14511 <UnitCalculator_WeaponAttackCommand as ::unity::ClassIdentity>::NAME,
14512 "get_Name",
14513 )
14514 });
14515 let __inner: extern "C" fn(UnitCalculator_WeaponAttackCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
14516 ::core::mem::transmute(__vi.method_ptr);
14517 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
14518 __inner(__receiver, __mi)
14519 }
14520 }
14521 }
14522 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
14523 fn get_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
14524 unsafe {
14525 let __receiver =
14526 <UnitCalculator_WeaponAttackCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
14527 {
14528 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
14529 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
14530 panic!(
14531 "unity: virtual slot {}
14532 out of range (vtable len {}
14533) on the runtime class behind {}
14534 (method `{}
14535`)",
14536 31usize,
14537 __vt.len(),
14538 <UnitCalculator_WeaponAttackCommand as ::unity::ClassIdentity>::NAME,
14539 "GetImpl",
14540 )
14541 });
14542 let __inner: extern "C" fn(
14543 UnitCalculator_WeaponAttackCommand,
14544 crate::app::battleinfoside::BattleInfoSide,
14545 ::unity::OptionalMethod,
14546 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
14547 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
14548 __inner(__receiver, ::core::convert::Into::into(side), __mi)
14549 }
14550 }
14551 }
14552 #[doc = "`SetImpl(crate::app::battleinfoside::BattleInfoSide, f32)` overload"]
14553 fn set_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>, value: impl ::core::convert::Into<f32>) -> () {
14554 unsafe {
14555 let __receiver =
14556 <UnitCalculator_WeaponAttackCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
14557 {
14558 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
14559 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
14560 panic!(
14561 "unity: virtual slot {}
14562 out of range (vtable len {}
14563) on the runtime class behind {}
14564 (method `{}
14565`)",
14566 33usize,
14567 __vt.len(),
14568 <UnitCalculator_WeaponAttackCommand as ::unity::ClassIdentity>::NAME,
14569 "SetImpl",
14570 )
14571 });
14572 let __inner: extern "C" fn(
14573 UnitCalculator_WeaponAttackCommand,
14574 crate::app::battleinfoside::BattleInfoSide,
14575 f32,
14576 ::unity::OptionalMethod,
14577 ) -> () = ::core::mem::transmute(__vi.method_ptr);
14578 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
14579 __inner(__receiver, ::core::convert::Into::into(side), ::core::convert::Into::into(value), __mi)
14580 }
14581 }
14582 }
14583 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
14584 fn get_impl_2(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
14585 unsafe {
14586 let __receiver =
14587 <UnitCalculator_WeaponAttackCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
14588 {
14589 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
14590 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
14591 panic!(
14592 "unity: virtual slot {}
14593 out of range (vtable len {}
14594) on the runtime class behind {}
14595 (method `{}
14596`)",
14597 30usize,
14598 __vt.len(),
14599 <UnitCalculator_WeaponAttackCommand as ::unity::ClassIdentity>::NAME,
14600 "GetImpl",
14601 )
14602 });
14603 let __inner: extern "C" fn(UnitCalculator_WeaponAttackCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
14604 ::core::mem::transmute(__vi.method_ptr);
14605 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
14606 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
14607 }
14608 }
14609 }
14610 #[doc = "`IsVisible()` overload"]
14611 fn is_visible(self) -> bool {
14612 unsafe {
14613 let __receiver =
14614 <UnitCalculator_WeaponAttackCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
14615 {
14616 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
14617 let __vi = *__vt.get(43usize).unwrap_or_else(|| {
14618 panic!(
14619 "unity: virtual slot {}
14620 out of range (vtable len {}
14621) on the runtime class behind {}
14622 (method `{}
14623`)",
14624 43usize,
14625 __vt.len(),
14626 <UnitCalculator_WeaponAttackCommand as ::unity::ClassIdentity>::NAME,
14627 "IsVisible",
14628 )
14629 });
14630 let __inner: extern "C" fn(UnitCalculator_WeaponAttackCommand, ::unity::OptionalMethod) -> bool =
14631 ::core::mem::transmute(__vi.method_ptr);
14632 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
14633 __inner(__receiver, __mi)
14634 }
14635 }
14636 }
14637 #[doc = "`.ctor()` overload"]
14638 fn ctor(self) -> () {
14639 unsafe {
14640 let __receiver =
14641 <UnitCalculator_WeaponAttackCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
14642 ::unity::il2cpp_call!((::unity::module_base()+0x1b4db90usize)as*mut u8,();
14643(UnitCalculator_WeaponAttackCommand)__receiver)
14644 }
14645 }
14646}
14647
14648#[cfg(feature = "app-unitcalculator")]
14649impl<__T: IUnitCalculator_WeaponAttackCommand> IUnitCalculator_WeaponAttackCommandMethods for __T {}
14650
14651#[cfg(feature = "app-unitcalculator")]
14652impl UnitCalculator_WeaponAttackCommand {
14653 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
14654 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
14655 }
14656
14657 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
14658 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
14659 }
14660
14661 pub fn set_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
14662 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
14663 }
14664
14665 pub fn get_impl_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
14666 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
14667 }
14668
14669 pub fn is_visible_method_info() -> &'static ::unity::il2cpp::MethodInfo {
14670 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
14671 }
14672
14673 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
14674 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
14675 }
14676}
14677
14678#[cfg(feature = "app-unitcalculator")]
14679impl UnitCalculator_WeaponAttackCommand {
14680 #[doc = "Direct (non-virtual) call to `UnitCalculator_WeaponAttackCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
14681 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
14682 let __mi = Self::get_name_method_info();
14683 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
14684 __inner(this.into(), ::core::option::Option::None)
14685 }
14686
14687 #[doc = "Direct (non-virtual) call to `UnitCalculator_WeaponAttackCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
14688 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
14689 let __mi = Self::get_impl_method_info();
14690 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
14691 ::core::mem::transmute(__mi.method_ptr);
14692 __inner(this.into(), side, ::core::option::Option::None)
14693 }
14694
14695 #[doc = "Direct (non-virtual) call to `UnitCalculator_WeaponAttackCommand`'s own `SetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
14696 pub unsafe fn set_impl(
14697 this: impl ::core::convert::Into<::unity::IlInstance>,
14698 side: crate::app::battleinfoside::BattleInfoSide,
14699 value: f32,
14700 ) -> () {
14701 let __mi = Self::set_impl_method_info();
14702 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, f32, ::unity::OptionalMethod) -> () =
14703 ::core::mem::transmute(__mi.method_ptr);
14704 __inner(this.into(), side, value, ::core::option::Option::None)
14705 }
14706
14707 #[doc = "Direct (non-virtual) call to `UnitCalculator_WeaponAttackCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
14708 pub unsafe fn get_impl_2(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
14709 let __mi = Self::get_impl_2_method_info();
14710 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
14711 ::core::mem::transmute(__mi.method_ptr);
14712 __inner(this.into(), unit, ::core::option::Option::None)
14713 }
14714
14715 #[doc = "Direct (non-virtual) call to `UnitCalculator_WeaponAttackCommand`'s own `IsVisible`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
14716 pub unsafe fn is_visible(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
14717 let __mi = Self::is_visible_method_info();
14718 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
14719 __inner(this.into(), ::core::option::Option::None)
14720 }
14721}
14722
14723#[cfg(feature = "app-unitcalculator")]
14724impl UnitCalculator_WeaponAttackCommand {
14725 #[doc = "`.ctor()` — no args"]
14726 pub fn new() -> Self {
14727 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
14728 panic!(
14729 "{}
14730::{}
14731 failed to instantiate",
14732 ::core::stringify!(UnitCalculator_WeaponAttackCommand),
14733 ::core::stringify!(new),
14734 )
14735 });
14736 <Self as IUnitCalculator_WeaponAttackCommandMethods>::ctor(this);
14737 this
14738 }
14739}
14740
14741#[cfg(feature = "app-unitcalculator")]
14742pub trait IUnitCalculator_RangeEnemyCountCommandMethods: IUnitCalculator_RangeEnemyCountCommand {
14743 #[doc = "`get_Name()` overload"]
14744 fn get_name(self) -> ::unity::Il2CppString {
14745 unsafe {
14746 let __receiver = <UnitCalculator_RangeEnemyCountCommand as ::unity::FromIlInstance>::from_il_instance(
14747 <Self as ::unity::SystemObject>::as_instance(self),
14748 );
14749 {
14750 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
14751 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
14752 panic!(
14753 "unity: virtual slot {}
14754 out of range (vtable len {}
14755) on the runtime class behind {}
14756 (method `{}
14757`)",
14758 4usize,
14759 __vt.len(),
14760 <UnitCalculator_RangeEnemyCountCommand as ::unity::ClassIdentity>::NAME,
14761 "get_Name",
14762 )
14763 });
14764 let __inner: extern "C" fn(UnitCalculator_RangeEnemyCountCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
14765 ::core::mem::transmute(__vi.method_ptr);
14766 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
14767 __inner(__receiver, __mi)
14768 }
14769 }
14770 }
14771 #[doc = "`FuncImpl(crate::app::unit::Unit, crate::system::collections::generic::list_1::List_1<f32>)` overload"]
14772 fn func_impl(
14773 self,
14774 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
14775 args: impl ::core::convert::Into<crate::system::collections::generic::list_1::List_1<f32>>,
14776 ) -> f32 {
14777 unsafe {
14778 let __receiver = <UnitCalculator_RangeEnemyCountCommand as ::unity::FromIlInstance>::from_il_instance(
14779 <Self as ::unity::SystemObject>::as_instance(self),
14780 );
14781 {
14782 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
14783 let __vi = *__vt.get(34usize).unwrap_or_else(|| {
14784 panic!(
14785 "unity: virtual slot {}
14786 out of range (vtable len {}
14787) on the runtime class behind {}
14788 (method `{}
14789`)",
14790 34usize,
14791 __vt.len(),
14792 <UnitCalculator_RangeEnemyCountCommand as ::unity::ClassIdentity>::NAME,
14793 "FuncImpl",
14794 )
14795 });
14796 let __inner: extern "C" fn(
14797 UnitCalculator_RangeEnemyCountCommand,
14798 crate::app::unit::Unit,
14799 crate::system::collections::generic::list_1::List_1<f32>,
14800 ::unity::OptionalMethod,
14801 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
14802 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
14803 __inner(__receiver, ::core::convert::Into::into(unit), ::core::convert::Into::into(args), __mi)
14804 }
14805 }
14806 }
14807 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
14808 fn get_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
14809 unsafe {
14810 let __receiver = <UnitCalculator_RangeEnemyCountCommand as ::unity::FromIlInstance>::from_il_instance(
14811 <Self as ::unity::SystemObject>::as_instance(self),
14812 );
14813 {
14814 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
14815 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
14816 panic!(
14817 "unity: virtual slot {}
14818 out of range (vtable len {}
14819) on the runtime class behind {}
14820 (method `{}
14821`)",
14822 30usize,
14823 __vt.len(),
14824 <UnitCalculator_RangeEnemyCountCommand as ::unity::ClassIdentity>::NAME,
14825 "GetImpl",
14826 )
14827 });
14828 let __inner: extern "C" fn(UnitCalculator_RangeEnemyCountCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
14829 ::core::mem::transmute(__vi.method_ptr);
14830 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
14831 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
14832 }
14833 }
14834 }
14835 #[doc = "`.ctor()` overload"]
14836 fn ctor(self) -> () {
14837 unsafe {
14838 let __receiver = <UnitCalculator_RangeEnemyCountCommand as ::unity::FromIlInstance>::from_il_instance(
14839 <Self as ::unity::SystemObject>::as_instance(self),
14840 );
14841 ::unity::il2cpp_call!((::unity::module_base()+0x1b4b490usize)as*mut u8,();
14842(UnitCalculator_RangeEnemyCountCommand)__receiver)
14843 }
14844 }
14845}
14846
14847#[cfg(feature = "app-unitcalculator")]
14848impl<__T: IUnitCalculator_RangeEnemyCountCommand> IUnitCalculator_RangeEnemyCountCommandMethods for __T {}
14849
14850#[cfg(feature = "app-unitcalculator")]
14851impl UnitCalculator_RangeEnemyCountCommand {
14852 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
14853 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
14854 }
14855
14856 pub fn func_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
14857 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
14858 }
14859
14860 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
14861 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
14862 }
14863
14864 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
14865 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
14866 }
14867}
14868
14869#[cfg(feature = "app-unitcalculator")]
14870impl UnitCalculator_RangeEnemyCountCommand {
14871 #[doc = "Direct (non-virtual) call to `UnitCalculator_RangeEnemyCountCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
14872 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
14873 let __mi = Self::get_name_method_info();
14874 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
14875 __inner(this.into(), ::core::option::Option::None)
14876 }
14877
14878 #[doc = "Direct (non-virtual) call to `UnitCalculator_RangeEnemyCountCommand`'s own `FuncImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
14879 pub unsafe fn func_impl(
14880 this: impl ::core::convert::Into<::unity::IlInstance>,
14881 unit: crate::app::unit::Unit,
14882 args: crate::system::collections::generic::list_1::List_1<f32>,
14883 ) -> f32 {
14884 let __mi = Self::func_impl_method_info();
14885 let __inner: extern "C" fn(
14886 ::unity::IlInstance,
14887 crate::app::unit::Unit,
14888 crate::system::collections::generic::list_1::List_1<f32>,
14889 ::unity::OptionalMethod,
14890 ) -> f32 = ::core::mem::transmute(__mi.method_ptr);
14891 __inner(this.into(), unit, args, ::core::option::Option::None)
14892 }
14893
14894 #[doc = "Direct (non-virtual) call to `UnitCalculator_RangeEnemyCountCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
14895 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
14896 let __mi = Self::get_impl_method_info();
14897 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
14898 ::core::mem::transmute(__mi.method_ptr);
14899 __inner(this.into(), unit, ::core::option::Option::None)
14900 }
14901}
14902
14903#[cfg(feature = "app-unitcalculator")]
14904impl UnitCalculator_RangeEnemyCountCommand {
14905 #[doc = "`.ctor()` — no args"]
14906 pub fn new() -> Self {
14907 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
14908 panic!(
14909 "{}
14910::{}
14911 failed to instantiate",
14912 ::core::stringify!(UnitCalculator_RangeEnemyCountCommand),
14913 ::core::stringify!(new),
14914 )
14915 });
14916 <Self as IUnitCalculator_RangeEnemyCountCommandMethods>::ctor(this);
14917 this
14918 }
14919}
14920
14921#[cfg(feature = "app-unitcalculator")]
14922impl UnitCalculator {
14923 #[doc = "`GetItemEquipped(crate::app::unit::Unit)` overload"]
14924 pub fn get_item_equipped(unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> crate::app::unititem::UnitItem {
14925 unsafe {
14926 ::unity::il2cpp_call!((::unity::module_base()+0x1f724a0usize)as*mut u8,crate::app::unititem::UnitItem;
14927(crate::app::unit::Unit)::core::convert::Into::into(unit))
14928 }
14929 }
14930
14931 #[doc = "`HasForceUnit(i32, i32, crate::app::force::Force_Type)` overload"]
14932 pub fn has_force_unit(
14933 x: impl ::core::convert::Into<i32>,
14934 z: impl ::core::convert::Into<i32>,
14935 force_type: impl ::core::convert::Into<crate::app::force::Force_Type>,
14936 ) -> bool {
14937 unsafe {
14938 ::unity::il2cpp_call!((::unity::module_base()+0x1f72540usize)as*mut u8,bool;
14939(i32)::core::convert::Into::into(x),(i32)::core::convert::Into::into(z),(crate::app::force::Force_Type)::core::convert::Into::into(force_type))
14940 }
14941 }
14942
14943 #[doc = "`AddCommand(crate::app::gamecalculator::GameCalculator)` overload"]
14944 pub fn add_command(calculator: impl ::core::convert::Into<crate::app::gamecalculator::GameCalculator>) -> () {
14945 unsafe {
14946 ::unity::il2cpp_call!((::unity::module_base()+0x1f726a0usize)as*mut u8,();
14947(crate::app::gamecalculator::GameCalculator)::core::convert::Into::into(calculator))
14948 }
14949 }
14950}
14951
14952#[cfg(feature = "app-unitcalculator")]
14953pub trait IUnitCalculatorMethods: IUnitCalculator {
14954 #[doc = "`.ctor()` overload"]
14955 fn ctor(self) -> () {
14956 unsafe {
14957 let __receiver = <UnitCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
14958 ::unity::il2cpp_call!((::unity::module_base()+0x1f73a00usize)as*mut u8,();
14959(UnitCalculator)__receiver)
14960 }
14961 }
14962}
14963
14964#[cfg(feature = "app-unitcalculator")]
14965impl<__T: IUnitCalculator> IUnitCalculatorMethods for __T {}
14966
14967#[cfg(feature = "app-unitcalculator")]
14968impl UnitCalculator {
14969 pub fn get_item_equipped_method_info() -> &'static ::unity::il2cpp::MethodInfo {
14970 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
14971 }
14972
14973 pub fn has_force_unit_method_info() -> &'static ::unity::il2cpp::MethodInfo {
14974 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
14975 }
14976
14977 pub fn add_command_method_info() -> &'static ::unity::il2cpp::MethodInfo {
14978 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
14979 }
14980
14981 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
14982 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
14983 }
14984}
14985
14986#[cfg(feature = "app-unitcalculator")]
14987impl UnitCalculator {
14988 #[doc = "`.ctor()` — no args"]
14989 pub fn new() -> Self {
14990 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
14991 panic!(
14992 "{}
14993::{}
14994 failed to instantiate",
14995 ::core::stringify!(UnitCalculator),
14996 ::core::stringify!(new),
14997 )
14998 });
14999 <Self as IUnitCalculatorMethods>::ctor(this);
15000 this
15001 }
15002}
15003
15004#[cfg(feature = "app-unitcalculator")]
15005pub trait IUnitCalculator_BattleArenaCommandMethods: IUnitCalculator_BattleArenaCommand {
15006 #[doc = "`get_Name()` overload"]
15007 fn get_name(self) -> ::unity::Il2CppString {
15008 unsafe {
15009 let __receiver =
15010 <UnitCalculator_BattleArenaCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
15011 {
15012 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
15013 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
15014 panic!(
15015 "unity: virtual slot {}
15016 out of range (vtable len {}
15017) on the runtime class behind {}
15018 (method `{}
15019`)",
15020 4usize,
15021 __vt.len(),
15022 <UnitCalculator_BattleArenaCommand as ::unity::ClassIdentity>::NAME,
15023 "get_Name",
15024 )
15025 });
15026 let __inner: extern "C" fn(UnitCalculator_BattleArenaCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
15027 ::core::mem::transmute(__vi.method_ptr);
15028 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
15029 __inner(__receiver, __mi)
15030 }
15031 }
15032 }
15033 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
15034 fn get_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
15035 unsafe {
15036 let __receiver =
15037 <UnitCalculator_BattleArenaCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
15038 {
15039 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
15040 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
15041 panic!(
15042 "unity: virtual slot {}
15043 out of range (vtable len {}
15044) on the runtime class behind {}
15045 (method `{}
15046`)",
15047 31usize,
15048 __vt.len(),
15049 <UnitCalculator_BattleArenaCommand as ::unity::ClassIdentity>::NAME,
15050 "GetImpl",
15051 )
15052 });
15053 let __inner: extern "C" fn(
15054 UnitCalculator_BattleArenaCommand,
15055 crate::app::battleinfoside::BattleInfoSide,
15056 ::unity::OptionalMethod,
15057 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
15058 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
15059 __inner(__receiver, ::core::convert::Into::into(side), __mi)
15060 }
15061 }
15062 }
15063 #[doc = "`.ctor()` overload"]
15064 fn ctor(self) -> () {
15065 unsafe {
15066 let __receiver =
15067 <UnitCalculator_BattleArenaCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
15068 ::unity::il2cpp_call!((::unity::module_base()+0x1b45760usize)as*mut u8,();
15069(UnitCalculator_BattleArenaCommand)__receiver)
15070 }
15071 }
15072}
15073
15074#[cfg(feature = "app-unitcalculator")]
15075impl<__T: IUnitCalculator_BattleArenaCommand> IUnitCalculator_BattleArenaCommandMethods for __T {}
15076
15077#[cfg(feature = "app-unitcalculator")]
15078impl UnitCalculator_BattleArenaCommand {
15079 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
15080 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
15081 }
15082
15083 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
15084 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
15085 }
15086
15087 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
15088 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
15089 }
15090}
15091
15092#[cfg(feature = "app-unitcalculator")]
15093impl UnitCalculator_BattleArenaCommand {
15094 #[doc = "Direct (non-virtual) call to `UnitCalculator_BattleArenaCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
15095 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
15096 let __mi = Self::get_name_method_info();
15097 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
15098 __inner(this.into(), ::core::option::Option::None)
15099 }
15100
15101 #[doc = "Direct (non-virtual) call to `UnitCalculator_BattleArenaCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
15102 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
15103 let __mi = Self::get_impl_method_info();
15104 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
15105 ::core::mem::transmute(__mi.method_ptr);
15106 __inner(this.into(), side, ::core::option::Option::None)
15107 }
15108}
15109
15110#[cfg(feature = "app-unitcalculator")]
15111impl UnitCalculator_BattleArenaCommand {
15112 #[doc = "`.ctor()` — no args"]
15113 pub fn new() -> Self {
15114 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
15115 panic!(
15116 "{}
15117::{}
15118 failed to instantiate",
15119 ::core::stringify!(UnitCalculator_BattleArenaCommand),
15120 ::core::stringify!(new),
15121 )
15122 });
15123 <Self as IUnitCalculator_BattleArenaCommandMethods>::ctor(this);
15124 this
15125 }
15126}
15127
15128#[cfg(feature = "app-unitcalculator")]
15129pub trait IUnitCalculator_AvoidCommandMethods: IUnitCalculator_AvoidCommand {
15130 #[doc = "`get_Name()` overload"]
15131 fn get_name(self) -> ::unity::Il2CppString {
15132 unsafe {
15133 let __receiver =
15134 <UnitCalculator_AvoidCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
15135 {
15136 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
15137 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
15138 panic!(
15139 "unity: virtual slot {}
15140 out of range (vtable len {}
15141) on the runtime class behind {}
15142 (method `{}
15143`)",
15144 4usize,
15145 __vt.len(),
15146 <UnitCalculator_AvoidCommand as ::unity::ClassIdentity>::NAME,
15147 "get_Name",
15148 )
15149 });
15150 let __inner: extern "C" fn(UnitCalculator_AvoidCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
15151 ::core::mem::transmute(__vi.method_ptr);
15152 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
15153 __inner(__receiver, __mi)
15154 }
15155 }
15156 }
15157 #[doc = "`GetParam(crate::app::battleinfoside::BattleInfoSide)` overload"]
15158 fn get_param(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> crate::app::battleparam::BattleParam {
15159 unsafe {
15160 let __receiver =
15161 <UnitCalculator_AvoidCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
15162 {
15163 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
15164 let __vi = *__vt.get(44usize).unwrap_or_else(|| {
15165 panic!(
15166 "unity: virtual slot {}
15167 out of range (vtable len {}
15168) on the runtime class behind {}
15169 (method `{}
15170`)",
15171 44usize,
15172 __vt.len(),
15173 <UnitCalculator_AvoidCommand as ::unity::ClassIdentity>::NAME,
15174 "GetParam",
15175 )
15176 });
15177 let __inner: extern "C" fn(
15178 UnitCalculator_AvoidCommand,
15179 crate::app::battleinfoside::BattleInfoSide,
15180 ::unity::OptionalMethod,
15181 ) -> crate::app::battleparam::BattleParam = ::core::mem::transmute(__vi.method_ptr);
15182 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
15183 __inner(__receiver, ::core::convert::Into::into(side), __mi)
15184 }
15185 }
15186 }
15187 #[doc = "`IsVisible()` overload"]
15188 fn is_visible(self) -> bool {
15189 unsafe {
15190 let __receiver =
15191 <UnitCalculator_AvoidCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
15192 {
15193 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
15194 let __vi = *__vt.get(43usize).unwrap_or_else(|| {
15195 panic!(
15196 "unity: virtual slot {}
15197 out of range (vtable len {}
15198) on the runtime class behind {}
15199 (method `{}
15200`)",
15201 43usize,
15202 __vt.len(),
15203 <UnitCalculator_AvoidCommand as ::unity::ClassIdentity>::NAME,
15204 "IsVisible",
15205 )
15206 });
15207 let __inner: extern "C" fn(UnitCalculator_AvoidCommand, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
15208 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
15209 __inner(__receiver, __mi)
15210 }
15211 }
15212 }
15213 #[doc = "`.ctor()` overload"]
15214 fn ctor(self) -> () {
15215 unsafe {
15216 let __receiver =
15217 <UnitCalculator_AvoidCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
15218 ::unity::il2cpp_call!((::unity::module_base()+0x1b455c0usize)as*mut u8,();
15219(UnitCalculator_AvoidCommand)__receiver)
15220 }
15221 }
15222}
15223
15224#[cfg(feature = "app-unitcalculator")]
15225impl<__T: IUnitCalculator_AvoidCommand> IUnitCalculator_AvoidCommandMethods for __T {}
15226
15227#[cfg(feature = "app-unitcalculator")]
15228impl UnitCalculator_AvoidCommand {
15229 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
15230 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
15231 }
15232
15233 pub fn get_param_method_info() -> &'static ::unity::il2cpp::MethodInfo {
15234 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
15235 }
15236
15237 pub fn is_visible_method_info() -> &'static ::unity::il2cpp::MethodInfo {
15238 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
15239 }
15240
15241 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
15242 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
15243 }
15244}
15245
15246#[cfg(feature = "app-unitcalculator")]
15247impl UnitCalculator_AvoidCommand {
15248 #[doc = "Direct (non-virtual) call to `UnitCalculator_AvoidCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
15249 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
15250 let __mi = Self::get_name_method_info();
15251 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
15252 __inner(this.into(), ::core::option::Option::None)
15253 }
15254
15255 #[doc = "Direct (non-virtual) call to `UnitCalculator_AvoidCommand`'s own `GetParam`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
15256 pub unsafe fn get_param(
15257 this: impl ::core::convert::Into<::unity::IlInstance>,
15258 side: crate::app::battleinfoside::BattleInfoSide,
15259 ) -> crate::app::battleparam::BattleParam {
15260 let __mi = Self::get_param_method_info();
15261 let __inner: extern "C" fn(
15262 ::unity::IlInstance,
15263 crate::app::battleinfoside::BattleInfoSide,
15264 ::unity::OptionalMethod,
15265 ) -> crate::app::battleparam::BattleParam = ::core::mem::transmute(__mi.method_ptr);
15266 __inner(this.into(), side, ::core::option::Option::None)
15267 }
15268
15269 #[doc = "Direct (non-virtual) call to `UnitCalculator_AvoidCommand`'s own `IsVisible`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
15270 pub unsafe fn is_visible(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
15271 let __mi = Self::is_visible_method_info();
15272 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
15273 __inner(this.into(), ::core::option::Option::None)
15274 }
15275}
15276
15277#[cfg(feature = "app-unitcalculator")]
15278impl UnitCalculator_AvoidCommand {
15279 #[doc = "`.ctor()` — no args"]
15280 pub fn new() -> Self {
15281 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
15282 panic!(
15283 "{}
15284::{}
15285 failed to instantiate",
15286 ::core::stringify!(UnitCalculator_AvoidCommand),
15287 ::core::stringify!(new),
15288 )
15289 });
15290 <Self as IUnitCalculator_AvoidCommandMethods>::ctor(this);
15291 this
15292 }
15293}
15294
15295#[cfg(feature = "app-unitcalculator")]
15296pub trait IUnitCalculator_PosLowZCommandMethods: IUnitCalculator_PosLowZCommand {
15297 #[doc = "`get_Name()` overload"]
15298 fn get_name(self) -> ::unity::Il2CppString {
15299 unsafe {
15300 let __receiver =
15301 <UnitCalculator_PosLowZCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
15302 {
15303 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
15304 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
15305 panic!(
15306 "unity: virtual slot {}
15307 out of range (vtable len {}
15308) on the runtime class behind {}
15309 (method `{}
15310`)",
15311 4usize,
15312 __vt.len(),
15313 <UnitCalculator_PosLowZCommand as ::unity::ClassIdentity>::NAME,
15314 "get_Name",
15315 )
15316 });
15317 let __inner: extern "C" fn(UnitCalculator_PosLowZCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
15318 ::core::mem::transmute(__vi.method_ptr);
15319 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
15320 __inner(__receiver, __mi)
15321 }
15322 }
15323 }
15324 #[doc = "`.ctor()` overload"]
15325 fn ctor(self) -> () {
15326 unsafe {
15327 let __receiver =
15328 <UnitCalculator_PosLowZCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
15329 ::unity::il2cpp_call!((::unity::module_base()+0x1b4aba0usize)as*mut u8,();
15330(UnitCalculator_PosLowZCommand)__receiver)
15331 }
15332 }
15333}
15334
15335#[cfg(feature = "app-unitcalculator")]
15336impl<__T: IUnitCalculator_PosLowZCommand> IUnitCalculator_PosLowZCommandMethods for __T {}
15337
15338#[cfg(feature = "app-unitcalculator")]
15339impl UnitCalculator_PosLowZCommand {
15340 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
15341 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
15342 }
15343
15344 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
15345 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
15346 }
15347}
15348
15349#[cfg(feature = "app-unitcalculator")]
15350impl UnitCalculator_PosLowZCommand {
15351 #[doc = "Direct (non-virtual) call to `UnitCalculator_PosLowZCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
15352 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
15353 let __mi = Self::get_name_method_info();
15354 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
15355 __inner(this.into(), ::core::option::Option::None)
15356 }
15357}
15358
15359#[cfg(feature = "app-unitcalculator")]
15360impl UnitCalculator_PosLowZCommand {
15361 #[doc = "`.ctor()` — no args"]
15362 pub fn new() -> Self {
15363 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
15364 panic!(
15365 "{}
15366::{}
15367 failed to instantiate",
15368 ::core::stringify!(UnitCalculator_PosLowZCommand),
15369 ::core::stringify!(new),
15370 )
15371 });
15372 <Self as IUnitCalculator_PosLowZCommandMethods>::ctor(this);
15373 this
15374 }
15375}
15376
15377#[cfg(feature = "app-unitcalculator")]
15378pub trait IUnitCalculator_GainGoldCommandMethods: IUnitCalculator_GainGoldCommand {
15379 #[doc = "`get_Name()` overload"]
15380 fn get_name(self) -> ::unity::Il2CppString {
15381 unsafe {
15382 let __receiver =
15383 <UnitCalculator_GainGoldCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
15384 {
15385 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
15386 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
15387 panic!(
15388 "unity: virtual slot {}
15389 out of range (vtable len {}
15390) on the runtime class behind {}
15391 (method `{}
15392`)",
15393 4usize,
15394 __vt.len(),
15395 <UnitCalculator_GainGoldCommand as ::unity::ClassIdentity>::NAME,
15396 "get_Name",
15397 )
15398 });
15399 let __inner: extern "C" fn(UnitCalculator_GainGoldCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
15400 ::core::mem::transmute(__vi.method_ptr);
15401 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
15402 __inner(__receiver, __mi)
15403 }
15404 }
15405 }
15406 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
15407 fn get_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
15408 unsafe {
15409 let __receiver =
15410 <UnitCalculator_GainGoldCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
15411 {
15412 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
15413 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
15414 panic!(
15415 "unity: virtual slot {}
15416 out of range (vtable len {}
15417) on the runtime class behind {}
15418 (method `{}
15419`)",
15420 31usize,
15421 __vt.len(),
15422 <UnitCalculator_GainGoldCommand as ::unity::ClassIdentity>::NAME,
15423 "GetImpl",
15424 )
15425 });
15426 let __inner: extern "C" fn(
15427 UnitCalculator_GainGoldCommand,
15428 crate::app::battleinfoside::BattleInfoSide,
15429 ::unity::OptionalMethod,
15430 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
15431 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
15432 __inner(__receiver, ::core::convert::Into::into(side), __mi)
15433 }
15434 }
15435 }
15436 #[doc = "`SetImpl(crate::app::battleinfoside::BattleInfoSide, f32)` overload"]
15437 fn set_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>, value: impl ::core::convert::Into<f32>) -> () {
15438 unsafe {
15439 let __receiver =
15440 <UnitCalculator_GainGoldCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
15441 {
15442 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
15443 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
15444 panic!(
15445 "unity: virtual slot {}
15446 out of range (vtable len {}
15447) on the runtime class behind {}
15448 (method `{}
15449`)",
15450 33usize,
15451 __vt.len(),
15452 <UnitCalculator_GainGoldCommand as ::unity::ClassIdentity>::NAME,
15453 "SetImpl",
15454 )
15455 });
15456 let __inner: extern "C" fn(
15457 UnitCalculator_GainGoldCommand,
15458 crate::app::battleinfoside::BattleInfoSide,
15459 f32,
15460 ::unity::OptionalMethod,
15461 ) -> () = ::core::mem::transmute(__vi.method_ptr);
15462 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
15463 __inner(__receiver, ::core::convert::Into::into(side), ::core::convert::Into::into(value), __mi)
15464 }
15465 }
15466 }
15467 #[doc = "`.ctor()` overload"]
15468 fn ctor(self) -> () {
15469 unsafe {
15470 let __receiver =
15471 <UnitCalculator_GainGoldCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
15472 ::unity::il2cpp_call!((::unity::module_base()+0x1b47a20usize)as*mut u8,();
15473(UnitCalculator_GainGoldCommand)__receiver)
15474 }
15475 }
15476}
15477
15478#[cfg(feature = "app-unitcalculator")]
15479impl<__T: IUnitCalculator_GainGoldCommand> IUnitCalculator_GainGoldCommandMethods for __T {}
15480
15481#[cfg(feature = "app-unitcalculator")]
15482impl UnitCalculator_GainGoldCommand {
15483 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
15484 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
15485 }
15486
15487 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
15488 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
15489 }
15490
15491 pub fn set_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
15492 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
15493 }
15494
15495 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
15496 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
15497 }
15498}
15499
15500#[cfg(feature = "app-unitcalculator")]
15501impl UnitCalculator_GainGoldCommand {
15502 #[doc = "Direct (non-virtual) call to `UnitCalculator_GainGoldCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
15503 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
15504 let __mi = Self::get_name_method_info();
15505 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
15506 __inner(this.into(), ::core::option::Option::None)
15507 }
15508
15509 #[doc = "Direct (non-virtual) call to `UnitCalculator_GainGoldCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
15510 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
15511 let __mi = Self::get_impl_method_info();
15512 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
15513 ::core::mem::transmute(__mi.method_ptr);
15514 __inner(this.into(), side, ::core::option::Option::None)
15515 }
15516
15517 #[doc = "Direct (non-virtual) call to `UnitCalculator_GainGoldCommand`'s own `SetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
15518 pub unsafe fn set_impl(
15519 this: impl ::core::convert::Into<::unity::IlInstance>,
15520 side: crate::app::battleinfoside::BattleInfoSide,
15521 value: f32,
15522 ) -> () {
15523 let __mi = Self::set_impl_method_info();
15524 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, f32, ::unity::OptionalMethod) -> () =
15525 ::core::mem::transmute(__mi.method_ptr);
15526 __inner(this.into(), side, value, ::core::option::Option::None)
15527 }
15528}
15529
15530#[cfg(feature = "app-unitcalculator")]
15531impl UnitCalculator_GainGoldCommand {
15532 #[doc = "`.ctor()` — no args"]
15533 pub fn new() -> Self {
15534 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
15535 panic!(
15536 "{}
15537::{}
15538 failed to instantiate",
15539 ::core::stringify!(UnitCalculator_GainGoldCommand),
15540 ::core::stringify!(new),
15541 )
15542 });
15543 <Self as IUnitCalculator_GainGoldCommandMethods>::ctor(this);
15544 this
15545 }
15546}
15547
15548#[cfg(feature = "app-unitcalculator")]
15549pub trait IUnitCalculator_RelianceAroundTotalCommandMethods: IUnitCalculator_RelianceAroundTotalCommand {
15550 #[doc = "`get_Name()` overload"]
15551 fn get_name(self) -> ::unity::Il2CppString {
15552 unsafe {
15553 let __receiver = <UnitCalculator_RelianceAroundTotalCommand as ::unity::FromIlInstance>::from_il_instance(
15554 <Self as ::unity::SystemObject>::as_instance(self),
15555 );
15556 {
15557 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
15558 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
15559 panic!(
15560 "unity: virtual slot {}
15561 out of range (vtable len {}
15562) on the runtime class behind {}
15563 (method `{}
15564`)",
15565 4usize,
15566 __vt.len(),
15567 <UnitCalculator_RelianceAroundTotalCommand as ::unity::ClassIdentity>::NAME,
15568 "get_Name",
15569 )
15570 });
15571 let __inner: extern "C" fn(UnitCalculator_RelianceAroundTotalCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
15572 ::core::mem::transmute(__vi.method_ptr);
15573 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
15574 __inner(__receiver, __mi)
15575 }
15576 }
15577 }
15578 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
15579 fn get_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
15580 unsafe {
15581 let __receiver = <UnitCalculator_RelianceAroundTotalCommand as ::unity::FromIlInstance>::from_il_instance(
15582 <Self as ::unity::SystemObject>::as_instance(self),
15583 );
15584 {
15585 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
15586 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
15587 panic!(
15588 "unity: virtual slot {}
15589 out of range (vtable len {}
15590) on the runtime class behind {}
15591 (method `{}
15592`)",
15593 30usize,
15594 __vt.len(),
15595 <UnitCalculator_RelianceAroundTotalCommand as ::unity::ClassIdentity>::NAME,
15596 "GetImpl",
15597 )
15598 });
15599 let __inner: extern "C" fn(UnitCalculator_RelianceAroundTotalCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
15600 ::core::mem::transmute(__vi.method_ptr);
15601 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
15602 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
15603 }
15604 }
15605 }
15606 #[doc = "`.ctor()` overload"]
15607 fn ctor(self) -> () {
15608 unsafe {
15609 let __receiver = <UnitCalculator_RelianceAroundTotalCommand as ::unity::FromIlInstance>::from_il_instance(
15610 <Self as ::unity::SystemObject>::as_instance(self),
15611 );
15612 ::unity::il2cpp_call!((::unity::module_base()+0x1b4b990usize)as*mut u8,();
15613(UnitCalculator_RelianceAroundTotalCommand)__receiver)
15614 }
15615 }
15616}
15617
15618#[cfg(feature = "app-unitcalculator")]
15619impl<__T: IUnitCalculator_RelianceAroundTotalCommand> IUnitCalculator_RelianceAroundTotalCommandMethods for __T {}
15620
15621#[cfg(feature = "app-unitcalculator")]
15622impl UnitCalculator_RelianceAroundTotalCommand {
15623 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
15624 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
15625 }
15626
15627 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
15628 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
15629 }
15630
15631 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
15632 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
15633 }
15634}
15635
15636#[cfg(feature = "app-unitcalculator")]
15637impl UnitCalculator_RelianceAroundTotalCommand {
15638 #[doc = "Direct (non-virtual) call to `UnitCalculator_RelianceAroundTotalCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
15639 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
15640 let __mi = Self::get_name_method_info();
15641 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
15642 __inner(this.into(), ::core::option::Option::None)
15643 }
15644
15645 #[doc = "Direct (non-virtual) call to `UnitCalculator_RelianceAroundTotalCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
15646 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
15647 let __mi = Self::get_impl_method_info();
15648 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
15649 ::core::mem::transmute(__mi.method_ptr);
15650 __inner(this.into(), unit, ::core::option::Option::None)
15651 }
15652}
15653
15654#[cfg(feature = "app-unitcalculator")]
15655impl UnitCalculator_RelianceAroundTotalCommand {
15656 #[doc = "`.ctor()` — no args"]
15657 pub fn new() -> Self {
15658 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
15659 panic!(
15660 "{}
15661::{}
15662 failed to instantiate",
15663 ::core::stringify!(UnitCalculator_RelianceAroundTotalCommand),
15664 ::core::stringify!(new),
15665 )
15666 });
15667 <Self as IUnitCalculator_RelianceAroundTotalCommandMethods>::ctor(this);
15668 this
15669 }
15670}
15671
15672#[cfg(feature = "app-unitcalculator")]
15673pub trait IUnitCalculator_LinkStrCommandMethods: IUnitCalculator_LinkStrCommand {
15674 #[doc = "`get_Name()` overload"]
15675 fn get_name(self) -> ::unity::Il2CppString {
15676 unsafe {
15677 let __receiver =
15678 <UnitCalculator_LinkStrCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
15679 {
15680 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
15681 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
15682 panic!(
15683 "unity: virtual slot {}
15684 out of range (vtable len {}
15685) on the runtime class behind {}
15686 (method `{}
15687`)",
15688 4usize,
15689 __vt.len(),
15690 <UnitCalculator_LinkStrCommand as ::unity::ClassIdentity>::NAME,
15691 "get_Name",
15692 )
15693 });
15694 let __inner: extern "C" fn(UnitCalculator_LinkStrCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
15695 ::core::mem::transmute(__vi.method_ptr);
15696 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
15697 __inner(__receiver, __mi)
15698 }
15699 }
15700 }
15701 #[doc = "`get_CapabilityType()` overload"]
15702 fn get_capability_type(self) -> crate::app::capabilitydefinition::CapabilityDefinition_Type {
15703 unsafe {
15704 let __receiver =
15705 <UnitCalculator_LinkStrCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
15706 {
15707 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
15708 let __vi = *__vt.get(44usize).unwrap_or_else(|| {
15709 panic!(
15710 "unity: virtual slot {}
15711 out of range (vtable len {}
15712) on the runtime class behind {}
15713 (method `{}
15714`)",
15715 44usize,
15716 __vt.len(),
15717 <UnitCalculator_LinkStrCommand as ::unity::ClassIdentity>::NAME,
15718 "get_CapabilityType",
15719 )
15720 });
15721 let __inner: extern "C" fn(
15722 UnitCalculator_LinkStrCommand,
15723 ::unity::OptionalMethod,
15724 ) -> crate::app::capabilitydefinition::CapabilityDefinition_Type = ::core::mem::transmute(__vi.method_ptr);
15725 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
15726 __inner(__receiver, __mi)
15727 }
15728 }
15729 }
15730 #[doc = "`.ctor()` overload"]
15731 fn ctor(self) -> () {
15732 unsafe {
15733 let __receiver =
15734 <UnitCalculator_LinkStrCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
15735 ::unity::il2cpp_call!((::unity::module_base()+0x1b48cd0usize)as*mut u8,();
15736(UnitCalculator_LinkStrCommand)__receiver)
15737 }
15738 }
15739}
15740
15741#[cfg(feature = "app-unitcalculator")]
15742impl<__T: IUnitCalculator_LinkStrCommand> IUnitCalculator_LinkStrCommandMethods for __T {}
15743
15744#[cfg(feature = "app-unitcalculator")]
15745impl UnitCalculator_LinkStrCommand {
15746 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
15747 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
15748 }
15749
15750 pub fn get_capability_type_method_info() -> &'static ::unity::il2cpp::MethodInfo {
15751 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
15752 }
15753
15754 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
15755 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
15756 }
15757}
15758
15759#[cfg(feature = "app-unitcalculator")]
15760impl UnitCalculator_LinkStrCommand {
15761 #[doc = "Direct (non-virtual) call to `UnitCalculator_LinkStrCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
15762 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
15763 let __mi = Self::get_name_method_info();
15764 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
15765 __inner(this.into(), ::core::option::Option::None)
15766 }
15767
15768 #[doc = "Direct (non-virtual) call to `UnitCalculator_LinkStrCommand`'s own `get_CapabilityType`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
15769 pub unsafe fn get_capability_type(
15770 this: impl ::core::convert::Into<::unity::IlInstance>,
15771 ) -> crate::app::capabilitydefinition::CapabilityDefinition_Type {
15772 let __mi = Self::get_capability_type_method_info();
15773 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::capabilitydefinition::CapabilityDefinition_Type =
15774 ::core::mem::transmute(__mi.method_ptr);
15775 __inner(this.into(), ::core::option::Option::None)
15776 }
15777}
15778
15779#[cfg(feature = "app-unitcalculator")]
15780impl UnitCalculator_LinkStrCommand {
15781 #[doc = "`.ctor()` — no args"]
15782 pub fn new() -> Self {
15783 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
15784 panic!(
15785 "{}
15786::{}
15787 failed to instantiate",
15788 ::core::stringify!(UnitCalculator_LinkStrCommand),
15789 ::core::stringify!(new),
15790 )
15791 });
15792 <Self as IUnitCalculator_LinkStrCommandMethods>::ctor(this);
15793 this
15794 }
15795}
15796
15797#[cfg(feature = "app-unitcalculator")]
15798pub trait IUnitCalculator_BlowRatioCommandMethods: IUnitCalculator_BlowRatioCommand {
15799 #[doc = "`get_Name()` overload"]
15800 fn get_name(self) -> ::unity::Il2CppString {
15801 unsafe {
15802 let __receiver =
15803 <UnitCalculator_BlowRatioCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
15804 {
15805 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
15806 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
15807 panic!(
15808 "unity: virtual slot {}
15809 out of range (vtable len {}
15810) on the runtime class behind {}
15811 (method `{}
15812`)",
15813 4usize,
15814 __vt.len(),
15815 <UnitCalculator_BlowRatioCommand as ::unity::ClassIdentity>::NAME,
15816 "get_Name",
15817 )
15818 });
15819 let __inner: extern "C" fn(UnitCalculator_BlowRatioCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
15820 ::core::mem::transmute(__vi.method_ptr);
15821 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
15822 __inner(__receiver, __mi)
15823 }
15824 }
15825 }
15826 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
15827 fn get_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
15828 unsafe {
15829 let __receiver =
15830 <UnitCalculator_BlowRatioCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
15831 {
15832 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
15833 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
15834 panic!(
15835 "unity: virtual slot {}
15836 out of range (vtable len {}
15837) on the runtime class behind {}
15838 (method `{}
15839`)",
15840 31usize,
15841 __vt.len(),
15842 <UnitCalculator_BlowRatioCommand as ::unity::ClassIdentity>::NAME,
15843 "GetImpl",
15844 )
15845 });
15846 let __inner: extern "C" fn(
15847 UnitCalculator_BlowRatioCommand,
15848 crate::app::battleinfoside::BattleInfoSide,
15849 ::unity::OptionalMethod,
15850 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
15851 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
15852 __inner(__receiver, ::core::convert::Into::into(side), __mi)
15853 }
15854 }
15855 }
15856 #[doc = "`SetImpl(crate::app::battleinfoside::BattleInfoSide, f32)` overload"]
15857 fn set_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>, value: impl ::core::convert::Into<f32>) -> () {
15858 unsafe {
15859 let __receiver =
15860 <UnitCalculator_BlowRatioCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
15861 {
15862 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
15863 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
15864 panic!(
15865 "unity: virtual slot {}
15866 out of range (vtable len {}
15867) on the runtime class behind {}
15868 (method `{}
15869`)",
15870 33usize,
15871 __vt.len(),
15872 <UnitCalculator_BlowRatioCommand as ::unity::ClassIdentity>::NAME,
15873 "SetImpl",
15874 )
15875 });
15876 let __inner: extern "C" fn(
15877 UnitCalculator_BlowRatioCommand,
15878 crate::app::battleinfoside::BattleInfoSide,
15879 f32,
15880 ::unity::OptionalMethod,
15881 ) -> () = ::core::mem::transmute(__vi.method_ptr);
15882 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
15883 __inner(__receiver, ::core::convert::Into::into(side), ::core::convert::Into::into(value), __mi)
15884 }
15885 }
15886 }
15887 #[doc = "`.ctor()` overload"]
15888 fn ctor(self) -> () {
15889 unsafe {
15890 let __receiver =
15891 <UnitCalculator_BlowRatioCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
15892 ::unity::il2cpp_call!((::unity::module_base()+0x1b46930usize)as*mut u8,();
15893(UnitCalculator_BlowRatioCommand)__receiver)
15894 }
15895 }
15896}
15897
15898#[cfg(feature = "app-unitcalculator")]
15899impl<__T: IUnitCalculator_BlowRatioCommand> IUnitCalculator_BlowRatioCommandMethods for __T {}
15900
15901#[cfg(feature = "app-unitcalculator")]
15902impl UnitCalculator_BlowRatioCommand {
15903 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
15904 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
15905 }
15906
15907 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
15908 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
15909 }
15910
15911 pub fn set_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
15912 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
15913 }
15914
15915 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
15916 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
15917 }
15918}
15919
15920#[cfg(feature = "app-unitcalculator")]
15921impl UnitCalculator_BlowRatioCommand {
15922 #[doc = "Direct (non-virtual) call to `UnitCalculator_BlowRatioCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
15923 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
15924 let __mi = Self::get_name_method_info();
15925 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
15926 __inner(this.into(), ::core::option::Option::None)
15927 }
15928
15929 #[doc = "Direct (non-virtual) call to `UnitCalculator_BlowRatioCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
15930 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
15931 let __mi = Self::get_impl_method_info();
15932 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
15933 ::core::mem::transmute(__mi.method_ptr);
15934 __inner(this.into(), side, ::core::option::Option::None)
15935 }
15936
15937 #[doc = "Direct (non-virtual) call to `UnitCalculator_BlowRatioCommand`'s own `SetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
15938 pub unsafe fn set_impl(
15939 this: impl ::core::convert::Into<::unity::IlInstance>,
15940 side: crate::app::battleinfoside::BattleInfoSide,
15941 value: f32,
15942 ) -> () {
15943 let __mi = Self::set_impl_method_info();
15944 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, f32, ::unity::OptionalMethod) -> () =
15945 ::core::mem::transmute(__mi.method_ptr);
15946 __inner(this.into(), side, value, ::core::option::Option::None)
15947 }
15948}
15949
15950#[cfg(feature = "app-unitcalculator")]
15951impl UnitCalculator_BlowRatioCommand {
15952 #[doc = "`.ctor()` — no args"]
15953 pub fn new() -> Self {
15954 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
15955 panic!(
15956 "{}
15957::{}
15958 failed to instantiate",
15959 ::core::stringify!(UnitCalculator_BlowRatioCommand),
15960 ::core::stringify!(new),
15961 )
15962 });
15963 <Self as IUnitCalculator_BlowRatioCommandMethods>::ctor(this);
15964 this
15965 }
15966}
15967
15968#[cfg(feature = "app-unitcalculator")]
15969pub trait IUnitCalculator_PosXCommandMethods: IUnitCalculator_PosXCommand {
15970 #[doc = "`get_Name()` overload"]
15971 fn get_name(self) -> ::unity::Il2CppString {
15972 unsafe {
15973 let __receiver =
15974 <UnitCalculator_PosXCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
15975 {
15976 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
15977 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
15978 panic!(
15979 "unity: virtual slot {}
15980 out of range (vtable len {}
15981) on the runtime class behind {}
15982 (method `{}
15983`)",
15984 4usize,
15985 __vt.len(),
15986 <UnitCalculator_PosXCommand as ::unity::ClassIdentity>::NAME,
15987 "get_Name",
15988 )
15989 });
15990 let __inner: extern "C" fn(UnitCalculator_PosXCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
15991 ::core::mem::transmute(__vi.method_ptr);
15992 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
15993 __inner(__receiver, __mi)
15994 }
15995 }
15996 }
15997 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
15998 fn get_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
15999 unsafe {
16000 let __receiver =
16001 <UnitCalculator_PosXCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
16002 {
16003 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
16004 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
16005 panic!(
16006 "unity: virtual slot {}
16007 out of range (vtable len {}
16008) on the runtime class behind {}
16009 (method `{}
16010`)",
16011 30usize,
16012 __vt.len(),
16013 <UnitCalculator_PosXCommand as ::unity::ClassIdentity>::NAME,
16014 "GetImpl",
16015 )
16016 });
16017 let __inner: extern "C" fn(UnitCalculator_PosXCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
16018 ::core::mem::transmute(__vi.method_ptr);
16019 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
16020 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
16021 }
16022 }
16023 }
16024 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
16025 fn get_impl_2(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
16026 unsafe {
16027 let __receiver =
16028 <UnitCalculator_PosXCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
16029 {
16030 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
16031 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
16032 panic!(
16033 "unity: virtual slot {}
16034 out of range (vtable len {}
16035) on the runtime class behind {}
16036 (method `{}
16037`)",
16038 31usize,
16039 __vt.len(),
16040 <UnitCalculator_PosXCommand as ::unity::ClassIdentity>::NAME,
16041 "GetImpl",
16042 )
16043 });
16044 let __inner: extern "C" fn(UnitCalculator_PosXCommand, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
16045 ::core::mem::transmute(__vi.method_ptr);
16046 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
16047 __inner(__receiver, ::core::convert::Into::into(side), __mi)
16048 }
16049 }
16050 }
16051 #[doc = "`GetInvalid()` overload"]
16052 fn get_invalid(self) -> f32 {
16053 unsafe {
16054 let __receiver =
16055 <UnitCalculator_PosXCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
16056 {
16057 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
16058 let __vi = *__vt.get(42usize).unwrap_or_else(|| {
16059 panic!(
16060 "unity: virtual slot {}
16061 out of range (vtable len {}
16062) on the runtime class behind {}
16063 (method `{}
16064`)",
16065 42usize,
16066 __vt.len(),
16067 <UnitCalculator_PosXCommand as ::unity::ClassIdentity>::NAME,
16068 "GetInvalid",
16069 )
16070 });
16071 let __inner: extern "C" fn(UnitCalculator_PosXCommand, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__vi.method_ptr);
16072 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
16073 __inner(__receiver, __mi)
16074 }
16075 }
16076 }
16077 #[doc = "`.ctor()` overload"]
16078 fn ctor(self) -> () {
16079 unsafe {
16080 let __receiver =
16081 <UnitCalculator_PosXCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
16082 ::unity::il2cpp_call!((::unity::module_base()+0x1b4ab40usize)as*mut u8,();
16083(UnitCalculator_PosXCommand)__receiver)
16084 }
16085 }
16086}
16087
16088#[cfg(feature = "app-unitcalculator")]
16089impl<__T: IUnitCalculator_PosXCommand> IUnitCalculator_PosXCommandMethods for __T {}
16090
16091#[cfg(feature = "app-unitcalculator")]
16092impl UnitCalculator_PosXCommand {
16093 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
16094 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
16095 }
16096
16097 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
16098 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
16099 }
16100
16101 pub fn get_impl_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
16102 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
16103 }
16104
16105 pub fn get_invalid_method_info() -> &'static ::unity::il2cpp::MethodInfo {
16106 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
16107 }
16108
16109 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
16110 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
16111 }
16112}
16113
16114#[cfg(feature = "app-unitcalculator")]
16115impl UnitCalculator_PosXCommand {
16116 #[doc = "Direct (non-virtual) call to `UnitCalculator_PosXCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
16117 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
16118 let __mi = Self::get_name_method_info();
16119 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
16120 __inner(this.into(), ::core::option::Option::None)
16121 }
16122
16123 #[doc = "Direct (non-virtual) call to `UnitCalculator_PosXCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
16124 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
16125 let __mi = Self::get_impl_method_info();
16126 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
16127 ::core::mem::transmute(__mi.method_ptr);
16128 __inner(this.into(), unit, ::core::option::Option::None)
16129 }
16130
16131 #[doc = "Direct (non-virtual) call to `UnitCalculator_PosXCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
16132 pub unsafe fn get_impl_2(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
16133 let __mi = Self::get_impl_2_method_info();
16134 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
16135 ::core::mem::transmute(__mi.method_ptr);
16136 __inner(this.into(), side, ::core::option::Option::None)
16137 }
16138
16139 #[doc = "Direct (non-virtual) call to `UnitCalculator_PosXCommand`'s own `GetInvalid`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
16140 pub unsafe fn get_invalid(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
16141 let __mi = Self::get_invalid_method_info();
16142 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
16143 __inner(this.into(), ::core::option::Option::None)
16144 }
16145}
16146
16147#[cfg(feature = "app-unitcalculator")]
16148impl UnitCalculator_PosXCommand {
16149 #[doc = "`.ctor()` — no args"]
16150 pub fn new() -> Self {
16151 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
16152 panic!(
16153 "{}
16154::{}
16155 failed to instantiate",
16156 ::core::stringify!(UnitCalculator_PosXCommand),
16157 ::core::stringify!(new),
16158 )
16159 });
16160 <Self as IUnitCalculator_PosXCommandMethods>::ctor(this);
16161 this
16162 }
16163}
16164
16165#[cfg(feature = "app-unitcalculator")]
16166pub trait IUnitCalculator_BattleChainAttackCountCommandMethods: IUnitCalculator_BattleChainAttackCountCommand {
16167 #[doc = "`get_Name()` overload"]
16168 fn get_name(self) -> ::unity::Il2CppString {
16169 unsafe {
16170 let __receiver = <UnitCalculator_BattleChainAttackCountCommand as ::unity::FromIlInstance>::from_il_instance(
16171 <Self as ::unity::SystemObject>::as_instance(self),
16172 );
16173 {
16174 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
16175 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
16176 panic!(
16177 "unity: virtual slot {}
16178 out of range (vtable len {}
16179) on the runtime class behind {}
16180 (method `{}
16181`)",
16182 4usize,
16183 __vt.len(),
16184 <UnitCalculator_BattleChainAttackCountCommand as ::unity::ClassIdentity>::NAME,
16185 "get_Name",
16186 )
16187 });
16188 let __inner: extern "C" fn(UnitCalculator_BattleChainAttackCountCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
16189 ::core::mem::transmute(__vi.method_ptr);
16190 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
16191 __inner(__receiver, __mi)
16192 }
16193 }
16194 }
16195 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
16196 fn get_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
16197 unsafe {
16198 let __receiver = <UnitCalculator_BattleChainAttackCountCommand as ::unity::FromIlInstance>::from_il_instance(
16199 <Self as ::unity::SystemObject>::as_instance(self),
16200 );
16201 {
16202 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
16203 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
16204 panic!(
16205 "unity: virtual slot {}
16206 out of range (vtable len {}
16207) on the runtime class behind {}
16208 (method `{}
16209`)",
16210 31usize,
16211 __vt.len(),
16212 <UnitCalculator_BattleChainAttackCountCommand as ::unity::ClassIdentity>::NAME,
16213 "GetImpl",
16214 )
16215 });
16216 let __inner: extern "C" fn(
16217 UnitCalculator_BattleChainAttackCountCommand,
16218 crate::app::battleinfoside::BattleInfoSide,
16219 ::unity::OptionalMethod,
16220 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
16221 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
16222 __inner(__receiver, ::core::convert::Into::into(side), __mi)
16223 }
16224 }
16225 }
16226 #[doc = "`.ctor()` overload"]
16227 fn ctor(self) -> () {
16228 unsafe {
16229 let __receiver = <UnitCalculator_BattleChainAttackCountCommand as ::unity::FromIlInstance>::from_il_instance(
16230 <Self as ::unity::SystemObject>::as_instance(self),
16231 );
16232 ::unity::il2cpp_call!((::unity::module_base()+0x1b457d0usize)as*mut u8,();
16233(UnitCalculator_BattleChainAttackCountCommand)__receiver)
16234 }
16235 }
16236}
16237
16238#[cfg(feature = "app-unitcalculator")]
16239impl<__T: IUnitCalculator_BattleChainAttackCountCommand> IUnitCalculator_BattleChainAttackCountCommandMethods for __T {}
16240
16241#[cfg(feature = "app-unitcalculator")]
16242impl UnitCalculator_BattleChainAttackCountCommand {
16243 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
16244 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
16245 }
16246
16247 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
16248 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
16249 }
16250
16251 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
16252 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
16253 }
16254}
16255
16256#[cfg(feature = "app-unitcalculator")]
16257impl UnitCalculator_BattleChainAttackCountCommand {
16258 #[doc = "Direct (non-virtual) call to `UnitCalculator_BattleChainAttackCountCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
16259 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
16260 let __mi = Self::get_name_method_info();
16261 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
16262 __inner(this.into(), ::core::option::Option::None)
16263 }
16264
16265 #[doc = "Direct (non-virtual) call to `UnitCalculator_BattleChainAttackCountCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
16266 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
16267 let __mi = Self::get_impl_method_info();
16268 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
16269 ::core::mem::transmute(__mi.method_ptr);
16270 __inner(this.into(), side, ::core::option::Option::None)
16271 }
16272}
16273
16274#[cfg(feature = "app-unitcalculator")]
16275impl UnitCalculator_BattleChainAttackCountCommand {
16276 #[doc = "`.ctor()` — no args"]
16277 pub fn new() -> Self {
16278 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
16279 panic!(
16280 "{}
16281::{}
16282 failed to instantiate",
16283 ::core::stringify!(UnitCalculator_BattleChainAttackCountCommand),
16284 ::core::stringify!(new),
16285 )
16286 });
16287 <Self as IUnitCalculator_BattleChainAttackCountCommandMethods>::ctor(this);
16288 this
16289 }
16290}
16291
16292#[cfg(feature = "app-unitcalculator")]
16293pub trait IUnitCalculator_QuickCommandMethods: IUnitCalculator_QuickCommand {
16294 #[doc = "`get_Name()` overload"]
16295 fn get_name(self) -> ::unity::Il2CppString {
16296 unsafe {
16297 let __receiver =
16298 <UnitCalculator_QuickCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
16299 {
16300 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
16301 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
16302 panic!(
16303 "unity: virtual slot {}
16304 out of range (vtable len {}
16305) on the runtime class behind {}
16306 (method `{}
16307`)",
16308 4usize,
16309 __vt.len(),
16310 <UnitCalculator_QuickCommand as ::unity::ClassIdentity>::NAME,
16311 "get_Name",
16312 )
16313 });
16314 let __inner: extern "C" fn(UnitCalculator_QuickCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
16315 ::core::mem::transmute(__vi.method_ptr);
16316 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
16317 __inner(__receiver, __mi)
16318 }
16319 }
16320 }
16321 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
16322 fn get_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
16323 unsafe {
16324 let __receiver =
16325 <UnitCalculator_QuickCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
16326 {
16327 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
16328 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
16329 panic!(
16330 "unity: virtual slot {}
16331 out of range (vtable len {}
16332) on the runtime class behind {}
16333 (method `{}
16334`)",
16335 30usize,
16336 __vt.len(),
16337 <UnitCalculator_QuickCommand as ::unity::ClassIdentity>::NAME,
16338 "GetImpl",
16339 )
16340 });
16341 let __inner: extern "C" fn(UnitCalculator_QuickCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
16342 ::core::mem::transmute(__vi.method_ptr);
16343 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
16344 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
16345 }
16346 }
16347 }
16348 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
16349 fn get_impl_2(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
16350 unsafe {
16351 let __receiver =
16352 <UnitCalculator_QuickCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
16353 {
16354 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
16355 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
16356 panic!(
16357 "unity: virtual slot {}
16358 out of range (vtable len {}
16359) on the runtime class behind {}
16360 (method `{}
16361`)",
16362 31usize,
16363 __vt.len(),
16364 <UnitCalculator_QuickCommand as ::unity::ClassIdentity>::NAME,
16365 "GetImpl",
16366 )
16367 });
16368 let __inner: extern "C" fn(UnitCalculator_QuickCommand, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
16369 ::core::mem::transmute(__vi.method_ptr);
16370 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
16371 __inner(__receiver, ::core::convert::Into::into(side), __mi)
16372 }
16373 }
16374 }
16375 #[doc = "`SetImpl(crate::app::battleinfoside::BattleInfoSide, f32)` overload"]
16376 fn set_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>, value: impl ::core::convert::Into<f32>) -> () {
16377 unsafe {
16378 let __receiver =
16379 <UnitCalculator_QuickCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
16380 {
16381 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
16382 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
16383 panic!(
16384 "unity: virtual slot {}
16385 out of range (vtable len {}
16386) on the runtime class behind {}
16387 (method `{}
16388`)",
16389 33usize,
16390 __vt.len(),
16391 <UnitCalculator_QuickCommand as ::unity::ClassIdentity>::NAME,
16392 "SetImpl",
16393 )
16394 });
16395 let __inner: extern "C" fn(
16396 UnitCalculator_QuickCommand,
16397 crate::app::battleinfoside::BattleInfoSide,
16398 f32,
16399 ::unity::OptionalMethod,
16400 ) -> () = ::core::mem::transmute(__vi.method_ptr);
16401 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
16402 __inner(__receiver, ::core::convert::Into::into(side), ::core::convert::Into::into(value), __mi)
16403 }
16404 }
16405 }
16406 #[doc = "`.ctor()` overload"]
16407 fn ctor(self) -> () {
16408 unsafe {
16409 let __receiver =
16410 <UnitCalculator_QuickCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
16411 ::unity::il2cpp_call!((::unity::module_base()+0x1b4b3b0usize)as*mut u8,();
16412(UnitCalculator_QuickCommand)__receiver)
16413 }
16414 }
16415}
16416
16417#[cfg(feature = "app-unitcalculator")]
16418impl<__T: IUnitCalculator_QuickCommand> IUnitCalculator_QuickCommandMethods for __T {}
16419
16420#[cfg(feature = "app-unitcalculator")]
16421impl UnitCalculator_QuickCommand {
16422 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
16423 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
16424 }
16425
16426 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
16427 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
16428 }
16429
16430 pub fn get_impl_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
16431 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
16432 }
16433
16434 pub fn set_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
16435 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
16436 }
16437
16438 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
16439 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
16440 }
16441}
16442
16443#[cfg(feature = "app-unitcalculator")]
16444impl UnitCalculator_QuickCommand {
16445 #[doc = "Direct (non-virtual) call to `UnitCalculator_QuickCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
16446 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
16447 let __mi = Self::get_name_method_info();
16448 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
16449 __inner(this.into(), ::core::option::Option::None)
16450 }
16451
16452 #[doc = "Direct (non-virtual) call to `UnitCalculator_QuickCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
16453 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
16454 let __mi = Self::get_impl_method_info();
16455 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
16456 ::core::mem::transmute(__mi.method_ptr);
16457 __inner(this.into(), unit, ::core::option::Option::None)
16458 }
16459
16460 #[doc = "Direct (non-virtual) call to `UnitCalculator_QuickCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
16461 pub unsafe fn get_impl_2(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
16462 let __mi = Self::get_impl_2_method_info();
16463 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
16464 ::core::mem::transmute(__mi.method_ptr);
16465 __inner(this.into(), side, ::core::option::Option::None)
16466 }
16467
16468 #[doc = "Direct (non-virtual) call to `UnitCalculator_QuickCommand`'s own `SetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
16469 pub unsafe fn set_impl(
16470 this: impl ::core::convert::Into<::unity::IlInstance>,
16471 side: crate::app::battleinfoside::BattleInfoSide,
16472 value: f32,
16473 ) -> () {
16474 let __mi = Self::set_impl_method_info();
16475 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, f32, ::unity::OptionalMethod) -> () =
16476 ::core::mem::transmute(__mi.method_ptr);
16477 __inner(this.into(), side, value, ::core::option::Option::None)
16478 }
16479}
16480
16481#[cfg(feature = "app-unitcalculator")]
16482impl UnitCalculator_QuickCommand {
16483 #[doc = "`.ctor()` — no args"]
16484 pub fn new() -> Self {
16485 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
16486 panic!(
16487 "{}
16488::{}
16489 failed to instantiate",
16490 ::core::stringify!(UnitCalculator_QuickCommand),
16491 ::core::stringify!(new),
16492 )
16493 });
16494 <Self as IUnitCalculator_QuickCommandMethods>::ctor(this);
16495 this
16496 }
16497}
16498
16499#[cfg(feature = "app-unitcalculator")]
16500pub trait IUnitCalculator_ExpDestroyCountCommandMethods: IUnitCalculator_ExpDestroyCountCommand {
16501 #[doc = "`get_Name()` overload"]
16502 fn get_name(self) -> ::unity::Il2CppString {
16503 unsafe {
16504 let __receiver = <UnitCalculator_ExpDestroyCountCommand as ::unity::FromIlInstance>::from_il_instance(
16505 <Self as ::unity::SystemObject>::as_instance(self),
16506 );
16507 {
16508 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
16509 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
16510 panic!(
16511 "unity: virtual slot {}
16512 out of range (vtable len {}
16513) on the runtime class behind {}
16514 (method `{}
16515`)",
16516 4usize,
16517 __vt.len(),
16518 <UnitCalculator_ExpDestroyCountCommand as ::unity::ClassIdentity>::NAME,
16519 "get_Name",
16520 )
16521 });
16522 let __inner: extern "C" fn(UnitCalculator_ExpDestroyCountCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
16523 ::core::mem::transmute(__vi.method_ptr);
16524 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
16525 __inner(__receiver, __mi)
16526 }
16527 }
16528 }
16529 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
16530 fn get_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
16531 unsafe {
16532 let __receiver = <UnitCalculator_ExpDestroyCountCommand as ::unity::FromIlInstance>::from_il_instance(
16533 <Self as ::unity::SystemObject>::as_instance(self),
16534 );
16535 {
16536 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
16537 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
16538 panic!(
16539 "unity: virtual slot {}
16540 out of range (vtable len {}
16541) on the runtime class behind {}
16542 (method `{}
16543`)",
16544 30usize,
16545 __vt.len(),
16546 <UnitCalculator_ExpDestroyCountCommand as ::unity::ClassIdentity>::NAME,
16547 "GetImpl",
16548 )
16549 });
16550 let __inner: extern "C" fn(UnitCalculator_ExpDestroyCountCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
16551 ::core::mem::transmute(__vi.method_ptr);
16552 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
16553 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
16554 }
16555 }
16556 }
16557 #[doc = "`.ctor()` overload"]
16558 fn ctor(self) -> () {
16559 unsafe {
16560 let __receiver = <UnitCalculator_ExpDestroyCountCommand as ::unity::FromIlInstance>::from_il_instance(
16561 <Self as ::unity::SystemObject>::as_instance(self),
16562 );
16563 ::unity::il2cpp_call!((::unity::module_base()+0x1b472d0usize)as*mut u8,();
16564(UnitCalculator_ExpDestroyCountCommand)__receiver)
16565 }
16566 }
16567}
16568
16569#[cfg(feature = "app-unitcalculator")]
16570impl<__T: IUnitCalculator_ExpDestroyCountCommand> IUnitCalculator_ExpDestroyCountCommandMethods for __T {}
16571
16572#[cfg(feature = "app-unitcalculator")]
16573impl UnitCalculator_ExpDestroyCountCommand {
16574 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
16575 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
16576 }
16577
16578 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
16579 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
16580 }
16581
16582 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
16583 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
16584 }
16585}
16586
16587#[cfg(feature = "app-unitcalculator")]
16588impl UnitCalculator_ExpDestroyCountCommand {
16589 #[doc = "Direct (non-virtual) call to `UnitCalculator_ExpDestroyCountCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
16590 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
16591 let __mi = Self::get_name_method_info();
16592 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
16593 __inner(this.into(), ::core::option::Option::None)
16594 }
16595
16596 #[doc = "Direct (non-virtual) call to `UnitCalculator_ExpDestroyCountCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
16597 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
16598 let __mi = Self::get_impl_method_info();
16599 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
16600 ::core::mem::transmute(__mi.method_ptr);
16601 __inner(this.into(), unit, ::core::option::Option::None)
16602 }
16603}
16604
16605#[cfg(feature = "app-unitcalculator")]
16606impl UnitCalculator_ExpDestroyCountCommand {
16607 #[doc = "`.ctor()` — no args"]
16608 pub fn new() -> Self {
16609 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
16610 panic!(
16611 "{}
16612::{}
16613 failed to instantiate",
16614 ::core::stringify!(UnitCalculator_ExpDestroyCountCommand),
16615 ::core::stringify!(new),
16616 )
16617 });
16618 <Self as IUnitCalculator_ExpDestroyCountCommandMethods>::ctor(this);
16619 this
16620 }
16621}
16622
16623#[cfg(feature = "app-unitcalculator")]
16624pub trait IUnitCalculator_TerrainAvoidCommandMethods: IUnitCalculator_TerrainAvoidCommand {
16625 #[doc = "`get_Name()` overload"]
16626 fn get_name(self) -> ::unity::Il2CppString {
16627 unsafe {
16628 let __receiver =
16629 <UnitCalculator_TerrainAvoidCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
16630 {
16631 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
16632 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
16633 panic!(
16634 "unity: virtual slot {}
16635 out of range (vtable len {}
16636) on the runtime class behind {}
16637 (method `{}
16638`)",
16639 4usize,
16640 __vt.len(),
16641 <UnitCalculator_TerrainAvoidCommand as ::unity::ClassIdentity>::NAME,
16642 "get_Name",
16643 )
16644 });
16645 let __inner: extern "C" fn(UnitCalculator_TerrainAvoidCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
16646 ::core::mem::transmute(__vi.method_ptr);
16647 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
16648 __inner(__receiver, __mi)
16649 }
16650 }
16651 }
16652 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
16653 fn get_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
16654 unsafe {
16655 let __receiver =
16656 <UnitCalculator_TerrainAvoidCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
16657 {
16658 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
16659 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
16660 panic!(
16661 "unity: virtual slot {}
16662 out of range (vtable len {}
16663) on the runtime class behind {}
16664 (method `{}
16665`)",
16666 31usize,
16667 __vt.len(),
16668 <UnitCalculator_TerrainAvoidCommand as ::unity::ClassIdentity>::NAME,
16669 "GetImpl",
16670 )
16671 });
16672 let __inner: extern "C" fn(
16673 UnitCalculator_TerrainAvoidCommand,
16674 crate::app::battleinfoside::BattleInfoSide,
16675 ::unity::OptionalMethod,
16676 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
16677 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
16678 __inner(__receiver, ::core::convert::Into::into(side), __mi)
16679 }
16680 }
16681 }
16682 #[doc = "`SetImpl(crate::app::battleinfoside::BattleInfoSide, f32)` overload"]
16683 fn set_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>, value: impl ::core::convert::Into<f32>) -> () {
16684 unsafe {
16685 let __receiver =
16686 <UnitCalculator_TerrainAvoidCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
16687 {
16688 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
16689 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
16690 panic!(
16691 "unity: virtual slot {}
16692 out of range (vtable len {}
16693) on the runtime class behind {}
16694 (method `{}
16695`)",
16696 33usize,
16697 __vt.len(),
16698 <UnitCalculator_TerrainAvoidCommand as ::unity::ClassIdentity>::NAME,
16699 "SetImpl",
16700 )
16701 });
16702 let __inner: extern "C" fn(
16703 UnitCalculator_TerrainAvoidCommand,
16704 crate::app::battleinfoside::BattleInfoSide,
16705 f32,
16706 ::unity::OptionalMethod,
16707 ) -> () = ::core::mem::transmute(__vi.method_ptr);
16708 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
16709 __inner(__receiver, ::core::convert::Into::into(side), ::core::convert::Into::into(value), __mi)
16710 }
16711 }
16712 }
16713 #[doc = "`IsVisible()` overload"]
16714 fn is_visible(self) -> bool {
16715 unsafe {
16716 let __receiver =
16717 <UnitCalculator_TerrainAvoidCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
16718 {
16719 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
16720 let __vi = *__vt.get(43usize).unwrap_or_else(|| {
16721 panic!(
16722 "unity: virtual slot {}
16723 out of range (vtable len {}
16724) on the runtime class behind {}
16725 (method `{}
16726`)",
16727 43usize,
16728 __vt.len(),
16729 <UnitCalculator_TerrainAvoidCommand as ::unity::ClassIdentity>::NAME,
16730 "IsVisible",
16731 )
16732 });
16733 let __inner: extern "C" fn(UnitCalculator_TerrainAvoidCommand, ::unity::OptionalMethod) -> bool =
16734 ::core::mem::transmute(__vi.method_ptr);
16735 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
16736 __inner(__receiver, __mi)
16737 }
16738 }
16739 }
16740 #[doc = "`.ctor()` overload"]
16741 fn ctor(self) -> () {
16742 unsafe {
16743 let __receiver =
16744 <UnitCalculator_TerrainAvoidCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
16745 ::unity::il2cpp_call!((::unity::module_base()+0x1b4ca20usize)as*mut u8,();
16746(UnitCalculator_TerrainAvoidCommand)__receiver)
16747 }
16748 }
16749}
16750
16751#[cfg(feature = "app-unitcalculator")]
16752impl<__T: IUnitCalculator_TerrainAvoidCommand> IUnitCalculator_TerrainAvoidCommandMethods for __T {}
16753
16754#[cfg(feature = "app-unitcalculator")]
16755impl UnitCalculator_TerrainAvoidCommand {
16756 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
16757 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
16758 }
16759
16760 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
16761 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
16762 }
16763
16764 pub fn set_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
16765 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
16766 }
16767
16768 pub fn is_visible_method_info() -> &'static ::unity::il2cpp::MethodInfo {
16769 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
16770 }
16771
16772 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
16773 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
16774 }
16775}
16776
16777#[cfg(feature = "app-unitcalculator")]
16778impl UnitCalculator_TerrainAvoidCommand {
16779 #[doc = "Direct (non-virtual) call to `UnitCalculator_TerrainAvoidCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
16780 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
16781 let __mi = Self::get_name_method_info();
16782 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
16783 __inner(this.into(), ::core::option::Option::None)
16784 }
16785
16786 #[doc = "Direct (non-virtual) call to `UnitCalculator_TerrainAvoidCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
16787 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
16788 let __mi = Self::get_impl_method_info();
16789 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
16790 ::core::mem::transmute(__mi.method_ptr);
16791 __inner(this.into(), side, ::core::option::Option::None)
16792 }
16793
16794 #[doc = "Direct (non-virtual) call to `UnitCalculator_TerrainAvoidCommand`'s own `SetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
16795 pub unsafe fn set_impl(
16796 this: impl ::core::convert::Into<::unity::IlInstance>,
16797 side: crate::app::battleinfoside::BattleInfoSide,
16798 value: f32,
16799 ) -> () {
16800 let __mi = Self::set_impl_method_info();
16801 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, f32, ::unity::OptionalMethod) -> () =
16802 ::core::mem::transmute(__mi.method_ptr);
16803 __inner(this.into(), side, value, ::core::option::Option::None)
16804 }
16805
16806 #[doc = "Direct (non-virtual) call to `UnitCalculator_TerrainAvoidCommand`'s own `IsVisible`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
16807 pub unsafe fn is_visible(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
16808 let __mi = Self::is_visible_method_info();
16809 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
16810 __inner(this.into(), ::core::option::Option::None)
16811 }
16812}
16813
16814#[cfg(feature = "app-unitcalculator")]
16815impl UnitCalculator_TerrainAvoidCommand {
16816 #[doc = "`.ctor()` — no args"]
16817 pub fn new() -> Self {
16818 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
16819 panic!(
16820 "{}
16821::{}
16822 failed to instantiate",
16823 ::core::stringify!(UnitCalculator_TerrainAvoidCommand),
16824 ::core::stringify!(new),
16825 )
16826 });
16827 <Self as IUnitCalculator_TerrainAvoidCommandMethods>::ctor(this);
16828 this
16829 }
16830}
16831
16832#[cfg(feature = "app-unitcalculator")]
16833pub trait IUnitCalculator_LinkDefCommandMethods: IUnitCalculator_LinkDefCommand {
16834 #[doc = "`get_Name()` overload"]
16835 fn get_name(self) -> ::unity::Il2CppString {
16836 unsafe {
16837 let __receiver =
16838 <UnitCalculator_LinkDefCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
16839 {
16840 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
16841 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
16842 panic!(
16843 "unity: virtual slot {}
16844 out of range (vtable len {}
16845) on the runtime class behind {}
16846 (method `{}
16847`)",
16848 4usize,
16849 __vt.len(),
16850 <UnitCalculator_LinkDefCommand as ::unity::ClassIdentity>::NAME,
16851 "get_Name",
16852 )
16853 });
16854 let __inner: extern "C" fn(UnitCalculator_LinkDefCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
16855 ::core::mem::transmute(__vi.method_ptr);
16856 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
16857 __inner(__receiver, __mi)
16858 }
16859 }
16860 }
16861 #[doc = "`get_CapabilityType()` overload"]
16862 fn get_capability_type(self) -> crate::app::capabilitydefinition::CapabilityDefinition_Type {
16863 unsafe {
16864 let __receiver =
16865 <UnitCalculator_LinkDefCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
16866 {
16867 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
16868 let __vi = *__vt.get(44usize).unwrap_or_else(|| {
16869 panic!(
16870 "unity: virtual slot {}
16871 out of range (vtable len {}
16872) on the runtime class behind {}
16873 (method `{}
16874`)",
16875 44usize,
16876 __vt.len(),
16877 <UnitCalculator_LinkDefCommand as ::unity::ClassIdentity>::NAME,
16878 "get_CapabilityType",
16879 )
16880 });
16881 let __inner: extern "C" fn(
16882 UnitCalculator_LinkDefCommand,
16883 ::unity::OptionalMethod,
16884 ) -> crate::app::capabilitydefinition::CapabilityDefinition_Type = ::core::mem::transmute(__vi.method_ptr);
16885 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
16886 __inner(__receiver, __mi)
16887 }
16888 }
16889 }
16890 #[doc = "`.ctor()` overload"]
16891 fn ctor(self) -> () {
16892 unsafe {
16893 let __receiver =
16894 <UnitCalculator_LinkDefCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
16895 ::unity::il2cpp_call!((::unity::module_base()+0x1b487a0usize)as*mut u8,();
16896(UnitCalculator_LinkDefCommand)__receiver)
16897 }
16898 }
16899}
16900
16901#[cfg(feature = "app-unitcalculator")]
16902impl<__T: IUnitCalculator_LinkDefCommand> IUnitCalculator_LinkDefCommandMethods for __T {}
16903
16904#[cfg(feature = "app-unitcalculator")]
16905impl UnitCalculator_LinkDefCommand {
16906 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
16907 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
16908 }
16909
16910 pub fn get_capability_type_method_info() -> &'static ::unity::il2cpp::MethodInfo {
16911 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
16912 }
16913
16914 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
16915 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
16916 }
16917}
16918
16919#[cfg(feature = "app-unitcalculator")]
16920impl UnitCalculator_LinkDefCommand {
16921 #[doc = "Direct (non-virtual) call to `UnitCalculator_LinkDefCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
16922 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
16923 let __mi = Self::get_name_method_info();
16924 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
16925 __inner(this.into(), ::core::option::Option::None)
16926 }
16927
16928 #[doc = "Direct (non-virtual) call to `UnitCalculator_LinkDefCommand`'s own `get_CapabilityType`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
16929 pub unsafe fn get_capability_type(
16930 this: impl ::core::convert::Into<::unity::IlInstance>,
16931 ) -> crate::app::capabilitydefinition::CapabilityDefinition_Type {
16932 let __mi = Self::get_capability_type_method_info();
16933 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::capabilitydefinition::CapabilityDefinition_Type =
16934 ::core::mem::transmute(__mi.method_ptr);
16935 __inner(this.into(), ::core::option::Option::None)
16936 }
16937}
16938
16939#[cfg(feature = "app-unitcalculator")]
16940impl UnitCalculator_LinkDefCommand {
16941 #[doc = "`.ctor()` — no args"]
16942 pub fn new() -> Self {
16943 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
16944 panic!(
16945 "{}
16946::{}
16947 failed to instantiate",
16948 ::core::stringify!(UnitCalculator_LinkDefCommand),
16949 ::core::stringify!(new),
16950 )
16951 });
16952 <Self as IUnitCalculator_LinkDefCommandMethods>::ctor(this);
16953 this
16954 }
16955}
16956
16957#[cfg(feature = "app-unitcalculator")]
16958pub trait IUnitCalculator_TechCommandMethods: IUnitCalculator_TechCommand {
16959 #[doc = "`get_Name()` overload"]
16960 fn get_name(self) -> ::unity::Il2CppString {
16961 unsafe {
16962 let __receiver =
16963 <UnitCalculator_TechCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
16964 {
16965 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
16966 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
16967 panic!(
16968 "unity: virtual slot {}
16969 out of range (vtable len {}
16970) on the runtime class behind {}
16971 (method `{}
16972`)",
16973 4usize,
16974 __vt.len(),
16975 <UnitCalculator_TechCommand as ::unity::ClassIdentity>::NAME,
16976 "get_Name",
16977 )
16978 });
16979 let __inner: extern "C" fn(UnitCalculator_TechCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
16980 ::core::mem::transmute(__vi.method_ptr);
16981 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
16982 __inner(__receiver, __mi)
16983 }
16984 }
16985 }
16986 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
16987 fn get_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
16988 unsafe {
16989 let __receiver =
16990 <UnitCalculator_TechCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
16991 {
16992 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
16993 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
16994 panic!(
16995 "unity: virtual slot {}
16996 out of range (vtable len {}
16997) on the runtime class behind {}
16998 (method `{}
16999`)",
17000 30usize,
17001 __vt.len(),
17002 <UnitCalculator_TechCommand as ::unity::ClassIdentity>::NAME,
17003 "GetImpl",
17004 )
17005 });
17006 let __inner: extern "C" fn(UnitCalculator_TechCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
17007 ::core::mem::transmute(__vi.method_ptr);
17008 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
17009 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
17010 }
17011 }
17012 }
17013 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
17014 fn get_impl_2(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
17015 unsafe {
17016 let __receiver =
17017 <UnitCalculator_TechCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
17018 {
17019 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
17020 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
17021 panic!(
17022 "unity: virtual slot {}
17023 out of range (vtable len {}
17024) on the runtime class behind {}
17025 (method `{}
17026`)",
17027 31usize,
17028 __vt.len(),
17029 <UnitCalculator_TechCommand as ::unity::ClassIdentity>::NAME,
17030 "GetImpl",
17031 )
17032 });
17033 let __inner: extern "C" fn(UnitCalculator_TechCommand, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
17034 ::core::mem::transmute(__vi.method_ptr);
17035 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
17036 __inner(__receiver, ::core::convert::Into::into(side), __mi)
17037 }
17038 }
17039 }
17040 #[doc = "`SetImpl(crate::app::battleinfoside::BattleInfoSide, f32)` overload"]
17041 fn set_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>, value: impl ::core::convert::Into<f32>) -> () {
17042 unsafe {
17043 let __receiver =
17044 <UnitCalculator_TechCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
17045 {
17046 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
17047 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
17048 panic!(
17049 "unity: virtual slot {}
17050 out of range (vtable len {}
17051) on the runtime class behind {}
17052 (method `{}
17053`)",
17054 33usize,
17055 __vt.len(),
17056 <UnitCalculator_TechCommand as ::unity::ClassIdentity>::NAME,
17057 "SetImpl",
17058 )
17059 });
17060 let __inner: extern "C" fn(
17061 UnitCalculator_TechCommand,
17062 crate::app::battleinfoside::BattleInfoSide,
17063 f32,
17064 ::unity::OptionalMethod,
17065 ) -> () = ::core::mem::transmute(__vi.method_ptr);
17066 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
17067 __inner(__receiver, ::core::convert::Into::into(side), ::core::convert::Into::into(value), __mi)
17068 }
17069 }
17070 }
17071 #[doc = "`.ctor()` overload"]
17072 fn ctor(self) -> () {
17073 unsafe {
17074 let __receiver =
17075 <UnitCalculator_TechCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
17076 ::unity::il2cpp_call!((::unity::module_base()+0x1b4c880usize)as*mut u8,();
17077(UnitCalculator_TechCommand)__receiver)
17078 }
17079 }
17080}
17081
17082#[cfg(feature = "app-unitcalculator")]
17083impl<__T: IUnitCalculator_TechCommand> IUnitCalculator_TechCommandMethods for __T {}
17084
17085#[cfg(feature = "app-unitcalculator")]
17086impl UnitCalculator_TechCommand {
17087 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
17088 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
17089 }
17090
17091 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
17092 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
17093 }
17094
17095 pub fn get_impl_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
17096 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
17097 }
17098
17099 pub fn set_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
17100 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
17101 }
17102
17103 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
17104 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
17105 }
17106}
17107
17108#[cfg(feature = "app-unitcalculator")]
17109impl UnitCalculator_TechCommand {
17110 #[doc = "Direct (non-virtual) call to `UnitCalculator_TechCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
17111 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
17112 let __mi = Self::get_name_method_info();
17113 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
17114 __inner(this.into(), ::core::option::Option::None)
17115 }
17116
17117 #[doc = "Direct (non-virtual) call to `UnitCalculator_TechCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
17118 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
17119 let __mi = Self::get_impl_method_info();
17120 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
17121 ::core::mem::transmute(__mi.method_ptr);
17122 __inner(this.into(), unit, ::core::option::Option::None)
17123 }
17124
17125 #[doc = "Direct (non-virtual) call to `UnitCalculator_TechCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
17126 pub unsafe fn get_impl_2(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
17127 let __mi = Self::get_impl_2_method_info();
17128 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
17129 ::core::mem::transmute(__mi.method_ptr);
17130 __inner(this.into(), side, ::core::option::Option::None)
17131 }
17132
17133 #[doc = "Direct (non-virtual) call to `UnitCalculator_TechCommand`'s own `SetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
17134 pub unsafe fn set_impl(
17135 this: impl ::core::convert::Into<::unity::IlInstance>,
17136 side: crate::app::battleinfoside::BattleInfoSide,
17137 value: f32,
17138 ) -> () {
17139 let __mi = Self::set_impl_method_info();
17140 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, f32, ::unity::OptionalMethod) -> () =
17141 ::core::mem::transmute(__mi.method_ptr);
17142 __inner(this.into(), side, value, ::core::option::Option::None)
17143 }
17144}
17145
17146#[cfg(feature = "app-unitcalculator")]
17147impl UnitCalculator_TechCommand {
17148 #[doc = "`.ctor()` — no args"]
17149 pub fn new() -> Self {
17150 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
17151 panic!(
17152 "{}
17153::{}
17154 failed to instantiate",
17155 ::core::stringify!(UnitCalculator_TechCommand),
17156 ::core::stringify!(new),
17157 )
17158 });
17159 <Self as IUnitCalculator_TechCommandMethods>::ctor(this);
17160 this
17161 }
17162}
17163
17164#[cfg(feature = "app-unitcalculator")]
17165pub trait IUnitCalculator_TemporaryCommandMethods: IUnitCalculator_TemporaryCommand {
17166 #[doc = "`get_Name()` overload"]
17167 fn get_name(self) -> ::unity::Il2CppString {
17168 unsafe {
17169 let __receiver =
17170 <UnitCalculator_TemporaryCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
17171 {
17172 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
17173 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
17174 panic!(
17175 "unity: virtual slot {}
17176 out of range (vtable len {}
17177) on the runtime class behind {}
17178 (method `{}
17179`)",
17180 4usize,
17181 __vt.len(),
17182 <UnitCalculator_TemporaryCommand as ::unity::ClassIdentity>::NAME,
17183 "get_Name",
17184 )
17185 });
17186 let __inner: extern "C" fn(UnitCalculator_TemporaryCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
17187 ::core::mem::transmute(__vi.method_ptr);
17188 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
17189 __inner(__receiver, __mi)
17190 }
17191 }
17192 }
17193 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
17194 fn get_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
17195 unsafe {
17196 let __receiver =
17197 <UnitCalculator_TemporaryCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
17198 {
17199 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
17200 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
17201 panic!(
17202 "unity: virtual slot {}
17203 out of range (vtable len {}
17204) on the runtime class behind {}
17205 (method `{}
17206`)",
17207 31usize,
17208 __vt.len(),
17209 <UnitCalculator_TemporaryCommand as ::unity::ClassIdentity>::NAME,
17210 "GetImpl",
17211 )
17212 });
17213 let __inner: extern "C" fn(
17214 UnitCalculator_TemporaryCommand,
17215 crate::app::battleinfoside::BattleInfoSide,
17216 ::unity::OptionalMethod,
17217 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
17218 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
17219 __inner(__receiver, ::core::convert::Into::into(side), __mi)
17220 }
17221 }
17222 }
17223 #[doc = "`SetImpl(crate::app::battleinfoside::BattleInfoSide, f32)` overload"]
17224 fn set_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>, value: impl ::core::convert::Into<f32>) -> () {
17225 unsafe {
17226 let __receiver =
17227 <UnitCalculator_TemporaryCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
17228 {
17229 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
17230 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
17231 panic!(
17232 "unity: virtual slot {}
17233 out of range (vtable len {}
17234) on the runtime class behind {}
17235 (method `{}
17236`)",
17237 33usize,
17238 __vt.len(),
17239 <UnitCalculator_TemporaryCommand as ::unity::ClassIdentity>::NAME,
17240 "SetImpl",
17241 )
17242 });
17243 let __inner: extern "C" fn(
17244 UnitCalculator_TemporaryCommand,
17245 crate::app::battleinfoside::BattleInfoSide,
17246 f32,
17247 ::unity::OptionalMethod,
17248 ) -> () = ::core::mem::transmute(__vi.method_ptr);
17249 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
17250 __inner(__receiver, ::core::convert::Into::into(side), ::core::convert::Into::into(value), __mi)
17251 }
17252 }
17253 }
17254 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
17255 fn get_impl_2(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
17256 unsafe {
17257 let __receiver =
17258 <UnitCalculator_TemporaryCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
17259 {
17260 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
17261 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
17262 panic!(
17263 "unity: virtual slot {}
17264 out of range (vtable len {}
17265) on the runtime class behind {}
17266 (method `{}
17267`)",
17268 30usize,
17269 __vt.len(),
17270 <UnitCalculator_TemporaryCommand as ::unity::ClassIdentity>::NAME,
17271 "GetImpl",
17272 )
17273 });
17274 let __inner: extern "C" fn(UnitCalculator_TemporaryCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
17275 ::core::mem::transmute(__vi.method_ptr);
17276 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
17277 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
17278 }
17279 }
17280 }
17281 #[doc = "`SetImpl(crate::app::unit::Unit, f32)` overload"]
17282 fn set_impl_2(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>, value: impl ::core::convert::Into<f32>) -> () {
17283 unsafe {
17284 let __receiver =
17285 <UnitCalculator_TemporaryCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
17286 {
17287 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
17288 let __vi = *__vt.get(32usize).unwrap_or_else(|| {
17289 panic!(
17290 "unity: virtual slot {}
17291 out of range (vtable len {}
17292) on the runtime class behind {}
17293 (method `{}
17294`)",
17295 32usize,
17296 __vt.len(),
17297 <UnitCalculator_TemporaryCommand as ::unity::ClassIdentity>::NAME,
17298 "SetImpl",
17299 )
17300 });
17301 let __inner: extern "C" fn(UnitCalculator_TemporaryCommand, crate::app::unit::Unit, f32, ::unity::OptionalMethod) -> () =
17302 ::core::mem::transmute(__vi.method_ptr);
17303 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
17304 __inner(__receiver, ::core::convert::Into::into(unit), ::core::convert::Into::into(value), __mi)
17305 }
17306 }
17307 }
17308 #[doc = "`.ctor()` overload"]
17309 fn ctor(self) -> () {
17310 unsafe {
17311 let __receiver =
17312 <UnitCalculator_TemporaryCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
17313 ::unity::il2cpp_call!((::unity::module_base()+0x1b4c960usize)as*mut u8,();
17314(UnitCalculator_TemporaryCommand)__receiver)
17315 }
17316 }
17317}
17318
17319#[cfg(feature = "app-unitcalculator")]
17320impl<__T: IUnitCalculator_TemporaryCommand> IUnitCalculator_TemporaryCommandMethods for __T {}
17321
17322#[cfg(feature = "app-unitcalculator")]
17323impl UnitCalculator_TemporaryCommand {
17324 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
17325 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
17326 }
17327
17328 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
17329 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
17330 }
17331
17332 pub fn set_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
17333 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
17334 }
17335
17336 pub fn get_impl_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
17337 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
17338 }
17339
17340 pub fn set_impl_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
17341 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
17342 }
17343
17344 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
17345 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
17346 }
17347}
17348
17349#[cfg(feature = "app-unitcalculator")]
17350impl UnitCalculator_TemporaryCommand {
17351 #[doc = "Direct (non-virtual) call to `UnitCalculator_TemporaryCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
17352 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
17353 let __mi = Self::get_name_method_info();
17354 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
17355 __inner(this.into(), ::core::option::Option::None)
17356 }
17357
17358 #[doc = "Direct (non-virtual) call to `UnitCalculator_TemporaryCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
17359 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
17360 let __mi = Self::get_impl_method_info();
17361 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
17362 ::core::mem::transmute(__mi.method_ptr);
17363 __inner(this.into(), side, ::core::option::Option::None)
17364 }
17365
17366 #[doc = "Direct (non-virtual) call to `UnitCalculator_TemporaryCommand`'s own `SetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
17367 pub unsafe fn set_impl(
17368 this: impl ::core::convert::Into<::unity::IlInstance>,
17369 side: crate::app::battleinfoside::BattleInfoSide,
17370 value: f32,
17371 ) -> () {
17372 let __mi = Self::set_impl_method_info();
17373 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, f32, ::unity::OptionalMethod) -> () =
17374 ::core::mem::transmute(__mi.method_ptr);
17375 __inner(this.into(), side, value, ::core::option::Option::None)
17376 }
17377
17378 #[doc = "Direct (non-virtual) call to `UnitCalculator_TemporaryCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
17379 pub unsafe fn get_impl_2(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
17380 let __mi = Self::get_impl_2_method_info();
17381 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
17382 ::core::mem::transmute(__mi.method_ptr);
17383 __inner(this.into(), unit, ::core::option::Option::None)
17384 }
17385
17386 #[doc = "Direct (non-virtual) call to `UnitCalculator_TemporaryCommand`'s own `SetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
17387 pub unsafe fn set_impl_2(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit, value: f32) -> () {
17388 let __mi = Self::set_impl_2_method_info();
17389 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, f32, ::unity::OptionalMethod) -> () =
17390 ::core::mem::transmute(__mi.method_ptr);
17391 __inner(this.into(), unit, value, ::core::option::Option::None)
17392 }
17393}
17394
17395#[cfg(feature = "app-unitcalculator")]
17396impl UnitCalculator_TemporaryCommand {
17397 #[doc = "`.ctor()` — no args"]
17398 pub fn new() -> Self {
17399 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
17400 panic!(
17401 "{}
17402::{}
17403 failed to instantiate",
17404 ::core::stringify!(UnitCalculator_TemporaryCommand),
17405 ::core::stringify!(new),
17406 )
17407 });
17408 <Self as IUnitCalculator_TemporaryCommandMethods>::ctor(this);
17409 this
17410 }
17411}
17412
17413#[cfg(feature = "app-unitcalculator")]
17414pub trait IUnitCalculator_WeaponEfficacyCommandMethods: IUnitCalculator_WeaponEfficacyCommand {
17415 #[doc = "`get_Name()` overload"]
17416 fn get_name(self) -> ::unity::Il2CppString {
17417 unsafe {
17418 let __receiver = <UnitCalculator_WeaponEfficacyCommand as ::unity::FromIlInstance>::from_il_instance(
17419 <Self as ::unity::SystemObject>::as_instance(self),
17420 );
17421 {
17422 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
17423 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
17424 panic!(
17425 "unity: virtual slot {}
17426 out of range (vtable len {}
17427) on the runtime class behind {}
17428 (method `{}
17429`)",
17430 4usize,
17431 __vt.len(),
17432 <UnitCalculator_WeaponEfficacyCommand as ::unity::ClassIdentity>::NAME,
17433 "get_Name",
17434 )
17435 });
17436 let __inner: extern "C" fn(UnitCalculator_WeaponEfficacyCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
17437 ::core::mem::transmute(__vi.method_ptr);
17438 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
17439 __inner(__receiver, __mi)
17440 }
17441 }
17442 }
17443 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
17444 fn get_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
17445 unsafe {
17446 let __receiver = <UnitCalculator_WeaponEfficacyCommand as ::unity::FromIlInstance>::from_il_instance(
17447 <Self as ::unity::SystemObject>::as_instance(self),
17448 );
17449 {
17450 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
17451 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
17452 panic!(
17453 "unity: virtual slot {}
17454 out of range (vtable len {}
17455) on the runtime class behind {}
17456 (method `{}
17457`)",
17458 31usize,
17459 __vt.len(),
17460 <UnitCalculator_WeaponEfficacyCommand as ::unity::ClassIdentity>::NAME,
17461 "GetImpl",
17462 )
17463 });
17464 let __inner: extern "C" fn(
17465 UnitCalculator_WeaponEfficacyCommand,
17466 crate::app::battleinfoside::BattleInfoSide,
17467 ::unity::OptionalMethod,
17468 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
17469 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
17470 __inner(__receiver, ::core::convert::Into::into(side), __mi)
17471 }
17472 }
17473 }
17474 #[doc = "`SetImpl(crate::app::battleinfoside::BattleInfoSide, f32)` overload"]
17475 fn set_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>, value: impl ::core::convert::Into<f32>) -> () {
17476 unsafe {
17477 let __receiver = <UnitCalculator_WeaponEfficacyCommand as ::unity::FromIlInstance>::from_il_instance(
17478 <Self as ::unity::SystemObject>::as_instance(self),
17479 );
17480 {
17481 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
17482 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
17483 panic!(
17484 "unity: virtual slot {}
17485 out of range (vtable len {}
17486) on the runtime class behind {}
17487 (method `{}
17488`)",
17489 33usize,
17490 __vt.len(),
17491 <UnitCalculator_WeaponEfficacyCommand as ::unity::ClassIdentity>::NAME,
17492 "SetImpl",
17493 )
17494 });
17495 let __inner: extern "C" fn(
17496 UnitCalculator_WeaponEfficacyCommand,
17497 crate::app::battleinfoside::BattleInfoSide,
17498 f32,
17499 ::unity::OptionalMethod,
17500 ) -> () = ::core::mem::transmute(__vi.method_ptr);
17501 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
17502 __inner(__receiver, ::core::convert::Into::into(side), ::core::convert::Into::into(value), __mi)
17503 }
17504 }
17505 }
17506 #[doc = "`IsVisible()` overload"]
17507 fn is_visible(self) -> bool {
17508 unsafe {
17509 let __receiver = <UnitCalculator_WeaponEfficacyCommand as ::unity::FromIlInstance>::from_il_instance(
17510 <Self as ::unity::SystemObject>::as_instance(self),
17511 );
17512 {
17513 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
17514 let __vi = *__vt.get(43usize).unwrap_or_else(|| {
17515 panic!(
17516 "unity: virtual slot {}
17517 out of range (vtable len {}
17518) on the runtime class behind {}
17519 (method `{}
17520`)",
17521 43usize,
17522 __vt.len(),
17523 <UnitCalculator_WeaponEfficacyCommand as ::unity::ClassIdentity>::NAME,
17524 "IsVisible",
17525 )
17526 });
17527 let __inner: extern "C" fn(UnitCalculator_WeaponEfficacyCommand, ::unity::OptionalMethod) -> bool =
17528 ::core::mem::transmute(__vi.method_ptr);
17529 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
17530 __inner(__receiver, __mi)
17531 }
17532 }
17533 }
17534 #[doc = "`.ctor()` overload"]
17535 fn ctor(self) -> () {
17536 unsafe {
17537 let __receiver = <UnitCalculator_WeaponEfficacyCommand as ::unity::FromIlInstance>::from_il_instance(
17538 <Self as ::unity::SystemObject>::as_instance(self),
17539 );
17540 ::unity::il2cpp_call!((::unity::module_base()+0x1b4de60usize)as*mut u8,();
17541(UnitCalculator_WeaponEfficacyCommand)__receiver)
17542 }
17543 }
17544}
17545
17546#[cfg(feature = "app-unitcalculator")]
17547impl<__T: IUnitCalculator_WeaponEfficacyCommand> IUnitCalculator_WeaponEfficacyCommandMethods for __T {}
17548
17549#[cfg(feature = "app-unitcalculator")]
17550impl UnitCalculator_WeaponEfficacyCommand {
17551 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
17552 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
17553 }
17554
17555 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
17556 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
17557 }
17558
17559 pub fn set_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
17560 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
17561 }
17562
17563 pub fn is_visible_method_info() -> &'static ::unity::il2cpp::MethodInfo {
17564 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
17565 }
17566
17567 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
17568 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
17569 }
17570}
17571
17572#[cfg(feature = "app-unitcalculator")]
17573impl UnitCalculator_WeaponEfficacyCommand {
17574 #[doc = "Direct (non-virtual) call to `UnitCalculator_WeaponEfficacyCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
17575 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
17576 let __mi = Self::get_name_method_info();
17577 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
17578 __inner(this.into(), ::core::option::Option::None)
17579 }
17580
17581 #[doc = "Direct (non-virtual) call to `UnitCalculator_WeaponEfficacyCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
17582 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
17583 let __mi = Self::get_impl_method_info();
17584 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
17585 ::core::mem::transmute(__mi.method_ptr);
17586 __inner(this.into(), side, ::core::option::Option::None)
17587 }
17588
17589 #[doc = "Direct (non-virtual) call to `UnitCalculator_WeaponEfficacyCommand`'s own `SetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
17590 pub unsafe fn set_impl(
17591 this: impl ::core::convert::Into<::unity::IlInstance>,
17592 side: crate::app::battleinfoside::BattleInfoSide,
17593 value: f32,
17594 ) -> () {
17595 let __mi = Self::set_impl_method_info();
17596 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, f32, ::unity::OptionalMethod) -> () =
17597 ::core::mem::transmute(__mi.method_ptr);
17598 __inner(this.into(), side, value, ::core::option::Option::None)
17599 }
17600
17601 #[doc = "Direct (non-virtual) call to `UnitCalculator_WeaponEfficacyCommand`'s own `IsVisible`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
17602 pub unsafe fn is_visible(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
17603 let __mi = Self::is_visible_method_info();
17604 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
17605 __inner(this.into(), ::core::option::Option::None)
17606 }
17607}
17608
17609#[cfg(feature = "app-unitcalculator")]
17610impl UnitCalculator_WeaponEfficacyCommand {
17611 #[doc = "`.ctor()` — no args"]
17612 pub fn new() -> Self {
17613 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
17614 panic!(
17615 "{}
17616::{}
17617 failed to instantiate",
17618 ::core::stringify!(UnitCalculator_WeaponEfficacyCommand),
17619 ::core::stringify!(new),
17620 )
17621 });
17622 <Self as IUnitCalculator_WeaponEfficacyCommandMethods>::ctor(this);
17623 this
17624 }
17625}
17626
17627#[cfg(feature = "app-unitcalculator")]
17628pub trait IUnitCalculator_HealCommandMethods: IUnitCalculator_HealCommand {
17629 #[doc = "`get_Name()` overload"]
17630 fn get_name(self) -> ::unity::Il2CppString {
17631 unsafe {
17632 let __receiver =
17633 <UnitCalculator_HealCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
17634 {
17635 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
17636 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
17637 panic!(
17638 "unity: virtual slot {}
17639 out of range (vtable len {}
17640) on the runtime class behind {}
17641 (method `{}
17642`)",
17643 4usize,
17644 __vt.len(),
17645 <UnitCalculator_HealCommand as ::unity::ClassIdentity>::NAME,
17646 "get_Name",
17647 )
17648 });
17649 let __inner: extern "C" fn(UnitCalculator_HealCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
17650 ::core::mem::transmute(__vi.method_ptr);
17651 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
17652 __inner(__receiver, __mi)
17653 }
17654 }
17655 }
17656 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
17657 fn get_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
17658 unsafe {
17659 let __receiver =
17660 <UnitCalculator_HealCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
17661 {
17662 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
17663 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
17664 panic!(
17665 "unity: virtual slot {}
17666 out of range (vtable len {}
17667) on the runtime class behind {}
17668 (method `{}
17669`)",
17670 31usize,
17671 __vt.len(),
17672 <UnitCalculator_HealCommand as ::unity::ClassIdentity>::NAME,
17673 "GetImpl",
17674 )
17675 });
17676 let __inner: extern "C" fn(UnitCalculator_HealCommand, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
17677 ::core::mem::transmute(__vi.method_ptr);
17678 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
17679 __inner(__receiver, ::core::convert::Into::into(side), __mi)
17680 }
17681 }
17682 }
17683 #[doc = "`SetImpl(crate::app::battleinfoside::BattleInfoSide, f32)` overload"]
17684 fn set_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>, value: impl ::core::convert::Into<f32>) -> () {
17685 unsafe {
17686 let __receiver =
17687 <UnitCalculator_HealCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
17688 {
17689 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
17690 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
17691 panic!(
17692 "unity: virtual slot {}
17693 out of range (vtable len {}
17694) on the runtime class behind {}
17695 (method `{}
17696`)",
17697 33usize,
17698 __vt.len(),
17699 <UnitCalculator_HealCommand as ::unity::ClassIdentity>::NAME,
17700 "SetImpl",
17701 )
17702 });
17703 let __inner: extern "C" fn(
17704 UnitCalculator_HealCommand,
17705 crate::app::battleinfoside::BattleInfoSide,
17706 f32,
17707 ::unity::OptionalMethod,
17708 ) -> () = ::core::mem::transmute(__vi.method_ptr);
17709 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
17710 __inner(__receiver, ::core::convert::Into::into(side), ::core::convert::Into::into(value), __mi)
17711 }
17712 }
17713 }
17714 #[doc = "`.ctor()` overload"]
17715 fn ctor(self) -> () {
17716 unsafe {
17717 let __receiver =
17718 <UnitCalculator_HealCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
17719 ::unity::il2cpp_call!((::unity::module_base()+0x1b484d0usize)as*mut u8,();
17720(UnitCalculator_HealCommand)__receiver)
17721 }
17722 }
17723}
17724
17725#[cfg(feature = "app-unitcalculator")]
17726impl<__T: IUnitCalculator_HealCommand> IUnitCalculator_HealCommandMethods for __T {}
17727
17728#[cfg(feature = "app-unitcalculator")]
17729impl UnitCalculator_HealCommand {
17730 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
17731 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
17732 }
17733
17734 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
17735 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
17736 }
17737
17738 pub fn set_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
17739 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
17740 }
17741
17742 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
17743 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
17744 }
17745}
17746
17747#[cfg(feature = "app-unitcalculator")]
17748impl UnitCalculator_HealCommand {
17749 #[doc = "Direct (non-virtual) call to `UnitCalculator_HealCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
17750 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
17751 let __mi = Self::get_name_method_info();
17752 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
17753 __inner(this.into(), ::core::option::Option::None)
17754 }
17755
17756 #[doc = "Direct (non-virtual) call to `UnitCalculator_HealCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
17757 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
17758 let __mi = Self::get_impl_method_info();
17759 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
17760 ::core::mem::transmute(__mi.method_ptr);
17761 __inner(this.into(), side, ::core::option::Option::None)
17762 }
17763
17764 #[doc = "Direct (non-virtual) call to `UnitCalculator_HealCommand`'s own `SetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
17765 pub unsafe fn set_impl(
17766 this: impl ::core::convert::Into<::unity::IlInstance>,
17767 side: crate::app::battleinfoside::BattleInfoSide,
17768 value: f32,
17769 ) -> () {
17770 let __mi = Self::set_impl_method_info();
17771 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, f32, ::unity::OptionalMethod) -> () =
17772 ::core::mem::transmute(__mi.method_ptr);
17773 __inner(this.into(), side, value, ::core::option::Option::None)
17774 }
17775}
17776
17777#[cfg(feature = "app-unitcalculator")]
17778impl UnitCalculator_HealCommand {
17779 #[doc = "`.ctor()` — no args"]
17780 pub fn new() -> Self {
17781 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
17782 panic!(
17783 "{}
17784::{}
17785 failed to instantiate",
17786 ::core::stringify!(UnitCalculator_HealCommand),
17787 ::core::stringify!(new),
17788 )
17789 });
17790 <Self as IUnitCalculator_HealCommandMethods>::ctor(this);
17791 this
17792 }
17793}
17794
17795#[cfg(feature = "app-unitcalculator")]
17796pub trait IUnitCalculator_MoveDistanceCommandMethods: IUnitCalculator_MoveDistanceCommand {
17797 #[doc = "`get_Name()` overload"]
17798 fn get_name(self) -> ::unity::Il2CppString {
17799 unsafe {
17800 let __receiver =
17801 <UnitCalculator_MoveDistanceCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
17802 {
17803 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
17804 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
17805 panic!(
17806 "unity: virtual slot {}
17807 out of range (vtable len {}
17808) on the runtime class behind {}
17809 (method `{}
17810`)",
17811 4usize,
17812 __vt.len(),
17813 <UnitCalculator_MoveDistanceCommand as ::unity::ClassIdentity>::NAME,
17814 "get_Name",
17815 )
17816 });
17817 let __inner: extern "C" fn(UnitCalculator_MoveDistanceCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
17818 ::core::mem::transmute(__vi.method_ptr);
17819 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
17820 __inner(__receiver, __mi)
17821 }
17822 }
17823 }
17824 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
17825 fn get_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
17826 unsafe {
17827 let __receiver =
17828 <UnitCalculator_MoveDistanceCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
17829 {
17830 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
17831 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
17832 panic!(
17833 "unity: virtual slot {}
17834 out of range (vtable len {}
17835) on the runtime class behind {}
17836 (method `{}
17837`)",
17838 30usize,
17839 __vt.len(),
17840 <UnitCalculator_MoveDistanceCommand as ::unity::ClassIdentity>::NAME,
17841 "GetImpl",
17842 )
17843 });
17844 let __inner: extern "C" fn(UnitCalculator_MoveDistanceCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
17845 ::core::mem::transmute(__vi.method_ptr);
17846 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
17847 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
17848 }
17849 }
17850 }
17851 #[doc = "`IsVisible()` overload"]
17852 fn is_visible(self) -> bool {
17853 unsafe {
17854 let __receiver =
17855 <UnitCalculator_MoveDistanceCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
17856 {
17857 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
17858 let __vi = *__vt.get(43usize).unwrap_or_else(|| {
17859 panic!(
17860 "unity: virtual slot {}
17861 out of range (vtable len {}
17862) on the runtime class behind {}
17863 (method `{}
17864`)",
17865 43usize,
17866 __vt.len(),
17867 <UnitCalculator_MoveDistanceCommand as ::unity::ClassIdentity>::NAME,
17868 "IsVisible",
17869 )
17870 });
17871 let __inner: extern "C" fn(UnitCalculator_MoveDistanceCommand, ::unity::OptionalMethod) -> bool =
17872 ::core::mem::transmute(__vi.method_ptr);
17873 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
17874 __inner(__receiver, __mi)
17875 }
17876 }
17877 }
17878 #[doc = "`.ctor()` overload"]
17879 fn ctor(self) -> () {
17880 unsafe {
17881 let __receiver =
17882 <UnitCalculator_MoveDistanceCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
17883 ::unity::il2cpp_call!((::unity::module_base()+0x1b4a610usize)as*mut u8,();
17884(UnitCalculator_MoveDistanceCommand)__receiver)
17885 }
17886 }
17887}
17888
17889#[cfg(feature = "app-unitcalculator")]
17890impl<__T: IUnitCalculator_MoveDistanceCommand> IUnitCalculator_MoveDistanceCommandMethods for __T {}
17891
17892#[cfg(feature = "app-unitcalculator")]
17893impl UnitCalculator_MoveDistanceCommand {
17894 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
17895 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
17896 }
17897
17898 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
17899 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
17900 }
17901
17902 pub fn is_visible_method_info() -> &'static ::unity::il2cpp::MethodInfo {
17903 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
17904 }
17905
17906 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
17907 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
17908 }
17909}
17910
17911#[cfg(feature = "app-unitcalculator")]
17912impl UnitCalculator_MoveDistanceCommand {
17913 #[doc = "Direct (non-virtual) call to `UnitCalculator_MoveDistanceCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
17914 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
17915 let __mi = Self::get_name_method_info();
17916 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
17917 __inner(this.into(), ::core::option::Option::None)
17918 }
17919
17920 #[doc = "Direct (non-virtual) call to `UnitCalculator_MoveDistanceCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
17921 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
17922 let __mi = Self::get_impl_method_info();
17923 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
17924 ::core::mem::transmute(__mi.method_ptr);
17925 __inner(this.into(), unit, ::core::option::Option::None)
17926 }
17927
17928 #[doc = "Direct (non-virtual) call to `UnitCalculator_MoveDistanceCommand`'s own `IsVisible`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
17929 pub unsafe fn is_visible(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
17930 let __mi = Self::is_visible_method_info();
17931 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
17932 __inner(this.into(), ::core::option::Option::None)
17933 }
17934}
17935
17936#[cfg(feature = "app-unitcalculator")]
17937impl UnitCalculator_MoveDistanceCommand {
17938 #[doc = "`.ctor()` — no args"]
17939 pub fn new() -> Self {
17940 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
17941 panic!(
17942 "{}
17943::{}
17944 failed to instantiate",
17945 ::core::stringify!(UnitCalculator_MoveDistanceCommand),
17946 ::core::stringify!(new),
17947 )
17948 });
17949 <Self as IUnitCalculator_MoveDistanceCommandMethods>::ctor(this);
17950 this
17951 }
17952}
17953
17954#[cfg(feature = "app-unitcalculator")]
17955pub trait IUnitCalculator_BattleStyleCommandMethods: IUnitCalculator_BattleStyleCommand {
17956 #[doc = "`get_Name()` overload"]
17957 fn get_name(self) -> ::unity::Il2CppString {
17958 unsafe {
17959 let __receiver =
17960 <UnitCalculator_BattleStyleCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
17961 {
17962 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
17963 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
17964 panic!(
17965 "unity: virtual slot {}
17966 out of range (vtable len {}
17967) on the runtime class behind {}
17968 (method `{}
17969`)",
17970 4usize,
17971 __vt.len(),
17972 <UnitCalculator_BattleStyleCommand as ::unity::ClassIdentity>::NAME,
17973 "get_Name",
17974 )
17975 });
17976 let __inner: extern "C" fn(UnitCalculator_BattleStyleCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
17977 ::core::mem::transmute(__vi.method_ptr);
17978 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
17979 __inner(__receiver, __mi)
17980 }
17981 }
17982 }
17983 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
17984 fn get_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
17985 unsafe {
17986 let __receiver =
17987 <UnitCalculator_BattleStyleCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
17988 {
17989 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
17990 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
17991 panic!(
17992 "unity: virtual slot {}
17993 out of range (vtable len {}
17994) on the runtime class behind {}
17995 (method `{}
17996`)",
17997 30usize,
17998 __vt.len(),
17999 <UnitCalculator_BattleStyleCommand as ::unity::ClassIdentity>::NAME,
18000 "GetImpl",
18001 )
18002 });
18003 let __inner: extern "C" fn(UnitCalculator_BattleStyleCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
18004 ::core::mem::transmute(__vi.method_ptr);
18005 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
18006 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
18007 }
18008 }
18009 }
18010 #[doc = "`.ctor()` overload"]
18011 fn ctor(self) -> () {
18012 unsafe {
18013 let __receiver =
18014 <UnitCalculator_BattleStyleCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
18015 ::unity::il2cpp_call!((::unity::module_base()+0x1b46730usize)as*mut u8,();
18016(UnitCalculator_BattleStyleCommand)__receiver)
18017 }
18018 }
18019}
18020
18021#[cfg(feature = "app-unitcalculator")]
18022impl<__T: IUnitCalculator_BattleStyleCommand> IUnitCalculator_BattleStyleCommandMethods for __T {}
18023
18024#[cfg(feature = "app-unitcalculator")]
18025impl UnitCalculator_BattleStyleCommand {
18026 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
18027 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
18028 }
18029
18030 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
18031 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
18032 }
18033
18034 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
18035 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
18036 }
18037}
18038
18039#[cfg(feature = "app-unitcalculator")]
18040impl UnitCalculator_BattleStyleCommand {
18041 #[doc = "Direct (non-virtual) call to `UnitCalculator_BattleStyleCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
18042 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
18043 let __mi = Self::get_name_method_info();
18044 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
18045 __inner(this.into(), ::core::option::Option::None)
18046 }
18047
18048 #[doc = "Direct (non-virtual) call to `UnitCalculator_BattleStyleCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
18049 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
18050 let __mi = Self::get_impl_method_info();
18051 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
18052 ::core::mem::transmute(__mi.method_ptr);
18053 __inner(this.into(), unit, ::core::option::Option::None)
18054 }
18055}
18056
18057#[cfg(feature = "app-unitcalculator")]
18058impl UnitCalculator_BattleStyleCommand {
18059 #[doc = "`.ctor()` — no args"]
18060 pub fn new() -> Self {
18061 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
18062 panic!(
18063 "{}
18064::{}
18065 failed to instantiate",
18066 ::core::stringify!(UnitCalculator_BattleStyleCommand),
18067 ::core::stringify!(new),
18068 )
18069 });
18070 <Self as IUnitCalculator_BattleStyleCommandMethods>::ctor(this);
18071 this
18072 }
18073}
18074
18075#[cfg(feature = "app-unitcalculator")]
18076pub trait IUnitCalculator_TotalResultCommandMethods: IUnitCalculator_TotalResultCommand {
18077 #[doc = "`get_Name()` overload"]
18078 fn get_name(self) -> ::unity::Il2CppString {
18079 unsafe {
18080 let __receiver =
18081 <UnitCalculator_TotalResultCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
18082 {
18083 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
18084 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
18085 panic!(
18086 "unity: virtual slot {}
18087 out of range (vtable len {}
18088) on the runtime class behind {}
18089 (method `{}
18090`)",
18091 4usize,
18092 __vt.len(),
18093 <UnitCalculator_TotalResultCommand as ::unity::ClassIdentity>::NAME,
18094 "get_Name",
18095 )
18096 });
18097 let __inner: extern "C" fn(UnitCalculator_TotalResultCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
18098 ::core::mem::transmute(__vi.method_ptr);
18099 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
18100 __inner(__receiver, __mi)
18101 }
18102 }
18103 }
18104 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
18105 fn get_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
18106 unsafe {
18107 let __receiver =
18108 <UnitCalculator_TotalResultCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
18109 {
18110 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
18111 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
18112 panic!(
18113 "unity: virtual slot {}
18114 out of range (vtable len {}
18115) on the runtime class behind {}
18116 (method `{}
18117`)",
18118 30usize,
18119 __vt.len(),
18120 <UnitCalculator_TotalResultCommand as ::unity::ClassIdentity>::NAME,
18121 "GetImpl",
18122 )
18123 });
18124 let __inner: extern "C" fn(UnitCalculator_TotalResultCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
18125 ::core::mem::transmute(__vi.method_ptr);
18126 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
18127 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
18128 }
18129 }
18130 }
18131 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
18132 fn get_impl_2(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
18133 unsafe {
18134 let __receiver =
18135 <UnitCalculator_TotalResultCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
18136 {
18137 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
18138 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
18139 panic!(
18140 "unity: virtual slot {}
18141 out of range (vtable len {}
18142) on the runtime class behind {}
18143 (method `{}
18144`)",
18145 31usize,
18146 __vt.len(),
18147 <UnitCalculator_TotalResultCommand as ::unity::ClassIdentity>::NAME,
18148 "GetImpl",
18149 )
18150 });
18151 let __inner: extern "C" fn(
18152 UnitCalculator_TotalResultCommand,
18153 crate::app::battleinfoside::BattleInfoSide,
18154 ::unity::OptionalMethod,
18155 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
18156 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
18157 __inner(__receiver, ::core::convert::Into::into(side), __mi)
18158 }
18159 }
18160 }
18161 #[doc = "`FuncImpl(crate::app::unit::Unit, crate::system::collections::generic::list_1::List_1<f32>)` overload"]
18162 fn func_impl(
18163 self,
18164 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
18165 args: impl ::core::convert::Into<crate::system::collections::generic::list_1::List_1<f32>>,
18166 ) -> f32 {
18167 unsafe {
18168 let __receiver =
18169 <UnitCalculator_TotalResultCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
18170 {
18171 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
18172 let __vi = *__vt.get(34usize).unwrap_or_else(|| {
18173 panic!(
18174 "unity: virtual slot {}
18175 out of range (vtable len {}
18176) on the runtime class behind {}
18177 (method `{}
18178`)",
18179 34usize,
18180 __vt.len(),
18181 <UnitCalculator_TotalResultCommand as ::unity::ClassIdentity>::NAME,
18182 "FuncImpl",
18183 )
18184 });
18185 let __inner: extern "C" fn(
18186 UnitCalculator_TotalResultCommand,
18187 crate::app::unit::Unit,
18188 crate::system::collections::generic::list_1::List_1<f32>,
18189 ::unity::OptionalMethod,
18190 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
18191 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
18192 __inner(__receiver, ::core::convert::Into::into(unit), ::core::convert::Into::into(args), __mi)
18193 }
18194 }
18195 }
18196 #[doc = "`FuncImpl(crate::app::battleinfoside::BattleInfoSide, crate::system::collections::generic::list_1::List_1<f32>)` overload"]
18197 fn func_impl_2(
18198 self,
18199 side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
18200 args: impl ::core::convert::Into<crate::system::collections::generic::list_1::List_1<f32>>,
18201 ) -> f32 {
18202 unsafe {
18203 let __receiver =
18204 <UnitCalculator_TotalResultCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
18205 {
18206 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
18207 let __vi = *__vt.get(35usize).unwrap_or_else(|| {
18208 panic!(
18209 "unity: virtual slot {}
18210 out of range (vtable len {}
18211) on the runtime class behind {}
18212 (method `{}
18213`)",
18214 35usize,
18215 __vt.len(),
18216 <UnitCalculator_TotalResultCommand as ::unity::ClassIdentity>::NAME,
18217 "FuncImpl",
18218 )
18219 });
18220 let __inner: extern "C" fn(
18221 UnitCalculator_TotalResultCommand,
18222 crate::app::battleinfoside::BattleInfoSide,
18223 crate::system::collections::generic::list_1::List_1<f32>,
18224 ::unity::OptionalMethod,
18225 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
18226 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
18227 __inner(__receiver, ::core::convert::Into::into(side), ::core::convert::Into::into(args), __mi)
18228 }
18229 }
18230 }
18231 #[doc = "`.ctor()` overload"]
18232 fn ctor(self) -> () {
18233 unsafe {
18234 let __receiver =
18235 <UnitCalculator_TotalResultCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
18236 ::unity::il2cpp_call!((::unity::module_base()+0x1b4cf90usize)as*mut u8,();
18237(UnitCalculator_TotalResultCommand)__receiver)
18238 }
18239 }
18240}
18241
18242#[cfg(feature = "app-unitcalculator")]
18243impl<__T: IUnitCalculator_TotalResultCommand> IUnitCalculator_TotalResultCommandMethods for __T {}
18244
18245#[cfg(feature = "app-unitcalculator")]
18246impl UnitCalculator_TotalResultCommand {
18247 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
18248 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
18249 }
18250
18251 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
18252 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
18253 }
18254
18255 pub fn get_impl_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
18256 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
18257 }
18258
18259 pub fn func_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
18260 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
18261 }
18262
18263 pub fn func_impl_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
18264 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
18265 }
18266
18267 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
18268 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
18269 }
18270}
18271
18272#[cfg(feature = "app-unitcalculator")]
18273impl UnitCalculator_TotalResultCommand {
18274 #[doc = "Direct (non-virtual) call to `UnitCalculator_TotalResultCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
18275 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
18276 let __mi = Self::get_name_method_info();
18277 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
18278 __inner(this.into(), ::core::option::Option::None)
18279 }
18280
18281 #[doc = "Direct (non-virtual) call to `UnitCalculator_TotalResultCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
18282 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
18283 let __mi = Self::get_impl_method_info();
18284 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
18285 ::core::mem::transmute(__mi.method_ptr);
18286 __inner(this.into(), unit, ::core::option::Option::None)
18287 }
18288
18289 #[doc = "Direct (non-virtual) call to `UnitCalculator_TotalResultCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
18290 pub unsafe fn get_impl_2(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
18291 let __mi = Self::get_impl_2_method_info();
18292 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
18293 ::core::mem::transmute(__mi.method_ptr);
18294 __inner(this.into(), side, ::core::option::Option::None)
18295 }
18296
18297 #[doc = "Direct (non-virtual) call to `UnitCalculator_TotalResultCommand`'s own `FuncImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
18298 pub unsafe fn func_impl(
18299 this: impl ::core::convert::Into<::unity::IlInstance>,
18300 unit: crate::app::unit::Unit,
18301 args: crate::system::collections::generic::list_1::List_1<f32>,
18302 ) -> f32 {
18303 let __mi = Self::func_impl_method_info();
18304 let __inner: extern "C" fn(
18305 ::unity::IlInstance,
18306 crate::app::unit::Unit,
18307 crate::system::collections::generic::list_1::List_1<f32>,
18308 ::unity::OptionalMethod,
18309 ) -> f32 = ::core::mem::transmute(__mi.method_ptr);
18310 __inner(this.into(), unit, args, ::core::option::Option::None)
18311 }
18312
18313 #[doc = "Direct (non-virtual) call to `UnitCalculator_TotalResultCommand`'s own `FuncImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
18314 pub unsafe fn func_impl_2(
18315 this: impl ::core::convert::Into<::unity::IlInstance>,
18316 side: crate::app::battleinfoside::BattleInfoSide,
18317 args: crate::system::collections::generic::list_1::List_1<f32>,
18318 ) -> f32 {
18319 let __mi = Self::func_impl_2_method_info();
18320 let __inner: extern "C" fn(
18321 ::unity::IlInstance,
18322 crate::app::battleinfoside::BattleInfoSide,
18323 crate::system::collections::generic::list_1::List_1<f32>,
18324 ::unity::OptionalMethod,
18325 ) -> f32 = ::core::mem::transmute(__mi.method_ptr);
18326 __inner(this.into(), side, args, ::core::option::Option::None)
18327 }
18328}
18329
18330#[cfg(feature = "app-unitcalculator")]
18331impl UnitCalculator_TotalResultCommand {
18332 #[doc = "`.ctor()` — no args"]
18333 pub fn new() -> Self {
18334 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
18335 panic!(
18336 "{}
18337::{}
18338 failed to instantiate",
18339 ::core::stringify!(UnitCalculator_TotalResultCommand),
18340 ::core::stringify!(new),
18341 )
18342 });
18343 <Self as IUnitCalculator_TotalResultCommandMethods>::ctor(this);
18344 this
18345 }
18346}
18347
18348#[cfg(feature = "app-unitcalculator")]
18349pub trait IUnitCalculator_LinkLuukCommandMethods: IUnitCalculator_LinkLuukCommand {
18350 #[doc = "`get_Name()` overload"]
18351 fn get_name(self) -> ::unity::Il2CppString {
18352 unsafe {
18353 let __receiver =
18354 <UnitCalculator_LinkLuukCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
18355 {
18356 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
18357 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
18358 panic!(
18359 "unity: virtual slot {}
18360 out of range (vtable len {}
18361) on the runtime class behind {}
18362 (method `{}
18363`)",
18364 4usize,
18365 __vt.len(),
18366 <UnitCalculator_LinkLuukCommand as ::unity::ClassIdentity>::NAME,
18367 "get_Name",
18368 )
18369 });
18370 let __inner: extern "C" fn(UnitCalculator_LinkLuukCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
18371 ::core::mem::transmute(__vi.method_ptr);
18372 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
18373 __inner(__receiver, __mi)
18374 }
18375 }
18376 }
18377 #[doc = "`get_CapabilityType()` overload"]
18378 fn get_capability_type(self) -> crate::app::capabilitydefinition::CapabilityDefinition_Type {
18379 unsafe {
18380 let __receiver =
18381 <UnitCalculator_LinkLuukCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
18382 {
18383 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
18384 let __vi = *__vt.get(44usize).unwrap_or_else(|| {
18385 panic!(
18386 "unity: virtual slot {}
18387 out of range (vtable len {}
18388) on the runtime class behind {}
18389 (method `{}
18390`)",
18391 44usize,
18392 __vt.len(),
18393 <UnitCalculator_LinkLuukCommand as ::unity::ClassIdentity>::NAME,
18394 "get_CapabilityType",
18395 )
18396 });
18397 let __inner: extern "C" fn(
18398 UnitCalculator_LinkLuukCommand,
18399 ::unity::OptionalMethod,
18400 ) -> crate::app::capabilitydefinition::CapabilityDefinition_Type = ::core::mem::transmute(__vi.method_ptr);
18401 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
18402 __inner(__receiver, __mi)
18403 }
18404 }
18405 }
18406 #[doc = "`.ctor()` overload"]
18407 fn ctor(self) -> () {
18408 unsafe {
18409 let __receiver =
18410 <UnitCalculator_LinkLuukCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
18411 ::unity::il2cpp_call!((::unity::module_base()+0x1b48aa0usize)as*mut u8,();
18412(UnitCalculator_LinkLuukCommand)__receiver)
18413 }
18414 }
18415}
18416
18417#[cfg(feature = "app-unitcalculator")]
18418impl<__T: IUnitCalculator_LinkLuukCommand> IUnitCalculator_LinkLuukCommandMethods for __T {}
18419
18420#[cfg(feature = "app-unitcalculator")]
18421impl UnitCalculator_LinkLuukCommand {
18422 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
18423 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
18424 }
18425
18426 pub fn get_capability_type_method_info() -> &'static ::unity::il2cpp::MethodInfo {
18427 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
18428 }
18429
18430 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
18431 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
18432 }
18433}
18434
18435#[cfg(feature = "app-unitcalculator")]
18436impl UnitCalculator_LinkLuukCommand {
18437 #[doc = "Direct (non-virtual) call to `UnitCalculator_LinkLuukCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
18438 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
18439 let __mi = Self::get_name_method_info();
18440 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
18441 __inner(this.into(), ::core::option::Option::None)
18442 }
18443
18444 #[doc = "Direct (non-virtual) call to `UnitCalculator_LinkLuukCommand`'s own `get_CapabilityType`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
18445 pub unsafe fn get_capability_type(
18446 this: impl ::core::convert::Into<::unity::IlInstance>,
18447 ) -> crate::app::capabilitydefinition::CapabilityDefinition_Type {
18448 let __mi = Self::get_capability_type_method_info();
18449 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::capabilitydefinition::CapabilityDefinition_Type =
18450 ::core::mem::transmute(__mi.method_ptr);
18451 __inner(this.into(), ::core::option::Option::None)
18452 }
18453}
18454
18455#[cfg(feature = "app-unitcalculator")]
18456impl UnitCalculator_LinkLuukCommand {
18457 #[doc = "`.ctor()` — no args"]
18458 pub fn new() -> Self {
18459 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
18460 panic!(
18461 "{}
18462::{}
18463 failed to instantiate",
18464 ::core::stringify!(UnitCalculator_LinkLuukCommand),
18465 ::core::stringify!(new),
18466 )
18467 });
18468 <Self as IUnitCalculator_LinkLuukCommandMethods>::ctor(this);
18469 this
18470 }
18471}
18472
18473#[cfg(feature = "app-unitcalculator")]
18474pub trait IUnitCalculator_WeaponWeightCommandMethods: IUnitCalculator_WeaponWeightCommand {
18475 #[doc = "`get_Name()` overload"]
18476 fn get_name(self) -> ::unity::Il2CppString {
18477 unsafe {
18478 let __receiver =
18479 <UnitCalculator_WeaponWeightCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
18480 {
18481 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
18482 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
18483 panic!(
18484 "unity: virtual slot {}
18485 out of range (vtable len {}
18486) on the runtime class behind {}
18487 (method `{}
18488`)",
18489 4usize,
18490 __vt.len(),
18491 <UnitCalculator_WeaponWeightCommand as ::unity::ClassIdentity>::NAME,
18492 "get_Name",
18493 )
18494 });
18495 let __inner: extern "C" fn(UnitCalculator_WeaponWeightCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
18496 ::core::mem::transmute(__vi.method_ptr);
18497 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
18498 __inner(__receiver, __mi)
18499 }
18500 }
18501 }
18502 #[doc = "`GetWeight(crate::app::itemdata::ItemData)` overload"]
18503 fn get_weight(self, item: impl ::core::convert::Into<crate::app::itemdata::ItemData>) -> f32 {
18504 unsafe {
18505 let __receiver =
18506 <UnitCalculator_WeaponWeightCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
18507 ::unity::il2cpp_call!((::unity::module_base()+0x1b4edb0usize)as*mut u8,f32;
18508(UnitCalculator_WeaponWeightCommand)__receiver,(crate::app::itemdata::ItemData)::core::convert::Into::into(item))
18509 }
18510 }
18511 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
18512 fn get_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
18513 unsafe {
18514 let __receiver =
18515 <UnitCalculator_WeaponWeightCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
18516 {
18517 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
18518 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
18519 panic!(
18520 "unity: virtual slot {}
18521 out of range (vtable len {}
18522) on the runtime class behind {}
18523 (method `{}
18524`)",
18525 30usize,
18526 __vt.len(),
18527 <UnitCalculator_WeaponWeightCommand as ::unity::ClassIdentity>::NAME,
18528 "GetImpl",
18529 )
18530 });
18531 let __inner: extern "C" fn(UnitCalculator_WeaponWeightCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
18532 ::core::mem::transmute(__vi.method_ptr);
18533 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
18534 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
18535 }
18536 }
18537 }
18538 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
18539 fn get_impl_2(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
18540 unsafe {
18541 let __receiver =
18542 <UnitCalculator_WeaponWeightCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
18543 {
18544 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
18545 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
18546 panic!(
18547 "unity: virtual slot {}
18548 out of range (vtable len {}
18549) on the runtime class behind {}
18550 (method `{}
18551`)",
18552 31usize,
18553 __vt.len(),
18554 <UnitCalculator_WeaponWeightCommand as ::unity::ClassIdentity>::NAME,
18555 "GetImpl",
18556 )
18557 });
18558 let __inner: extern "C" fn(
18559 UnitCalculator_WeaponWeightCommand,
18560 crate::app::battleinfoside::BattleInfoSide,
18561 ::unity::OptionalMethod,
18562 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
18563 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
18564 __inner(__receiver, ::core::convert::Into::into(side), __mi)
18565 }
18566 }
18567 }
18568 #[doc = "`SetImpl(crate::app::battleinfoside::BattleInfoSide, f32)` overload"]
18569 fn set_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>, value: impl ::core::convert::Into<f32>) -> () {
18570 unsafe {
18571 let __receiver =
18572 <UnitCalculator_WeaponWeightCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
18573 {
18574 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
18575 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
18576 panic!(
18577 "unity: virtual slot {}
18578 out of range (vtable len {}
18579) on the runtime class behind {}
18580 (method `{}
18581`)",
18582 33usize,
18583 __vt.len(),
18584 <UnitCalculator_WeaponWeightCommand as ::unity::ClassIdentity>::NAME,
18585 "SetImpl",
18586 )
18587 });
18588 let __inner: extern "C" fn(
18589 UnitCalculator_WeaponWeightCommand,
18590 crate::app::battleinfoside::BattleInfoSide,
18591 f32,
18592 ::unity::OptionalMethod,
18593 ) -> () = ::core::mem::transmute(__vi.method_ptr);
18594 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
18595 __inner(__receiver, ::core::convert::Into::into(side), ::core::convert::Into::into(value), __mi)
18596 }
18597 }
18598 }
18599 #[doc = "`IsVisible()` overload"]
18600 fn is_visible(self) -> bool {
18601 unsafe {
18602 let __receiver =
18603 <UnitCalculator_WeaponWeightCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
18604 {
18605 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
18606 let __vi = *__vt.get(43usize).unwrap_or_else(|| {
18607 panic!(
18608 "unity: virtual slot {}
18609 out of range (vtable len {}
18610) on the runtime class behind {}
18611 (method `{}
18612`)",
18613 43usize,
18614 __vt.len(),
18615 <UnitCalculator_WeaponWeightCommand as ::unity::ClassIdentity>::NAME,
18616 "IsVisible",
18617 )
18618 });
18619 let __inner: extern "C" fn(UnitCalculator_WeaponWeightCommand, ::unity::OptionalMethod) -> bool =
18620 ::core::mem::transmute(__vi.method_ptr);
18621 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
18622 __inner(__receiver, __mi)
18623 }
18624 }
18625 }
18626 #[doc = "`.ctor()` overload"]
18627 fn ctor(self) -> () {
18628 unsafe {
18629 let __receiver =
18630 <UnitCalculator_WeaponWeightCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
18631 ::unity::il2cpp_call!((::unity::module_base()+0x1b4ef90usize)as*mut u8,();
18632(UnitCalculator_WeaponWeightCommand)__receiver)
18633 }
18634 }
18635}
18636
18637#[cfg(feature = "app-unitcalculator")]
18638impl<__T: IUnitCalculator_WeaponWeightCommand> IUnitCalculator_WeaponWeightCommandMethods for __T {}
18639
18640#[cfg(feature = "app-unitcalculator")]
18641impl UnitCalculator_WeaponWeightCommand {
18642 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
18643 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
18644 }
18645
18646 pub fn get_weight_method_info() -> &'static ::unity::il2cpp::MethodInfo {
18647 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
18648 }
18649
18650 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
18651 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
18652 }
18653
18654 pub fn get_impl_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
18655 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
18656 }
18657
18658 pub fn set_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
18659 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
18660 }
18661
18662 pub fn is_visible_method_info() -> &'static ::unity::il2cpp::MethodInfo {
18663 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
18664 }
18665
18666 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
18667 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
18668 }
18669}
18670
18671#[cfg(feature = "app-unitcalculator")]
18672impl UnitCalculator_WeaponWeightCommand {
18673 #[doc = "Direct (non-virtual) call to `UnitCalculator_WeaponWeightCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
18674 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
18675 let __mi = Self::get_name_method_info();
18676 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
18677 __inner(this.into(), ::core::option::Option::None)
18678 }
18679
18680 #[doc = "Direct (non-virtual) call to `UnitCalculator_WeaponWeightCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
18681 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
18682 let __mi = Self::get_impl_method_info();
18683 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
18684 ::core::mem::transmute(__mi.method_ptr);
18685 __inner(this.into(), unit, ::core::option::Option::None)
18686 }
18687
18688 #[doc = "Direct (non-virtual) call to `UnitCalculator_WeaponWeightCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
18689 pub unsafe fn get_impl_2(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
18690 let __mi = Self::get_impl_2_method_info();
18691 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
18692 ::core::mem::transmute(__mi.method_ptr);
18693 __inner(this.into(), side, ::core::option::Option::None)
18694 }
18695
18696 #[doc = "Direct (non-virtual) call to `UnitCalculator_WeaponWeightCommand`'s own `SetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
18697 pub unsafe fn set_impl(
18698 this: impl ::core::convert::Into<::unity::IlInstance>,
18699 side: crate::app::battleinfoside::BattleInfoSide,
18700 value: f32,
18701 ) -> () {
18702 let __mi = Self::set_impl_method_info();
18703 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, f32, ::unity::OptionalMethod) -> () =
18704 ::core::mem::transmute(__mi.method_ptr);
18705 __inner(this.into(), side, value, ::core::option::Option::None)
18706 }
18707
18708 #[doc = "Direct (non-virtual) call to `UnitCalculator_WeaponWeightCommand`'s own `IsVisible`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
18709 pub unsafe fn is_visible(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
18710 let __mi = Self::is_visible_method_info();
18711 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
18712 __inner(this.into(), ::core::option::Option::None)
18713 }
18714}
18715
18716#[cfg(feature = "app-unitcalculator")]
18717impl UnitCalculator_WeaponWeightCommand {
18718 #[doc = "`.ctor()` — no args"]
18719 pub fn new() -> Self {
18720 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
18721 panic!(
18722 "{}
18723::{}
18724 failed to instantiate",
18725 ::core::stringify!(UnitCalculator_WeaponWeightCommand),
18726 ::core::stringify!(new),
18727 )
18728 });
18729 <Self as IUnitCalculator_WeaponWeightCommandMethods>::ctor(this);
18730 this
18731 }
18732}
18733
18734#[cfg(feature = "app-unitcalculator")]
18735pub trait IUnitCalculator_SupportAvoidCommandMethods: IUnitCalculator_SupportAvoidCommand {
18736 #[doc = "`get_Name()` overload"]
18737 fn get_name(self) -> ::unity::Il2CppString {
18738 unsafe {
18739 let __receiver =
18740 <UnitCalculator_SupportAvoidCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
18741 {
18742 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
18743 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
18744 panic!(
18745 "unity: virtual slot {}
18746 out of range (vtable len {}
18747) on the runtime class behind {}
18748 (method `{}
18749`)",
18750 4usize,
18751 __vt.len(),
18752 <UnitCalculator_SupportAvoidCommand as ::unity::ClassIdentity>::NAME,
18753 "get_Name",
18754 )
18755 });
18756 let __inner: extern "C" fn(UnitCalculator_SupportAvoidCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
18757 ::core::mem::transmute(__vi.method_ptr);
18758 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
18759 __inner(__receiver, __mi)
18760 }
18761 }
18762 }
18763 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
18764 fn get_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
18765 unsafe {
18766 let __receiver =
18767 <UnitCalculator_SupportAvoidCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
18768 {
18769 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
18770 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
18771 panic!(
18772 "unity: virtual slot {}
18773 out of range (vtable len {}
18774) on the runtime class behind {}
18775 (method `{}
18776`)",
18777 31usize,
18778 __vt.len(),
18779 <UnitCalculator_SupportAvoidCommand as ::unity::ClassIdentity>::NAME,
18780 "GetImpl",
18781 )
18782 });
18783 let __inner: extern "C" fn(
18784 UnitCalculator_SupportAvoidCommand,
18785 crate::app::battleinfoside::BattleInfoSide,
18786 ::unity::OptionalMethod,
18787 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
18788 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
18789 __inner(__receiver, ::core::convert::Into::into(side), __mi)
18790 }
18791 }
18792 }
18793 #[doc = "`SetImpl(crate::app::battleinfoside::BattleInfoSide, f32)` overload"]
18794 fn set_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>, value: impl ::core::convert::Into<f32>) -> () {
18795 unsafe {
18796 let __receiver =
18797 <UnitCalculator_SupportAvoidCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
18798 {
18799 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
18800 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
18801 panic!(
18802 "unity: virtual slot {}
18803 out of range (vtable len {}
18804) on the runtime class behind {}
18805 (method `{}
18806`)",
18807 33usize,
18808 __vt.len(),
18809 <UnitCalculator_SupportAvoidCommand as ::unity::ClassIdentity>::NAME,
18810 "SetImpl",
18811 )
18812 });
18813 let __inner: extern "C" fn(
18814 UnitCalculator_SupportAvoidCommand,
18815 crate::app::battleinfoside::BattleInfoSide,
18816 f32,
18817 ::unity::OptionalMethod,
18818 ) -> () = ::core::mem::transmute(__vi.method_ptr);
18819 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
18820 __inner(__receiver, ::core::convert::Into::into(side), ::core::convert::Into::into(value), __mi)
18821 }
18822 }
18823 }
18824 #[doc = "`IsVisible()` overload"]
18825 fn is_visible(self) -> bool {
18826 unsafe {
18827 let __receiver =
18828 <UnitCalculator_SupportAvoidCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
18829 {
18830 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
18831 let __vi = *__vt.get(43usize).unwrap_or_else(|| {
18832 panic!(
18833 "unity: virtual slot {}
18834 out of range (vtable len {}
18835) on the runtime class behind {}
18836 (method `{}
18837`)",
18838 43usize,
18839 __vt.len(),
18840 <UnitCalculator_SupportAvoidCommand as ::unity::ClassIdentity>::NAME,
18841 "IsVisible",
18842 )
18843 });
18844 let __inner: extern "C" fn(UnitCalculator_SupportAvoidCommand, ::unity::OptionalMethod) -> bool =
18845 ::core::mem::transmute(__vi.method_ptr);
18846 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
18847 __inner(__receiver, __mi)
18848 }
18849 }
18850 }
18851 #[doc = "`.ctor()` overload"]
18852 fn ctor(self) -> () {
18853 unsafe {
18854 let __receiver =
18855 <UnitCalculator_SupportAvoidCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
18856 ::unity::il2cpp_call!((::unity::module_base()+0x1b4c2c0usize)as*mut u8,();
18857(UnitCalculator_SupportAvoidCommand)__receiver)
18858 }
18859 }
18860}
18861
18862#[cfg(feature = "app-unitcalculator")]
18863impl<__T: IUnitCalculator_SupportAvoidCommand> IUnitCalculator_SupportAvoidCommandMethods for __T {}
18864
18865#[cfg(feature = "app-unitcalculator")]
18866impl UnitCalculator_SupportAvoidCommand {
18867 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
18868 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
18869 }
18870
18871 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
18872 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
18873 }
18874
18875 pub fn set_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
18876 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
18877 }
18878
18879 pub fn is_visible_method_info() -> &'static ::unity::il2cpp::MethodInfo {
18880 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
18881 }
18882
18883 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
18884 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
18885 }
18886}
18887
18888#[cfg(feature = "app-unitcalculator")]
18889impl UnitCalculator_SupportAvoidCommand {
18890 #[doc = "Direct (non-virtual) call to `UnitCalculator_SupportAvoidCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
18891 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
18892 let __mi = Self::get_name_method_info();
18893 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
18894 __inner(this.into(), ::core::option::Option::None)
18895 }
18896
18897 #[doc = "Direct (non-virtual) call to `UnitCalculator_SupportAvoidCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
18898 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
18899 let __mi = Self::get_impl_method_info();
18900 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
18901 ::core::mem::transmute(__mi.method_ptr);
18902 __inner(this.into(), side, ::core::option::Option::None)
18903 }
18904
18905 #[doc = "Direct (non-virtual) call to `UnitCalculator_SupportAvoidCommand`'s own `SetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
18906 pub unsafe fn set_impl(
18907 this: impl ::core::convert::Into<::unity::IlInstance>,
18908 side: crate::app::battleinfoside::BattleInfoSide,
18909 value: f32,
18910 ) -> () {
18911 let __mi = Self::set_impl_method_info();
18912 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, f32, ::unity::OptionalMethod) -> () =
18913 ::core::mem::transmute(__mi.method_ptr);
18914 __inner(this.into(), side, value, ::core::option::Option::None)
18915 }
18916
18917 #[doc = "Direct (non-virtual) call to `UnitCalculator_SupportAvoidCommand`'s own `IsVisible`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
18918 pub unsafe fn is_visible(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
18919 let __mi = Self::is_visible_method_info();
18920 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
18921 __inner(this.into(), ::core::option::Option::None)
18922 }
18923}
18924
18925#[cfg(feature = "app-unitcalculator")]
18926impl UnitCalculator_SupportAvoidCommand {
18927 #[doc = "`.ctor()` — no args"]
18928 pub fn new() -> Self {
18929 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
18930 panic!(
18931 "{}
18932::{}
18933 failed to instantiate",
18934 ::core::stringify!(UnitCalculator_SupportAvoidCommand),
18935 ::core::stringify!(new),
18936 )
18937 });
18938 <Self as IUnitCalculator_SupportAvoidCommandMethods>::ctor(this);
18939 this
18940 }
18941}
18942
18943#[cfg(feature = "app-unitcalculator")]
18944pub trait IUnitCalculator_UnitSkillCommandMethods: IUnitCalculator_UnitSkillCommand {
18945 #[doc = "`get_Name()` overload"]
18946 fn get_name(self) -> ::unity::Il2CppString {
18947 unsafe {
18948 let __receiver =
18949 <UnitCalculator_UnitSkillCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
18950 {
18951 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
18952 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
18953 panic!(
18954 "unity: virtual slot {}
18955 out of range (vtable len {}
18956) on the runtime class behind {}
18957 (method `{}
18958`)",
18959 4usize,
18960 __vt.len(),
18961 <UnitCalculator_UnitSkillCommand as ::unity::ClassIdentity>::NAME,
18962 "get_Name",
18963 )
18964 });
18965 let __inner: extern "C" fn(UnitCalculator_UnitSkillCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
18966 ::core::mem::transmute(__vi.method_ptr);
18967 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
18968 __inner(__receiver, __mi)
18969 }
18970 }
18971 }
18972 #[doc = "`FuncImpl(crate::app::battleinfoside::BattleInfoSide, ::unity::Il2CppString)` overload"]
18973 fn func_impl(
18974 self,
18975 side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
18976 arg: impl ::core::convert::Into<::unity::Il2CppString>,
18977 ) -> f32 {
18978 unsafe {
18979 let __receiver =
18980 <UnitCalculator_UnitSkillCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
18981 {
18982 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
18983 let __vi = *__vt.get(37usize).unwrap_or_else(|| {
18984 panic!(
18985 "unity: virtual slot {}
18986 out of range (vtable len {}
18987) on the runtime class behind {}
18988 (method `{}
18989`)",
18990 37usize,
18991 __vt.len(),
18992 <UnitCalculator_UnitSkillCommand as ::unity::ClassIdentity>::NAME,
18993 "FuncImpl",
18994 )
18995 });
18996 let __inner: extern "C" fn(
18997 UnitCalculator_UnitSkillCommand,
18998 crate::app::battleinfoside::BattleInfoSide,
18999 ::unity::Il2CppString,
19000 ::unity::OptionalMethod,
19001 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
19002 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
19003 __inner(__receiver, ::core::convert::Into::into(side), ::core::convert::Into::into(arg), __mi)
19004 }
19005 }
19006 }
19007 #[doc = "`FuncImpl(crate::app::unit::Unit, ::unity::Il2CppString)` overload"]
19008 fn func_impl_2(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>, arg: impl ::core::convert::Into<::unity::Il2CppString>) -> f32 {
19009 unsafe {
19010 let __receiver =
19011 <UnitCalculator_UnitSkillCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
19012 {
19013 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
19014 let __vi = *__vt.get(36usize).unwrap_or_else(|| {
19015 panic!(
19016 "unity: virtual slot {}
19017 out of range (vtable len {}
19018) on the runtime class behind {}
19019 (method `{}
19020`)",
19021 36usize,
19022 __vt.len(),
19023 <UnitCalculator_UnitSkillCommand as ::unity::ClassIdentity>::NAME,
19024 "FuncImpl",
19025 )
19026 });
19027 let __inner: extern "C" fn(
19028 UnitCalculator_UnitSkillCommand,
19029 crate::app::unit::Unit,
19030 ::unity::Il2CppString,
19031 ::unity::OptionalMethod,
19032 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
19033 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
19034 __inner(__receiver, ::core::convert::Into::into(unit), ::core::convert::Into::into(arg), __mi)
19035 }
19036 }
19037 }
19038 #[doc = "`.ctor()` overload"]
19039 fn ctor(self) -> () {
19040 unsafe {
19041 let __receiver =
19042 <UnitCalculator_UnitSkillCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
19043 ::unity::il2cpp_call!((::unity::module_base()+0x1b4d9c0usize)as*mut u8,();
19044(UnitCalculator_UnitSkillCommand)__receiver)
19045 }
19046 }
19047}
19048
19049#[cfg(feature = "app-unitcalculator")]
19050impl<__T: IUnitCalculator_UnitSkillCommand> IUnitCalculator_UnitSkillCommandMethods for __T {}
19051
19052#[cfg(feature = "app-unitcalculator")]
19053impl UnitCalculator_UnitSkillCommand {
19054 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
19055 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
19056 }
19057
19058 pub fn func_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
19059 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
19060 }
19061
19062 pub fn func_impl_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
19063 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
19064 }
19065
19066 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
19067 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
19068 }
19069}
19070
19071#[cfg(feature = "app-unitcalculator")]
19072impl UnitCalculator_UnitSkillCommand {
19073 #[doc = "Direct (non-virtual) call to `UnitCalculator_UnitSkillCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
19074 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
19075 let __mi = Self::get_name_method_info();
19076 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
19077 __inner(this.into(), ::core::option::Option::None)
19078 }
19079
19080 #[doc = "Direct (non-virtual) call to `UnitCalculator_UnitSkillCommand`'s own `FuncImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
19081 pub unsafe fn func_impl(
19082 this: impl ::core::convert::Into<::unity::IlInstance>,
19083 side: crate::app::battleinfoside::BattleInfoSide,
19084 arg: ::unity::Il2CppString,
19085 ) -> f32 {
19086 let __mi = Self::func_impl_method_info();
19087 let __inner: extern "C" fn(
19088 ::unity::IlInstance,
19089 crate::app::battleinfoside::BattleInfoSide,
19090 ::unity::Il2CppString,
19091 ::unity::OptionalMethod,
19092 ) -> f32 = ::core::mem::transmute(__mi.method_ptr);
19093 __inner(this.into(), side, arg, ::core::option::Option::None)
19094 }
19095
19096 #[doc = "Direct (non-virtual) call to `UnitCalculator_UnitSkillCommand`'s own `FuncImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
19097 pub unsafe fn func_impl_2(
19098 this: impl ::core::convert::Into<::unity::IlInstance>,
19099 unit: crate::app::unit::Unit,
19100 arg: ::unity::Il2CppString,
19101 ) -> f32 {
19102 let __mi = Self::func_impl_2_method_info();
19103 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::Il2CppString, ::unity::OptionalMethod) -> f32 =
19104 ::core::mem::transmute(__mi.method_ptr);
19105 __inner(this.into(), unit, arg, ::core::option::Option::None)
19106 }
19107}
19108
19109#[cfg(feature = "app-unitcalculator")]
19110impl UnitCalculator_UnitSkillCommand {
19111 #[doc = "`.ctor()` — no args"]
19112 pub fn new() -> Self {
19113 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
19114 panic!(
19115 "{}
19116::{}
19117 failed to instantiate",
19118 ::core::stringify!(UnitCalculator_UnitSkillCommand),
19119 ::core::stringify!(new),
19120 )
19121 });
19122 <Self as IUnitCalculator_UnitSkillCommandMethods>::ctor(this);
19123 this
19124 }
19125}
19126
19127#[cfg(feature = "app-unitcalculator")]
19128pub trait IUnitCalculator_AttackCommandMethods: IUnitCalculator_AttackCommand {
19129 #[doc = "`get_Name()` overload"]
19130 fn get_name(self) -> ::unity::Il2CppString {
19131 unsafe {
19132 let __receiver =
19133 <UnitCalculator_AttackCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
19134 {
19135 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
19136 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
19137 panic!(
19138 "unity: virtual slot {}
19139 out of range (vtable len {}
19140) on the runtime class behind {}
19141 (method `{}
19142`)",
19143 4usize,
19144 __vt.len(),
19145 <UnitCalculator_AttackCommand as ::unity::ClassIdentity>::NAME,
19146 "get_Name",
19147 )
19148 });
19149 let __inner: extern "C" fn(UnitCalculator_AttackCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
19150 ::core::mem::transmute(__vi.method_ptr);
19151 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
19152 __inner(__receiver, __mi)
19153 }
19154 }
19155 }
19156 #[doc = "`GetParam(crate::app::battleinfoside::BattleInfoSide)` overload"]
19157 fn get_param(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> crate::app::battleparam::BattleParam {
19158 unsafe {
19159 let __receiver =
19160 <UnitCalculator_AttackCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
19161 {
19162 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
19163 let __vi = *__vt.get(44usize).unwrap_or_else(|| {
19164 panic!(
19165 "unity: virtual slot {}
19166 out of range (vtable len {}
19167) on the runtime class behind {}
19168 (method `{}
19169`)",
19170 44usize,
19171 __vt.len(),
19172 <UnitCalculator_AttackCommand as ::unity::ClassIdentity>::NAME,
19173 "GetParam",
19174 )
19175 });
19176 let __inner: extern "C" fn(
19177 UnitCalculator_AttackCommand,
19178 crate::app::battleinfoside::BattleInfoSide,
19179 ::unity::OptionalMethod,
19180 ) -> crate::app::battleparam::BattleParam = ::core::mem::transmute(__vi.method_ptr);
19181 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
19182 __inner(__receiver, ::core::convert::Into::into(side), __mi)
19183 }
19184 }
19185 }
19186 #[doc = "`IsVisible()` overload"]
19187 fn is_visible(self) -> bool {
19188 unsafe {
19189 let __receiver =
19190 <UnitCalculator_AttackCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
19191 {
19192 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
19193 let __vi = *__vt.get(43usize).unwrap_or_else(|| {
19194 panic!(
19195 "unity: virtual slot {}
19196 out of range (vtable len {}
19197) on the runtime class behind {}
19198 (method `{}
19199`)",
19200 43usize,
19201 __vt.len(),
19202 <UnitCalculator_AttackCommand as ::unity::ClassIdentity>::NAME,
19203 "IsVisible",
19204 )
19205 });
19206 let __inner: extern "C" fn(UnitCalculator_AttackCommand, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
19207 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
19208 __inner(__receiver, __mi)
19209 }
19210 }
19211 }
19212 #[doc = "`.ctor()` overload"]
19213 fn ctor(self) -> () {
19214 unsafe {
19215 let __receiver =
19216 <UnitCalculator_AttackCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
19217 ::unity::il2cpp_call!((::unity::module_base()+0x1b45470usize)as*mut u8,();
19218(UnitCalculator_AttackCommand)__receiver)
19219 }
19220 }
19221}
19222
19223#[cfg(feature = "app-unitcalculator")]
19224impl<__T: IUnitCalculator_AttackCommand> IUnitCalculator_AttackCommandMethods for __T {}
19225
19226#[cfg(feature = "app-unitcalculator")]
19227impl UnitCalculator_AttackCommand {
19228 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
19229 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
19230 }
19231
19232 pub fn get_param_method_info() -> &'static ::unity::il2cpp::MethodInfo {
19233 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
19234 }
19235
19236 pub fn is_visible_method_info() -> &'static ::unity::il2cpp::MethodInfo {
19237 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
19238 }
19239
19240 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
19241 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
19242 }
19243}
19244
19245#[cfg(feature = "app-unitcalculator")]
19246impl UnitCalculator_AttackCommand {
19247 #[doc = "Direct (non-virtual) call to `UnitCalculator_AttackCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
19248 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
19249 let __mi = Self::get_name_method_info();
19250 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
19251 __inner(this.into(), ::core::option::Option::None)
19252 }
19253
19254 #[doc = "Direct (non-virtual) call to `UnitCalculator_AttackCommand`'s own `GetParam`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
19255 pub unsafe fn get_param(
19256 this: impl ::core::convert::Into<::unity::IlInstance>,
19257 side: crate::app::battleinfoside::BattleInfoSide,
19258 ) -> crate::app::battleparam::BattleParam {
19259 let __mi = Self::get_param_method_info();
19260 let __inner: extern "C" fn(
19261 ::unity::IlInstance,
19262 crate::app::battleinfoside::BattleInfoSide,
19263 ::unity::OptionalMethod,
19264 ) -> crate::app::battleparam::BattleParam = ::core::mem::transmute(__mi.method_ptr);
19265 __inner(this.into(), side, ::core::option::Option::None)
19266 }
19267
19268 #[doc = "Direct (non-virtual) call to `UnitCalculator_AttackCommand`'s own `IsVisible`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
19269 pub unsafe fn is_visible(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
19270 let __mi = Self::is_visible_method_info();
19271 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
19272 __inner(this.into(), ::core::option::Option::None)
19273 }
19274}
19275
19276#[cfg(feature = "app-unitcalculator")]
19277impl UnitCalculator_AttackCommand {
19278 #[doc = "`.ctor()` — no args"]
19279 pub fn new() -> Self {
19280 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
19281 panic!(
19282 "{}
19283::{}
19284 failed to instantiate",
19285 ::core::stringify!(UnitCalculator_AttackCommand),
19286 ::core::stringify!(new),
19287 )
19288 });
19289 <Self as IUnitCalculator_AttackCommandMethods>::ctor(this);
19290 this
19291 }
19292}
19293
19294#[cfg(feature = "app-unitcalculator")]
19295pub trait IUnitCalculator_TotalLevelCommandMethods: IUnitCalculator_TotalLevelCommand {
19296 #[doc = "`get_Name()` overload"]
19297 fn get_name(self) -> ::unity::Il2CppString {
19298 unsafe {
19299 let __receiver =
19300 <UnitCalculator_TotalLevelCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
19301 {
19302 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
19303 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
19304 panic!(
19305 "unity: virtual slot {}
19306 out of range (vtable len {}
19307) on the runtime class behind {}
19308 (method `{}
19309`)",
19310 4usize,
19311 __vt.len(),
19312 <UnitCalculator_TotalLevelCommand as ::unity::ClassIdentity>::NAME,
19313 "get_Name",
19314 )
19315 });
19316 let __inner: extern "C" fn(UnitCalculator_TotalLevelCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
19317 ::core::mem::transmute(__vi.method_ptr);
19318 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
19319 __inner(__receiver, __mi)
19320 }
19321 }
19322 }
19323 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
19324 fn get_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
19325 unsafe {
19326 let __receiver =
19327 <UnitCalculator_TotalLevelCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
19328 {
19329 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
19330 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
19331 panic!(
19332 "unity: virtual slot {}
19333 out of range (vtable len {}
19334) on the runtime class behind {}
19335 (method `{}
19336`)",
19337 30usize,
19338 __vt.len(),
19339 <UnitCalculator_TotalLevelCommand as ::unity::ClassIdentity>::NAME,
19340 "GetImpl",
19341 )
19342 });
19343 let __inner: extern "C" fn(UnitCalculator_TotalLevelCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
19344 ::core::mem::transmute(__vi.method_ptr);
19345 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
19346 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
19347 }
19348 }
19349 }
19350 #[doc = "`.ctor()` overload"]
19351 fn ctor(self) -> () {
19352 unsafe {
19353 let __receiver =
19354 <UnitCalculator_TotalLevelCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
19355 ::unity::il2cpp_call!((::unity::module_base()+0x1b4ccd0usize)as*mut u8,();
19356(UnitCalculator_TotalLevelCommand)__receiver)
19357 }
19358 }
19359}
19360
19361#[cfg(feature = "app-unitcalculator")]
19362impl<__T: IUnitCalculator_TotalLevelCommand> IUnitCalculator_TotalLevelCommandMethods for __T {}
19363
19364#[cfg(feature = "app-unitcalculator")]
19365impl UnitCalculator_TotalLevelCommand {
19366 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
19367 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
19368 }
19369
19370 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
19371 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
19372 }
19373
19374 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
19375 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
19376 }
19377}
19378
19379#[cfg(feature = "app-unitcalculator")]
19380impl UnitCalculator_TotalLevelCommand {
19381 #[doc = "Direct (non-virtual) call to `UnitCalculator_TotalLevelCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
19382 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
19383 let __mi = Self::get_name_method_info();
19384 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
19385 __inner(this.into(), ::core::option::Option::None)
19386 }
19387
19388 #[doc = "Direct (non-virtual) call to `UnitCalculator_TotalLevelCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
19389 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
19390 let __mi = Self::get_impl_method_info();
19391 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
19392 ::core::mem::transmute(__mi.method_ptr);
19393 __inner(this.into(), unit, ::core::option::Option::None)
19394 }
19395}
19396
19397#[cfg(feature = "app-unitcalculator")]
19398impl UnitCalculator_TotalLevelCommand {
19399 #[doc = "`.ctor()` — no args"]
19400 pub fn new() -> Self {
19401 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
19402 panic!(
19403 "{}
19404::{}
19405 failed to instantiate",
19406 ::core::stringify!(UnitCalculator_TotalLevelCommand),
19407 ::core::stringify!(new),
19408 )
19409 });
19410 <Self as IUnitCalculator_TotalLevelCommandMethods>::ctor(this);
19411 this
19412 }
19413}
19414
19415#[cfg(feature = "app-unitcalculator")]
19416pub trait IUnitCalculator_TotalActionCommandMethods: IUnitCalculator_TotalActionCommand {
19417 #[doc = "`get_Name()` overload"]
19418 fn get_name(self) -> ::unity::Il2CppString {
19419 unsafe {
19420 let __receiver =
19421 <UnitCalculator_TotalActionCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
19422 {
19423 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
19424 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
19425 panic!(
19426 "unity: virtual slot {}
19427 out of range (vtable len {}
19428) on the runtime class behind {}
19429 (method `{}
19430`)",
19431 4usize,
19432 __vt.len(),
19433 <UnitCalculator_TotalActionCommand as ::unity::ClassIdentity>::NAME,
19434 "get_Name",
19435 )
19436 });
19437 let __inner: extern "C" fn(UnitCalculator_TotalActionCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
19438 ::core::mem::transmute(__vi.method_ptr);
19439 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
19440 __inner(__receiver, __mi)
19441 }
19442 }
19443 }
19444 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
19445 fn get_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
19446 unsafe {
19447 let __receiver =
19448 <UnitCalculator_TotalActionCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
19449 {
19450 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
19451 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
19452 panic!(
19453 "unity: virtual slot {}
19454 out of range (vtable len {}
19455) on the runtime class behind {}
19456 (method `{}
19457`)",
19458 31usize,
19459 __vt.len(),
19460 <UnitCalculator_TotalActionCommand as ::unity::ClassIdentity>::NAME,
19461 "GetImpl",
19462 )
19463 });
19464 let __inner: extern "C" fn(
19465 UnitCalculator_TotalActionCommand,
19466 crate::app::battleinfoside::BattleInfoSide,
19467 ::unity::OptionalMethod,
19468 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
19469 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
19470 __inner(__receiver, ::core::convert::Into::into(side), __mi)
19471 }
19472 }
19473 }
19474 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
19475 fn get_impl_2(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
19476 unsafe {
19477 let __receiver =
19478 <UnitCalculator_TotalActionCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
19479 {
19480 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
19481 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
19482 panic!(
19483 "unity: virtual slot {}
19484 out of range (vtable len {}
19485) on the runtime class behind {}
19486 (method `{}
19487`)",
19488 30usize,
19489 __vt.len(),
19490 <UnitCalculator_TotalActionCommand as ::unity::ClassIdentity>::NAME,
19491 "GetImpl",
19492 )
19493 });
19494 let __inner: extern "C" fn(UnitCalculator_TotalActionCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
19495 ::core::mem::transmute(__vi.method_ptr);
19496 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
19497 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
19498 }
19499 }
19500 }
19501 #[doc = "`.ctor()` overload"]
19502 fn ctor(self) -> () {
19503 unsafe {
19504 let __receiver =
19505 <UnitCalculator_TotalActionCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
19506 ::unity::il2cpp_call!((::unity::module_base()+0x1b4cb60usize)as*mut u8,();
19507(UnitCalculator_TotalActionCommand)__receiver)
19508 }
19509 }
19510}
19511
19512#[cfg(feature = "app-unitcalculator")]
19513impl<__T: IUnitCalculator_TotalActionCommand> IUnitCalculator_TotalActionCommandMethods for __T {}
19514
19515#[cfg(feature = "app-unitcalculator")]
19516impl UnitCalculator_TotalActionCommand {
19517 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
19518 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
19519 }
19520
19521 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
19522 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
19523 }
19524
19525 pub fn get_impl_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
19526 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
19527 }
19528
19529 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
19530 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
19531 }
19532}
19533
19534#[cfg(feature = "app-unitcalculator")]
19535impl UnitCalculator_TotalActionCommand {
19536 #[doc = "Direct (non-virtual) call to `UnitCalculator_TotalActionCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
19537 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
19538 let __mi = Self::get_name_method_info();
19539 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
19540 __inner(this.into(), ::core::option::Option::None)
19541 }
19542
19543 #[doc = "Direct (non-virtual) call to `UnitCalculator_TotalActionCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
19544 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
19545 let __mi = Self::get_impl_method_info();
19546 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
19547 ::core::mem::transmute(__mi.method_ptr);
19548 __inner(this.into(), side, ::core::option::Option::None)
19549 }
19550
19551 #[doc = "Direct (non-virtual) call to `UnitCalculator_TotalActionCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
19552 pub unsafe fn get_impl_2(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
19553 let __mi = Self::get_impl_2_method_info();
19554 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
19555 ::core::mem::transmute(__mi.method_ptr);
19556 __inner(this.into(), unit, ::core::option::Option::None)
19557 }
19558}
19559
19560#[cfg(feature = "app-unitcalculator")]
19561impl UnitCalculator_TotalActionCommand {
19562 #[doc = "`.ctor()` — no args"]
19563 pub fn new() -> Self {
19564 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
19565 panic!(
19566 "{}
19567::{}
19568 failed to instantiate",
19569 ::core::stringify!(UnitCalculator_TotalActionCommand),
19570 ::core::stringify!(new),
19571 )
19572 });
19573 <Self as IUnitCalculator_TotalActionCommandMethods>::ctor(this);
19574 this
19575 }
19576}
19577
19578#[cfg(feature = "app-unitcalculator")]
19579pub trait IUnitCalculator_BattleCountCommandMethods: IUnitCalculator_BattleCountCommand {
19580 #[doc = "`get_Name()` overload"]
19581 fn get_name(self) -> ::unity::Il2CppString {
19582 unsafe {
19583 let __receiver =
19584 <UnitCalculator_BattleCountCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
19585 {
19586 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
19587 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
19588 panic!(
19589 "unity: virtual slot {}
19590 out of range (vtable len {}
19591) on the runtime class behind {}
19592 (method `{}
19593`)",
19594 4usize,
19595 __vt.len(),
19596 <UnitCalculator_BattleCountCommand as ::unity::ClassIdentity>::NAME,
19597 "get_Name",
19598 )
19599 });
19600 let __inner: extern "C" fn(UnitCalculator_BattleCountCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
19601 ::core::mem::transmute(__vi.method_ptr);
19602 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
19603 __inner(__receiver, __mi)
19604 }
19605 }
19606 }
19607 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
19608 fn get_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
19609 unsafe {
19610 let __receiver =
19611 <UnitCalculator_BattleCountCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
19612 {
19613 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
19614 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
19615 panic!(
19616 "unity: virtual slot {}
19617 out of range (vtable len {}
19618) on the runtime class behind {}
19619 (method `{}
19620`)",
19621 31usize,
19622 __vt.len(),
19623 <UnitCalculator_BattleCountCommand as ::unity::ClassIdentity>::NAME,
19624 "GetImpl",
19625 )
19626 });
19627 let __inner: extern "C" fn(
19628 UnitCalculator_BattleCountCommand,
19629 crate::app::battleinfoside::BattleInfoSide,
19630 ::unity::OptionalMethod,
19631 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
19632 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
19633 __inner(__receiver, ::core::convert::Into::into(side), __mi)
19634 }
19635 }
19636 }
19637 #[doc = "`.ctor()` overload"]
19638 fn ctor(self) -> () {
19639 unsafe {
19640 let __receiver =
19641 <UnitCalculator_BattleCountCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
19642 ::unity::il2cpp_call!((::unity::module_base()+0x1b45920usize)as*mut u8,();
19643(UnitCalculator_BattleCountCommand)__receiver)
19644 }
19645 }
19646}
19647
19648#[cfg(feature = "app-unitcalculator")]
19649impl<__T: IUnitCalculator_BattleCountCommand> IUnitCalculator_BattleCountCommandMethods for __T {}
19650
19651#[cfg(feature = "app-unitcalculator")]
19652impl UnitCalculator_BattleCountCommand {
19653 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
19654 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
19655 }
19656
19657 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
19658 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
19659 }
19660
19661 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
19662 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
19663 }
19664}
19665
19666#[cfg(feature = "app-unitcalculator")]
19667impl UnitCalculator_BattleCountCommand {
19668 #[doc = "Direct (non-virtual) call to `UnitCalculator_BattleCountCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
19669 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
19670 let __mi = Self::get_name_method_info();
19671 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
19672 __inner(this.into(), ::core::option::Option::None)
19673 }
19674
19675 #[doc = "Direct (non-virtual) call to `UnitCalculator_BattleCountCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
19676 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
19677 let __mi = Self::get_impl_method_info();
19678 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
19679 ::core::mem::transmute(__mi.method_ptr);
19680 __inner(this.into(), side, ::core::option::Option::None)
19681 }
19682}
19683
19684#[cfg(feature = "app-unitcalculator")]
19685impl UnitCalculator_BattleCountCommand {
19686 #[doc = "`.ctor()` — no args"]
19687 pub fn new() -> Self {
19688 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
19689 panic!(
19690 "{}
19691::{}
19692 failed to instantiate",
19693 ::core::stringify!(UnitCalculator_BattleCountCommand),
19694 ::core::stringify!(new),
19695 )
19696 });
19697 <Self as IUnitCalculator_BattleCountCommandMethods>::ctor(this);
19698 this
19699 }
19700}
19701
19702#[cfg(feature = "app-unitcalculator")]
19703pub trait IUnitCalculator_RangeUnitCountCommandMethods: IUnitCalculator_RangeUnitCountCommand {
19704 #[doc = "`get_Name()` overload"]
19705 fn get_name(self) -> ::unity::Il2CppString {
19706 unsafe {
19707 let __receiver = <UnitCalculator_RangeUnitCountCommand as ::unity::FromIlInstance>::from_il_instance(
19708 <Self as ::unity::SystemObject>::as_instance(self),
19709 );
19710 {
19711 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
19712 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
19713 panic!(
19714 "unity: virtual slot {}
19715 out of range (vtable len {}
19716) on the runtime class behind {}
19717 (method `{}
19718`)",
19719 4usize,
19720 __vt.len(),
19721 <UnitCalculator_RangeUnitCountCommand as ::unity::ClassIdentity>::NAME,
19722 "get_Name",
19723 )
19724 });
19725 let __inner: extern "C" fn(UnitCalculator_RangeUnitCountCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
19726 ::core::mem::transmute(__vi.method_ptr);
19727 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
19728 __inner(__receiver, __mi)
19729 }
19730 }
19731 }
19732 #[doc = "`FuncImpl(crate::app::unit::Unit, crate::system::collections::generic::list_1::List_1<f32>)` overload"]
19733 fn func_impl(
19734 self,
19735 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
19736 args: impl ::core::convert::Into<crate::system::collections::generic::list_1::List_1<f32>>,
19737 ) -> f32 {
19738 unsafe {
19739 let __receiver = <UnitCalculator_RangeUnitCountCommand as ::unity::FromIlInstance>::from_il_instance(
19740 <Self as ::unity::SystemObject>::as_instance(self),
19741 );
19742 {
19743 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
19744 let __vi = *__vt.get(34usize).unwrap_or_else(|| {
19745 panic!(
19746 "unity: virtual slot {}
19747 out of range (vtable len {}
19748) on the runtime class behind {}
19749 (method `{}
19750`)",
19751 34usize,
19752 __vt.len(),
19753 <UnitCalculator_RangeUnitCountCommand as ::unity::ClassIdentity>::NAME,
19754 "FuncImpl",
19755 )
19756 });
19757 let __inner: extern "C" fn(
19758 UnitCalculator_RangeUnitCountCommand,
19759 crate::app::unit::Unit,
19760 crate::system::collections::generic::list_1::List_1<f32>,
19761 ::unity::OptionalMethod,
19762 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
19763 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
19764 __inner(__receiver, ::core::convert::Into::into(unit), ::core::convert::Into::into(args), __mi)
19765 }
19766 }
19767 }
19768 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
19769 fn get_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
19770 unsafe {
19771 let __receiver = <UnitCalculator_RangeUnitCountCommand as ::unity::FromIlInstance>::from_il_instance(
19772 <Self as ::unity::SystemObject>::as_instance(self),
19773 );
19774 {
19775 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
19776 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
19777 panic!(
19778 "unity: virtual slot {}
19779 out of range (vtable len {}
19780) on the runtime class behind {}
19781 (method `{}
19782`)",
19783 30usize,
19784 __vt.len(),
19785 <UnitCalculator_RangeUnitCountCommand as ::unity::ClassIdentity>::NAME,
19786 "GetImpl",
19787 )
19788 });
19789 let __inner: extern "C" fn(UnitCalculator_RangeUnitCountCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
19790 ::core::mem::transmute(__vi.method_ptr);
19791 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
19792 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
19793 }
19794 }
19795 }
19796 #[doc = "`.ctor()` overload"]
19797 fn ctor(self) -> () {
19798 unsafe {
19799 let __receiver = <UnitCalculator_RangeUnitCountCommand as ::unity::FromIlInstance>::from_il_instance(
19800 <Self as ::unity::SystemObject>::as_instance(self),
19801 );
19802 ::unity::il2cpp_call!((::unity::module_base()+0x1b4b770usize)as*mut u8,();
19803(UnitCalculator_RangeUnitCountCommand)__receiver)
19804 }
19805 }
19806}
19807
19808#[cfg(feature = "app-unitcalculator")]
19809impl<__T: IUnitCalculator_RangeUnitCountCommand> IUnitCalculator_RangeUnitCountCommandMethods for __T {}
19810
19811#[cfg(feature = "app-unitcalculator")]
19812impl UnitCalculator_RangeUnitCountCommand {
19813 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
19814 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
19815 }
19816
19817 pub fn func_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
19818 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
19819 }
19820
19821 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
19822 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
19823 }
19824
19825 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
19826 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
19827 }
19828}
19829
19830#[cfg(feature = "app-unitcalculator")]
19831impl UnitCalculator_RangeUnitCountCommand {
19832 #[doc = "Direct (non-virtual) call to `UnitCalculator_RangeUnitCountCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
19833 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
19834 let __mi = Self::get_name_method_info();
19835 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
19836 __inner(this.into(), ::core::option::Option::None)
19837 }
19838
19839 #[doc = "Direct (non-virtual) call to `UnitCalculator_RangeUnitCountCommand`'s own `FuncImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
19840 pub unsafe fn func_impl(
19841 this: impl ::core::convert::Into<::unity::IlInstance>,
19842 unit: crate::app::unit::Unit,
19843 args: crate::system::collections::generic::list_1::List_1<f32>,
19844 ) -> f32 {
19845 let __mi = Self::func_impl_method_info();
19846 let __inner: extern "C" fn(
19847 ::unity::IlInstance,
19848 crate::app::unit::Unit,
19849 crate::system::collections::generic::list_1::List_1<f32>,
19850 ::unity::OptionalMethod,
19851 ) -> f32 = ::core::mem::transmute(__mi.method_ptr);
19852 __inner(this.into(), unit, args, ::core::option::Option::None)
19853 }
19854
19855 #[doc = "Direct (non-virtual) call to `UnitCalculator_RangeUnitCountCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
19856 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
19857 let __mi = Self::get_impl_method_info();
19858 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
19859 ::core::mem::transmute(__mi.method_ptr);
19860 __inner(this.into(), unit, ::core::option::Option::None)
19861 }
19862}
19863
19864#[cfg(feature = "app-unitcalculator")]
19865impl UnitCalculator_RangeUnitCountCommand {
19866 #[doc = "`.ctor()` — no args"]
19867 pub fn new() -> Self {
19868 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
19869 panic!(
19870 "{}
19871::{}
19872 failed to instantiate",
19873 ::core::stringify!(UnitCalculator_RangeUnitCountCommand),
19874 ::core::stringify!(new),
19875 )
19876 });
19877 <Self as IUnitCalculator_RangeUnitCountCommandMethods>::ctor(this);
19878 this
19879 }
19880}
19881
19882#[cfg(feature = "app-unitcalculator")]
19883pub trait IUnitCalculator_UnitAroundCountdCommandMethods: IUnitCalculator_UnitAroundCountdCommand {
19884 #[doc = "`get_Name()` overload"]
19885 fn get_name(self) -> ::unity::Il2CppString {
19886 unsafe {
19887 let __receiver = <UnitCalculator_UnitAroundCountdCommand as ::unity::FromIlInstance>::from_il_instance(
19888 <Self as ::unity::SystemObject>::as_instance(self),
19889 );
19890 {
19891 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
19892 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
19893 panic!(
19894 "unity: virtual slot {}
19895 out of range (vtable len {}
19896) on the runtime class behind {}
19897 (method `{}
19898`)",
19899 4usize,
19900 __vt.len(),
19901 <UnitCalculator_UnitAroundCountdCommand as ::unity::ClassIdentity>::NAME,
19902 "get_Name",
19903 )
19904 });
19905 let __inner: extern "C" fn(UnitCalculator_UnitAroundCountdCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
19906 ::core::mem::transmute(__vi.method_ptr);
19907 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
19908 __inner(__receiver, __mi)
19909 }
19910 }
19911 }
19912 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
19913 fn get_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
19914 unsafe {
19915 let __receiver = <UnitCalculator_UnitAroundCountdCommand as ::unity::FromIlInstance>::from_il_instance(
19916 <Self as ::unity::SystemObject>::as_instance(self),
19917 );
19918 {
19919 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
19920 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
19921 panic!(
19922 "unity: virtual slot {}
19923 out of range (vtable len {}
19924) on the runtime class behind {}
19925 (method `{}
19926`)",
19927 30usize,
19928 __vt.len(),
19929 <UnitCalculator_UnitAroundCountdCommand as ::unity::ClassIdentity>::NAME,
19930 "GetImpl",
19931 )
19932 });
19933 let __inner: extern "C" fn(UnitCalculator_UnitAroundCountdCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
19934 ::core::mem::transmute(__vi.method_ptr);
19935 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
19936 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
19937 }
19938 }
19939 }
19940 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
19941 fn get_impl_2(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
19942 unsafe {
19943 let __receiver = <UnitCalculator_UnitAroundCountdCommand as ::unity::FromIlInstance>::from_il_instance(
19944 <Self as ::unity::SystemObject>::as_instance(self),
19945 );
19946 {
19947 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
19948 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
19949 panic!(
19950 "unity: virtual slot {}
19951 out of range (vtable len {}
19952) on the runtime class behind {}
19953 (method `{}
19954`)",
19955 31usize,
19956 __vt.len(),
19957 <UnitCalculator_UnitAroundCountdCommand as ::unity::ClassIdentity>::NAME,
19958 "GetImpl",
19959 )
19960 });
19961 let __inner: extern "C" fn(
19962 UnitCalculator_UnitAroundCountdCommand,
19963 crate::app::battleinfoside::BattleInfoSide,
19964 ::unity::OptionalMethod,
19965 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
19966 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
19967 __inner(__receiver, ::core::convert::Into::into(side), __mi)
19968 }
19969 }
19970 }
19971 #[doc = "`.ctor()` overload"]
19972 fn ctor(self) -> () {
19973 unsafe {
19974 let __receiver = <UnitCalculator_UnitAroundCountdCommand as ::unity::FromIlInstance>::from_il_instance(
19975 <Self as ::unity::SystemObject>::as_instance(self),
19976 );
19977 ::unity::il2cpp_call!((::unity::module_base()+0x1b4d200usize)as*mut u8,();
19978(UnitCalculator_UnitAroundCountdCommand)__receiver)
19979 }
19980 }
19981}
19982
19983#[cfg(feature = "app-unitcalculator")]
19984impl<__T: IUnitCalculator_UnitAroundCountdCommand> IUnitCalculator_UnitAroundCountdCommandMethods for __T {}
19985
19986#[cfg(feature = "app-unitcalculator")]
19987impl UnitCalculator_UnitAroundCountdCommand {
19988 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
19989 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
19990 }
19991
19992 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
19993 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
19994 }
19995
19996 pub fn get_impl_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
19997 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
19998 }
19999
20000 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
20001 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
20002 }
20003}
20004
20005#[cfg(feature = "app-unitcalculator")]
20006impl UnitCalculator_UnitAroundCountdCommand {
20007 #[doc = "Direct (non-virtual) call to `UnitCalculator_UnitAroundCountdCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
20008 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
20009 let __mi = Self::get_name_method_info();
20010 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
20011 __inner(this.into(), ::core::option::Option::None)
20012 }
20013
20014 #[doc = "Direct (non-virtual) call to `UnitCalculator_UnitAroundCountdCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
20015 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
20016 let __mi = Self::get_impl_method_info();
20017 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
20018 ::core::mem::transmute(__mi.method_ptr);
20019 __inner(this.into(), unit, ::core::option::Option::None)
20020 }
20021
20022 #[doc = "Direct (non-virtual) call to `UnitCalculator_UnitAroundCountdCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
20023 pub unsafe fn get_impl_2(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
20024 let __mi = Self::get_impl_2_method_info();
20025 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
20026 ::core::mem::transmute(__mi.method_ptr);
20027 __inner(this.into(), side, ::core::option::Option::None)
20028 }
20029}
20030
20031#[cfg(feature = "app-unitcalculator")]
20032impl UnitCalculator_UnitAroundCountdCommand {
20033 #[doc = "`.ctor()` — no args"]
20034 pub fn new() -> Self {
20035 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
20036 panic!(
20037 "{}
20038::{}
20039 failed to instantiate",
20040 ::core::stringify!(UnitCalculator_UnitAroundCountdCommand),
20041 ::core::stringify!(new),
20042 )
20043 });
20044 <Self as IUnitCalculator_UnitAroundCountdCommandMethods>::ctor(this);
20045 this
20046 }
20047}
20048
20049#[cfg(feature = "app-unitcalculator")]
20050pub trait IUnitCalculator_MaxHPCommandMethods: IUnitCalculator_MaxHPCommand {
20051 #[doc = "`get_Name()` overload"]
20052 fn get_name(self) -> ::unity::Il2CppString {
20053 unsafe {
20054 let __receiver =
20055 <UnitCalculator_MaxHPCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
20056 {
20057 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
20058 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
20059 panic!(
20060 "unity: virtual slot {}
20061 out of range (vtable len {}
20062) on the runtime class behind {}
20063 (method `{}
20064`)",
20065 4usize,
20066 __vt.len(),
20067 <UnitCalculator_MaxHPCommand as ::unity::ClassIdentity>::NAME,
20068 "get_Name",
20069 )
20070 });
20071 let __inner: extern "C" fn(UnitCalculator_MaxHPCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
20072 ::core::mem::transmute(__vi.method_ptr);
20073 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
20074 __inner(__receiver, __mi)
20075 }
20076 }
20077 }
20078 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
20079 fn get_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
20080 unsafe {
20081 let __receiver =
20082 <UnitCalculator_MaxHPCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
20083 {
20084 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
20085 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
20086 panic!(
20087 "unity: virtual slot {}
20088 out of range (vtable len {}
20089) on the runtime class behind {}
20090 (method `{}
20091`)",
20092 30usize,
20093 __vt.len(),
20094 <UnitCalculator_MaxHPCommand as ::unity::ClassIdentity>::NAME,
20095 "GetImpl",
20096 )
20097 });
20098 let __inner: extern "C" fn(UnitCalculator_MaxHPCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
20099 ::core::mem::transmute(__vi.method_ptr);
20100 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
20101 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
20102 }
20103 }
20104 }
20105 #[doc = "`.ctor()` overload"]
20106 fn ctor(self) -> () {
20107 unsafe {
20108 let __receiver =
20109 <UnitCalculator_MaxHPCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
20110 ::unity::il2cpp_call!((::unity::module_base()+0x1b4a2b0usize)as*mut u8,();
20111(UnitCalculator_MaxHPCommand)__receiver)
20112 }
20113 }
20114}
20115
20116#[cfg(feature = "app-unitcalculator")]
20117impl<__T: IUnitCalculator_MaxHPCommand> IUnitCalculator_MaxHPCommandMethods for __T {}
20118
20119#[cfg(feature = "app-unitcalculator")]
20120impl UnitCalculator_MaxHPCommand {
20121 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
20122 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
20123 }
20124
20125 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
20126 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
20127 }
20128
20129 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
20130 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
20131 }
20132}
20133
20134#[cfg(feature = "app-unitcalculator")]
20135impl UnitCalculator_MaxHPCommand {
20136 #[doc = "Direct (non-virtual) call to `UnitCalculator_MaxHPCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
20137 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
20138 let __mi = Self::get_name_method_info();
20139 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
20140 __inner(this.into(), ::core::option::Option::None)
20141 }
20142
20143 #[doc = "Direct (non-virtual) call to `UnitCalculator_MaxHPCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
20144 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
20145 let __mi = Self::get_impl_method_info();
20146 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
20147 ::core::mem::transmute(__mi.method_ptr);
20148 __inner(this.into(), unit, ::core::option::Option::None)
20149 }
20150}
20151
20152#[cfg(feature = "app-unitcalculator")]
20153impl UnitCalculator_MaxHPCommand {
20154 #[doc = "`.ctor()` — no args"]
20155 pub fn new() -> Self {
20156 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
20157 panic!(
20158 "{}
20159::{}
20160 failed to instantiate",
20161 ::core::stringify!(UnitCalculator_MaxHPCommand),
20162 ::core::stringify!(new),
20163 )
20164 });
20165 <Self as IUnitCalculator_MaxHPCommandMethods>::ctor(this);
20166 this
20167 }
20168}
20169
20170#[cfg(feature = "app-unitcalculator")]
20171pub trait IUnitCalculator_BattleSideCommandMethods: IUnitCalculator_BattleSideCommand {
20172 #[doc = "`get_Name()` overload"]
20173 fn get_name(self) -> ::unity::Il2CppString {
20174 unsafe {
20175 let __receiver =
20176 <UnitCalculator_BattleSideCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
20177 {
20178 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
20179 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
20180 panic!(
20181 "unity: virtual slot {}
20182 out of range (vtable len {}
20183) on the runtime class behind {}
20184 (method `{}
20185`)",
20186 4usize,
20187 __vt.len(),
20188 <UnitCalculator_BattleSideCommand as ::unity::ClassIdentity>::NAME,
20189 "get_Name",
20190 )
20191 });
20192 let __inner: extern "C" fn(UnitCalculator_BattleSideCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
20193 ::core::mem::transmute(__vi.method_ptr);
20194 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
20195 __inner(__receiver, __mi)
20196 }
20197 }
20198 }
20199 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
20200 fn get_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
20201 unsafe {
20202 let __receiver =
20203 <UnitCalculator_BattleSideCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
20204 {
20205 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
20206 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
20207 panic!(
20208 "unity: virtual slot {}
20209 out of range (vtable len {}
20210) on the runtime class behind {}
20211 (method `{}
20212`)",
20213 31usize,
20214 __vt.len(),
20215 <UnitCalculator_BattleSideCommand as ::unity::ClassIdentity>::NAME,
20216 "GetImpl",
20217 )
20218 });
20219 let __inner: extern "C" fn(
20220 UnitCalculator_BattleSideCommand,
20221 crate::app::battleinfoside::BattleInfoSide,
20222 ::unity::OptionalMethod,
20223 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
20224 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
20225 __inner(__receiver, ::core::convert::Into::into(side), __mi)
20226 }
20227 }
20228 }
20229 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
20230 fn get_impl_2(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
20231 unsafe {
20232 let __receiver =
20233 <UnitCalculator_BattleSideCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
20234 {
20235 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
20236 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
20237 panic!(
20238 "unity: virtual slot {}
20239 out of range (vtable len {}
20240) on the runtime class behind {}
20241 (method `{}
20242`)",
20243 30usize,
20244 __vt.len(),
20245 <UnitCalculator_BattleSideCommand as ::unity::ClassIdentity>::NAME,
20246 "GetImpl",
20247 )
20248 });
20249 let __inner: extern "C" fn(UnitCalculator_BattleSideCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
20250 ::core::mem::transmute(__vi.method_ptr);
20251 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
20252 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
20253 }
20254 }
20255 }
20256 #[doc = "`.ctor()` overload"]
20257 fn ctor(self) -> () {
20258 unsafe {
20259 let __receiver =
20260 <UnitCalculator_BattleSideCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
20261 ::unity::il2cpp_call!((::unity::module_base()+0x1b466c0usize)as*mut u8,();
20262(UnitCalculator_BattleSideCommand)__receiver)
20263 }
20264 }
20265}
20266
20267#[cfg(feature = "app-unitcalculator")]
20268impl<__T: IUnitCalculator_BattleSideCommand> IUnitCalculator_BattleSideCommandMethods for __T {}
20269
20270#[cfg(feature = "app-unitcalculator")]
20271impl UnitCalculator_BattleSideCommand {
20272 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
20273 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
20274 }
20275
20276 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
20277 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
20278 }
20279
20280 pub fn get_impl_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
20281 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
20282 }
20283
20284 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
20285 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
20286 }
20287}
20288
20289#[cfg(feature = "app-unitcalculator")]
20290impl UnitCalculator_BattleSideCommand {
20291 #[doc = "Direct (non-virtual) call to `UnitCalculator_BattleSideCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
20292 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
20293 let __mi = Self::get_name_method_info();
20294 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
20295 __inner(this.into(), ::core::option::Option::None)
20296 }
20297
20298 #[doc = "Direct (non-virtual) call to `UnitCalculator_BattleSideCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
20299 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
20300 let __mi = Self::get_impl_method_info();
20301 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
20302 ::core::mem::transmute(__mi.method_ptr);
20303 __inner(this.into(), side, ::core::option::Option::None)
20304 }
20305
20306 #[doc = "Direct (non-virtual) call to `UnitCalculator_BattleSideCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
20307 pub unsafe fn get_impl_2(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
20308 let __mi = Self::get_impl_2_method_info();
20309 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
20310 ::core::mem::transmute(__mi.method_ptr);
20311 __inner(this.into(), unit, ::core::option::Option::None)
20312 }
20313}
20314
20315#[cfg(feature = "app-unitcalculator")]
20316impl UnitCalculator_BattleSideCommand {
20317 #[doc = "`.ctor()` — no args"]
20318 pub fn new() -> Self {
20319 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
20320 panic!(
20321 "{}
20322::{}
20323 failed to instantiate",
20324 ::core::stringify!(UnitCalculator_BattleSideCommand),
20325 ::core::stringify!(new),
20326 )
20327 });
20328 <Self as IUnitCalculator_BattleSideCommandMethods>::ctor(this);
20329 this
20330 }
20331}
20332
20333#[cfg(feature = "app-unitcalculator")]
20334pub trait IUnitCalculator_AttackCountCommandMethods: IUnitCalculator_AttackCountCommand {
20335 #[doc = "`get_Name()` overload"]
20336 fn get_name(self) -> ::unity::Il2CppString {
20337 unsafe {
20338 let __receiver =
20339 <UnitCalculator_AttackCountCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
20340 {
20341 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
20342 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
20343 panic!(
20344 "unity: virtual slot {}
20345 out of range (vtable len {}
20346) on the runtime class behind {}
20347 (method `{}
20348`)",
20349 4usize,
20350 __vt.len(),
20351 <UnitCalculator_AttackCountCommand as ::unity::ClassIdentity>::NAME,
20352 "get_Name",
20353 )
20354 });
20355 let __inner: extern "C" fn(UnitCalculator_AttackCountCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
20356 ::core::mem::transmute(__vi.method_ptr);
20357 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
20358 __inner(__receiver, __mi)
20359 }
20360 }
20361 }
20362 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
20363 fn get_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
20364 unsafe {
20365 let __receiver =
20366 <UnitCalculator_AttackCountCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
20367 {
20368 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
20369 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
20370 panic!(
20371 "unity: virtual slot {}
20372 out of range (vtable len {}
20373) on the runtime class behind {}
20374 (method `{}
20375`)",
20376 31usize,
20377 __vt.len(),
20378 <UnitCalculator_AttackCountCommand as ::unity::ClassIdentity>::NAME,
20379 "GetImpl",
20380 )
20381 });
20382 let __inner: extern "C" fn(
20383 UnitCalculator_AttackCountCommand,
20384 crate::app::battleinfoside::BattleInfoSide,
20385 ::unity::OptionalMethod,
20386 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
20387 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
20388 __inner(__receiver, ::core::convert::Into::into(side), __mi)
20389 }
20390 }
20391 }
20392 #[doc = "`SetImpl(crate::app::battleinfoside::BattleInfoSide, f32)` overload"]
20393 fn set_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>, value: impl ::core::convert::Into<f32>) -> () {
20394 unsafe {
20395 let __receiver =
20396 <UnitCalculator_AttackCountCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
20397 {
20398 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
20399 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
20400 panic!(
20401 "unity: virtual slot {}
20402 out of range (vtable len {}
20403) on the runtime class behind {}
20404 (method `{}
20405`)",
20406 33usize,
20407 __vt.len(),
20408 <UnitCalculator_AttackCountCommand as ::unity::ClassIdentity>::NAME,
20409 "SetImpl",
20410 )
20411 });
20412 let __inner: extern "C" fn(
20413 UnitCalculator_AttackCountCommand,
20414 crate::app::battleinfoside::BattleInfoSide,
20415 f32,
20416 ::unity::OptionalMethod,
20417 ) -> () = ::core::mem::transmute(__vi.method_ptr);
20418 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
20419 __inner(__receiver, ::core::convert::Into::into(side), ::core::convert::Into::into(value), __mi)
20420 }
20421 }
20422 }
20423 #[doc = "`IsVisible()` overload"]
20424 fn is_visible(self) -> bool {
20425 unsafe {
20426 let __receiver =
20427 <UnitCalculator_AttackCountCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
20428 {
20429 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
20430 let __vi = *__vt.get(43usize).unwrap_or_else(|| {
20431 panic!(
20432 "unity: virtual slot {}
20433 out of range (vtable len {}
20434) on the runtime class behind {}
20435 (method `{}
20436`)",
20437 43usize,
20438 __vt.len(),
20439 <UnitCalculator_AttackCountCommand as ::unity::ClassIdentity>::NAME,
20440 "IsVisible",
20441 )
20442 });
20443 let __inner: extern "C" fn(UnitCalculator_AttackCountCommand, ::unity::OptionalMethod) -> bool =
20444 ::core::mem::transmute(__vi.method_ptr);
20445 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
20446 __inner(__receiver, __mi)
20447 }
20448 }
20449 }
20450 #[doc = "`.ctor()` overload"]
20451 fn ctor(self) -> () {
20452 unsafe {
20453 let __receiver =
20454 <UnitCalculator_AttackCountCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
20455 ::unity::il2cpp_call!((::unity::module_base()+0x1b45540usize)as*mut u8,();
20456(UnitCalculator_AttackCountCommand)__receiver)
20457 }
20458 }
20459}
20460
20461#[cfg(feature = "app-unitcalculator")]
20462impl<__T: IUnitCalculator_AttackCountCommand> IUnitCalculator_AttackCountCommandMethods for __T {}
20463
20464#[cfg(feature = "app-unitcalculator")]
20465impl UnitCalculator_AttackCountCommand {
20466 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
20467 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
20468 }
20469
20470 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
20471 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
20472 }
20473
20474 pub fn set_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
20475 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
20476 }
20477
20478 pub fn is_visible_method_info() -> &'static ::unity::il2cpp::MethodInfo {
20479 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
20480 }
20481
20482 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
20483 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
20484 }
20485}
20486
20487#[cfg(feature = "app-unitcalculator")]
20488impl UnitCalculator_AttackCountCommand {
20489 #[doc = "Direct (non-virtual) call to `UnitCalculator_AttackCountCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
20490 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
20491 let __mi = Self::get_name_method_info();
20492 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
20493 __inner(this.into(), ::core::option::Option::None)
20494 }
20495
20496 #[doc = "Direct (non-virtual) call to `UnitCalculator_AttackCountCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
20497 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
20498 let __mi = Self::get_impl_method_info();
20499 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
20500 ::core::mem::transmute(__mi.method_ptr);
20501 __inner(this.into(), side, ::core::option::Option::None)
20502 }
20503
20504 #[doc = "Direct (non-virtual) call to `UnitCalculator_AttackCountCommand`'s own `SetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
20505 pub unsafe fn set_impl(
20506 this: impl ::core::convert::Into<::unity::IlInstance>,
20507 side: crate::app::battleinfoside::BattleInfoSide,
20508 value: f32,
20509 ) -> () {
20510 let __mi = Self::set_impl_method_info();
20511 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, f32, ::unity::OptionalMethod) -> () =
20512 ::core::mem::transmute(__mi.method_ptr);
20513 __inner(this.into(), side, value, ::core::option::Option::None)
20514 }
20515
20516 #[doc = "Direct (non-virtual) call to `UnitCalculator_AttackCountCommand`'s own `IsVisible`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
20517 pub unsafe fn is_visible(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
20518 let __mi = Self::is_visible_method_info();
20519 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
20520 __inner(this.into(), ::core::option::Option::None)
20521 }
20522}
20523
20524#[cfg(feature = "app-unitcalculator")]
20525impl UnitCalculator_AttackCountCommand {
20526 #[doc = "`.ctor()` — no args"]
20527 pub fn new() -> Self {
20528 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
20529 panic!(
20530 "{}
20531::{}
20532 failed to instantiate",
20533 ::core::stringify!(UnitCalculator_AttackCountCommand),
20534 ::core::stringify!(new),
20535 )
20536 });
20537 <Self as IUnitCalculator_AttackCountCommandMethods>::ctor(this);
20538 this
20539 }
20540}
20541
20542#[cfg(feature = "app-unitcalculator")]
20543pub trait IUnitCalculator_SupportCriticalCommandMethods: IUnitCalculator_SupportCriticalCommand {
20544 #[doc = "`get_Name()` overload"]
20545 fn get_name(self) -> ::unity::Il2CppString {
20546 unsafe {
20547 let __receiver = <UnitCalculator_SupportCriticalCommand as ::unity::FromIlInstance>::from_il_instance(
20548 <Self as ::unity::SystemObject>::as_instance(self),
20549 );
20550 {
20551 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
20552 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
20553 panic!(
20554 "unity: virtual slot {}
20555 out of range (vtable len {}
20556) on the runtime class behind {}
20557 (method `{}
20558`)",
20559 4usize,
20560 __vt.len(),
20561 <UnitCalculator_SupportCriticalCommand as ::unity::ClassIdentity>::NAME,
20562 "get_Name",
20563 )
20564 });
20565 let __inner: extern "C" fn(UnitCalculator_SupportCriticalCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
20566 ::core::mem::transmute(__vi.method_ptr);
20567 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
20568 __inner(__receiver, __mi)
20569 }
20570 }
20571 }
20572 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
20573 fn get_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
20574 unsafe {
20575 let __receiver = <UnitCalculator_SupportCriticalCommand as ::unity::FromIlInstance>::from_il_instance(
20576 <Self as ::unity::SystemObject>::as_instance(self),
20577 );
20578 {
20579 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
20580 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
20581 panic!(
20582 "unity: virtual slot {}
20583 out of range (vtable len {}
20584) on the runtime class behind {}
20585 (method `{}
20586`)",
20587 31usize,
20588 __vt.len(),
20589 <UnitCalculator_SupportCriticalCommand as ::unity::ClassIdentity>::NAME,
20590 "GetImpl",
20591 )
20592 });
20593 let __inner: extern "C" fn(
20594 UnitCalculator_SupportCriticalCommand,
20595 crate::app::battleinfoside::BattleInfoSide,
20596 ::unity::OptionalMethod,
20597 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
20598 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
20599 __inner(__receiver, ::core::convert::Into::into(side), __mi)
20600 }
20601 }
20602 }
20603 #[doc = "`SetImpl(crate::app::battleinfoside::BattleInfoSide, f32)` overload"]
20604 fn set_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>, value: impl ::core::convert::Into<f32>) -> () {
20605 unsafe {
20606 let __receiver = <UnitCalculator_SupportCriticalCommand as ::unity::FromIlInstance>::from_il_instance(
20607 <Self as ::unity::SystemObject>::as_instance(self),
20608 );
20609 {
20610 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
20611 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
20612 panic!(
20613 "unity: virtual slot {}
20614 out of range (vtable len {}
20615) on the runtime class behind {}
20616 (method `{}
20617`)",
20618 33usize,
20619 __vt.len(),
20620 <UnitCalculator_SupportCriticalCommand as ::unity::ClassIdentity>::NAME,
20621 "SetImpl",
20622 )
20623 });
20624 let __inner: extern "C" fn(
20625 UnitCalculator_SupportCriticalCommand,
20626 crate::app::battleinfoside::BattleInfoSide,
20627 f32,
20628 ::unity::OptionalMethod,
20629 ) -> () = ::core::mem::transmute(__vi.method_ptr);
20630 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
20631 __inner(__receiver, ::core::convert::Into::into(side), ::core::convert::Into::into(value), __mi)
20632 }
20633 }
20634 }
20635 #[doc = "`IsVisible()` overload"]
20636 fn is_visible(self) -> bool {
20637 unsafe {
20638 let __receiver = <UnitCalculator_SupportCriticalCommand as ::unity::FromIlInstance>::from_il_instance(
20639 <Self as ::unity::SystemObject>::as_instance(self),
20640 );
20641 {
20642 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
20643 let __vi = *__vt.get(43usize).unwrap_or_else(|| {
20644 panic!(
20645 "unity: virtual slot {}
20646 out of range (vtable len {}
20647) on the runtime class behind {}
20648 (method `{}
20649`)",
20650 43usize,
20651 __vt.len(),
20652 <UnitCalculator_SupportCriticalCommand as ::unity::ClassIdentity>::NAME,
20653 "IsVisible",
20654 )
20655 });
20656 let __inner: extern "C" fn(UnitCalculator_SupportCriticalCommand, ::unity::OptionalMethod) -> bool =
20657 ::core::mem::transmute(__vi.method_ptr);
20658 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
20659 __inner(__receiver, __mi)
20660 }
20661 }
20662 }
20663 #[doc = "`.ctor()` overload"]
20664 fn ctor(self) -> () {
20665 unsafe {
20666 let __receiver = <UnitCalculator_SupportCriticalCommand as ::unity::FromIlInstance>::from_il_instance(
20667 <Self as ::unity::SystemObject>::as_instance(self),
20668 );
20669 ::unity::il2cpp_call!((::unity::module_base()+0x1b4c380usize)as*mut u8,();
20670(UnitCalculator_SupportCriticalCommand)__receiver)
20671 }
20672 }
20673}
20674
20675#[cfg(feature = "app-unitcalculator")]
20676impl<__T: IUnitCalculator_SupportCriticalCommand> IUnitCalculator_SupportCriticalCommandMethods for __T {}
20677
20678#[cfg(feature = "app-unitcalculator")]
20679impl UnitCalculator_SupportCriticalCommand {
20680 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
20681 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
20682 }
20683
20684 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
20685 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
20686 }
20687
20688 pub fn set_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
20689 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
20690 }
20691
20692 pub fn is_visible_method_info() -> &'static ::unity::il2cpp::MethodInfo {
20693 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
20694 }
20695
20696 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
20697 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
20698 }
20699}
20700
20701#[cfg(feature = "app-unitcalculator")]
20702impl UnitCalculator_SupportCriticalCommand {
20703 #[doc = "Direct (non-virtual) call to `UnitCalculator_SupportCriticalCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
20704 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
20705 let __mi = Self::get_name_method_info();
20706 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
20707 __inner(this.into(), ::core::option::Option::None)
20708 }
20709
20710 #[doc = "Direct (non-virtual) call to `UnitCalculator_SupportCriticalCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
20711 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
20712 let __mi = Self::get_impl_method_info();
20713 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
20714 ::core::mem::transmute(__mi.method_ptr);
20715 __inner(this.into(), side, ::core::option::Option::None)
20716 }
20717
20718 #[doc = "Direct (non-virtual) call to `UnitCalculator_SupportCriticalCommand`'s own `SetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
20719 pub unsafe fn set_impl(
20720 this: impl ::core::convert::Into<::unity::IlInstance>,
20721 side: crate::app::battleinfoside::BattleInfoSide,
20722 value: f32,
20723 ) -> () {
20724 let __mi = Self::set_impl_method_info();
20725 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, f32, ::unity::OptionalMethod) -> () =
20726 ::core::mem::transmute(__mi.method_ptr);
20727 __inner(this.into(), side, value, ::core::option::Option::None)
20728 }
20729
20730 #[doc = "Direct (non-virtual) call to `UnitCalculator_SupportCriticalCommand`'s own `IsVisible`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
20731 pub unsafe fn is_visible(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
20732 let __mi = Self::is_visible_method_info();
20733 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
20734 __inner(this.into(), ::core::option::Option::None)
20735 }
20736}
20737
20738#[cfg(feature = "app-unitcalculator")]
20739impl UnitCalculator_SupportCriticalCommand {
20740 #[doc = "`.ctor()` — no args"]
20741 pub fn new() -> Self {
20742 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
20743 panic!(
20744 "{}
20745::{}
20746 failed to instantiate",
20747 ::core::stringify!(UnitCalculator_SupportCriticalCommand),
20748 ::core::stringify!(new),
20749 )
20750 });
20751 <Self as IUnitCalculator_SupportCriticalCommandMethods>::ctor(this);
20752 this
20753 }
20754}
20755
20756#[cfg(feature = "app-unitcalculator")]
20757pub trait IUnitCalculator_TotalDamageCommandMethods: IUnitCalculator_TotalDamageCommand {
20758 #[doc = "`get_Name()` overload"]
20759 fn get_name(self) -> ::unity::Il2CppString {
20760 unsafe {
20761 let __receiver =
20762 <UnitCalculator_TotalDamageCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
20763 {
20764 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
20765 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
20766 panic!(
20767 "unity: virtual slot {}
20768 out of range (vtable len {}
20769) on the runtime class behind {}
20770 (method `{}
20771`)",
20772 4usize,
20773 __vt.len(),
20774 <UnitCalculator_TotalDamageCommand as ::unity::ClassIdentity>::NAME,
20775 "get_Name",
20776 )
20777 });
20778 let __inner: extern "C" fn(UnitCalculator_TotalDamageCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
20779 ::core::mem::transmute(__vi.method_ptr);
20780 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
20781 __inner(__receiver, __mi)
20782 }
20783 }
20784 }
20785 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
20786 fn get_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
20787 unsafe {
20788 let __receiver =
20789 <UnitCalculator_TotalDamageCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
20790 {
20791 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
20792 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
20793 panic!(
20794 "unity: virtual slot {}
20795 out of range (vtable len {}
20796) on the runtime class behind {}
20797 (method `{}
20798`)",
20799 31usize,
20800 __vt.len(),
20801 <UnitCalculator_TotalDamageCommand as ::unity::ClassIdentity>::NAME,
20802 "GetImpl",
20803 )
20804 });
20805 let __inner: extern "C" fn(
20806 UnitCalculator_TotalDamageCommand,
20807 crate::app::battleinfoside::BattleInfoSide,
20808 ::unity::OptionalMethod,
20809 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
20810 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
20811 __inner(__receiver, ::core::convert::Into::into(side), __mi)
20812 }
20813 }
20814 }
20815 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
20816 fn get_impl_2(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
20817 unsafe {
20818 let __receiver =
20819 <UnitCalculator_TotalDamageCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
20820 {
20821 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
20822 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
20823 panic!(
20824 "unity: virtual slot {}
20825 out of range (vtable len {}
20826) on the runtime class behind {}
20827 (method `{}
20828`)",
20829 30usize,
20830 __vt.len(),
20831 <UnitCalculator_TotalDamageCommand as ::unity::ClassIdentity>::NAME,
20832 "GetImpl",
20833 )
20834 });
20835 let __inner: extern "C" fn(UnitCalculator_TotalDamageCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
20836 ::core::mem::transmute(__vi.method_ptr);
20837 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
20838 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
20839 }
20840 }
20841 }
20842 #[doc = "`.ctor()` overload"]
20843 fn ctor(self) -> () {
20844 unsafe {
20845 let __receiver =
20846 <UnitCalculator_TotalDamageCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
20847 ::unity::il2cpp_call!((::unity::module_base()+0x1b4cc60usize)as*mut u8,();
20848(UnitCalculator_TotalDamageCommand)__receiver)
20849 }
20850 }
20851}
20852
20853#[cfg(feature = "app-unitcalculator")]
20854impl<__T: IUnitCalculator_TotalDamageCommand> IUnitCalculator_TotalDamageCommandMethods for __T {}
20855
20856#[cfg(feature = "app-unitcalculator")]
20857impl UnitCalculator_TotalDamageCommand {
20858 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
20859 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
20860 }
20861
20862 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
20863 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
20864 }
20865
20866 pub fn get_impl_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
20867 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
20868 }
20869
20870 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
20871 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
20872 }
20873}
20874
20875#[cfg(feature = "app-unitcalculator")]
20876impl UnitCalculator_TotalDamageCommand {
20877 #[doc = "Direct (non-virtual) call to `UnitCalculator_TotalDamageCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
20878 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
20879 let __mi = Self::get_name_method_info();
20880 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
20881 __inner(this.into(), ::core::option::Option::None)
20882 }
20883
20884 #[doc = "Direct (non-virtual) call to `UnitCalculator_TotalDamageCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
20885 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
20886 let __mi = Self::get_impl_method_info();
20887 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
20888 ::core::mem::transmute(__mi.method_ptr);
20889 __inner(this.into(), side, ::core::option::Option::None)
20890 }
20891
20892 #[doc = "Direct (non-virtual) call to `UnitCalculator_TotalDamageCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
20893 pub unsafe fn get_impl_2(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
20894 let __mi = Self::get_impl_2_method_info();
20895 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
20896 ::core::mem::transmute(__mi.method_ptr);
20897 __inner(this.into(), unit, ::core::option::Option::None)
20898 }
20899}
20900
20901#[cfg(feature = "app-unitcalculator")]
20902impl UnitCalculator_TotalDamageCommand {
20903 #[doc = "`.ctor()` — no args"]
20904 pub fn new() -> Self {
20905 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
20906 panic!(
20907 "{}
20908::{}
20909 failed to instantiate",
20910 ::core::stringify!(UnitCalculator_TotalDamageCommand),
20911 ::core::stringify!(new),
20912 )
20913 });
20914 <Self as IUnitCalculator_TotalDamageCommandMethods>::ctor(this);
20915 this
20916 }
20917}
20918
20919#[cfg(feature = "app-unitcalculator")]
20920pub trait IUnitCalculator_OverlapCanRemoveCommandMethods: IUnitCalculator_OverlapCanRemoveCommand {
20921 #[doc = "`get_Name()` overload"]
20922 fn get_name(self) -> ::unity::Il2CppString {
20923 unsafe {
20924 let __receiver = <UnitCalculator_OverlapCanRemoveCommand as ::unity::FromIlInstance>::from_il_instance(
20925 <Self as ::unity::SystemObject>::as_instance(self),
20926 );
20927 {
20928 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
20929 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
20930 panic!(
20931 "unity: virtual slot {}
20932 out of range (vtable len {}
20933) on the runtime class behind {}
20934 (method `{}
20935`)",
20936 4usize,
20937 __vt.len(),
20938 <UnitCalculator_OverlapCanRemoveCommand as ::unity::ClassIdentity>::NAME,
20939 "get_Name",
20940 )
20941 });
20942 let __inner: extern "C" fn(UnitCalculator_OverlapCanRemoveCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
20943 ::core::mem::transmute(__vi.method_ptr);
20944 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
20945 __inner(__receiver, __mi)
20946 }
20947 }
20948 }
20949 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
20950 fn get_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
20951 unsafe {
20952 let __receiver = <UnitCalculator_OverlapCanRemoveCommand as ::unity::FromIlInstance>::from_il_instance(
20953 <Self as ::unity::SystemObject>::as_instance(self),
20954 );
20955 {
20956 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
20957 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
20958 panic!(
20959 "unity: virtual slot {}
20960 out of range (vtable len {}
20961) on the runtime class behind {}
20962 (method `{}
20963`)",
20964 30usize,
20965 __vt.len(),
20966 <UnitCalculator_OverlapCanRemoveCommand as ::unity::ClassIdentity>::NAME,
20967 "GetImpl",
20968 )
20969 });
20970 let __inner: extern "C" fn(UnitCalculator_OverlapCanRemoveCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
20971 ::core::mem::transmute(__vi.method_ptr);
20972 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
20973 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
20974 }
20975 }
20976 }
20977 #[doc = "`.ctor()` overload"]
20978 fn ctor(self) -> () {
20979 unsafe {
20980 let __receiver = <UnitCalculator_OverlapCanRemoveCommand as ::unity::FromIlInstance>::from_il_instance(
20981 <Self as ::unity::SystemObject>::as_instance(self),
20982 );
20983 ::unity::il2cpp_call!((::unity::module_base()+0x1b4a750usize)as*mut u8,();
20984(UnitCalculator_OverlapCanRemoveCommand)__receiver)
20985 }
20986 }
20987}
20988
20989#[cfg(feature = "app-unitcalculator")]
20990impl<__T: IUnitCalculator_OverlapCanRemoveCommand> IUnitCalculator_OverlapCanRemoveCommandMethods for __T {}
20991
20992#[cfg(feature = "app-unitcalculator")]
20993impl UnitCalculator_OverlapCanRemoveCommand {
20994 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
20995 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
20996 }
20997
20998 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
20999 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
21000 }
21001
21002 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
21003 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
21004 }
21005}
21006
21007#[cfg(feature = "app-unitcalculator")]
21008impl UnitCalculator_OverlapCanRemoveCommand {
21009 #[doc = "Direct (non-virtual) call to `UnitCalculator_OverlapCanRemoveCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
21010 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
21011 let __mi = Self::get_name_method_info();
21012 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
21013 __inner(this.into(), ::core::option::Option::None)
21014 }
21015
21016 #[doc = "Direct (non-virtual) call to `UnitCalculator_OverlapCanRemoveCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
21017 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
21018 let __mi = Self::get_impl_method_info();
21019 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
21020 ::core::mem::transmute(__mi.method_ptr);
21021 __inner(this.into(), unit, ::core::option::Option::None)
21022 }
21023}
21024
21025#[cfg(feature = "app-unitcalculator")]
21026impl UnitCalculator_OverlapCanRemoveCommand {
21027 #[doc = "`.ctor()` — no args"]
21028 pub fn new() -> Self {
21029 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
21030 panic!(
21031 "{}
21032::{}
21033 failed to instantiate",
21034 ::core::stringify!(UnitCalculator_OverlapCanRemoveCommand),
21035 ::core::stringify!(new),
21036 )
21037 });
21038 <Self as IUnitCalculator_OverlapCanRemoveCommandMethods>::ctor(this);
21039 this
21040 }
21041}
21042
21043#[cfg(feature = "app-unitcalculator")]
21044pub trait IUnitCalculator_HPCommandMethods: IUnitCalculator_HPCommand {
21045 #[doc = "`get_Name()` overload"]
21046 fn get_name(self) -> ::unity::Il2CppString {
21047 unsafe {
21048 let __receiver =
21049 <UnitCalculator_HPCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
21050 {
21051 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
21052 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
21053 panic!(
21054 "unity: virtual slot {}
21055 out of range (vtable len {}
21056) on the runtime class behind {}
21057 (method `{}
21058`)",
21059 4usize,
21060 __vt.len(),
21061 <UnitCalculator_HPCommand as ::unity::ClassIdentity>::NAME,
21062 "get_Name",
21063 )
21064 });
21065 let __inner: extern "C" fn(UnitCalculator_HPCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
21066 ::core::mem::transmute(__vi.method_ptr);
21067 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
21068 __inner(__receiver, __mi)
21069 }
21070 }
21071 }
21072 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
21073 fn get_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
21074 unsafe {
21075 let __receiver =
21076 <UnitCalculator_HPCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
21077 {
21078 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
21079 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
21080 panic!(
21081 "unity: virtual slot {}
21082 out of range (vtable len {}
21083) on the runtime class behind {}
21084 (method `{}
21085`)",
21086 30usize,
21087 __vt.len(),
21088 <UnitCalculator_HPCommand as ::unity::ClassIdentity>::NAME,
21089 "GetImpl",
21090 )
21091 });
21092 let __inner: extern "C" fn(UnitCalculator_HPCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
21093 ::core::mem::transmute(__vi.method_ptr);
21094 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
21095 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
21096 }
21097 }
21098 }
21099 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
21100 fn get_impl_2(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
21101 unsafe {
21102 let __receiver =
21103 <UnitCalculator_HPCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
21104 {
21105 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
21106 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
21107 panic!(
21108 "unity: virtual slot {}
21109 out of range (vtable len {}
21110) on the runtime class behind {}
21111 (method `{}
21112`)",
21113 31usize,
21114 __vt.len(),
21115 <UnitCalculator_HPCommand as ::unity::ClassIdentity>::NAME,
21116 "GetImpl",
21117 )
21118 });
21119 let __inner: extern "C" fn(UnitCalculator_HPCommand, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
21120 ::core::mem::transmute(__vi.method_ptr);
21121 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
21122 __inner(__receiver, ::core::convert::Into::into(side), __mi)
21123 }
21124 }
21125 }
21126 #[doc = "`SetImpl(crate::app::unit::Unit, f32)` overload"]
21127 fn set_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>, value: impl ::core::convert::Into<f32>) -> () {
21128 unsafe {
21129 let __receiver =
21130 <UnitCalculator_HPCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
21131 {
21132 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
21133 let __vi = *__vt.get(32usize).unwrap_or_else(|| {
21134 panic!(
21135 "unity: virtual slot {}
21136 out of range (vtable len {}
21137) on the runtime class behind {}
21138 (method `{}
21139`)",
21140 32usize,
21141 __vt.len(),
21142 <UnitCalculator_HPCommand as ::unity::ClassIdentity>::NAME,
21143 "SetImpl",
21144 )
21145 });
21146 let __inner: extern "C" fn(UnitCalculator_HPCommand, crate::app::unit::Unit, f32, ::unity::OptionalMethod) -> () =
21147 ::core::mem::transmute(__vi.method_ptr);
21148 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
21149 __inner(__receiver, ::core::convert::Into::into(unit), ::core::convert::Into::into(value), __mi)
21150 }
21151 }
21152 }
21153 #[doc = "`SetImpl(crate::app::battleinfoside::BattleInfoSide, f32)` overload"]
21154 fn set_impl_2(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>, value: impl ::core::convert::Into<f32>) -> () {
21155 unsafe {
21156 let __receiver =
21157 <UnitCalculator_HPCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
21158 {
21159 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
21160 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
21161 panic!(
21162 "unity: virtual slot {}
21163 out of range (vtable len {}
21164) on the runtime class behind {}
21165 (method `{}
21166`)",
21167 33usize,
21168 __vt.len(),
21169 <UnitCalculator_HPCommand as ::unity::ClassIdentity>::NAME,
21170 "SetImpl",
21171 )
21172 });
21173 let __inner: extern "C" fn(UnitCalculator_HPCommand, crate::app::battleinfoside::BattleInfoSide, f32, ::unity::OptionalMethod) -> () =
21174 ::core::mem::transmute(__vi.method_ptr);
21175 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
21176 __inner(__receiver, ::core::convert::Into::into(side), ::core::convert::Into::into(value), __mi)
21177 }
21178 }
21179 }
21180 #[doc = "`IsVisible()` overload"]
21181 fn is_visible(self) -> bool {
21182 unsafe {
21183 let __receiver =
21184 <UnitCalculator_HPCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
21185 {
21186 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
21187 let __vi = *__vt.get(43usize).unwrap_or_else(|| {
21188 panic!(
21189 "unity: virtual slot {}
21190 out of range (vtable len {}
21191) on the runtime class behind {}
21192 (method `{}
21193`)",
21194 43usize,
21195 __vt.len(),
21196 <UnitCalculator_HPCommand as ::unity::ClassIdentity>::NAME,
21197 "IsVisible",
21198 )
21199 });
21200 let __inner: extern "C" fn(UnitCalculator_HPCommand, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
21201 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
21202 __inner(__receiver, __mi)
21203 }
21204 }
21205 }
21206 #[doc = "`.ctor()` overload"]
21207 fn ctor(self) -> () {
21208 unsafe {
21209 let __receiver =
21210 <UnitCalculator_HPCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
21211 ::unity::il2cpp_call!((::unity::module_base()+0x1b48430usize)as*mut u8,();
21212(UnitCalculator_HPCommand)__receiver)
21213 }
21214 }
21215}
21216
21217#[cfg(feature = "app-unitcalculator")]
21218impl<__T: IUnitCalculator_HPCommand> IUnitCalculator_HPCommandMethods for __T {}
21219
21220#[cfg(feature = "app-unitcalculator")]
21221impl UnitCalculator_HPCommand {
21222 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
21223 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
21224 }
21225
21226 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
21227 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
21228 }
21229
21230 pub fn get_impl_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
21231 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
21232 }
21233
21234 pub fn set_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
21235 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
21236 }
21237
21238 pub fn set_impl_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
21239 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
21240 }
21241
21242 pub fn is_visible_method_info() -> &'static ::unity::il2cpp::MethodInfo {
21243 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
21244 }
21245
21246 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
21247 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
21248 }
21249}
21250
21251#[cfg(feature = "app-unitcalculator")]
21252impl UnitCalculator_HPCommand {
21253 #[doc = "Direct (non-virtual) call to `UnitCalculator_HPCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
21254 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
21255 let __mi = Self::get_name_method_info();
21256 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
21257 __inner(this.into(), ::core::option::Option::None)
21258 }
21259
21260 #[doc = "Direct (non-virtual) call to `UnitCalculator_HPCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
21261 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
21262 let __mi = Self::get_impl_method_info();
21263 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
21264 ::core::mem::transmute(__mi.method_ptr);
21265 __inner(this.into(), unit, ::core::option::Option::None)
21266 }
21267
21268 #[doc = "Direct (non-virtual) call to `UnitCalculator_HPCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
21269 pub unsafe fn get_impl_2(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
21270 let __mi = Self::get_impl_2_method_info();
21271 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
21272 ::core::mem::transmute(__mi.method_ptr);
21273 __inner(this.into(), side, ::core::option::Option::None)
21274 }
21275
21276 #[doc = "Direct (non-virtual) call to `UnitCalculator_HPCommand`'s own `SetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
21277 pub unsafe fn set_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit, value: f32) -> () {
21278 let __mi = Self::set_impl_method_info();
21279 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, f32, ::unity::OptionalMethod) -> () =
21280 ::core::mem::transmute(__mi.method_ptr);
21281 __inner(this.into(), unit, value, ::core::option::Option::None)
21282 }
21283
21284 #[doc = "Direct (non-virtual) call to `UnitCalculator_HPCommand`'s own `SetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
21285 pub unsafe fn set_impl_2(
21286 this: impl ::core::convert::Into<::unity::IlInstance>,
21287 side: crate::app::battleinfoside::BattleInfoSide,
21288 value: f32,
21289 ) -> () {
21290 let __mi = Self::set_impl_2_method_info();
21291 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, f32, ::unity::OptionalMethod) -> () =
21292 ::core::mem::transmute(__mi.method_ptr);
21293 __inner(this.into(), side, value, ::core::option::Option::None)
21294 }
21295
21296 #[doc = "Direct (non-virtual) call to `UnitCalculator_HPCommand`'s own `IsVisible`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
21297 pub unsafe fn is_visible(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
21298 let __mi = Self::is_visible_method_info();
21299 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
21300 __inner(this.into(), ::core::option::Option::None)
21301 }
21302}
21303
21304#[cfg(feature = "app-unitcalculator")]
21305impl UnitCalculator_HPCommand {
21306 #[doc = "`.ctor()` — no args"]
21307 pub fn new() -> Self {
21308 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
21309 panic!(
21310 "{}
21311::{}
21312 failed to instantiate",
21313 ::core::stringify!(UnitCalculator_HPCommand),
21314 ::core::stringify!(new),
21315 )
21316 });
21317 <Self as IUnitCalculator_HPCommandMethods>::ctor(this);
21318 this
21319 }
21320}
21321
21322#[cfg(feature = "app-unitcalculator")]
21323pub trait IUnitCalculator_IBattleSceneResultCommandMethods: IUnitCalculator_IBattleSceneResultCommand {
21324 #[doc = "`GetImpl(crate::app::battlescene::BattleScene_Result)` overload"]
21325 fn get_impl(
21326 self,
21327 result: impl ::core::convert::Into<crate::app::battlescene::BattleScene_Result>,
21328 ) -> crate::app::battlescene::BattleScene_Result {
21329 unsafe {
21330 let __receiver = <UnitCalculator_IBattleSceneResultCommand as ::unity::FromIlInstance>::from_il_instance(
21331 <Self as ::unity::SystemObject>::as_instance(self),
21332 );
21333 ::unity::il2cpp_call!((::unity::module_base()+0x1b460b0usize)as*mut u8,crate::app::battlescene::BattleScene_Result;
21334(UnitCalculator_IBattleSceneResultCommand)__receiver,(crate::app::battlescene::BattleScene_Result)::core::convert::Into::into(result))
21335 }
21336 }
21337 #[doc = "`SetImpl(crate::app::battlescene::BattleScene_Result, crate::app::battlescene::BattleScene_Result)` overload"]
21338 fn set_impl(
21339 self,
21340 result: impl ::core::convert::Into<crate::app::battlescene::BattleScene_Result>,
21341 value: impl ::core::convert::Into<crate::app::battlescene::BattleScene_Result>,
21342 ) -> crate::app::battlescene::BattleScene_Result {
21343 unsafe {
21344 let __receiver = <UnitCalculator_IBattleSceneResultCommand as ::unity::FromIlInstance>::from_il_instance(
21345 <Self as ::unity::SystemObject>::as_instance(self),
21346 );
21347 ::unity::il2cpp_call!((::unity::module_base()+0x1b46110usize)as*mut u8,crate::app::battlescene::BattleScene_Result;
21348(UnitCalculator_IBattleSceneResultCommand)__receiver,(crate::app::battlescene::BattleScene_Result)::core::convert::Into::into(result),(crate::app::battlescene::BattleScene_Result)::core::convert::Into::into(value))
21349 }
21350 }
21351 #[doc = "`FuncImpl(crate::app::battlescene::BattleScene_Result, crate::app::battlescene::BattleScene_Result)` overload"]
21352 fn func_impl(
21353 self,
21354 result: impl ::core::convert::Into<crate::app::battlescene::BattleScene_Result>,
21355 value: impl ::core::convert::Into<crate::app::battlescene::BattleScene_Result>,
21356 ) -> f32 {
21357 unsafe {
21358 let __receiver = <UnitCalculator_IBattleSceneResultCommand as ::unity::FromIlInstance>::from_il_instance(
21359 <Self as ::unity::SystemObject>::as_instance(self),
21360 );
21361 ::unity::il2cpp_call!((::unity::module_base()+0x1b46210usize)as*mut u8,f32;
21362(UnitCalculator_IBattleSceneResultCommand)__receiver,(crate::app::battlescene::BattleScene_Result)::core::convert::Into::into(result),(crate::app::battlescene::BattleScene_Result)::core::convert::Into::into(value))
21363 }
21364 }
21365 #[doc = "`.ctor()` overload"]
21366 fn ctor(self) -> () {
21367 unsafe {
21368 let __receiver = <UnitCalculator_IBattleSceneResultCommand as ::unity::FromIlInstance>::from_il_instance(
21369 <Self as ::unity::SystemObject>::as_instance(self),
21370 );
21371 ::unity::il2cpp_call!((::unity::module_base()+0x1b46250usize)as*mut u8,();
21372(UnitCalculator_IBattleSceneResultCommand)__receiver)
21373 }
21374 }
21375}
21376
21377#[cfg(feature = "app-unitcalculator")]
21378impl<__T: IUnitCalculator_IBattleSceneResultCommand> IUnitCalculator_IBattleSceneResultCommandMethods for __T {}
21379
21380#[cfg(feature = "app-unitcalculator")]
21381impl UnitCalculator_IBattleSceneResultCommand {
21382 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
21383 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
21384 }
21385
21386 pub fn set_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
21387 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
21388 }
21389
21390 pub fn func_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
21391 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
21392 }
21393
21394 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
21395 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
21396 }
21397}
21398
21399#[cfg(feature = "app-unitcalculator")]
21400impl UnitCalculator_IBattleSceneResultCommand {
21401 #[doc = "`.ctor()` — no args"]
21402 pub fn new() -> Self {
21403 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
21404 panic!(
21405 "{}
21406::{}
21407 failed to instantiate",
21408 ::core::stringify!(UnitCalculator_IBattleSceneResultCommand),
21409 ::core::stringify!(new),
21410 )
21411 });
21412 <Self as IUnitCalculator_IBattleSceneResultCommandMethods>::ctor(this);
21413 this
21414 }
21415}
21416
21417#[cfg(feature = "app-unitcalculator")]
21418pub trait IUnitCalculator_WeaponKindCommandMethods: IUnitCalculator_WeaponKindCommand {
21419 #[doc = "`get_Name()` overload"]
21420 fn get_name(self) -> ::unity::Il2CppString {
21421 unsafe {
21422 let __receiver =
21423 <UnitCalculator_WeaponKindCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
21424 {
21425 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
21426 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
21427 panic!(
21428 "unity: virtual slot {}
21429 out of range (vtable len {}
21430) on the runtime class behind {}
21431 (method `{}
21432`)",
21433 4usize,
21434 __vt.len(),
21435 <UnitCalculator_WeaponKindCommand as ::unity::ClassIdentity>::NAME,
21436 "get_Name",
21437 )
21438 });
21439 let __inner: extern "C" fn(UnitCalculator_WeaponKindCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
21440 ::core::mem::transmute(__vi.method_ptr);
21441 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
21442 __inner(__receiver, __mi)
21443 }
21444 }
21445 }
21446 #[doc = "`GetKind(crate::app::itemdata::ItemData)` overload"]
21447 fn get_kind(self, item: impl ::core::convert::Into<crate::app::itemdata::ItemData>) -> i32 {
21448 unsafe {
21449 let __receiver =
21450 <UnitCalculator_WeaponKindCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
21451 ::unity::il2cpp_call!((::unity::module_base()+0x1b4e560usize)as*mut u8,i32;
21452(UnitCalculator_WeaponKindCommand)__receiver,(crate::app::itemdata::ItemData)::core::convert::Into::into(item))
21453 }
21454 }
21455 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
21456 fn get_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
21457 unsafe {
21458 let __receiver =
21459 <UnitCalculator_WeaponKindCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
21460 {
21461 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
21462 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
21463 panic!(
21464 "unity: virtual slot {}
21465 out of range (vtable len {}
21466) on the runtime class behind {}
21467 (method `{}
21468`)",
21469 30usize,
21470 __vt.len(),
21471 <UnitCalculator_WeaponKindCommand as ::unity::ClassIdentity>::NAME,
21472 "GetImpl",
21473 )
21474 });
21475 let __inner: extern "C" fn(UnitCalculator_WeaponKindCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
21476 ::core::mem::transmute(__vi.method_ptr);
21477 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
21478 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
21479 }
21480 }
21481 }
21482 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
21483 fn get_impl_2(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
21484 unsafe {
21485 let __receiver =
21486 <UnitCalculator_WeaponKindCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
21487 {
21488 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
21489 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
21490 panic!(
21491 "unity: virtual slot {}
21492 out of range (vtable len {}
21493) on the runtime class behind {}
21494 (method `{}
21495`)",
21496 31usize,
21497 __vt.len(),
21498 <UnitCalculator_WeaponKindCommand as ::unity::ClassIdentity>::NAME,
21499 "GetImpl",
21500 )
21501 });
21502 let __inner: extern "C" fn(
21503 UnitCalculator_WeaponKindCommand,
21504 crate::app::battleinfoside::BattleInfoSide,
21505 ::unity::OptionalMethod,
21506 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
21507 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
21508 __inner(__receiver, ::core::convert::Into::into(side), __mi)
21509 }
21510 }
21511 }
21512 #[doc = "`.ctor()` overload"]
21513 fn ctor(self) -> () {
21514 unsafe {
21515 let __receiver =
21516 <UnitCalculator_WeaponKindCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
21517 ::unity::il2cpp_call!((::unity::module_base()+0x1b4e760usize)as*mut u8,();
21518(UnitCalculator_WeaponKindCommand)__receiver)
21519 }
21520 }
21521}
21522
21523#[cfg(feature = "app-unitcalculator")]
21524impl<__T: IUnitCalculator_WeaponKindCommand> IUnitCalculator_WeaponKindCommandMethods for __T {}
21525
21526#[cfg(feature = "app-unitcalculator")]
21527impl UnitCalculator_WeaponKindCommand {
21528 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
21529 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
21530 }
21531
21532 pub fn get_kind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
21533 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
21534 }
21535
21536 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
21537 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
21538 }
21539
21540 pub fn get_impl_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
21541 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
21542 }
21543
21544 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
21545 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
21546 }
21547}
21548
21549#[cfg(feature = "app-unitcalculator")]
21550impl UnitCalculator_WeaponKindCommand {
21551 #[doc = "Direct (non-virtual) call to `UnitCalculator_WeaponKindCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
21552 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
21553 let __mi = Self::get_name_method_info();
21554 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
21555 __inner(this.into(), ::core::option::Option::None)
21556 }
21557
21558 #[doc = "Direct (non-virtual) call to `UnitCalculator_WeaponKindCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
21559 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
21560 let __mi = Self::get_impl_method_info();
21561 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
21562 ::core::mem::transmute(__mi.method_ptr);
21563 __inner(this.into(), unit, ::core::option::Option::None)
21564 }
21565
21566 #[doc = "Direct (non-virtual) call to `UnitCalculator_WeaponKindCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
21567 pub unsafe fn get_impl_2(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
21568 let __mi = Self::get_impl_2_method_info();
21569 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
21570 ::core::mem::transmute(__mi.method_ptr);
21571 __inner(this.into(), side, ::core::option::Option::None)
21572 }
21573}
21574
21575#[cfg(feature = "app-unitcalculator")]
21576impl UnitCalculator_WeaponKindCommand {
21577 #[doc = "`.ctor()` — no args"]
21578 pub fn new() -> Self {
21579 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
21580 panic!(
21581 "{}
21582::{}
21583 failed to instantiate",
21584 ::core::stringify!(UnitCalculator_WeaponKindCommand),
21585 ::core::stringify!(new),
21586 )
21587 });
21588 <Self as IUnitCalculator_WeaponKindCommandMethods>::ctor(this);
21589 this
21590 }
21591}
21592
21593#[cfg(feature = "app-unitcalculator")]
21594pub trait IUnitCalculator_ExpDanceCountCommandMethods: IUnitCalculator_ExpDanceCountCommand {
21595 #[doc = "`get_Name()` overload"]
21596 fn get_name(self) -> ::unity::Il2CppString {
21597 unsafe {
21598 let __receiver = <UnitCalculator_ExpDanceCountCommand as ::unity::FromIlInstance>::from_il_instance(
21599 <Self as ::unity::SystemObject>::as_instance(self),
21600 );
21601 {
21602 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
21603 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
21604 panic!(
21605 "unity: virtual slot {}
21606 out of range (vtable len {}
21607) on the runtime class behind {}
21608 (method `{}
21609`)",
21610 4usize,
21611 __vt.len(),
21612 <UnitCalculator_ExpDanceCountCommand as ::unity::ClassIdentity>::NAME,
21613 "get_Name",
21614 )
21615 });
21616 let __inner: extern "C" fn(UnitCalculator_ExpDanceCountCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
21617 ::core::mem::transmute(__vi.method_ptr);
21618 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
21619 __inner(__receiver, __mi)
21620 }
21621 }
21622 }
21623 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
21624 fn get_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
21625 unsafe {
21626 let __receiver = <UnitCalculator_ExpDanceCountCommand as ::unity::FromIlInstance>::from_il_instance(
21627 <Self as ::unity::SystemObject>::as_instance(self),
21628 );
21629 {
21630 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
21631 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
21632 panic!(
21633 "unity: virtual slot {}
21634 out of range (vtable len {}
21635) on the runtime class behind {}
21636 (method `{}
21637`)",
21638 30usize,
21639 __vt.len(),
21640 <UnitCalculator_ExpDanceCountCommand as ::unity::ClassIdentity>::NAME,
21641 "GetImpl",
21642 )
21643 });
21644 let __inner: extern "C" fn(UnitCalculator_ExpDanceCountCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
21645 ::core::mem::transmute(__vi.method_ptr);
21646 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
21647 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
21648 }
21649 }
21650 }
21651 #[doc = "`.ctor()` overload"]
21652 fn ctor(self) -> () {
21653 unsafe {
21654 let __receiver = <UnitCalculator_ExpDanceCountCommand as ::unity::FromIlInstance>::from_il_instance(
21655 <Self as ::unity::SystemObject>::as_instance(self),
21656 );
21657 ::unity::il2cpp_call!((::unity::module_base()+0x1b47240usize)as*mut u8,();
21658(UnitCalculator_ExpDanceCountCommand)__receiver)
21659 }
21660 }
21661}
21662
21663#[cfg(feature = "app-unitcalculator")]
21664impl<__T: IUnitCalculator_ExpDanceCountCommand> IUnitCalculator_ExpDanceCountCommandMethods for __T {}
21665
21666#[cfg(feature = "app-unitcalculator")]
21667impl UnitCalculator_ExpDanceCountCommand {
21668 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
21669 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
21670 }
21671
21672 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
21673 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
21674 }
21675
21676 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
21677 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
21678 }
21679}
21680
21681#[cfg(feature = "app-unitcalculator")]
21682impl UnitCalculator_ExpDanceCountCommand {
21683 #[doc = "Direct (non-virtual) call to `UnitCalculator_ExpDanceCountCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
21684 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
21685 let __mi = Self::get_name_method_info();
21686 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
21687 __inner(this.into(), ::core::option::Option::None)
21688 }
21689
21690 #[doc = "Direct (non-virtual) call to `UnitCalculator_ExpDanceCountCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
21691 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
21692 let __mi = Self::get_impl_method_info();
21693 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
21694 ::core::mem::transmute(__mi.method_ptr);
21695 __inner(this.into(), unit, ::core::option::Option::None)
21696 }
21697}
21698
21699#[cfg(feature = "app-unitcalculator")]
21700impl UnitCalculator_ExpDanceCountCommand {
21701 #[doc = "`.ctor()` — no args"]
21702 pub fn new() -> Self {
21703 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
21704 panic!(
21705 "{}
21706::{}
21707 failed to instantiate",
21708 ::core::stringify!(UnitCalculator_ExpDanceCountCommand),
21709 ::core::stringify!(new),
21710 )
21711 });
21712 <Self as IUnitCalculator_ExpDanceCountCommandMethods>::ctor(this);
21713 this
21714 }
21715}
21716
21717#[cfg(feature = "app-unitcalculator")]
21718pub trait IUnitCalculator_SupportSecureCommandMethods: IUnitCalculator_SupportSecureCommand {
21719 #[doc = "`get_Name()` overload"]
21720 fn get_name(self) -> ::unity::Il2CppString {
21721 unsafe {
21722 let __receiver = <UnitCalculator_SupportSecureCommand as ::unity::FromIlInstance>::from_il_instance(
21723 <Self as ::unity::SystemObject>::as_instance(self),
21724 );
21725 {
21726 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
21727 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
21728 panic!(
21729 "unity: virtual slot {}
21730 out of range (vtable len {}
21731) on the runtime class behind {}
21732 (method `{}
21733`)",
21734 4usize,
21735 __vt.len(),
21736 <UnitCalculator_SupportSecureCommand as ::unity::ClassIdentity>::NAME,
21737 "get_Name",
21738 )
21739 });
21740 let __inner: extern "C" fn(UnitCalculator_SupportSecureCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
21741 ::core::mem::transmute(__vi.method_ptr);
21742 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
21743 __inner(__receiver, __mi)
21744 }
21745 }
21746 }
21747 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
21748 fn get_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
21749 unsafe {
21750 let __receiver = <UnitCalculator_SupportSecureCommand as ::unity::FromIlInstance>::from_il_instance(
21751 <Self as ::unity::SystemObject>::as_instance(self),
21752 );
21753 {
21754 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
21755 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
21756 panic!(
21757 "unity: virtual slot {}
21758 out of range (vtable len {}
21759) on the runtime class behind {}
21760 (method `{}
21761`)",
21762 31usize,
21763 __vt.len(),
21764 <UnitCalculator_SupportSecureCommand as ::unity::ClassIdentity>::NAME,
21765 "GetImpl",
21766 )
21767 });
21768 let __inner: extern "C" fn(
21769 UnitCalculator_SupportSecureCommand,
21770 crate::app::battleinfoside::BattleInfoSide,
21771 ::unity::OptionalMethod,
21772 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
21773 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
21774 __inner(__receiver, ::core::convert::Into::into(side), __mi)
21775 }
21776 }
21777 }
21778 #[doc = "`SetImpl(crate::app::battleinfoside::BattleInfoSide, f32)` overload"]
21779 fn set_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>, value: impl ::core::convert::Into<f32>) -> () {
21780 unsafe {
21781 let __receiver = <UnitCalculator_SupportSecureCommand as ::unity::FromIlInstance>::from_il_instance(
21782 <Self as ::unity::SystemObject>::as_instance(self),
21783 );
21784 {
21785 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
21786 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
21787 panic!(
21788 "unity: virtual slot {}
21789 out of range (vtable len {}
21790) on the runtime class behind {}
21791 (method `{}
21792`)",
21793 33usize,
21794 __vt.len(),
21795 <UnitCalculator_SupportSecureCommand as ::unity::ClassIdentity>::NAME,
21796 "SetImpl",
21797 )
21798 });
21799 let __inner: extern "C" fn(
21800 UnitCalculator_SupportSecureCommand,
21801 crate::app::battleinfoside::BattleInfoSide,
21802 f32,
21803 ::unity::OptionalMethod,
21804 ) -> () = ::core::mem::transmute(__vi.method_ptr);
21805 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
21806 __inner(__receiver, ::core::convert::Into::into(side), ::core::convert::Into::into(value), __mi)
21807 }
21808 }
21809 }
21810 #[doc = "`IsVisible()` overload"]
21811 fn is_visible(self) -> bool {
21812 unsafe {
21813 let __receiver = <UnitCalculator_SupportSecureCommand as ::unity::FromIlInstance>::from_il_instance(
21814 <Self as ::unity::SystemObject>::as_instance(self),
21815 );
21816 {
21817 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
21818 let __vi = *__vt.get(43usize).unwrap_or_else(|| {
21819 panic!(
21820 "unity: virtual slot {}
21821 out of range (vtable len {}
21822) on the runtime class behind {}
21823 (method `{}
21824`)",
21825 43usize,
21826 __vt.len(),
21827 <UnitCalculator_SupportSecureCommand as ::unity::ClassIdentity>::NAME,
21828 "IsVisible",
21829 )
21830 });
21831 let __inner: extern "C" fn(UnitCalculator_SupportSecureCommand, ::unity::OptionalMethod) -> bool =
21832 ::core::mem::transmute(__vi.method_ptr);
21833 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
21834 __inner(__receiver, __mi)
21835 }
21836 }
21837 }
21838 #[doc = "`.ctor()` overload"]
21839 fn ctor(self) -> () {
21840 unsafe {
21841 let __receiver = <UnitCalculator_SupportSecureCommand as ::unity::FromIlInstance>::from_il_instance(
21842 <Self as ::unity::SystemObject>::as_instance(self),
21843 );
21844 ::unity::il2cpp_call!((::unity::module_base()+0x1b4c5b0usize)as*mut u8,();
21845(UnitCalculator_SupportSecureCommand)__receiver)
21846 }
21847 }
21848}
21849
21850#[cfg(feature = "app-unitcalculator")]
21851impl<__T: IUnitCalculator_SupportSecureCommand> IUnitCalculator_SupportSecureCommandMethods for __T {}
21852
21853#[cfg(feature = "app-unitcalculator")]
21854impl UnitCalculator_SupportSecureCommand {
21855 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
21856 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
21857 }
21858
21859 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
21860 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
21861 }
21862
21863 pub fn set_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
21864 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
21865 }
21866
21867 pub fn is_visible_method_info() -> &'static ::unity::il2cpp::MethodInfo {
21868 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
21869 }
21870
21871 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
21872 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
21873 }
21874}
21875
21876#[cfg(feature = "app-unitcalculator")]
21877impl UnitCalculator_SupportSecureCommand {
21878 #[doc = "Direct (non-virtual) call to `UnitCalculator_SupportSecureCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
21879 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
21880 let __mi = Self::get_name_method_info();
21881 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
21882 __inner(this.into(), ::core::option::Option::None)
21883 }
21884
21885 #[doc = "Direct (non-virtual) call to `UnitCalculator_SupportSecureCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
21886 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
21887 let __mi = Self::get_impl_method_info();
21888 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
21889 ::core::mem::transmute(__mi.method_ptr);
21890 __inner(this.into(), side, ::core::option::Option::None)
21891 }
21892
21893 #[doc = "Direct (non-virtual) call to `UnitCalculator_SupportSecureCommand`'s own `SetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
21894 pub unsafe fn set_impl(
21895 this: impl ::core::convert::Into<::unity::IlInstance>,
21896 side: crate::app::battleinfoside::BattleInfoSide,
21897 value: f32,
21898 ) -> () {
21899 let __mi = Self::set_impl_method_info();
21900 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, f32, ::unity::OptionalMethod) -> () =
21901 ::core::mem::transmute(__mi.method_ptr);
21902 __inner(this.into(), side, value, ::core::option::Option::None)
21903 }
21904
21905 #[doc = "Direct (non-virtual) call to `UnitCalculator_SupportSecureCommand`'s own `IsVisible`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
21906 pub unsafe fn is_visible(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
21907 let __mi = Self::is_visible_method_info();
21908 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
21909 __inner(this.into(), ::core::option::Option::None)
21910 }
21911}
21912
21913#[cfg(feature = "app-unitcalculator")]
21914impl UnitCalculator_SupportSecureCommand {
21915 #[doc = "`.ctor()` — no args"]
21916 pub fn new() -> Self {
21917 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
21918 panic!(
21919 "{}
21920::{}
21921 failed to instantiate",
21922 ::core::stringify!(UnitCalculator_SupportSecureCommand),
21923 ::core::stringify!(new),
21924 )
21925 });
21926 <Self as IUnitCalculator_SupportSecureCommandMethods>::ctor(this);
21927 this
21928 }
21929}
21930
21931#[cfg(feature = "app-unitcalculator")]
21932pub trait IUnitCalculator_SimpleHitCommandMethods: IUnitCalculator_SimpleHitCommand {
21933 #[doc = "`get_Name()` overload"]
21934 fn get_name(self) -> ::unity::Il2CppString {
21935 unsafe {
21936 let __receiver =
21937 <UnitCalculator_SimpleHitCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
21938 {
21939 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
21940 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
21941 panic!(
21942 "unity: virtual slot {}
21943 out of range (vtable len {}
21944) on the runtime class behind {}
21945 (method `{}
21946`)",
21947 4usize,
21948 __vt.len(),
21949 <UnitCalculator_SimpleHitCommand as ::unity::ClassIdentity>::NAME,
21950 "get_Name",
21951 )
21952 });
21953 let __inner: extern "C" fn(UnitCalculator_SimpleHitCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
21954 ::core::mem::transmute(__vi.method_ptr);
21955 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
21956 __inner(__receiver, __mi)
21957 }
21958 }
21959 }
21960 #[doc = "`GetParam(crate::app::battleinfoside::BattleInfoSide)` overload"]
21961 fn get_param(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> crate::app::battleparam::BattleParam {
21962 unsafe {
21963 let __receiver =
21964 <UnitCalculator_SimpleHitCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
21965 {
21966 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
21967 let __vi = *__vt.get(44usize).unwrap_or_else(|| {
21968 panic!(
21969 "unity: virtual slot {}
21970 out of range (vtable len {}
21971) on the runtime class behind {}
21972 (method `{}
21973`)",
21974 44usize,
21975 __vt.len(),
21976 <UnitCalculator_SimpleHitCommand as ::unity::ClassIdentity>::NAME,
21977 "GetParam",
21978 )
21979 });
21980 let __inner: extern "C" fn(
21981 UnitCalculator_SimpleHitCommand,
21982 crate::app::battleinfoside::BattleInfoSide,
21983 ::unity::OptionalMethod,
21984 ) -> crate::app::battleparam::BattleParam = ::core::mem::transmute(__vi.method_ptr);
21985 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
21986 __inner(__receiver, ::core::convert::Into::into(side), __mi)
21987 }
21988 }
21989 }
21990 #[doc = "`IsVisible()` overload"]
21991 fn is_visible(self) -> bool {
21992 unsafe {
21993 let __receiver =
21994 <UnitCalculator_SimpleHitCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
21995 {
21996 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
21997 let __vi = *__vt.get(43usize).unwrap_or_else(|| {
21998 panic!(
21999 "unity: virtual slot {}
22000 out of range (vtable len {}
22001) on the runtime class behind {}
22002 (method `{}
22003`)",
22004 43usize,
22005 __vt.len(),
22006 <UnitCalculator_SimpleHitCommand as ::unity::ClassIdentity>::NAME,
22007 "IsVisible",
22008 )
22009 });
22010 let __inner: extern "C" fn(UnitCalculator_SimpleHitCommand, ::unity::OptionalMethod) -> bool =
22011 ::core::mem::transmute(__vi.method_ptr);
22012 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
22013 __inner(__receiver, __mi)
22014 }
22015 }
22016 }
22017 #[doc = "`.ctor()` overload"]
22018 fn ctor(self) -> () {
22019 unsafe {
22020 let __receiver =
22021 <UnitCalculator_SimpleHitCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
22022 ::unity::il2cpp_call!((::unity::module_base()+0x1b4be00usize)as*mut u8,();
22023(UnitCalculator_SimpleHitCommand)__receiver)
22024 }
22025 }
22026}
22027
22028#[cfg(feature = "app-unitcalculator")]
22029impl<__T: IUnitCalculator_SimpleHitCommand> IUnitCalculator_SimpleHitCommandMethods for __T {}
22030
22031#[cfg(feature = "app-unitcalculator")]
22032impl UnitCalculator_SimpleHitCommand {
22033 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
22034 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
22035 }
22036
22037 pub fn get_param_method_info() -> &'static ::unity::il2cpp::MethodInfo {
22038 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
22039 }
22040
22041 pub fn is_visible_method_info() -> &'static ::unity::il2cpp::MethodInfo {
22042 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
22043 }
22044
22045 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
22046 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
22047 }
22048}
22049
22050#[cfg(feature = "app-unitcalculator")]
22051impl UnitCalculator_SimpleHitCommand {
22052 #[doc = "Direct (non-virtual) call to `UnitCalculator_SimpleHitCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
22053 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
22054 let __mi = Self::get_name_method_info();
22055 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
22056 __inner(this.into(), ::core::option::Option::None)
22057 }
22058
22059 #[doc = "Direct (non-virtual) call to `UnitCalculator_SimpleHitCommand`'s own `GetParam`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
22060 pub unsafe fn get_param(
22061 this: impl ::core::convert::Into<::unity::IlInstance>,
22062 side: crate::app::battleinfoside::BattleInfoSide,
22063 ) -> crate::app::battleparam::BattleParam {
22064 let __mi = Self::get_param_method_info();
22065 let __inner: extern "C" fn(
22066 ::unity::IlInstance,
22067 crate::app::battleinfoside::BattleInfoSide,
22068 ::unity::OptionalMethod,
22069 ) -> crate::app::battleparam::BattleParam = ::core::mem::transmute(__mi.method_ptr);
22070 __inner(this.into(), side, ::core::option::Option::None)
22071 }
22072
22073 #[doc = "Direct (non-virtual) call to `UnitCalculator_SimpleHitCommand`'s own `IsVisible`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
22074 pub unsafe fn is_visible(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
22075 let __mi = Self::is_visible_method_info();
22076 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
22077 __inner(this.into(), ::core::option::Option::None)
22078 }
22079}
22080
22081#[cfg(feature = "app-unitcalculator")]
22082impl UnitCalculator_SimpleHitCommand {
22083 #[doc = "`.ctor()` — no args"]
22084 pub fn new() -> Self {
22085 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
22086 panic!(
22087 "{}
22088::{}
22089 failed to instantiate",
22090 ::core::stringify!(UnitCalculator_SimpleHitCommand),
22091 ::core::stringify!(new),
22092 )
22093 });
22094 <Self as IUnitCalculator_SimpleHitCommandMethods>::ctor(this);
22095 this
22096 }
22097}
22098
22099#[cfg(feature = "app-unitcalculator")]
22100pub trait IUnitCalculator_BattlePinchingCommandMethods: IUnitCalculator_BattlePinchingCommand {
22101 #[doc = "`get_Name()` overload"]
22102 fn get_name(self) -> ::unity::Il2CppString {
22103 unsafe {
22104 let __receiver = <UnitCalculator_BattlePinchingCommand as ::unity::FromIlInstance>::from_il_instance(
22105 <Self as ::unity::SystemObject>::as_instance(self),
22106 );
22107 {
22108 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
22109 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
22110 panic!(
22111 "unity: virtual slot {}
22112 out of range (vtable len {}
22113) on the runtime class behind {}
22114 (method `{}
22115`)",
22116 4usize,
22117 __vt.len(),
22118 <UnitCalculator_BattlePinchingCommand as ::unity::ClassIdentity>::NAME,
22119 "get_Name",
22120 )
22121 });
22122 let __inner: extern "C" fn(UnitCalculator_BattlePinchingCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
22123 ::core::mem::transmute(__vi.method_ptr);
22124 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
22125 __inner(__receiver, __mi)
22126 }
22127 }
22128 }
22129 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
22130 fn get_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
22131 unsafe {
22132 let __receiver = <UnitCalculator_BattlePinchingCommand as ::unity::FromIlInstance>::from_il_instance(
22133 <Self as ::unity::SystemObject>::as_instance(self),
22134 );
22135 {
22136 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
22137 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
22138 panic!(
22139 "unity: virtual slot {}
22140 out of range (vtable len {}
22141) on the runtime class behind {}
22142 (method `{}
22143`)",
22144 31usize,
22145 __vt.len(),
22146 <UnitCalculator_BattlePinchingCommand as ::unity::ClassIdentity>::NAME,
22147 "GetImpl",
22148 )
22149 });
22150 let __inner: extern "C" fn(
22151 UnitCalculator_BattlePinchingCommand,
22152 crate::app::battleinfoside::BattleInfoSide,
22153 ::unity::OptionalMethod,
22154 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
22155 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
22156 __inner(__receiver, ::core::convert::Into::into(side), __mi)
22157 }
22158 }
22159 }
22160 #[doc = "`.ctor()` overload"]
22161 fn ctor(self) -> () {
22162 unsafe {
22163 let __receiver = <UnitCalculator_BattlePinchingCommand as ::unity::FromIlInstance>::from_il_instance(
22164 <Self as ::unity::SystemObject>::as_instance(self),
22165 );
22166 ::unity::il2cpp_call!((::unity::module_base()+0x1b45f10usize)as*mut u8,();
22167(UnitCalculator_BattlePinchingCommand)__receiver)
22168 }
22169 }
22170}
22171
22172#[cfg(feature = "app-unitcalculator")]
22173impl<__T: IUnitCalculator_BattlePinchingCommand> IUnitCalculator_BattlePinchingCommandMethods for __T {}
22174
22175#[cfg(feature = "app-unitcalculator")]
22176impl UnitCalculator_BattlePinchingCommand {
22177 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
22178 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
22179 }
22180
22181 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
22182 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
22183 }
22184
22185 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
22186 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
22187 }
22188}
22189
22190#[cfg(feature = "app-unitcalculator")]
22191impl UnitCalculator_BattlePinchingCommand {
22192 #[doc = "Direct (non-virtual) call to `UnitCalculator_BattlePinchingCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
22193 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
22194 let __mi = Self::get_name_method_info();
22195 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
22196 __inner(this.into(), ::core::option::Option::None)
22197 }
22198
22199 #[doc = "Direct (non-virtual) call to `UnitCalculator_BattlePinchingCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
22200 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
22201 let __mi = Self::get_impl_method_info();
22202 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
22203 ::core::mem::transmute(__mi.method_ptr);
22204 __inner(this.into(), side, ::core::option::Option::None)
22205 }
22206}
22207
22208#[cfg(feature = "app-unitcalculator")]
22209impl UnitCalculator_BattlePinchingCommand {
22210 #[doc = "`.ctor()` — no args"]
22211 pub fn new() -> Self {
22212 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
22213 panic!(
22214 "{}
22215::{}
22216 failed to instantiate",
22217 ::core::stringify!(UnitCalculator_BattlePinchingCommand),
22218 ::core::stringify!(new),
22219 )
22220 });
22221 <Self as IUnitCalculator_BattlePinchingCommandMethods>::ctor(this);
22222 this
22223 }
22224}
22225
22226#[cfg(feature = "app-unitcalculator")]
22227pub trait IUnitCalculator_ActionCountCommandMethods: IUnitCalculator_ActionCountCommand {
22228 #[doc = "`get_Name()` overload"]
22229 fn get_name(self) -> ::unity::Il2CppString {
22230 unsafe {
22231 let __receiver =
22232 <UnitCalculator_ActionCountCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
22233 {
22234 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
22235 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
22236 panic!(
22237 "unity: virtual slot {}
22238 out of range (vtable len {}
22239) on the runtime class behind {}
22240 (method `{}
22241`)",
22242 4usize,
22243 __vt.len(),
22244 <UnitCalculator_ActionCountCommand as ::unity::ClassIdentity>::NAME,
22245 "get_Name",
22246 )
22247 });
22248 let __inner: extern "C" fn(UnitCalculator_ActionCountCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
22249 ::core::mem::transmute(__vi.method_ptr);
22250 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
22251 __inner(__receiver, __mi)
22252 }
22253 }
22254 }
22255 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
22256 fn get_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
22257 unsafe {
22258 let __receiver =
22259 <UnitCalculator_ActionCountCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
22260 {
22261 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
22262 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
22263 panic!(
22264 "unity: virtual slot {}
22265 out of range (vtable len {}
22266) on the runtime class behind {}
22267 (method `{}
22268`)",
22269 31usize,
22270 __vt.len(),
22271 <UnitCalculator_ActionCountCommand as ::unity::ClassIdentity>::NAME,
22272 "GetImpl",
22273 )
22274 });
22275 let __inner: extern "C" fn(
22276 UnitCalculator_ActionCountCommand,
22277 crate::app::battleinfoside::BattleInfoSide,
22278 ::unity::OptionalMethod,
22279 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
22280 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
22281 __inner(__receiver, ::core::convert::Into::into(side), __mi)
22282 }
22283 }
22284 }
22285 #[doc = "`SetImpl(crate::app::battleinfoside::BattleInfoSide, f32)` overload"]
22286 fn set_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>, value: impl ::core::convert::Into<f32>) -> () {
22287 unsafe {
22288 let __receiver =
22289 <UnitCalculator_ActionCountCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
22290 {
22291 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
22292 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
22293 panic!(
22294 "unity: virtual slot {}
22295 out of range (vtable len {}
22296) on the runtime class behind {}
22297 (method `{}
22298`)",
22299 33usize,
22300 __vt.len(),
22301 <UnitCalculator_ActionCountCommand as ::unity::ClassIdentity>::NAME,
22302 "SetImpl",
22303 )
22304 });
22305 let __inner: extern "C" fn(
22306 UnitCalculator_ActionCountCommand,
22307 crate::app::battleinfoside::BattleInfoSide,
22308 f32,
22309 ::unity::OptionalMethod,
22310 ) -> () = ::core::mem::transmute(__vi.method_ptr);
22311 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
22312 __inner(__receiver, ::core::convert::Into::into(side), ::core::convert::Into::into(value), __mi)
22313 }
22314 }
22315 }
22316 #[doc = "`IsVisible()` overload"]
22317 fn is_visible(self) -> bool {
22318 unsafe {
22319 let __receiver =
22320 <UnitCalculator_ActionCountCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
22321 {
22322 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
22323 let __vi = *__vt.get(43usize).unwrap_or_else(|| {
22324 panic!(
22325 "unity: virtual slot {}
22326 out of range (vtable len {}
22327) on the runtime class behind {}
22328 (method `{}
22329`)",
22330 43usize,
22331 __vt.len(),
22332 <UnitCalculator_ActionCountCommand as ::unity::ClassIdentity>::NAME,
22333 "IsVisible",
22334 )
22335 });
22336 let __inner: extern "C" fn(UnitCalculator_ActionCountCommand, ::unity::OptionalMethod) -> bool =
22337 ::core::mem::transmute(__vi.method_ptr);
22338 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
22339 __inner(__receiver, __mi)
22340 }
22341 }
22342 }
22343 #[doc = "`.ctor()` overload"]
22344 fn ctor(self) -> () {
22345 unsafe {
22346 let __receiver =
22347 <UnitCalculator_ActionCountCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
22348 ::unity::il2cpp_call!((::unity::module_base()+0x1b44960usize)as*mut u8,();
22349(UnitCalculator_ActionCountCommand)__receiver)
22350 }
22351 }
22352}
22353
22354#[cfg(feature = "app-unitcalculator")]
22355impl<__T: IUnitCalculator_ActionCountCommand> IUnitCalculator_ActionCountCommandMethods for __T {}
22356
22357#[cfg(feature = "app-unitcalculator")]
22358impl UnitCalculator_ActionCountCommand {
22359 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
22360 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
22361 }
22362
22363 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
22364 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
22365 }
22366
22367 pub fn set_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
22368 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
22369 }
22370
22371 pub fn is_visible_method_info() -> &'static ::unity::il2cpp::MethodInfo {
22372 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
22373 }
22374
22375 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
22376 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
22377 }
22378}
22379
22380#[cfg(feature = "app-unitcalculator")]
22381impl UnitCalculator_ActionCountCommand {
22382 #[doc = "Direct (non-virtual) call to `UnitCalculator_ActionCountCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
22383 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
22384 let __mi = Self::get_name_method_info();
22385 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
22386 __inner(this.into(), ::core::option::Option::None)
22387 }
22388
22389 #[doc = "Direct (non-virtual) call to `UnitCalculator_ActionCountCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
22390 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
22391 let __mi = Self::get_impl_method_info();
22392 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
22393 ::core::mem::transmute(__mi.method_ptr);
22394 __inner(this.into(), side, ::core::option::Option::None)
22395 }
22396
22397 #[doc = "Direct (non-virtual) call to `UnitCalculator_ActionCountCommand`'s own `SetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
22398 pub unsafe fn set_impl(
22399 this: impl ::core::convert::Into<::unity::IlInstance>,
22400 side: crate::app::battleinfoside::BattleInfoSide,
22401 value: f32,
22402 ) -> () {
22403 let __mi = Self::set_impl_method_info();
22404 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, f32, ::unity::OptionalMethod) -> () =
22405 ::core::mem::transmute(__mi.method_ptr);
22406 __inner(this.into(), side, value, ::core::option::Option::None)
22407 }
22408
22409 #[doc = "Direct (non-virtual) call to `UnitCalculator_ActionCountCommand`'s own `IsVisible`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
22410 pub unsafe fn is_visible(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
22411 let __mi = Self::is_visible_method_info();
22412 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
22413 __inner(this.into(), ::core::option::Option::None)
22414 }
22415}
22416
22417#[cfg(feature = "app-unitcalculator")]
22418impl UnitCalculator_ActionCountCommand {
22419 #[doc = "`.ctor()` — no args"]
22420 pub fn new() -> Self {
22421 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
22422 panic!(
22423 "{}
22424::{}
22425 failed to instantiate",
22426 ::core::stringify!(UnitCalculator_ActionCountCommand),
22427 ::core::stringify!(new),
22428 )
22429 });
22430 <Self as IUnitCalculator_ActionCountCommandMethods>::ctor(this);
22431 this
22432 }
22433}
22434
22435#[cfg(feature = "app-unitcalculator")]
22436pub trait IUnitCalculator_GenderCommandMethods: IUnitCalculator_GenderCommand {
22437 #[doc = "`get_Name()` overload"]
22438 fn get_name(self) -> ::unity::Il2CppString {
22439 unsafe {
22440 let __receiver =
22441 <UnitCalculator_GenderCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
22442 {
22443 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
22444 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
22445 panic!(
22446 "unity: virtual slot {}
22447 out of range (vtable len {}
22448) on the runtime class behind {}
22449 (method `{}
22450`)",
22451 4usize,
22452 __vt.len(),
22453 <UnitCalculator_GenderCommand as ::unity::ClassIdentity>::NAME,
22454 "get_Name",
22455 )
22456 });
22457 let __inner: extern "C" fn(UnitCalculator_GenderCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
22458 ::core::mem::transmute(__vi.method_ptr);
22459 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
22460 __inner(__receiver, __mi)
22461 }
22462 }
22463 }
22464 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
22465 fn get_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
22466 unsafe {
22467 let __receiver =
22468 <UnitCalculator_GenderCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
22469 {
22470 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
22471 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
22472 panic!(
22473 "unity: virtual slot {}
22474 out of range (vtable len {}
22475) on the runtime class behind {}
22476 (method `{}
22477`)",
22478 30usize,
22479 __vt.len(),
22480 <UnitCalculator_GenderCommand as ::unity::ClassIdentity>::NAME,
22481 "GetImpl",
22482 )
22483 });
22484 let __inner: extern "C" fn(UnitCalculator_GenderCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
22485 ::core::mem::transmute(__vi.method_ptr);
22486 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
22487 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
22488 }
22489 }
22490 }
22491 #[doc = "`.ctor()` overload"]
22492 fn ctor(self) -> () {
22493 unsafe {
22494 let __receiver =
22495 <UnitCalculator_GenderCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
22496 ::unity::il2cpp_call!((::unity::module_base()+0x1b47bd0usize)as*mut u8,();
22497(UnitCalculator_GenderCommand)__receiver)
22498 }
22499 }
22500}
22501
22502#[cfg(feature = "app-unitcalculator")]
22503impl<__T: IUnitCalculator_GenderCommand> IUnitCalculator_GenderCommandMethods for __T {}
22504
22505#[cfg(feature = "app-unitcalculator")]
22506impl UnitCalculator_GenderCommand {
22507 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
22508 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
22509 }
22510
22511 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
22512 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
22513 }
22514
22515 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
22516 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
22517 }
22518}
22519
22520#[cfg(feature = "app-unitcalculator")]
22521impl UnitCalculator_GenderCommand {
22522 #[doc = "Direct (non-virtual) call to `UnitCalculator_GenderCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
22523 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
22524 let __mi = Self::get_name_method_info();
22525 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
22526 __inner(this.into(), ::core::option::Option::None)
22527 }
22528
22529 #[doc = "Direct (non-virtual) call to `UnitCalculator_GenderCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
22530 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
22531 let __mi = Self::get_impl_method_info();
22532 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
22533 ::core::mem::transmute(__mi.method_ptr);
22534 __inner(this.into(), unit, ::core::option::Option::None)
22535 }
22536}
22537
22538#[cfg(feature = "app-unitcalculator")]
22539impl UnitCalculator_GenderCommand {
22540 #[doc = "`.ctor()` — no args"]
22541 pub fn new() -> Self {
22542 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
22543 panic!(
22544 "{}
22545::{}
22546 failed to instantiate",
22547 ::core::stringify!(UnitCalculator_GenderCommand),
22548 ::core::stringify!(new),
22549 )
22550 });
22551 <Self as IUnitCalculator_GenderCommandMethods>::ctor(this);
22552 this
22553 }
22554}
22555
22556#[cfg(feature = "app-unitcalculator")]
22557pub trait IUnitCalculator_UnitGodCommandMethods: IUnitCalculator_UnitGodCommand {
22558 #[doc = "`get_Name()` overload"]
22559 fn get_name(self) -> ::unity::Il2CppString {
22560 unsafe {
22561 let __receiver =
22562 <UnitCalculator_UnitGodCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
22563 {
22564 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
22565 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
22566 panic!(
22567 "unity: virtual slot {}
22568 out of range (vtable len {}
22569) on the runtime class behind {}
22570 (method `{}
22571`)",
22572 4usize,
22573 __vt.len(),
22574 <UnitCalculator_UnitGodCommand as ::unity::ClassIdentity>::NAME,
22575 "get_Name",
22576 )
22577 });
22578 let __inner: extern "C" fn(UnitCalculator_UnitGodCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
22579 ::core::mem::transmute(__vi.method_ptr);
22580 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
22581 __inner(__receiver, __mi)
22582 }
22583 }
22584 }
22585 #[doc = "`FuncImpl(crate::app::unit::Unit, ::unity::Il2CppString)` overload"]
22586 fn func_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>, arg: impl ::core::convert::Into<::unity::Il2CppString>) -> f32 {
22587 unsafe {
22588 let __receiver =
22589 <UnitCalculator_UnitGodCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
22590 {
22591 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
22592 let __vi = *__vt.get(36usize).unwrap_or_else(|| {
22593 panic!(
22594 "unity: virtual slot {}
22595 out of range (vtable len {}
22596) on the runtime class behind {}
22597 (method `{}
22598`)",
22599 36usize,
22600 __vt.len(),
22601 <UnitCalculator_UnitGodCommand as ::unity::ClassIdentity>::NAME,
22602 "FuncImpl",
22603 )
22604 });
22605 let __inner: extern "C" fn(
22606 UnitCalculator_UnitGodCommand,
22607 crate::app::unit::Unit,
22608 ::unity::Il2CppString,
22609 ::unity::OptionalMethod,
22610 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
22611 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
22612 __inner(__receiver, ::core::convert::Into::into(unit), ::core::convert::Into::into(arg), __mi)
22613 }
22614 }
22615 }
22616 #[doc = "`.ctor()` overload"]
22617 fn ctor(self) -> () {
22618 unsafe {
22619 let __receiver =
22620 <UnitCalculator_UnitGodCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
22621 ::unity::il2cpp_call!((::unity::module_base()+0x1b4d580usize)as*mut u8,();
22622(UnitCalculator_UnitGodCommand)__receiver)
22623 }
22624 }
22625}
22626
22627#[cfg(feature = "app-unitcalculator")]
22628impl<__T: IUnitCalculator_UnitGodCommand> IUnitCalculator_UnitGodCommandMethods for __T {}
22629
22630#[cfg(feature = "app-unitcalculator")]
22631impl UnitCalculator_UnitGodCommand {
22632 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
22633 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
22634 }
22635
22636 pub fn func_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
22637 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
22638 }
22639
22640 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
22641 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
22642 }
22643}
22644
22645#[cfg(feature = "app-unitcalculator")]
22646impl UnitCalculator_UnitGodCommand {
22647 #[doc = "Direct (non-virtual) call to `UnitCalculator_UnitGodCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
22648 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
22649 let __mi = Self::get_name_method_info();
22650 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
22651 __inner(this.into(), ::core::option::Option::None)
22652 }
22653
22654 #[doc = "Direct (non-virtual) call to `UnitCalculator_UnitGodCommand`'s own `FuncImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
22655 pub unsafe fn func_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit, arg: ::unity::Il2CppString) -> f32 {
22656 let __mi = Self::func_impl_method_info();
22657 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::Il2CppString, ::unity::OptionalMethod) -> f32 =
22658 ::core::mem::transmute(__mi.method_ptr);
22659 __inner(this.into(), unit, arg, ::core::option::Option::None)
22660 }
22661}
22662
22663#[cfg(feature = "app-unitcalculator")]
22664impl UnitCalculator_UnitGodCommand {
22665 #[doc = "`.ctor()` — no args"]
22666 pub fn new() -> Self {
22667 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
22668 panic!(
22669 "{}
22670::{}
22671 failed to instantiate",
22672 ::core::stringify!(UnitCalculator_UnitGodCommand),
22673 ::core::stringify!(new),
22674 )
22675 });
22676 <Self as IUnitCalculator_UnitGodCommandMethods>::ctor(this);
22677 this
22678 }
22679}
22680
22681#[cfg(feature = "app-unitcalculator")]
22682pub trait IUnitCalculator_BlowDistanceCommandMethods: IUnitCalculator_BlowDistanceCommand {
22683 #[doc = "`get_Name()` overload"]
22684 fn get_name(self) -> ::unity::Il2CppString {
22685 unsafe {
22686 let __receiver =
22687 <UnitCalculator_BlowDistanceCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
22688 {
22689 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
22690 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
22691 panic!(
22692 "unity: virtual slot {}
22693 out of range (vtable len {}
22694) on the runtime class behind {}
22695 (method `{}
22696`)",
22697 4usize,
22698 __vt.len(),
22699 <UnitCalculator_BlowDistanceCommand as ::unity::ClassIdentity>::NAME,
22700 "get_Name",
22701 )
22702 });
22703 let __inner: extern "C" fn(UnitCalculator_BlowDistanceCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
22704 ::core::mem::transmute(__vi.method_ptr);
22705 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
22706 __inner(__receiver, __mi)
22707 }
22708 }
22709 }
22710 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
22711 fn get_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
22712 unsafe {
22713 let __receiver =
22714 <UnitCalculator_BlowDistanceCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
22715 {
22716 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
22717 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
22718 panic!(
22719 "unity: virtual slot {}
22720 out of range (vtable len {}
22721) on the runtime class behind {}
22722 (method `{}
22723`)",
22724 31usize,
22725 __vt.len(),
22726 <UnitCalculator_BlowDistanceCommand as ::unity::ClassIdentity>::NAME,
22727 "GetImpl",
22728 )
22729 });
22730 let __inner: extern "C" fn(
22731 UnitCalculator_BlowDistanceCommand,
22732 crate::app::battleinfoside::BattleInfoSide,
22733 ::unity::OptionalMethod,
22734 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
22735 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
22736 __inner(__receiver, ::core::convert::Into::into(side), __mi)
22737 }
22738 }
22739 }
22740 #[doc = "`SetImpl(crate::app::battleinfoside::BattleInfoSide, f32)` overload"]
22741 fn set_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>, value: impl ::core::convert::Into<f32>) -> () {
22742 unsafe {
22743 let __receiver =
22744 <UnitCalculator_BlowDistanceCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
22745 {
22746 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
22747 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
22748 panic!(
22749 "unity: virtual slot {}
22750 out of range (vtable len {}
22751) on the runtime class behind {}
22752 (method `{}
22753`)",
22754 33usize,
22755 __vt.len(),
22756 <UnitCalculator_BlowDistanceCommand as ::unity::ClassIdentity>::NAME,
22757 "SetImpl",
22758 )
22759 });
22760 let __inner: extern "C" fn(
22761 UnitCalculator_BlowDistanceCommand,
22762 crate::app::battleinfoside::BattleInfoSide,
22763 f32,
22764 ::unity::OptionalMethod,
22765 ) -> () = ::core::mem::transmute(__vi.method_ptr);
22766 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
22767 __inner(__receiver, ::core::convert::Into::into(side), ::core::convert::Into::into(value), __mi)
22768 }
22769 }
22770 }
22771 #[doc = "`.ctor()` overload"]
22772 fn ctor(self) -> () {
22773 unsafe {
22774 let __receiver =
22775 <UnitCalculator_BlowDistanceCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
22776 ::unity::il2cpp_call!((::unity::module_base()+0x1b46880usize)as*mut u8,();
22777(UnitCalculator_BlowDistanceCommand)__receiver)
22778 }
22779 }
22780}
22781
22782#[cfg(feature = "app-unitcalculator")]
22783impl<__T: IUnitCalculator_BlowDistanceCommand> IUnitCalculator_BlowDistanceCommandMethods for __T {}
22784
22785#[cfg(feature = "app-unitcalculator")]
22786impl UnitCalculator_BlowDistanceCommand {
22787 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
22788 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
22789 }
22790
22791 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
22792 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
22793 }
22794
22795 pub fn set_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
22796 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
22797 }
22798
22799 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
22800 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
22801 }
22802}
22803
22804#[cfg(feature = "app-unitcalculator")]
22805impl UnitCalculator_BlowDistanceCommand {
22806 #[doc = "Direct (non-virtual) call to `UnitCalculator_BlowDistanceCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
22807 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
22808 let __mi = Self::get_name_method_info();
22809 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
22810 __inner(this.into(), ::core::option::Option::None)
22811 }
22812
22813 #[doc = "Direct (non-virtual) call to `UnitCalculator_BlowDistanceCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
22814 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
22815 let __mi = Self::get_impl_method_info();
22816 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
22817 ::core::mem::transmute(__mi.method_ptr);
22818 __inner(this.into(), side, ::core::option::Option::None)
22819 }
22820
22821 #[doc = "Direct (non-virtual) call to `UnitCalculator_BlowDistanceCommand`'s own `SetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
22822 pub unsafe fn set_impl(
22823 this: impl ::core::convert::Into<::unity::IlInstance>,
22824 side: crate::app::battleinfoside::BattleInfoSide,
22825 value: f32,
22826 ) -> () {
22827 let __mi = Self::set_impl_method_info();
22828 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, f32, ::unity::OptionalMethod) -> () =
22829 ::core::mem::transmute(__mi.method_ptr);
22830 __inner(this.into(), side, value, ::core::option::Option::None)
22831 }
22832}
22833
22834#[cfg(feature = "app-unitcalculator")]
22835impl UnitCalculator_BlowDistanceCommand {
22836 #[doc = "`.ctor()` — no args"]
22837 pub fn new() -> Self {
22838 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
22839 panic!(
22840 "{}
22841::{}
22842 failed to instantiate",
22843 ::core::stringify!(UnitCalculator_BlowDistanceCommand),
22844 ::core::stringify!(new),
22845 )
22846 });
22847 <Self as IUnitCalculator_BlowDistanceCommandMethods>::ctor(this);
22848 this
22849 }
22850}
22851
22852#[cfg(feature = "app-unitcalculator")]
22853pub trait IUnitCalculator_WeaponExpendCommandMethods: IUnitCalculator_WeaponExpendCommand {
22854 #[doc = "`get_Name()` overload"]
22855 fn get_name(self) -> ::unity::Il2CppString {
22856 unsafe {
22857 let __receiver =
22858 <UnitCalculator_WeaponExpendCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
22859 {
22860 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
22861 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
22862 panic!(
22863 "unity: virtual slot {}
22864 out of range (vtable len {}
22865) on the runtime class behind {}
22866 (method `{}
22867`)",
22868 4usize,
22869 __vt.len(),
22870 <UnitCalculator_WeaponExpendCommand as ::unity::ClassIdentity>::NAME,
22871 "get_Name",
22872 )
22873 });
22874 let __inner: extern "C" fn(UnitCalculator_WeaponExpendCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
22875 ::core::mem::transmute(__vi.method_ptr);
22876 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
22877 __inner(__receiver, __mi)
22878 }
22879 }
22880 }
22881 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
22882 fn get_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
22883 unsafe {
22884 let __receiver =
22885 <UnitCalculator_WeaponExpendCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
22886 {
22887 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
22888 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
22889 panic!(
22890 "unity: virtual slot {}
22891 out of range (vtable len {}
22892) on the runtime class behind {}
22893 (method `{}
22894`)",
22895 31usize,
22896 __vt.len(),
22897 <UnitCalculator_WeaponExpendCommand as ::unity::ClassIdentity>::NAME,
22898 "GetImpl",
22899 )
22900 });
22901 let __inner: extern "C" fn(
22902 UnitCalculator_WeaponExpendCommand,
22903 crate::app::battleinfoside::BattleInfoSide,
22904 ::unity::OptionalMethod,
22905 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
22906 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
22907 __inner(__receiver, ::core::convert::Into::into(side), __mi)
22908 }
22909 }
22910 }
22911 #[doc = "`SetImpl(crate::app::battleinfoside::BattleInfoSide, f32)` overload"]
22912 fn set_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>, value: impl ::core::convert::Into<f32>) -> () {
22913 unsafe {
22914 let __receiver =
22915 <UnitCalculator_WeaponExpendCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
22916 {
22917 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
22918 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
22919 panic!(
22920 "unity: virtual slot {}
22921 out of range (vtable len {}
22922) on the runtime class behind {}
22923 (method `{}
22924`)",
22925 33usize,
22926 __vt.len(),
22927 <UnitCalculator_WeaponExpendCommand as ::unity::ClassIdentity>::NAME,
22928 "SetImpl",
22929 )
22930 });
22931 let __inner: extern "C" fn(
22932 UnitCalculator_WeaponExpendCommand,
22933 crate::app::battleinfoside::BattleInfoSide,
22934 f32,
22935 ::unity::OptionalMethod,
22936 ) -> () = ::core::mem::transmute(__vi.method_ptr);
22937 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
22938 __inner(__receiver, ::core::convert::Into::into(side), ::core::convert::Into::into(value), __mi)
22939 }
22940 }
22941 }
22942 #[doc = "`.ctor()` overload"]
22943 fn ctor(self) -> () {
22944 unsafe {
22945 let __receiver =
22946 <UnitCalculator_WeaponExpendCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
22947 ::unity::il2cpp_call!((::unity::module_base()+0x1b4e1a0usize)as*mut u8,();
22948(UnitCalculator_WeaponExpendCommand)__receiver)
22949 }
22950 }
22951}
22952
22953#[cfg(feature = "app-unitcalculator")]
22954impl<__T: IUnitCalculator_WeaponExpendCommand> IUnitCalculator_WeaponExpendCommandMethods for __T {}
22955
22956#[cfg(feature = "app-unitcalculator")]
22957impl UnitCalculator_WeaponExpendCommand {
22958 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
22959 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
22960 }
22961
22962 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
22963 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
22964 }
22965
22966 pub fn set_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
22967 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
22968 }
22969
22970 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
22971 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
22972 }
22973}
22974
22975#[cfg(feature = "app-unitcalculator")]
22976impl UnitCalculator_WeaponExpendCommand {
22977 #[doc = "Direct (non-virtual) call to `UnitCalculator_WeaponExpendCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
22978 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
22979 let __mi = Self::get_name_method_info();
22980 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
22981 __inner(this.into(), ::core::option::Option::None)
22982 }
22983
22984 #[doc = "Direct (non-virtual) call to `UnitCalculator_WeaponExpendCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
22985 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
22986 let __mi = Self::get_impl_method_info();
22987 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
22988 ::core::mem::transmute(__mi.method_ptr);
22989 __inner(this.into(), side, ::core::option::Option::None)
22990 }
22991
22992 #[doc = "Direct (non-virtual) call to `UnitCalculator_WeaponExpendCommand`'s own `SetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
22993 pub unsafe fn set_impl(
22994 this: impl ::core::convert::Into<::unity::IlInstance>,
22995 side: crate::app::battleinfoside::BattleInfoSide,
22996 value: f32,
22997 ) -> () {
22998 let __mi = Self::set_impl_method_info();
22999 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, f32, ::unity::OptionalMethod) -> () =
23000 ::core::mem::transmute(__mi.method_ptr);
23001 __inner(this.into(), side, value, ::core::option::Option::None)
23002 }
23003}
23004
23005#[cfg(feature = "app-unitcalculator")]
23006impl UnitCalculator_WeaponExpendCommand {
23007 #[doc = "`.ctor()` — no args"]
23008 pub fn new() -> Self {
23009 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
23010 panic!(
23011 "{}
23012::{}
23013 failed to instantiate",
23014 ::core::stringify!(UnitCalculator_WeaponExpendCommand),
23015 ::core::stringify!(new),
23016 )
23017 });
23018 <Self as IUnitCalculator_WeaponExpendCommandMethods>::ctor(this);
23019 this
23020 }
23021}
23022
23023#[cfg(feature = "app-unitcalculator")]
23024pub trait IUnitCalculator_WeaponAttributeCommandMethods: IUnitCalculator_WeaponAttributeCommand {
23025 #[doc = "`get_Name()` overload"]
23026 fn get_name(self) -> ::unity::Il2CppString {
23027 unsafe {
23028 let __receiver = <UnitCalculator_WeaponAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
23029 <Self as ::unity::SystemObject>::as_instance(self),
23030 );
23031 {
23032 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
23033 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
23034 panic!(
23035 "unity: virtual slot {}
23036 out of range (vtable len {}
23037) on the runtime class behind {}
23038 (method `{}
23039`)",
23040 4usize,
23041 __vt.len(),
23042 <UnitCalculator_WeaponAttributeCommand as ::unity::ClassIdentity>::NAME,
23043 "get_Name",
23044 )
23045 });
23046 let __inner: extern "C" fn(UnitCalculator_WeaponAttributeCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
23047 ::core::mem::transmute(__vi.method_ptr);
23048 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
23049 __inner(__receiver, __mi)
23050 }
23051 }
23052 }
23053 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
23054 fn get_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
23055 unsafe {
23056 let __receiver = <UnitCalculator_WeaponAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
23057 <Self as ::unity::SystemObject>::as_instance(self),
23058 );
23059 {
23060 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
23061 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
23062 panic!(
23063 "unity: virtual slot {}
23064 out of range (vtable len {}
23065) on the runtime class behind {}
23066 (method `{}
23067`)",
23068 31usize,
23069 __vt.len(),
23070 <UnitCalculator_WeaponAttributeCommand as ::unity::ClassIdentity>::NAME,
23071 "GetImpl",
23072 )
23073 });
23074 let __inner: extern "C" fn(
23075 UnitCalculator_WeaponAttributeCommand,
23076 crate::app::battleinfoside::BattleInfoSide,
23077 ::unity::OptionalMethod,
23078 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
23079 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
23080 __inner(__receiver, ::core::convert::Into::into(side), __mi)
23081 }
23082 }
23083 }
23084 #[doc = "`.ctor()` overload"]
23085 fn ctor(self) -> () {
23086 unsafe {
23087 let __receiver = <UnitCalculator_WeaponAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
23088 <Self as ::unity::SystemObject>::as_instance(self),
23089 );
23090 ::unity::il2cpp_call!((::unity::module_base()+0x1b4dc20usize)as*mut u8,();
23091(UnitCalculator_WeaponAttributeCommand)__receiver)
23092 }
23093 }
23094}
23095
23096#[cfg(feature = "app-unitcalculator")]
23097impl<__T: IUnitCalculator_WeaponAttributeCommand> IUnitCalculator_WeaponAttributeCommandMethods for __T {}
23098
23099#[cfg(feature = "app-unitcalculator")]
23100impl UnitCalculator_WeaponAttributeCommand {
23101 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
23102 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
23103 }
23104
23105 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
23106 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
23107 }
23108
23109 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
23110 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
23111 }
23112}
23113
23114#[cfg(feature = "app-unitcalculator")]
23115impl UnitCalculator_WeaponAttributeCommand {
23116 #[doc = "Direct (non-virtual) call to `UnitCalculator_WeaponAttributeCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
23117 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
23118 let __mi = Self::get_name_method_info();
23119 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
23120 __inner(this.into(), ::core::option::Option::None)
23121 }
23122
23123 #[doc = "Direct (non-virtual) call to `UnitCalculator_WeaponAttributeCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
23124 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
23125 let __mi = Self::get_impl_method_info();
23126 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
23127 ::core::mem::transmute(__mi.method_ptr);
23128 __inner(this.into(), side, ::core::option::Option::None)
23129 }
23130}
23131
23132#[cfg(feature = "app-unitcalculator")]
23133impl UnitCalculator_WeaponAttributeCommand {
23134 #[doc = "`.ctor()` — no args"]
23135 pub fn new() -> Self {
23136 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
23137 panic!(
23138 "{}
23139::{}
23140 failed to instantiate",
23141 ::core::stringify!(UnitCalculator_WeaponAttributeCommand),
23142 ::core::stringify!(new),
23143 )
23144 });
23145 <Self as IUnitCalculator_WeaponAttributeCommandMethods>::ctor(this);
23146 this
23147 }
23148}
23149
23150#[cfg(feature = "app-unitcalculator")]
23151pub trait IUnitCalculator_JobInternalLevelCommandMethods: IUnitCalculator_JobInternalLevelCommand {
23152 #[doc = "`get_Name()` overload"]
23153 fn get_name(self) -> ::unity::Il2CppString {
23154 unsafe {
23155 let __receiver = <UnitCalculator_JobInternalLevelCommand as ::unity::FromIlInstance>::from_il_instance(
23156 <Self as ::unity::SystemObject>::as_instance(self),
23157 );
23158 {
23159 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
23160 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
23161 panic!(
23162 "unity: virtual slot {}
23163 out of range (vtable len {}
23164) on the runtime class behind {}
23165 (method `{}
23166`)",
23167 4usize,
23168 __vt.len(),
23169 <UnitCalculator_JobInternalLevelCommand as ::unity::ClassIdentity>::NAME,
23170 "get_Name",
23171 )
23172 });
23173 let __inner: extern "C" fn(UnitCalculator_JobInternalLevelCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
23174 ::core::mem::transmute(__vi.method_ptr);
23175 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
23176 __inner(__receiver, __mi)
23177 }
23178 }
23179 }
23180 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
23181 fn get_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
23182 unsafe {
23183 let __receiver = <UnitCalculator_JobInternalLevelCommand as ::unity::FromIlInstance>::from_il_instance(
23184 <Self as ::unity::SystemObject>::as_instance(self),
23185 );
23186 {
23187 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
23188 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
23189 panic!(
23190 "unity: virtual slot {}
23191 out of range (vtable len {}
23192) on the runtime class behind {}
23193 (method `{}
23194`)",
23195 30usize,
23196 __vt.len(),
23197 <UnitCalculator_JobInternalLevelCommand as ::unity::ClassIdentity>::NAME,
23198 "GetImpl",
23199 )
23200 });
23201 let __inner: extern "C" fn(UnitCalculator_JobInternalLevelCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
23202 ::core::mem::transmute(__vi.method_ptr);
23203 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
23204 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
23205 }
23206 }
23207 }
23208 #[doc = "`.ctor()` overload"]
23209 fn ctor(self) -> () {
23210 unsafe {
23211 let __receiver = <UnitCalculator_JobInternalLevelCommand as ::unity::FromIlInstance>::from_il_instance(
23212 <Self as ::unity::SystemObject>::as_instance(self),
23213 );
23214 ::unity::il2cpp_call!((::unity::module_base()+0x1b48630usize)as*mut u8,();
23215(UnitCalculator_JobInternalLevelCommand)__receiver)
23216 }
23217 }
23218}
23219
23220#[cfg(feature = "app-unitcalculator")]
23221impl<__T: IUnitCalculator_JobInternalLevelCommand> IUnitCalculator_JobInternalLevelCommandMethods for __T {}
23222
23223#[cfg(feature = "app-unitcalculator")]
23224impl UnitCalculator_JobInternalLevelCommand {
23225 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
23226 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
23227 }
23228
23229 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
23230 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
23231 }
23232
23233 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
23234 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
23235 }
23236}
23237
23238#[cfg(feature = "app-unitcalculator")]
23239impl UnitCalculator_JobInternalLevelCommand {
23240 #[doc = "Direct (non-virtual) call to `UnitCalculator_JobInternalLevelCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
23241 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
23242 let __mi = Self::get_name_method_info();
23243 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
23244 __inner(this.into(), ::core::option::Option::None)
23245 }
23246
23247 #[doc = "Direct (non-virtual) call to `UnitCalculator_JobInternalLevelCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
23248 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
23249 let __mi = Self::get_impl_method_info();
23250 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
23251 ::core::mem::transmute(__mi.method_ptr);
23252 __inner(this.into(), unit, ::core::option::Option::None)
23253 }
23254}
23255
23256#[cfg(feature = "app-unitcalculator")]
23257impl UnitCalculator_JobInternalLevelCommand {
23258 #[doc = "`.ctor()` — no args"]
23259 pub fn new() -> Self {
23260 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
23261 panic!(
23262 "{}
23263::{}
23264 failed to instantiate",
23265 ::core::stringify!(UnitCalculator_JobInternalLevelCommand),
23266 ::core::stringify!(new),
23267 )
23268 });
23269 <Self as IUnitCalculator_JobInternalLevelCommandMethods>::ctor(this);
23270 this
23271 }
23272}
23273
23274#[cfg(feature = "app-unitcalculator")]
23275pub trait IUnitCalculator_CriticalCommandMethods: IUnitCalculator_CriticalCommand {
23276 #[doc = "`get_Name()` overload"]
23277 fn get_name(self) -> ::unity::Il2CppString {
23278 unsafe {
23279 let __receiver =
23280 <UnitCalculator_CriticalCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
23281 {
23282 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
23283 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
23284 panic!(
23285 "unity: virtual slot {}
23286 out of range (vtable len {}
23287) on the runtime class behind {}
23288 (method `{}
23289`)",
23290 4usize,
23291 __vt.len(),
23292 <UnitCalculator_CriticalCommand as ::unity::ClassIdentity>::NAME,
23293 "get_Name",
23294 )
23295 });
23296 let __inner: extern "C" fn(UnitCalculator_CriticalCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
23297 ::core::mem::transmute(__vi.method_ptr);
23298 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
23299 __inner(__receiver, __mi)
23300 }
23301 }
23302 }
23303 #[doc = "`GetParam(crate::app::battleinfoside::BattleInfoSide)` overload"]
23304 fn get_param(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> crate::app::battleparam::BattleParam {
23305 unsafe {
23306 let __receiver =
23307 <UnitCalculator_CriticalCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
23308 {
23309 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
23310 let __vi = *__vt.get(44usize).unwrap_or_else(|| {
23311 panic!(
23312 "unity: virtual slot {}
23313 out of range (vtable len {}
23314) on the runtime class behind {}
23315 (method `{}
23316`)",
23317 44usize,
23318 __vt.len(),
23319 <UnitCalculator_CriticalCommand as ::unity::ClassIdentity>::NAME,
23320 "GetParam",
23321 )
23322 });
23323 let __inner: extern "C" fn(
23324 UnitCalculator_CriticalCommand,
23325 crate::app::battleinfoside::BattleInfoSide,
23326 ::unity::OptionalMethod,
23327 ) -> crate::app::battleparam::BattleParam = ::core::mem::transmute(__vi.method_ptr);
23328 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
23329 __inner(__receiver, ::core::convert::Into::into(side), __mi)
23330 }
23331 }
23332 }
23333 #[doc = "`IsVisible()` overload"]
23334 fn is_visible(self) -> bool {
23335 unsafe {
23336 let __receiver =
23337 <UnitCalculator_CriticalCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
23338 {
23339 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
23340 let __vi = *__vt.get(43usize).unwrap_or_else(|| {
23341 panic!(
23342 "unity: virtual slot {}
23343 out of range (vtable len {}
23344) on the runtime class behind {}
23345 (method `{}
23346`)",
23347 43usize,
23348 __vt.len(),
23349 <UnitCalculator_CriticalCommand as ::unity::ClassIdentity>::NAME,
23350 "IsVisible",
23351 )
23352 });
23353 let __inner: extern "C" fn(UnitCalculator_CriticalCommand, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
23354 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
23355 __inner(__receiver, __mi)
23356 }
23357 }
23358 }
23359 #[doc = "`.ctor()` overload"]
23360 fn ctor(self) -> () {
23361 unsafe {
23362 let __receiver =
23363 <UnitCalculator_CriticalCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
23364 ::unity::il2cpp_call!((::unity::module_base()+0x1b46a30usize)as*mut u8,();
23365(UnitCalculator_CriticalCommand)__receiver)
23366 }
23367 }
23368}
23369
23370#[cfg(feature = "app-unitcalculator")]
23371impl<__T: IUnitCalculator_CriticalCommand> IUnitCalculator_CriticalCommandMethods for __T {}
23372
23373#[cfg(feature = "app-unitcalculator")]
23374impl UnitCalculator_CriticalCommand {
23375 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
23376 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
23377 }
23378
23379 pub fn get_param_method_info() -> &'static ::unity::il2cpp::MethodInfo {
23380 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
23381 }
23382
23383 pub fn is_visible_method_info() -> &'static ::unity::il2cpp::MethodInfo {
23384 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
23385 }
23386
23387 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
23388 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
23389 }
23390}
23391
23392#[cfg(feature = "app-unitcalculator")]
23393impl UnitCalculator_CriticalCommand {
23394 #[doc = "Direct (non-virtual) call to `UnitCalculator_CriticalCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
23395 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
23396 let __mi = Self::get_name_method_info();
23397 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
23398 __inner(this.into(), ::core::option::Option::None)
23399 }
23400
23401 #[doc = "Direct (non-virtual) call to `UnitCalculator_CriticalCommand`'s own `GetParam`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
23402 pub unsafe fn get_param(
23403 this: impl ::core::convert::Into<::unity::IlInstance>,
23404 side: crate::app::battleinfoside::BattleInfoSide,
23405 ) -> crate::app::battleparam::BattleParam {
23406 let __mi = Self::get_param_method_info();
23407 let __inner: extern "C" fn(
23408 ::unity::IlInstance,
23409 crate::app::battleinfoside::BattleInfoSide,
23410 ::unity::OptionalMethod,
23411 ) -> crate::app::battleparam::BattleParam = ::core::mem::transmute(__mi.method_ptr);
23412 __inner(this.into(), side, ::core::option::Option::None)
23413 }
23414
23415 #[doc = "Direct (non-virtual) call to `UnitCalculator_CriticalCommand`'s own `IsVisible`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
23416 pub unsafe fn is_visible(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
23417 let __mi = Self::is_visible_method_info();
23418 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
23419 __inner(this.into(), ::core::option::Option::None)
23420 }
23421}
23422
23423#[cfg(feature = "app-unitcalculator")]
23424impl UnitCalculator_CriticalCommand {
23425 #[doc = "`.ctor()` — no args"]
23426 pub fn new() -> Self {
23427 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
23428 panic!(
23429 "{}
23430::{}
23431 failed to instantiate",
23432 ::core::stringify!(UnitCalculator_CriticalCommand),
23433 ::core::stringify!(new),
23434 )
23435 });
23436 <Self as IUnitCalculator_CriticalCommandMethods>::ctor(this);
23437 this
23438 }
23439}
23440
23441#[cfg(feature = "app-unitcalculator")]
23442pub trait IUnitCalculator_FixedFriendCountCommandMethods: IUnitCalculator_FixedFriendCountCommand {
23443 #[doc = "`get_Name()` overload"]
23444 fn get_name(self) -> ::unity::Il2CppString {
23445 unsafe {
23446 let __receiver = <UnitCalculator_FixedFriendCountCommand as ::unity::FromIlInstance>::from_il_instance(
23447 <Self as ::unity::SystemObject>::as_instance(self),
23448 );
23449 {
23450 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
23451 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
23452 panic!(
23453 "unity: virtual slot {}
23454 out of range (vtable len {}
23455) on the runtime class behind {}
23456 (method `{}
23457`)",
23458 4usize,
23459 __vt.len(),
23460 <UnitCalculator_FixedFriendCountCommand as ::unity::ClassIdentity>::NAME,
23461 "get_Name",
23462 )
23463 });
23464 let __inner: extern "C" fn(UnitCalculator_FixedFriendCountCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
23465 ::core::mem::transmute(__vi.method_ptr);
23466 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
23467 __inner(__receiver, __mi)
23468 }
23469 }
23470 }
23471 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
23472 fn get_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
23473 unsafe {
23474 let __receiver = <UnitCalculator_FixedFriendCountCommand as ::unity::FromIlInstance>::from_il_instance(
23475 <Self as ::unity::SystemObject>::as_instance(self),
23476 );
23477 {
23478 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
23479 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
23480 panic!(
23481 "unity: virtual slot {}
23482 out of range (vtable len {}
23483) on the runtime class behind {}
23484 (method `{}
23485`)",
23486 30usize,
23487 __vt.len(),
23488 <UnitCalculator_FixedFriendCountCommand as ::unity::ClassIdentity>::NAME,
23489 "GetImpl",
23490 )
23491 });
23492 let __inner: extern "C" fn(UnitCalculator_FixedFriendCountCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
23493 ::core::mem::transmute(__vi.method_ptr);
23494 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
23495 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
23496 }
23497 }
23498 }
23499 #[doc = "`.ctor()` overload"]
23500 fn ctor(self) -> () {
23501 unsafe {
23502 let __receiver = <UnitCalculator_FixedFriendCountCommand as ::unity::FromIlInstance>::from_il_instance(
23503 <Self as ::unity::SystemObject>::as_instance(self),
23504 );
23505 ::unity::il2cpp_call!((::unity::module_base()+0x1b47850usize)as*mut u8,();
23506(UnitCalculator_FixedFriendCountCommand)__receiver)
23507 }
23508 }
23509}
23510
23511#[cfg(feature = "app-unitcalculator")]
23512impl<__T: IUnitCalculator_FixedFriendCountCommand> IUnitCalculator_FixedFriendCountCommandMethods for __T {}
23513
23514#[cfg(feature = "app-unitcalculator")]
23515impl UnitCalculator_FixedFriendCountCommand {
23516 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
23517 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
23518 }
23519
23520 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
23521 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
23522 }
23523
23524 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
23525 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
23526 }
23527}
23528
23529#[cfg(feature = "app-unitcalculator")]
23530impl UnitCalculator_FixedFriendCountCommand {
23531 #[doc = "Direct (non-virtual) call to `UnitCalculator_FixedFriendCountCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
23532 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
23533 let __mi = Self::get_name_method_info();
23534 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
23535 __inner(this.into(), ::core::option::Option::None)
23536 }
23537
23538 #[doc = "Direct (non-virtual) call to `UnitCalculator_FixedFriendCountCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
23539 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
23540 let __mi = Self::get_impl_method_info();
23541 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
23542 ::core::mem::transmute(__mi.method_ptr);
23543 __inner(this.into(), unit, ::core::option::Option::None)
23544 }
23545}
23546
23547#[cfg(feature = "app-unitcalculator")]
23548impl UnitCalculator_FixedFriendCountCommand {
23549 #[doc = "`.ctor()` — no args"]
23550 pub fn new() -> Self {
23551 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
23552 panic!(
23553 "{}
23554::{}
23555 failed to instantiate",
23556 ::core::stringify!(UnitCalculator_FixedFriendCountCommand),
23557 ::core::stringify!(new),
23558 )
23559 });
23560 <Self as IUnitCalculator_FixedFriendCountCommandMethods>::ctor(this);
23561 this
23562 }
23563}
23564
23565#[cfg(feature = "app-unitcalculator")]
23566pub trait IUnitCalculator_LinkGodCommandMethods: IUnitCalculator_LinkGodCommand {
23567 #[doc = "`get_CapabilityType()` overload"]
23568 fn get_capability_type(self) -> crate::app::capabilitydefinition::CapabilityDefinition_Type {
23569 unsafe {
23570 let __receiver =
23571 <UnitCalculator_LinkGodCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
23572 {
23573 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
23574 let __vi = *__vt.get(44usize).unwrap_or_else(|| {
23575 panic!(
23576 "unity: virtual slot {}
23577 out of range (vtable len {}
23578) on the runtime class behind {}
23579 (method `{}
23580`)",
23581 44usize,
23582 __vt.len(),
23583 <UnitCalculator_LinkGodCommand as ::unity::ClassIdentity>::NAME,
23584 "get_CapabilityType",
23585 )
23586 });
23587 let __inner: extern "C" fn(
23588 UnitCalculator_LinkGodCommand,
23589 ::unity::OptionalMethod,
23590 ) -> crate::app::capabilitydefinition::CapabilityDefinition_Type = ::core::mem::transmute(__vi.method_ptr);
23591 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
23592 __inner(__receiver, __mi)
23593 }
23594 }
23595 }
23596 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
23597 fn get_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
23598 unsafe {
23599 let __receiver =
23600 <UnitCalculator_LinkGodCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
23601 {
23602 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
23603 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
23604 panic!(
23605 "unity: virtual slot {}
23606 out of range (vtable len {}
23607) on the runtime class behind {}
23608 (method `{}
23609`)",
23610 30usize,
23611 __vt.len(),
23612 <UnitCalculator_LinkGodCommand as ::unity::ClassIdentity>::NAME,
23613 "GetImpl",
23614 )
23615 });
23616 let __inner: extern "C" fn(UnitCalculator_LinkGodCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
23617 ::core::mem::transmute(__vi.method_ptr);
23618 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
23619 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
23620 }
23621 }
23622 }
23623 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
23624 fn get_impl_2(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
23625 unsafe {
23626 let __receiver =
23627 <UnitCalculator_LinkGodCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
23628 {
23629 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
23630 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
23631 panic!(
23632 "unity: virtual slot {}
23633 out of range (vtable len {}
23634) on the runtime class behind {}
23635 (method `{}
23636`)",
23637 31usize,
23638 __vt.len(),
23639 <UnitCalculator_LinkGodCommand as ::unity::ClassIdentity>::NAME,
23640 "GetImpl",
23641 )
23642 });
23643 let __inner: extern "C" fn(
23644 UnitCalculator_LinkGodCommand,
23645 crate::app::battleinfoside::BattleInfoSide,
23646 ::unity::OptionalMethod,
23647 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
23648 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
23649 __inner(__receiver, ::core::convert::Into::into(side), __mi)
23650 }
23651 }
23652 }
23653 #[doc = "`SetImpl(crate::app::battleinfoside::BattleInfoSide, f32)` overload"]
23654 fn set_impl(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>, value: impl ::core::convert::Into<f32>) -> () {
23655 unsafe {
23656 let __receiver =
23657 <UnitCalculator_LinkGodCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
23658 {
23659 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
23660 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
23661 panic!(
23662 "unity: virtual slot {}
23663 out of range (vtable len {}
23664) on the runtime class behind {}
23665 (method `{}
23666`)",
23667 33usize,
23668 __vt.len(),
23669 <UnitCalculator_LinkGodCommand as ::unity::ClassIdentity>::NAME,
23670 "SetImpl",
23671 )
23672 });
23673 let __inner: extern "C" fn(
23674 UnitCalculator_LinkGodCommand,
23675 crate::app::battleinfoside::BattleInfoSide,
23676 f32,
23677 ::unity::OptionalMethod,
23678 ) -> () = ::core::mem::transmute(__vi.method_ptr);
23679 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
23680 __inner(__receiver, ::core::convert::Into::into(side), ::core::convert::Into::into(value), __mi)
23681 }
23682 }
23683 }
23684 #[doc = "`GetCapability(crate::app::battleinfoside::BattleInfoSide)` overload"]
23685 fn get_capability(
23686 self,
23687 side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>,
23688 ) -> crate::app::capabilityint::CapabilityInt {
23689 unsafe {
23690 let __receiver =
23691 <UnitCalculator_LinkGodCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
23692 ::unity::il2cpp_call!((::unity::module_base()+0x1b488c0usize)as*mut u8,crate::app::capabilityint::CapabilityInt;
23693(UnitCalculator_LinkGodCommand)__receiver,(crate::app::battleinfoside::BattleInfoSide)::core::convert::Into::into(side))
23694 }
23695 }
23696 #[doc = "`.ctor()` overload"]
23697 fn ctor(self) -> () {
23698 unsafe {
23699 let __receiver =
23700 <UnitCalculator_LinkGodCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
23701 ::unity::il2cpp_call!((::unity::module_base()+0x1b487b0usize)as*mut u8,();
23702(UnitCalculator_LinkGodCommand)__receiver)
23703 }
23704 }
23705}
23706
23707#[cfg(feature = "app-unitcalculator")]
23708impl<__T: IUnitCalculator_LinkGodCommand> IUnitCalculator_LinkGodCommandMethods for __T {}
23709
23710#[cfg(feature = "app-unitcalculator")]
23711impl UnitCalculator_LinkGodCommand {
23712 pub fn get_capability_type_method_info() -> &'static ::unity::il2cpp::MethodInfo {
23713 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
23714 }
23715
23716 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
23717 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
23718 }
23719
23720 pub fn get_impl_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
23721 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
23722 }
23723
23724 pub fn set_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
23725 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
23726 }
23727
23728 pub fn get_capability_method_info() -> &'static ::unity::il2cpp::MethodInfo {
23729 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
23730 }
23731
23732 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
23733 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
23734 }
23735}
23736
23737#[cfg(feature = "app-unitcalculator")]
23738impl UnitCalculator_LinkGodCommand {
23739 #[doc = "Direct (non-virtual) call to `UnitCalculator_LinkGodCommand`'s own `get_CapabilityType`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
23740 pub unsafe fn get_capability_type(
23741 this: impl ::core::convert::Into<::unity::IlInstance>,
23742 ) -> crate::app::capabilitydefinition::CapabilityDefinition_Type {
23743 let __mi = Self::get_capability_type_method_info();
23744 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::capabilitydefinition::CapabilityDefinition_Type =
23745 ::core::mem::transmute(__mi.method_ptr);
23746 __inner(this.into(), ::core::option::Option::None)
23747 }
23748
23749 #[doc = "Direct (non-virtual) call to `UnitCalculator_LinkGodCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
23750 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
23751 let __mi = Self::get_impl_method_info();
23752 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
23753 ::core::mem::transmute(__mi.method_ptr);
23754 __inner(this.into(), unit, ::core::option::Option::None)
23755 }
23756
23757 #[doc = "Direct (non-virtual) call to `UnitCalculator_LinkGodCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
23758 pub unsafe fn get_impl_2(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
23759 let __mi = Self::get_impl_2_method_info();
23760 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
23761 ::core::mem::transmute(__mi.method_ptr);
23762 __inner(this.into(), side, ::core::option::Option::None)
23763 }
23764
23765 #[doc = "Direct (non-virtual) call to `UnitCalculator_LinkGodCommand`'s own `SetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
23766 pub unsafe fn set_impl(
23767 this: impl ::core::convert::Into<::unity::IlInstance>,
23768 side: crate::app::battleinfoside::BattleInfoSide,
23769 value: f32,
23770 ) -> () {
23771 let __mi = Self::set_impl_method_info();
23772 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, f32, ::unity::OptionalMethod) -> () =
23773 ::core::mem::transmute(__mi.method_ptr);
23774 __inner(this.into(), side, value, ::core::option::Option::None)
23775 }
23776}
23777
23778#[cfg(feature = "app-unitcalculator")]
23779impl UnitCalculator_LinkGodCommand {
23780 #[doc = "`.ctor()` — no args"]
23781 pub fn new() -> Self {
23782 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
23783 panic!(
23784 "{}
23785::{}
23786 failed to instantiate",
23787 ::core::stringify!(UnitCalculator_LinkGodCommand),
23788 ::core::stringify!(new),
23789 )
23790 });
23791 <Self as IUnitCalculator_LinkGodCommandMethods>::ctor(this);
23792 this
23793 }
23794}
23795
23796#[cfg(feature = "app-unitcalculator")]
23797pub trait IUnitCalculator_UnitAttributeCommandMethods: IUnitCalculator_UnitAttributeCommand {
23798 #[doc = "`get_Name()` overload"]
23799 fn get_name(self) -> ::unity::Il2CppString {
23800 unsafe {
23801 let __receiver = <UnitCalculator_UnitAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
23802 <Self as ::unity::SystemObject>::as_instance(self),
23803 );
23804 {
23805 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
23806 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
23807 panic!(
23808 "unity: virtual slot {}
23809 out of range (vtable len {}
23810) on the runtime class behind {}
23811 (method `{}
23812`)",
23813 4usize,
23814 __vt.len(),
23815 <UnitCalculator_UnitAttributeCommand as ::unity::ClassIdentity>::NAME,
23816 "get_Name",
23817 )
23818 });
23819 let __inner: extern "C" fn(UnitCalculator_UnitAttributeCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
23820 ::core::mem::transmute(__vi.method_ptr);
23821 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
23822 __inner(__receiver, __mi)
23823 }
23824 }
23825 }
23826 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
23827 fn get_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
23828 unsafe {
23829 let __receiver = <UnitCalculator_UnitAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
23830 <Self as ::unity::SystemObject>::as_instance(self),
23831 );
23832 {
23833 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
23834 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
23835 panic!(
23836 "unity: virtual slot {}
23837 out of range (vtable len {}
23838) on the runtime class behind {}
23839 (method `{}
23840`)",
23841 30usize,
23842 __vt.len(),
23843 <UnitCalculator_UnitAttributeCommand as ::unity::ClassIdentity>::NAME,
23844 "GetImpl",
23845 )
23846 });
23847 let __inner: extern "C" fn(UnitCalculator_UnitAttributeCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
23848 ::core::mem::transmute(__vi.method_ptr);
23849 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
23850 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
23851 }
23852 }
23853 }
23854 #[doc = "`FuncImpl(crate::app::unit::Unit, crate::system::collections::generic::list_1::List_1<f32>)` overload"]
23855 fn func_impl(
23856 self,
23857 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
23858 args: impl ::core::convert::Into<crate::system::collections::generic::list_1::List_1<f32>>,
23859 ) -> f32 {
23860 unsafe {
23861 let __receiver = <UnitCalculator_UnitAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
23862 <Self as ::unity::SystemObject>::as_instance(self),
23863 );
23864 {
23865 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
23866 let __vi = *__vt.get(34usize).unwrap_or_else(|| {
23867 panic!(
23868 "unity: virtual slot {}
23869 out of range (vtable len {}
23870) on the runtime class behind {}
23871 (method `{}
23872`)",
23873 34usize,
23874 __vt.len(),
23875 <UnitCalculator_UnitAttributeCommand as ::unity::ClassIdentity>::NAME,
23876 "FuncImpl",
23877 )
23878 });
23879 let __inner: extern "C" fn(
23880 UnitCalculator_UnitAttributeCommand,
23881 crate::app::unit::Unit,
23882 crate::system::collections::generic::list_1::List_1<f32>,
23883 ::unity::OptionalMethod,
23884 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
23885 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
23886 __inner(__receiver, ::core::convert::Into::into(unit), ::core::convert::Into::into(args), __mi)
23887 }
23888 }
23889 }
23890 #[doc = "`.ctor()` overload"]
23891 fn ctor(self) -> () {
23892 unsafe {
23893 let __receiver = <UnitCalculator_UnitAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
23894 <Self as ::unity::SystemObject>::as_instance(self),
23895 );
23896 ::unity::il2cpp_call!((::unity::module_base()+0x1b4d3f0usize)as*mut u8,();
23897(UnitCalculator_UnitAttributeCommand)__receiver)
23898 }
23899 }
23900}
23901
23902#[cfg(feature = "app-unitcalculator")]
23903impl<__T: IUnitCalculator_UnitAttributeCommand> IUnitCalculator_UnitAttributeCommandMethods for __T {}
23904
23905#[cfg(feature = "app-unitcalculator")]
23906impl UnitCalculator_UnitAttributeCommand {
23907 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
23908 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
23909 }
23910
23911 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
23912 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
23913 }
23914
23915 pub fn func_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
23916 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
23917 }
23918
23919 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
23920 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
23921 }
23922}
23923
23924#[cfg(feature = "app-unitcalculator")]
23925impl UnitCalculator_UnitAttributeCommand {
23926 #[doc = "Direct (non-virtual) call to `UnitCalculator_UnitAttributeCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
23927 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
23928 let __mi = Self::get_name_method_info();
23929 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
23930 __inner(this.into(), ::core::option::Option::None)
23931 }
23932
23933 #[doc = "Direct (non-virtual) call to `UnitCalculator_UnitAttributeCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
23934 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
23935 let __mi = Self::get_impl_method_info();
23936 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
23937 ::core::mem::transmute(__mi.method_ptr);
23938 __inner(this.into(), unit, ::core::option::Option::None)
23939 }
23940
23941 #[doc = "Direct (non-virtual) call to `UnitCalculator_UnitAttributeCommand`'s own `FuncImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
23942 pub unsafe fn func_impl(
23943 this: impl ::core::convert::Into<::unity::IlInstance>,
23944 unit: crate::app::unit::Unit,
23945 args: crate::system::collections::generic::list_1::List_1<f32>,
23946 ) -> f32 {
23947 let __mi = Self::func_impl_method_info();
23948 let __inner: extern "C" fn(
23949 ::unity::IlInstance,
23950 crate::app::unit::Unit,
23951 crate::system::collections::generic::list_1::List_1<f32>,
23952 ::unity::OptionalMethod,
23953 ) -> f32 = ::core::mem::transmute(__mi.method_ptr);
23954 __inner(this.into(), unit, args, ::core::option::Option::None)
23955 }
23956}
23957
23958#[cfg(feature = "app-unitcalculator")]
23959impl UnitCalculator_UnitAttributeCommand {
23960 #[doc = "`.ctor()` — no args"]
23961 pub fn new() -> Self {
23962 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
23963 panic!(
23964 "{}
23965::{}
23966 failed to instantiate",
23967 ::core::stringify!(UnitCalculator_UnitAttributeCommand),
23968 ::core::stringify!(new),
23969 )
23970 });
23971 <Self as IUnitCalculator_UnitAttributeCommandMethods>::ctor(this);
23972 this
23973 }
23974}
23975
23976#[cfg(feature = "app-unitcalculator")]
23977pub trait IUnitCalculator_RodTypeCommandMethods: IUnitCalculator_RodTypeCommand {
23978 #[doc = "`get_Name()` overload"]
23979 fn get_name(self) -> ::unity::Il2CppString {
23980 unsafe {
23981 let __receiver =
23982 <UnitCalculator_RodTypeCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
23983 {
23984 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
23985 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
23986 panic!(
23987 "unity: virtual slot {}
23988 out of range (vtable len {}
23989) on the runtime class behind {}
23990 (method `{}
23991`)",
23992 4usize,
23993 __vt.len(),
23994 <UnitCalculator_RodTypeCommand as ::unity::ClassIdentity>::NAME,
23995 "get_Name",
23996 )
23997 });
23998 let __inner: extern "C" fn(UnitCalculator_RodTypeCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
23999 ::core::mem::transmute(__vi.method_ptr);
24000 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
24001 __inner(__receiver, __mi)
24002 }
24003 }
24004 }
24005 #[doc = "`GetKind(crate::app::itemdata::ItemData)` overload"]
24006 fn get_kind(self, item: impl ::core::convert::Into<crate::app::itemdata::ItemData>) -> i32 {
24007 unsafe {
24008 let __receiver =
24009 <UnitCalculator_RodTypeCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
24010 ::unity::il2cpp_call!((::unity::module_base()+0x1b4ba80usize)as*mut u8,i32;
24011(UnitCalculator_RodTypeCommand)__receiver,(crate::app::itemdata::ItemData)::core::convert::Into::into(item))
24012 }
24013 }
24014 #[doc = "`GetImpl(crate::app::unit::Unit)` overload"]
24015 fn get_impl(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> f32 {
24016 unsafe {
24017 let __receiver =
24018 <UnitCalculator_RodTypeCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
24019 {
24020 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
24021 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
24022 panic!(
24023 "unity: virtual slot {}
24024 out of range (vtable len {}
24025) on the runtime class behind {}
24026 (method `{}
24027`)",
24028 30usize,
24029 __vt.len(),
24030 <UnitCalculator_RodTypeCommand as ::unity::ClassIdentity>::NAME,
24031 "GetImpl",
24032 )
24033 });
24034 let __inner: extern "C" fn(UnitCalculator_RodTypeCommand, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
24035 ::core::mem::transmute(__vi.method_ptr);
24036 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
24037 __inner(__receiver, ::core::convert::Into::into(unit), __mi)
24038 }
24039 }
24040 }
24041 #[doc = "`GetImpl(crate::app::battleinfoside::BattleInfoSide)` overload"]
24042 fn get_impl_2(self, side: impl ::core::convert::Into<crate::app::battleinfoside::BattleInfoSide>) -> f32 {
24043 unsafe {
24044 let __receiver =
24045 <UnitCalculator_RodTypeCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
24046 {
24047 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
24048 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
24049 panic!(
24050 "unity: virtual slot {}
24051 out of range (vtable len {}
24052) on the runtime class behind {}
24053 (method `{}
24054`)",
24055 31usize,
24056 __vt.len(),
24057 <UnitCalculator_RodTypeCommand as ::unity::ClassIdentity>::NAME,
24058 "GetImpl",
24059 )
24060 });
24061 let __inner: extern "C" fn(
24062 UnitCalculator_RodTypeCommand,
24063 crate::app::battleinfoside::BattleInfoSide,
24064 ::unity::OptionalMethod,
24065 ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
24066 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
24067 __inner(__receiver, ::core::convert::Into::into(side), __mi)
24068 }
24069 }
24070 }
24071 #[doc = "`.ctor()` overload"]
24072 fn ctor(self) -> () {
24073 unsafe {
24074 let __receiver =
24075 <UnitCalculator_RodTypeCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
24076 ::unity::il2cpp_call!((::unity::module_base()+0x1b4bc80usize)as*mut u8,();
24077(UnitCalculator_RodTypeCommand)__receiver)
24078 }
24079 }
24080}
24081
24082#[cfg(feature = "app-unitcalculator")]
24083impl<__T: IUnitCalculator_RodTypeCommand> IUnitCalculator_RodTypeCommandMethods for __T {}
24084
24085#[cfg(feature = "app-unitcalculator")]
24086impl UnitCalculator_RodTypeCommand {
24087 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
24088 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
24089 }
24090
24091 pub fn get_kind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
24092 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
24093 }
24094
24095 pub fn get_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
24096 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
24097 }
24098
24099 pub fn get_impl_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
24100 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
24101 }
24102
24103 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
24104 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
24105 }
24106}
24107
24108#[cfg(feature = "app-unitcalculator")]
24109impl UnitCalculator_RodTypeCommand {
24110 #[doc = "Direct (non-virtual) call to `UnitCalculator_RodTypeCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
24111 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
24112 let __mi = Self::get_name_method_info();
24113 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
24114 __inner(this.into(), ::core::option::Option::None)
24115 }
24116
24117 #[doc = "Direct (non-virtual) call to `UnitCalculator_RodTypeCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
24118 pub unsafe fn get_impl(this: impl ::core::convert::Into<::unity::IlInstance>, unit: crate::app::unit::Unit) -> f32 {
24119 let __mi = Self::get_impl_method_info();
24120 let __inner: extern "C" fn(::unity::IlInstance, crate::app::unit::Unit, ::unity::OptionalMethod) -> f32 =
24121 ::core::mem::transmute(__mi.method_ptr);
24122 __inner(this.into(), unit, ::core::option::Option::None)
24123 }
24124
24125 #[doc = "Direct (non-virtual) call to `UnitCalculator_RodTypeCommand`'s own `GetImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
24126 pub unsafe fn get_impl_2(this: impl ::core::convert::Into<::unity::IlInstance>, side: crate::app::battleinfoside::BattleInfoSide) -> f32 {
24127 let __mi = Self::get_impl_2_method_info();
24128 let __inner: extern "C" fn(::unity::IlInstance, crate::app::battleinfoside::BattleInfoSide, ::unity::OptionalMethod) -> f32 =
24129 ::core::mem::transmute(__mi.method_ptr);
24130 __inner(this.into(), side, ::core::option::Option::None)
24131 }
24132}
24133
24134#[cfg(feature = "app-unitcalculator")]
24135impl UnitCalculator_RodTypeCommand {
24136 #[doc = "`.ctor()` — no args"]
24137 pub fn new() -> Self {
24138 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
24139 panic!(
24140 "{}
24141::{}
24142 failed to instantiate",
24143 ::core::stringify!(UnitCalculator_RodTypeCommand),
24144 ::core::stringify!(new),
24145 )
24146 });
24147 <Self as IUnitCalculator_RodTypeCommandMethods>::ctor(this);
24148 this
24149 }
24150}
24151
24152#[cfg(feature = "app-unitcalculator")]
24153#[doc(hidden)]
24154pub mod prelude {
24155 pub use super::{
24156 IUnitCalculator, IUnitCalculatorMethods, IUnitCalculator_ActionCountCommand, IUnitCalculator_ActionCountCommandMethods,
24157 IUnitCalculator_AroundGenderCountCommand, IUnitCalculator_AroundGenderCountCommandMethods, IUnitCalculator_AttackAttributeCommand,
24158 IUnitCalculator_AttackAttributeCommandMethods, IUnitCalculator_AttackCommand, IUnitCalculator_AttackCommandMethods,
24159 IUnitCalculator_AttackCountCommand, IUnitCalculator_AttackCountCommandMethods, IUnitCalculator_AvoidCommand,
24160 IUnitCalculator_AvoidCommandMethods, IUnitCalculator_BattleAliveCommand, IUnitCalculator_BattleAliveCommandMethods,
24161 IUnitCalculator_BattleArenaCommand, IUnitCalculator_BattleArenaCommandMethods, IUnitCalculator_BattleChainAttackCountCommand,
24162 IUnitCalculator_BattleChainAttackCountCommandMethods, IUnitCalculator_BattleChainAttackDefeatCommand,
24163 IUnitCalculator_BattleChainAttackDefeatCommandMethods, IUnitCalculator_BattleChainGuardCountCommand,
24164 IUnitCalculator_BattleChainGuardCountCommandMethods, IUnitCalculator_BattleCountCommand, IUnitCalculator_BattleCountCommandMethods,
24165 IUnitCalculator_BattleDeadCommand, IUnitCalculator_BattleDeadCommandMethods, IUnitCalculator_BattleDistanceCommand,
24166 IUnitCalculator_BattleDistanceCommandMethods, IUnitCalculator_BattleEscortCommand, IUnitCalculator_BattleEscortCommandMethods,
24167 IUnitCalculator_BattleLastTargetCommand, IUnitCalculator_BattleLastTargetCommandMethods, IUnitCalculator_BattleParamCommand,
24168 IUnitCalculator_BattleParamCommandMethods, IUnitCalculator_BattlePinchingCommand, IUnitCalculator_BattlePinchingCommandMethods,
24169 IUnitCalculator_BattleReviveCommand, IUnitCalculator_BattleReviveCommandMethods, IUnitCalculator_BattleSceneResultBreakCommand,
24170 IUnitCalculator_BattleSceneResultBreakCommandMethods, IUnitCalculator_BattleSceneResultCommand,
24171 IUnitCalculator_BattleSceneResultCommandMethods, IUnitCalculator_BattleSceneResultCriticalCommand,
24172 IUnitCalculator_BattleSceneResultCriticalCommandMethods, IUnitCalculator_BattleSceneResultEfficacyCommand,
24173 IUnitCalculator_BattleSceneResultEfficacyCommandMethods, IUnitCalculator_BattleSceneResultHitCommand,
24174 IUnitCalculator_BattleSceneResultHitCommandMethods, IUnitCalculator_BattleSceneResultMissCommand,
24175 IUnitCalculator_BattleSceneResultMissCommandMethods, IUnitCalculator_BattleSideCommand, IUnitCalculator_BattleSideCommandMethods,
24176 IUnitCalculator_BattleStyleCommand, IUnitCalculator_BattleStyleCommandMethods, IUnitCalculator_BattleTimesCommand,
24177 IUnitCalculator_BattleTimesCommandMethods, IUnitCalculator_BlowDistanceCommand, IUnitCalculator_BlowDistanceCommandMethods,
24178 IUnitCalculator_BlowRatioCommand, IUnitCalculator_BlowRatioCommandMethods, IUnitCalculator_ContinuousCommand,
24179 IUnitCalculator_ContinuousCommandMethods, IUnitCalculator_CriticalCommand, IUnitCalculator_CriticalCommandMethods,
24180 IUnitCalculator_DamageCommand, IUnitCalculator_DamageCommandMethods, IUnitCalculator_DefCommand, IUnitCalculator_DefCommandMethods,
24181 IUnitCalculator_DefenseCommand, IUnitCalculator_DefenseCommandMethods, IUnitCalculator_DropItemRatioCommand,
24182 IUnitCalculator_DropItemRatioCommandMethods, IUnitCalculator_EngageCountCommand, IUnitCalculator_EngageCountCommandMethods,
24183 IUnitCalculator_EngageCountLimitCommand, IUnitCalculator_EngageCountLimitCommandMethods, IUnitCalculator_ExpBattleGiveCountCommand,
24184 IUnitCalculator_ExpBattleGiveCountCommandMethods, IUnitCalculator_ExpCommand, IUnitCalculator_ExpCommandMethods,
24185 IUnitCalculator_ExpDanceCountCommand, IUnitCalculator_ExpDanceCountCommandMethods, IUnitCalculator_ExpDestroyCountCommand,
24186 IUnitCalculator_ExpDestroyCountCommandMethods, IUnitCalculator_ExpInterferenceCountCommand,
24187 IUnitCalculator_ExpInterferenceCountCommandMethods, IUnitCalculator_ExpRodCountCommand, IUnitCalculator_ExpRodCountCommandMethods,
24188 IUnitCalculator_FixedEnemyCountCommand, IUnitCalculator_FixedEnemyCountCommandMethods, IUnitCalculator_FixedFriendCountCommand,
24189 IUnitCalculator_FixedFriendCountCommandMethods, IUnitCalculator_ForceCommand, IUnitCalculator_ForceCommandMethods,
24190 IUnitCalculator_GainExpCommand, IUnitCalculator_GainExpCommandMethods, IUnitCalculator_GainGoldCommand,
24191 IUnitCalculator_GainGoldCommandMethods, IUnitCalculator_GenderCommand, IUnitCalculator_GenderCommandMethods,
24192 IUnitCalculator_GodEngagingCommand, IUnitCalculator_GodEngagingCommandMethods, IUnitCalculator_GodGoodWeaponCommand,
24193 IUnitCalculator_GodGoodWeaponCommandMethods, IUnitCalculator_GodLevelCommand, IUnitCalculator_GodLevelCommandMethods,
24194 IUnitCalculator_GodSkillCorrectCommand, IUnitCalculator_GodSkillCorrectCommandMethods, IUnitCalculator_HPCommand,
24195 IUnitCalculator_HPCommandMethods, IUnitCalculator_HealCommand, IUnitCalculator_HealCommandMethods, IUnitCalculator_HitCommand,
24196 IUnitCalculator_HitCommandMethods, IUnitCalculator_IBattleSceneResultCommand, IUnitCalculator_IBattleSceneResultCommandMethods,
24197 IUnitCalculator_InternalLevelCommand, IUnitCalculator_InternalLevelCommandMethods, IUnitCalculator_JobInternalLevelCommand,
24198 IUnitCalculator_JobInternalLevelCommandMethods, IUnitCalculator_JobRankCommand, IUnitCalculator_JobRankCommandMethods,
24199 IUnitCalculator_LevelCommand, IUnitCalculator_LevelCommandMethods, IUnitCalculator_LinkDefCommand, IUnitCalculator_LinkDefCommandMethods,
24200 IUnitCalculator_LinkGodCommand, IUnitCalculator_LinkGodCommandMethods, IUnitCalculator_LinkLuukCommand,
24201 IUnitCalculator_LinkLuukCommandMethods, IUnitCalculator_LinkMagicCommand, IUnitCalculator_LinkMagicCommandMethods,
24202 IUnitCalculator_LinkMdefCommand, IUnitCalculator_LinkMdefCommandMethods, IUnitCalculator_LinkPhysCommand,
24203 IUnitCalculator_LinkPhysCommandMethods, IUnitCalculator_LinkQuickCommand, IUnitCalculator_LinkQuickCommandMethods,
24204 IUnitCalculator_LinkStrCommand, IUnitCalculator_LinkStrCommandMethods, IUnitCalculator_LinkTechCommand,
24205 IUnitCalculator_LinkTechCommandMethods, IUnitCalculator_LuukCommand, IUnitCalculator_LuukCommandMethods, IUnitCalculator_MagicCommand,
24206 IUnitCalculator_MagicCommandMethods, IUnitCalculator_MapPhaseCommand, IUnitCalculator_MapPhaseCommandMethods,
24207 IUnitCalculator_MapUnitCountCommand, IUnitCalculator_MapUnitCountCommandMethods, IUnitCalculator_MaxHPCommand,
24208 IUnitCalculator_MaxHPCommandMethods, IUnitCalculator_MdefCommand, IUnitCalculator_MdefCommandMethods, IUnitCalculator_MoveDistanceCommand,
24209 IUnitCalculator_MoveDistanceCommandMethods, IUnitCalculator_MoveTypeCommand, IUnitCalculator_MoveTypeCommandMethods,
24210 IUnitCalculator_OverlapCanRemoveCommand, IUnitCalculator_OverlapCanRemoveCommandMethods, IUnitCalculator_PhysCommand,
24211 IUnitCalculator_PhysCommandMethods, IUnitCalculator_PickupItemCommand, IUnitCalculator_PickupItemCommandMethods,
24212 IUnitCalculator_PosLowXCommand, IUnitCalculator_PosLowXCommandMethods, IUnitCalculator_PosLowZCommand, IUnitCalculator_PosLowZCommandMethods,
24213 IUnitCalculator_PosXCommand, IUnitCalculator_PosXCommandMethods, IUnitCalculator_PosZCommand, IUnitCalculator_PosZCommandMethods,
24214 IUnitCalculator_ProbabilityCommand, IUnitCalculator_ProbabilityCommandMethods, IUnitCalculator_ProbabilityGodSkillCommand,
24215 IUnitCalculator_ProbabilityGodSkillCommandMethods, IUnitCalculator_ProbabilitySkillCommand, IUnitCalculator_ProbabilitySkillCommandMethods,
24216 IUnitCalculator_QuickCommand, IUnitCalculator_QuickCommandMethods, IUnitCalculator_RangeEnemyCountCommand,
24217 IUnitCalculator_RangeEnemyCountCommandMethods, IUnitCalculator_RangeFriendCountCommand, IUnitCalculator_RangeFriendCountCommandMethods,
24218 IUnitCalculator_RangeGenderCountCommand, IUnitCalculator_RangeGenderCountCommandMethods, IUnitCalculator_RangeUnitCountCommand,
24219 IUnitCalculator_RangeUnitCountCommandMethods, IUnitCalculator_ReciveAttackCountCommand, IUnitCalculator_ReciveAttackCountCommandMethods,
24220 IUnitCalculator_RelianceAroundTotalCommand, IUnitCalculator_RelianceAroundTotalCommandMethods, IUnitCalculator_RodExpCommand,
24221 IUnitCalculator_RodExpCommandMethods, IUnitCalculator_RodTypeCommand, IUnitCalculator_RodTypeCommandMethods, IUnitCalculator_SecureCommand,
24222 IUnitCalculator_SecureCommandMethods, IUnitCalculator_SimpleCriticalCommand, IUnitCalculator_SimpleCriticalCommandMethods,
24223 IUnitCalculator_SimpleHitCommand, IUnitCalculator_SimpleHitCommandMethods, IUnitCalculator_SimplePowerCommand,
24224 IUnitCalculator_SimplePowerCommandMethods, IUnitCalculator_SkillCorrectCommand, IUnitCalculator_SkillCorrectCommandMethods,
24225 IUnitCalculator_StrCommand, IUnitCalculator_StrCommandMethods, IUnitCalculator_SupportAvoidCommand,
24226 IUnitCalculator_SupportAvoidCommandMethods, IUnitCalculator_SupportCriticalCommand, IUnitCalculator_SupportCriticalCommandMethods,
24227 IUnitCalculator_SupportHitCommand, IUnitCalculator_SupportHitCommandMethods, IUnitCalculator_SupportLevelCommand,
24228 IUnitCalculator_SupportLevelCommandMethods, IUnitCalculator_SupportSecureCommand, IUnitCalculator_SupportSecureCommandMethods,
24229 IUnitCalculator_TechCommand, IUnitCalculator_TechCommandMethods, IUnitCalculator_TemporaryCommand, IUnitCalculator_TemporaryCommandMethods,
24230 IUnitCalculator_TerrainAvoidCommand, IUnitCalculator_TerrainAvoidCommandMethods, IUnitCalculator_TerrainDefenseCommand,
24231 IUnitCalculator_TerrainDefenseCommandMethods, IUnitCalculator_TotalActionCommand, IUnitCalculator_TotalActionCommandMethods,
24232 IUnitCalculator_TotalAttackCommand, IUnitCalculator_TotalAttackCommandMethods, IUnitCalculator_TotalDamageCommand,
24233 IUnitCalculator_TotalDamageCommandMethods, IUnitCalculator_TotalLevelCommand, IUnitCalculator_TotalLevelCommandMethods,
24234 IUnitCalculator_TotalOrderCommand, IUnitCalculator_TotalOrderCommandMethods, IUnitCalculator_TotalResultCommand,
24235 IUnitCalculator_TotalResultCommandMethods, IUnitCalculator_UnitAroundCountdCommand, IUnitCalculator_UnitAroundCountdCommandMethods,
24236 IUnitCalculator_UnitAttackCommand, IUnitCalculator_UnitAttackCommandMethods, IUnitCalculator_UnitAttributeCommand,
24237 IUnitCalculator_UnitAttributeCommandMethods, IUnitCalculator_UnitDefenseCommand, IUnitCalculator_UnitDefenseCommandMethods,
24238 IUnitCalculator_UnitGodCommand, IUnitCalculator_UnitGodCommandMethods, IUnitCalculator_UnitIdentCommand,
24239 IUnitCalculator_UnitIdentCommandMethods, IUnitCalculator_UnitJobCommand, IUnitCalculator_UnitJobCommandMethods,
24240 IUnitCalculator_UnitPersonCommand, IUnitCalculator_UnitPersonCommandMethods, IUnitCalculator_UnitSkillCommand,
24241 IUnitCalculator_UnitSkillCommandMethods, IUnitCalculator_WeaponAttackCommand, IUnitCalculator_WeaponAttackCommandMethods,
24242 IUnitCalculator_WeaponAttributeCommand, IUnitCalculator_WeaponAttributeCommandMethods, IUnitCalculator_WeaponAvoidCommand,
24243 IUnitCalculator_WeaponAvoidCommandMethods, IUnitCalculator_WeaponCriticalCommand, IUnitCalculator_WeaponCriticalCommandMethods,
24244 IUnitCalculator_WeaponEfficacyCommand, IUnitCalculator_WeaponEfficacyCommandMethods, IUnitCalculator_WeaponEnduranceCommand,
24245 IUnitCalculator_WeaponEnduranceCommandMethods, IUnitCalculator_WeaponExpendCommand, IUnitCalculator_WeaponExpendCommandMethods,
24246 IUnitCalculator_WeaponHitCommand, IUnitCalculator_WeaponHitCommandMethods, IUnitCalculator_WeaponInteractCommand,
24247 IUnitCalculator_WeaponInteractCommandMethods, IUnitCalculator_WeaponKindCommand, IUnitCalculator_WeaponKindCommandMethods,
24248 IUnitCalculator_WeaponLevelBaseCommand, IUnitCalculator_WeaponLevelBaseCommandMethods, IUnitCalculator_WeaponLevelCommand,
24249 IUnitCalculator_WeaponLevelCommandMethods, IUnitCalculator_WeaponSecureCommand, IUnitCalculator_WeaponSecureCommandMethods,
24250 IUnitCalculator_WeaponWeightCommand, IUnitCalculator_WeaponWeightCommandMethods, UnitCalculator, UnitCalculator_ActionCountCommand,
24251 UnitCalculator_AroundGenderCountCommand, UnitCalculator_AttackAttributeCommand, UnitCalculator_AttackCommand,
24252 UnitCalculator_AttackCountCommand, UnitCalculator_AvoidCommand, UnitCalculator_BattleAliveCommand, UnitCalculator_BattleArenaCommand,
24253 UnitCalculator_BattleChainAttackCountCommand, UnitCalculator_BattleChainAttackDefeatCommand, UnitCalculator_BattleChainGuardCountCommand,
24254 UnitCalculator_BattleCountCommand, UnitCalculator_BattleDeadCommand, UnitCalculator_BattleDistanceCommand,
24255 UnitCalculator_BattleEscortCommand, UnitCalculator_BattleLastTargetCommand, UnitCalculator_BattleParamCommand,
24256 UnitCalculator_BattlePinchingCommand, UnitCalculator_BattleReviveCommand, UnitCalculator_BattleSceneResultBreakCommand,
24257 UnitCalculator_BattleSceneResultCommand, UnitCalculator_BattleSceneResultCriticalCommand, UnitCalculator_BattleSceneResultEfficacyCommand,
24258 UnitCalculator_BattleSceneResultHitCommand, UnitCalculator_BattleSceneResultMissCommand, UnitCalculator_BattleSideCommand,
24259 UnitCalculator_BattleStyleCommand, UnitCalculator_BattleTimesCommand, UnitCalculator_BlowDistanceCommand, UnitCalculator_BlowRatioCommand,
24260 UnitCalculator_ContinuousCommand, UnitCalculator_CriticalCommand, UnitCalculator_DamageCommand, UnitCalculator_DefCommand,
24261 UnitCalculator_DefenseCommand, UnitCalculator_DropItemRatioCommand, UnitCalculator_EngageCountCommand,
24262 UnitCalculator_EngageCountLimitCommand, UnitCalculator_ExpBattleGiveCountCommand, UnitCalculator_ExpCommand,
24263 UnitCalculator_ExpDanceCountCommand, UnitCalculator_ExpDestroyCountCommand, UnitCalculator_ExpInterferenceCountCommand,
24264 UnitCalculator_ExpRodCountCommand, UnitCalculator_FixedEnemyCountCommand, UnitCalculator_FixedFriendCountCommand,
24265 UnitCalculator_ForceCommand, UnitCalculator_GainExpCommand, UnitCalculator_GainGoldCommand, UnitCalculator_GenderCommand,
24266 UnitCalculator_GodEngagingCommand, UnitCalculator_GodGoodWeaponCommand, UnitCalculator_GodLevelCommand,
24267 UnitCalculator_GodSkillCorrectCommand, UnitCalculator_HPCommand, UnitCalculator_HealCommand, UnitCalculator_HitCommand,
24268 UnitCalculator_IBattleSceneResultCommand, UnitCalculator_InternalLevelCommand, UnitCalculator_JobInternalLevelCommand,
24269 UnitCalculator_JobRankCommand, UnitCalculator_LevelCommand, UnitCalculator_LinkDefCommand, UnitCalculator_LinkGodCommand,
24270 UnitCalculator_LinkLuukCommand, UnitCalculator_LinkMagicCommand, UnitCalculator_LinkMdefCommand, UnitCalculator_LinkPhysCommand,
24271 UnitCalculator_LinkQuickCommand, UnitCalculator_LinkStrCommand, UnitCalculator_LinkTechCommand, UnitCalculator_LuukCommand,
24272 UnitCalculator_MagicCommand, UnitCalculator_MapPhaseCommand, UnitCalculator_MapUnitCountCommand,
24273 UnitCalculator_MapUnitCountCommand_Candidates, UnitCalculator_MaxHPCommand, UnitCalculator_MdefCommand, UnitCalculator_MoveDistanceCommand,
24274 UnitCalculator_MoveTypeCommand, UnitCalculator_OverlapCanRemoveCommand, UnitCalculator_PhysCommand, UnitCalculator_PickupItemCommand,
24275 UnitCalculator_PosLowXCommand, UnitCalculator_PosLowZCommand, UnitCalculator_PosXCommand, UnitCalculator_PosZCommand,
24276 UnitCalculator_ProbabilityCommand, UnitCalculator_ProbabilityGodSkillCommand, UnitCalculator_ProbabilitySkillCommand,
24277 UnitCalculator_QuickCommand, UnitCalculator_RangeEnemyCountCommand, UnitCalculator_RangeFriendCountCommand,
24278 UnitCalculator_RangeGenderCountCommand, UnitCalculator_RangeUnitCountCommand, UnitCalculator_ReciveAttackCountCommand,
24279 UnitCalculator_RelianceAroundTotalCommand, UnitCalculator_RodExpCommand, UnitCalculator_RodTypeCommand, UnitCalculator_SecureCommand,
24280 UnitCalculator_SimpleCriticalCommand, UnitCalculator_SimpleHitCommand, UnitCalculator_SimplePowerCommand, UnitCalculator_SkillCorrectCommand,
24281 UnitCalculator_StrCommand, UnitCalculator_SupportAvoidCommand, UnitCalculator_SupportCriticalCommand, UnitCalculator_SupportHitCommand,
24282 UnitCalculator_SupportLevelCommand, UnitCalculator_SupportSecureCommand, UnitCalculator_TechCommand, UnitCalculator_TemporaryCommand,
24283 UnitCalculator_TerrainAvoidCommand, UnitCalculator_TerrainDefenseCommand, UnitCalculator_TotalActionCommand,
24284 UnitCalculator_TotalAttackCommand, UnitCalculator_TotalDamageCommand, UnitCalculator_TotalLevelCommand, UnitCalculator_TotalOrderCommand,
24285 UnitCalculator_TotalResultCommand, UnitCalculator_UnitAroundCountdCommand, UnitCalculator_UnitAttackCommand,
24286 UnitCalculator_UnitAttributeCommand, UnitCalculator_UnitDefenseCommand, UnitCalculator_UnitGodCommand, UnitCalculator_UnitIdentCommand,
24287 UnitCalculator_UnitJobCommand, UnitCalculator_UnitPersonCommand, UnitCalculator_UnitSkillCommand, UnitCalculator_WeaponAttackCommand,
24288 UnitCalculator_WeaponAttributeCommand, UnitCalculator_WeaponAvoidCommand, UnitCalculator_WeaponCriticalCommand,
24289 UnitCalculator_WeaponEfficacyCommand, UnitCalculator_WeaponEnduranceCommand, UnitCalculator_WeaponExpendCommand,
24290 UnitCalculator_WeaponHitCommand, UnitCalculator_WeaponInteractCommand, UnitCalculator_WeaponKindCommand,
24291 UnitCalculator_WeaponLevelBaseCommand, UnitCalculator_WeaponLevelCommand, UnitCalculator_WeaponSecureCommand,
24292 UnitCalculator_WeaponWeightCommand,
24293 };
24294 #[cfg(feature = "app-calculatorcommand")]
24295 pub use crate::app::calculatorcommand::ICalculatorCommandMethods;
24296 #[cfg(feature = "app-gamecalculatorcommand")]
24297 pub use crate::app::gamecalculatorcommand::IGameCalculatorCommandMethods;
24298 #[cfg(feature = "system-object")]
24299 pub use crate::system::object::IObjectMethods;
24300 #[cfg(feature = "system-enum")]
24301 pub use crate::system::r#enum::IEnumMethods;
24302 #[cfg(feature = "system-valuetype")]
24303 pub use crate::system::valuetype::IValueTypeMethods;
24304 pub use crate::{
24305 app::{calculatorcommand::ICalculatorCommand, gamecalculatorcommand::IGameCalculatorCommand},
24306 system::{object::IObject, r#enum::IEnum, valuetype::IValueType},
24307 };
24308}