1#[cfg(feature = "app-rankingsequence-types")]
4mod __types {
5 #[allow(unused_imports)] use ::unity::prelude::*;
6
7 use super::*;
8 use crate::{
9 app::{
10 menuitem::{IMenuItem, MenuItem},
11 procinst::{IProcInst, ProcInst},
12 singletonprocinst_1::{ISingletonProcInst_1, SingletonProcInst_1},
13 },
14 system::{
15 object::{IObject, Object},
16 r#enum::{Enum, IEnum},
17 valuetype::{IValueType, ValueType},
18 },
19 };
20
21 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/rankingsequence/RankingSequence_TopMenu_BaseMenuItem.md"))]
22 #[::unity::class(namespace = "App", name = "RankingSequence.TopMenu.BaseMenuItem")]
23 #[parent(crate::app::menuitem::MenuItem)]
24 pub struct RankingSequence_TopMenu_BaseMenuItem {}
25
26 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/rankingsequence/RankingSequence_TopMenu_ChapterSelect.md"))]
27 #[::unity::class(namespace = "App", name = "RankingSequence.TopMenu.ChapterSelect")]
28 #[parent(crate::app::menuitem::MenuItem)]
29 pub struct RankingSequence_TopMenu_ChapterSelect {}
30
31 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/rankingsequence/RankingSequence_UploadPairsMenu_RandomAddUploadPairsMenuItem.md"))]
32 #[::unity::class(namespace = "App", name = "RankingSequence.UploadPairsMenu.RandomAddUploadPairsMenuItem")]
33 #[parent(crate::app::rankingsequence::RankingSequence_TopMenu_BaseMenuItem)]
34 pub struct RankingSequence_UploadPairsMenu_RandomAddUploadPairsMenuItem {}
35
36 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/rankingsequence/RankingSequence_UploadPairsMenu_AddUploadPairsMenuItem.md"))]
37 #[::unity::class(namespace = "App", name = "RankingSequence.UploadPairsMenu.AddUploadPairsMenuItem")]
38 #[parent(crate::app::rankingsequence::RankingSequence_TopMenu_BaseMenuItem)]
39 pub struct RankingSequence_UploadPairsMenu_AddUploadPairsMenuItem {
40 #[offset(32)]
41 #[rename(name = "m_UploadPersonMenuItem")]
42 pub m_upload_person_menu_item: crate::app::rankingsequence::RankingSequence_UploadPairsMenu_UploadPersonMenuItem,
43 #[offset(40)]
44 #[rename(name = "m_UploadGodMenuItem")]
45 pub m_upload_god_menu_item: crate::app::rankingsequence::RankingSequence_UploadPairsMenu_UploadGodMenuItem,
46 }
47
48 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/rankingsequence/RankingSequence_Label.md"))]
49 #[repr(C)]
50 #[derive(::core::clone::Clone, ::core::marker::Copy, ::core::fmt::Debug, ::core::cmp::PartialEq, ::core::cmp::Eq)]
51 pub struct RankingSequence_Label {
52 pub value: i32,
53 }
54 impl ::unity::ClassIdentity for RankingSequence_Label {
55 const NAME: &'static str = "RankingSequence.Label";
56 const NAMESPACE: &'static str = "App";
57
58 fn class() -> ::unity::Class {
59 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
60 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
61 }
62 }
63 impl ::unity::IlType for RankingSequence_Label {
64 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
65 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
66 }
67 }
68 impl RankingSequence_Label {
69 pub fn menu() -> Self {
70 Self { value: 0 }
71 }
72
73 pub fn ranking() -> Self {
74 Self { value: 1 }
75 }
76
77 pub fn upload_menu() -> Self {
78 Self { value: 2 }
79 }
80
81 pub fn upload_data() -> Self {
82 Self { value: 3 }
83 }
84
85 pub fn upload_pairs_list() -> Self {
86 Self { value: 4 }
87 }
88
89 pub fn add_upload_pairs() -> Self {
90 Self { value: 5 }
91 }
92
93 pub fn random_add_upload_pairs() -> Self {
94 Self { value: 6 }
95 }
96
97 pub fn clear_upload_pairs() -> Self {
98 Self { value: 7 }
99 }
100
101 pub fn end() -> Self {
102 Self { value: 8 }
103 }
104 }
105
106 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/rankingsequence/RankingSequence_TopMenu.md"))]
107 #[::unity::class(namespace = "App", name = "RankingSequence.TopMenu")]
108 #[parent(crate::system::object::Object)]
109 pub struct RankingSequence_TopMenu {}
110
111 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/rankingsequence/RankingSequence_PairMenuItem.md"))]
112 #[::unity::class(namespace = "App", name = "RankingSequence.PairMenuItem")]
113 #[parent(crate::app::menuitem::MenuItem)]
114 pub struct RankingSequence_PairMenuItem {
115 #[offset(32)]
116 #[rename(name = "m_Data")]
117 pub m_data: crate::app::nexranking::NexRanking_Data,
118 #[static_field]
119 #[rename(name = "MaxRatingSlot")]
120 pub max_rating_slot: u32,
121 }
122
123 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/rankingsequence/RankingSequence_UploadPairsMenu_UploadPairMenuItem.md"))]
124 #[::unity::class(namespace = "App", name = "RankingSequence.UploadPairsMenu.UploadPairMenuItem")]
125 #[parent(crate::app::rankingsequence::RankingSequence_TopMenu_BaseMenuItem)]
126 pub struct RankingSequence_UploadPairsMenu_UploadPairMenuItem {}
127
128 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/rankingsequence/RankingSequence_UploadPairsMenu_UploadGodMenuItem.md"))]
129 #[::unity::class(namespace = "App", name = "RankingSequence.UploadPairsMenu.UploadGodMenuItem")]
130 #[parent(crate::app::menuitem::MenuItem)]
131 pub struct RankingSequence_UploadPairsMenu_UploadGodMenuItem {
132 #[offset(32)]
133 #[rename(name = "m_Name")]
134 pub m_name: ::unity::Il2CppString,
135 }
136
137 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/rankingsequence/RankingSequence_UploadPairsMenu_UploadPersonMenuItem.md"))]
138 #[::unity::class(namespace = "App", name = "RankingSequence.UploadPairsMenu.UploadPersonMenuItem")]
139 #[parent(crate::app::menuitem::MenuItem)]
140 pub struct RankingSequence_UploadPairsMenu_UploadPersonMenuItem {
141 #[offset(32)]
142 #[rename(name = "m_Name")]
143 pub m_name: ::unity::Il2CppString,
144 }
145
146 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/rankingsequence/RankingSequence.md"))]
147 #[::unity::class(namespace = "App", name = "RankingSequence")]
148 #[parent(crate::app::singletonprocinst_1::SingletonProcInst_1<crate::app::rankingsequence::RankingSequence>)]
149 pub struct RankingSequence {
150 #[static_field]
151 #[rename(name = "MaxRankingCount")]
152 pub max_ranking_count: i32,
153 #[offset(114)]
154 #[rename(name = "m_IsLastChapter")]
155 pub m_is_last_chapter: bool,
156 #[offset(120)]
157 #[rename(name = "m_Cid")]
158 pub m_cid: ::unity::Il2CppString,
159 #[offset(128)]
160 #[rename(name = "m_ChapterIndex")]
161 pub m_chapter_index: i32,
162 #[offset(132)]
163 #[rename(name = "m_SelectNetRankingIndex")]
164 pub m_select_net_ranking_index: i32,
165 #[offset(136)]
166 #[rename(name = "m_PersonIndex")]
167 pub m_person_index: i32,
168 #[offset(140)]
169 #[rename(name = "m_GodIndex")]
170 pub m_god_index: i32,
171 #[offset(144)]
172 #[rename(name = "m_RandomAddNum")]
173 pub m_random_add_num: i32,
174 #[offset(152)]
175 #[rename(name = "m_Pairs")]
176 pub m_pairs: crate::system::collections::generic::list_1::List_1<crate::app::nexranking::NexRanking_Data>,
177 }
178
179 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/rankingsequence/RankingSequence_TopMenu_RankingMenuItem.md"))]
180 #[::unity::class(namespace = "App", name = "RankingSequence.TopMenu.RankingMenuItem")]
181 #[parent(crate::app::rankingsequence::RankingSequence_TopMenu_BaseMenuItem)]
182 pub struct RankingSequence_TopMenu_RankingMenuItem {}
183
184 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/rankingsequence/RankingSequence_UploadPairsMenu.md"))]
185 #[::unity::class(namespace = "App", name = "RankingSequence.UploadPairsMenu")]
186 #[parent(crate::app::rankingsequence::RankingSequence_TopMenu)]
187 pub struct RankingSequence_UploadPairsMenu {}
188
189 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/rankingsequence/RankingSequence_UploadPairsMenu_ClearUploadPairsMenuItem.md"))]
190 #[::unity::class(namespace = "App", name = "RankingSequence.UploadPairsMenu.ClearUploadPairsMenuItem")]
191 #[parent(crate::app::rankingsequence::RankingSequence_TopMenu_BaseMenuItem)]
192 pub struct RankingSequence_UploadPairsMenu_ClearUploadPairsMenuItem {}
193
194 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/rankingsequence/RankingSequence_UploadPairsMenu_UploadDataMenuItem.md"))]
195 #[::unity::class(namespace = "App", name = "RankingSequence.UploadPairsMenu.UploadDataMenuItem")]
196 #[parent(crate::app::rankingsequence::RankingSequence_TopMenu_BaseMenuItem)]
197 pub struct RankingSequence_UploadPairsMenu_UploadDataMenuItem {}
198
199 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/rankingsequence/RankingSequence_TopMenu_UploadMenuItem.md"))]
200 #[::unity::class(namespace = "App", name = "RankingSequence.TopMenu.UploadMenuItem")]
201 #[parent(crate::app::rankingsequence::RankingSequence_TopMenu_BaseMenuItem)]
202 pub struct RankingSequence_TopMenu_UploadMenuItem {}
203}
204
205#[cfg(feature = "app-rankingsequence-types")]
206pub use __types::*;
207
208#[cfg(feature = "app-rankingsequence")]
209pub trait IRankingSequence_TopMenu_BaseMenuItemMethods: IRankingSequence_TopMenu_BaseMenuItem {
210 #[doc = "`get_Label()` overload"]
211 fn get_label(self) -> crate::app::rankingsequence::RankingSequence_Label {
212 unsafe {
213 let __receiver = <RankingSequence_TopMenu_BaseMenuItem as ::unity::FromIlInstance>::from_il_instance(
214 <Self as ::unity::SystemObject>::as_instance(self),
215 );
216 {
217 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
218 let __vi = *__vt.get(72usize).unwrap_or_else(|| {
219 panic!(
220 "unity: virtual slot {}
221 out of range (vtable len {}
222) on the runtime class behind {}
223 (method `{}
224`)",
225 72usize,
226 __vt.len(),
227 <RankingSequence_TopMenu_BaseMenuItem as ::unity::ClassIdentity>::NAME,
228 "get_Label",
229 )
230 });
231 let __inner: extern "C" fn(
232 RankingSequence_TopMenu_BaseMenuItem,
233 ::unity::OptionalMethod,
234 ) -> crate::app::rankingsequence::RankingSequence_Label = ::core::mem::transmute(__vi.method_ptr);
235 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
236 __inner(__receiver, __mi)
237 }
238 }
239 }
240 #[doc = "`GetName()` overload"]
241 fn get_name(self) -> ::unity::Il2CppString {
242 unsafe {
243 let __receiver = <RankingSequence_TopMenu_BaseMenuItem as ::unity::FromIlInstance>::from_il_instance(
244 <Self as ::unity::SystemObject>::as_instance(self),
245 );
246 {
247 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
248 let __vi = *__vt.get(5usize).unwrap_or_else(|| {
249 panic!(
250 "unity: virtual slot {}
251 out of range (vtable len {}
252) on the runtime class behind {}
253 (method `{}
254`)",
255 5usize,
256 __vt.len(),
257 <RankingSequence_TopMenu_BaseMenuItem as ::unity::ClassIdentity>::NAME,
258 "GetName",
259 )
260 });
261 let __inner: extern "C" fn(RankingSequence_TopMenu_BaseMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
262 ::core::mem::transmute(__vi.method_ptr);
263 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
264 __inner(__receiver, __mi)
265 }
266 }
267 }
268 #[doc = "`ACall()` overload"]
269 fn a_call(self) -> crate::app::menuitem::MenuItem_Result {
270 unsafe {
271 let __receiver = <RankingSequence_TopMenu_BaseMenuItem as ::unity::FromIlInstance>::from_il_instance(
272 <Self as ::unity::SystemObject>::as_instance(self),
273 );
274 {
275 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
276 let __vi = *__vt.get(12usize).unwrap_or_else(|| {
277 panic!(
278 "unity: virtual slot {}
279 out of range (vtable len {}
280) on the runtime class behind {}
281 (method `{}
282`)",
283 12usize,
284 __vt.len(),
285 <RankingSequence_TopMenu_BaseMenuItem as ::unity::ClassIdentity>::NAME,
286 "ACall",
287 )
288 });
289 let __inner: extern "C" fn(RankingSequence_TopMenu_BaseMenuItem, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Result =
290 ::core::mem::transmute(__vi.method_ptr);
291 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
292 __inner(__receiver, __mi)
293 }
294 }
295 }
296 #[doc = "`.ctor()` overload"]
297 fn ctor(self) -> () {
298 unsafe {
299 let __receiver = <RankingSequence_TopMenu_BaseMenuItem as ::unity::FromIlInstance>::from_il_instance(
300 <Self as ::unity::SystemObject>::as_instance(self),
301 );
302 ::unity::il2cpp_call!((::unity::module_base()+0x1b79bf0usize)as*mut u8,();
303(RankingSequence_TopMenu_BaseMenuItem)__receiver)
304 }
305 }
306}
307
308#[cfg(feature = "app-rankingsequence")]
309impl<__T: IRankingSequence_TopMenu_BaseMenuItem> IRankingSequence_TopMenu_BaseMenuItemMethods for __T {}
310
311#[cfg(feature = "app-rankingsequence")]
312impl RankingSequence_TopMenu_BaseMenuItem {
313 pub fn get_label_method_info() -> &'static ::unity::il2cpp::MethodInfo {
314 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
315 }
316
317 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
318 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
319 }
320
321 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
322 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
323 }
324
325 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
326 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
327 }
328}
329
330#[cfg(feature = "app-rankingsequence")]
331impl RankingSequence_TopMenu_BaseMenuItem {
332 #[doc = "Direct (non-virtual) call to `RankingSequence_TopMenu_BaseMenuItem`'s own `get_Label`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
333 pub unsafe fn get_label(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::rankingsequence::RankingSequence_Label {
334 let __mi = Self::get_label_method_info();
335 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::rankingsequence::RankingSequence_Label =
336 ::core::mem::transmute(__mi.method_ptr);
337 __inner(this.into(), ::core::option::Option::None)
338 }
339
340 #[doc = "Direct (non-virtual) call to `RankingSequence_TopMenu_BaseMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
341 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
342 let __mi = Self::get_name_method_info();
343 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
344 __inner(this.into(), ::core::option::Option::None)
345 }
346
347 #[doc = "Direct (non-virtual) call to `RankingSequence_TopMenu_BaseMenuItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
348 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::menuitem::MenuItem_Result {
349 let __mi = Self::a_call_method_info();
350 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Result =
351 ::core::mem::transmute(__mi.method_ptr);
352 __inner(this.into(), ::core::option::Option::None)
353 }
354}
355
356#[cfg(feature = "app-rankingsequence")]
357impl RankingSequence_TopMenu_BaseMenuItem {
358 #[doc = "`.ctor()` — no args"]
359 pub fn new() -> Self {
360 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
361 panic!(
362 "{}
363::{}
364 failed to instantiate",
365 ::core::stringify!(RankingSequence_TopMenu_BaseMenuItem),
366 ::core::stringify!(new),
367 )
368 });
369 <Self as IRankingSequence_TopMenu_BaseMenuItemMethods>::ctor(this);
370 this
371 }
372}
373
374#[cfg(feature = "app-rankingsequence")]
375pub trait IRankingSequence_TopMenu_ChapterSelectMethods: IRankingSequence_TopMenu_ChapterSelect {
376 #[doc = "`IsEnable()` overload"]
377 fn is_enable(self) -> bool {
378 unsafe {
379 let __receiver = <RankingSequence_TopMenu_ChapterSelect as ::unity::FromIlInstance>::from_il_instance(
380 <Self as ::unity::SystemObject>::as_instance(self),
381 );
382 {
383 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
384 let __vi = *__vt.get(22usize).unwrap_or_else(|| {
385 panic!(
386 "unity: virtual slot {}
387 out of range (vtable len {}
388) on the runtime class behind {}
389 (method `{}
390`)",
391 22usize,
392 __vt.len(),
393 <RankingSequence_TopMenu_ChapterSelect as ::unity::ClassIdentity>::NAME,
394 "IsEnable",
395 )
396 });
397 let __inner: extern "C" fn(RankingSequence_TopMenu_ChapterSelect, ::unity::OptionalMethod) -> bool =
398 ::core::mem::transmute(__vi.method_ptr);
399 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
400 __inner(__receiver, __mi)
401 }
402 }
403 }
404 #[doc = "`GetName()` overload"]
405 fn get_name(self) -> ::unity::Il2CppString {
406 unsafe {
407 let __receiver = <RankingSequence_TopMenu_ChapterSelect as ::unity::FromIlInstance>::from_il_instance(
408 <Self as ::unity::SystemObject>::as_instance(self),
409 );
410 {
411 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
412 let __vi = *__vt.get(5usize).unwrap_or_else(|| {
413 panic!(
414 "unity: virtual slot {}
415 out of range (vtable len {}
416) on the runtime class behind {}
417 (method `{}
418`)",
419 5usize,
420 __vt.len(),
421 <RankingSequence_TopMenu_ChapterSelect as ::unity::ClassIdentity>::NAME,
422 "GetName",
423 )
424 });
425 let __inner: extern "C" fn(RankingSequence_TopMenu_ChapterSelect, ::unity::OptionalMethod) -> ::unity::Il2CppString =
426 ::core::mem::transmute(__vi.method_ptr);
427 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
428 __inner(__receiver, __mi)
429 }
430 }
431 }
432 #[doc = "`OnLeftRight(i32, bool)` overload"]
433 fn on_left_right(self, step: impl ::core::convert::Into<i32>, is_trigger: impl ::core::convert::Into<bool>) -> () {
434 unsafe {
435 let __receiver = <RankingSequence_TopMenu_ChapterSelect as ::unity::FromIlInstance>::from_il_instance(
436 <Self as ::unity::SystemObject>::as_instance(self),
437 );
438 {
439 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
440 let __vi = *__vt.get(70usize).unwrap_or_else(|| {
441 panic!(
442 "unity: virtual slot {}
443 out of range (vtable len {}
444) on the runtime class behind {}
445 (method `{}
446`)",
447 70usize,
448 __vt.len(),
449 <RankingSequence_TopMenu_ChapterSelect as ::unity::ClassIdentity>::NAME,
450 "OnLeftRight",
451 )
452 });
453 let __inner: extern "C" fn(RankingSequence_TopMenu_ChapterSelect, i32, bool, ::unity::OptionalMethod) -> () =
454 ::core::mem::transmute(__vi.method_ptr);
455 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
456 __inner(
457 __receiver,
458 ::core::convert::Into::into(step),
459 ::core::convert::Into::into(is_trigger),
460 __mi,
461 )
462 }
463 }
464 }
465 #[doc = "`.ctor()` overload"]
466 fn ctor(self) -> () {
467 unsafe {
468 let __receiver = <RankingSequence_TopMenu_ChapterSelect as ::unity::FromIlInstance>::from_il_instance(
469 <Self as ::unity::SystemObject>::as_instance(self),
470 );
471 ::unity::il2cpp_call!((::unity::module_base()+0x1b79fc0usize)as*mut u8,();
472(RankingSequence_TopMenu_ChapterSelect)__receiver)
473 }
474 }
475}
476
477#[cfg(feature = "app-rankingsequence")]
478impl<__T: IRankingSequence_TopMenu_ChapterSelect> IRankingSequence_TopMenu_ChapterSelectMethods for __T {}
479
480#[cfg(feature = "app-rankingsequence")]
481impl RankingSequence_TopMenu_ChapterSelect {
482 pub fn is_enable_method_info() -> &'static ::unity::il2cpp::MethodInfo {
483 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
484 }
485
486 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
487 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
488 }
489
490 pub fn on_left_right_method_info() -> &'static ::unity::il2cpp::MethodInfo {
491 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
492 }
493
494 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
495 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
496 }
497}
498
499#[cfg(feature = "app-rankingsequence")]
500impl RankingSequence_TopMenu_ChapterSelect {
501 #[doc = "Direct (non-virtual) call to `RankingSequence_TopMenu_ChapterSelect`'s own `IsEnable`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
502 pub unsafe fn is_enable(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
503 let __mi = Self::is_enable_method_info();
504 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
505 __inner(this.into(), ::core::option::Option::None)
506 }
507
508 #[doc = "Direct (non-virtual) call to `RankingSequence_TopMenu_ChapterSelect`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
509 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
510 let __mi = Self::get_name_method_info();
511 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
512 __inner(this.into(), ::core::option::Option::None)
513 }
514
515 #[doc = "Direct (non-virtual) call to `RankingSequence_TopMenu_ChapterSelect`'s own `OnLeftRight`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
516 pub unsafe fn on_left_right(this: impl ::core::convert::Into<::unity::IlInstance>, step: i32, is_trigger: bool) -> () {
517 let __mi = Self::on_left_right_method_info();
518 let __inner: extern "C" fn(::unity::IlInstance, i32, bool, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
519 __inner(this.into(), step, is_trigger, ::core::option::Option::None)
520 }
521}
522
523#[cfg(feature = "app-rankingsequence")]
524impl RankingSequence_TopMenu_ChapterSelect {
525 #[doc = "`.ctor()` — no args"]
526 pub fn new() -> Self {
527 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
528 panic!(
529 "{}
530::{}
531 failed to instantiate",
532 ::core::stringify!(RankingSequence_TopMenu_ChapterSelect),
533 ::core::stringify!(new),
534 )
535 });
536 <Self as IRankingSequence_TopMenu_ChapterSelectMethods>::ctor(this);
537 this
538 }
539}
540
541#[cfg(feature = "app-rankingsequence")]
542pub trait IRankingSequence_UploadPairsMenu_RandomAddUploadPairsMenuItemMethods:
543 IRankingSequence_UploadPairsMenu_RandomAddUploadPairsMenuItem
544{
545 #[doc = "`get_Label()` overload"]
546 fn get_label(self) -> crate::app::rankingsequence::RankingSequence_Label {
547 unsafe {
548 let __receiver = <RankingSequence_UploadPairsMenu_RandomAddUploadPairsMenuItem as ::unity::FromIlInstance>::from_il_instance(
549 <Self as ::unity::SystemObject>::as_instance(self),
550 );
551 {
552 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
553 let __vi = *__vt.get(72usize).unwrap_or_else(|| {
554 panic!(
555 "unity: virtual slot {}
556 out of range (vtable len {}
557) on the runtime class behind {}
558 (method `{}
559`)",
560 72usize,
561 __vt.len(),
562 <RankingSequence_UploadPairsMenu_RandomAddUploadPairsMenuItem as ::unity::ClassIdentity>::NAME,
563 "get_Label",
564 )
565 });
566 let __inner: extern "C" fn(
567 RankingSequence_UploadPairsMenu_RandomAddUploadPairsMenuItem,
568 ::unity::OptionalMethod,
569 ) -> crate::app::rankingsequence::RankingSequence_Label = ::core::mem::transmute(__vi.method_ptr);
570 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
571 __inner(__receiver, __mi)
572 }
573 }
574 }
575 #[doc = "`GetName()` overload"]
576 fn get_name(self) -> ::unity::Il2CppString {
577 unsafe {
578 let __receiver = <RankingSequence_UploadPairsMenu_RandomAddUploadPairsMenuItem as ::unity::FromIlInstance>::from_il_instance(
579 <Self as ::unity::SystemObject>::as_instance(self),
580 );
581 {
582 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
583 let __vi = *__vt.get(5usize).unwrap_or_else(|| {
584 panic!(
585 "unity: virtual slot {}
586 out of range (vtable len {}
587) on the runtime class behind {}
588 (method `{}
589`)",
590 5usize,
591 __vt.len(),
592 <RankingSequence_UploadPairsMenu_RandomAddUploadPairsMenuItem as ::unity::ClassIdentity>::NAME,
593 "GetName",
594 )
595 });
596 let __inner: extern "C" fn(
597 RankingSequence_UploadPairsMenu_RandomAddUploadPairsMenuItem,
598 ::unity::OptionalMethod,
599 ) -> ::unity::Il2CppString = ::core::mem::transmute(__vi.method_ptr);
600 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
601 __inner(__receiver, __mi)
602 }
603 }
604 }
605 #[doc = "`IsEnable()` overload"]
606 fn is_enable(self) -> bool {
607 unsafe {
608 let __receiver = <RankingSequence_UploadPairsMenu_RandomAddUploadPairsMenuItem as ::unity::FromIlInstance>::from_il_instance(
609 <Self as ::unity::SystemObject>::as_instance(self),
610 );
611 {
612 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
613 let __vi = *__vt.get(22usize).unwrap_or_else(|| {
614 panic!(
615 "unity: virtual slot {}
616 out of range (vtable len {}
617) on the runtime class behind {}
618 (method `{}
619`)",
620 22usize,
621 __vt.len(),
622 <RankingSequence_UploadPairsMenu_RandomAddUploadPairsMenuItem as ::unity::ClassIdentity>::NAME,
623 "IsEnable",
624 )
625 });
626 let __inner: extern "C" fn(RankingSequence_UploadPairsMenu_RandomAddUploadPairsMenuItem, ::unity::OptionalMethod) -> bool =
627 ::core::mem::transmute(__vi.method_ptr);
628 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
629 __inner(__receiver, __mi)
630 }
631 }
632 }
633 #[doc = "`OnLeftRight(i32, bool)` overload"]
634 fn on_left_right(self, step: impl ::core::convert::Into<i32>, is_trigger: impl ::core::convert::Into<bool>) -> () {
635 unsafe {
636 let __receiver = <RankingSequence_UploadPairsMenu_RandomAddUploadPairsMenuItem as ::unity::FromIlInstance>::from_il_instance(
637 <Self as ::unity::SystemObject>::as_instance(self),
638 );
639 {
640 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
641 let __vi = *__vt.get(70usize).unwrap_or_else(|| {
642 panic!(
643 "unity: virtual slot {}
644 out of range (vtable len {}
645) on the runtime class behind {}
646 (method `{}
647`)",
648 70usize,
649 __vt.len(),
650 <RankingSequence_UploadPairsMenu_RandomAddUploadPairsMenuItem as ::unity::ClassIdentity>::NAME,
651 "OnLeftRight",
652 )
653 });
654 let __inner: extern "C" fn(RankingSequence_UploadPairsMenu_RandomAddUploadPairsMenuItem, i32, bool, ::unity::OptionalMethod) -> () =
655 ::core::mem::transmute(__vi.method_ptr);
656 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
657 __inner(
658 __receiver,
659 ::core::convert::Into::into(step),
660 ::core::convert::Into::into(is_trigger),
661 __mi,
662 )
663 }
664 }
665 }
666 #[doc = "`.ctor()` overload"]
667 fn ctor(self) -> () {
668 unsafe {
669 let __receiver = <RankingSequence_UploadPairsMenu_RandomAddUploadPairsMenuItem as ::unity::FromIlInstance>::from_il_instance(
670 <Self as ::unity::SystemObject>::as_instance(self),
671 );
672 ::unity::il2cpp_call!((::unity::module_base()+0x1b7a500usize)as*mut u8,();
673(RankingSequence_UploadPairsMenu_RandomAddUploadPairsMenuItem)__receiver)
674 }
675 }
676}
677
678#[cfg(feature = "app-rankingsequence")]
679impl<__T: IRankingSequence_UploadPairsMenu_RandomAddUploadPairsMenuItem> IRankingSequence_UploadPairsMenu_RandomAddUploadPairsMenuItemMethods
680 for __T
681{
682}
683
684#[cfg(feature = "app-rankingsequence")]
685impl RankingSequence_UploadPairsMenu_RandomAddUploadPairsMenuItem {
686 pub fn get_label_method_info() -> &'static ::unity::il2cpp::MethodInfo {
687 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
688 }
689
690 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
691 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
692 }
693
694 pub fn is_enable_method_info() -> &'static ::unity::il2cpp::MethodInfo {
695 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
696 }
697
698 pub fn on_left_right_method_info() -> &'static ::unity::il2cpp::MethodInfo {
699 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
700 }
701
702 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
703 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
704 }
705}
706
707#[cfg(feature = "app-rankingsequence")]
708impl RankingSequence_UploadPairsMenu_RandomAddUploadPairsMenuItem {
709 #[doc = "Direct (non-virtual) call to `RankingSequence_UploadPairsMenu_RandomAddUploadPairsMenuItem`'s own `get_Label`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
710 pub unsafe fn get_label(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::rankingsequence::RankingSequence_Label {
711 let __mi = Self::get_label_method_info();
712 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::rankingsequence::RankingSequence_Label =
713 ::core::mem::transmute(__mi.method_ptr);
714 __inner(this.into(), ::core::option::Option::None)
715 }
716
717 #[doc = "Direct (non-virtual) call to `RankingSequence_UploadPairsMenu_RandomAddUploadPairsMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
718 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
719 let __mi = Self::get_name_method_info();
720 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
721 __inner(this.into(), ::core::option::Option::None)
722 }
723
724 #[doc = "Direct (non-virtual) call to `RankingSequence_UploadPairsMenu_RandomAddUploadPairsMenuItem`'s own `IsEnable`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
725 pub unsafe fn is_enable(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
726 let __mi = Self::is_enable_method_info();
727 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
728 __inner(this.into(), ::core::option::Option::None)
729 }
730
731 #[doc = "Direct (non-virtual) call to `RankingSequence_UploadPairsMenu_RandomAddUploadPairsMenuItem`'s own `OnLeftRight`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
732 pub unsafe fn on_left_right(this: impl ::core::convert::Into<::unity::IlInstance>, step: i32, is_trigger: bool) -> () {
733 let __mi = Self::on_left_right_method_info();
734 let __inner: extern "C" fn(::unity::IlInstance, i32, bool, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
735 __inner(this.into(), step, is_trigger, ::core::option::Option::None)
736 }
737}
738
739#[cfg(feature = "app-rankingsequence")]
740impl RankingSequence_UploadPairsMenu_RandomAddUploadPairsMenuItem {
741 #[doc = "`.ctor()` — no args"]
742 pub fn new() -> Self {
743 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
744 panic!(
745 "{}
746::{}
747 failed to instantiate",
748 ::core::stringify!(RankingSequence_UploadPairsMenu_RandomAddUploadPairsMenuItem),
749 ::core::stringify!(new),
750 )
751 });
752 <Self as IRankingSequence_UploadPairsMenu_RandomAddUploadPairsMenuItemMethods>::ctor(this);
753 this
754 }
755}
756
757#[cfg(feature = "app-rankingsequence")]
758pub trait IRankingSequence_UploadPairsMenu_AddUploadPairsMenuItemMethods: IRankingSequence_UploadPairsMenu_AddUploadPairsMenuItem {
759 #[doc = "`get_Label()` overload"]
760 fn get_label(self) -> crate::app::rankingsequence::RankingSequence_Label {
761 unsafe {
762 let __receiver = <RankingSequence_UploadPairsMenu_AddUploadPairsMenuItem as ::unity::FromIlInstance>::from_il_instance(
763 <Self as ::unity::SystemObject>::as_instance(self),
764 );
765 {
766 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
767 let __vi = *__vt.get(72usize).unwrap_or_else(|| {
768 panic!(
769 "unity: virtual slot {}
770 out of range (vtable len {}
771) on the runtime class behind {}
772 (method `{}
773`)",
774 72usize,
775 __vt.len(),
776 <RankingSequence_UploadPairsMenu_AddUploadPairsMenuItem as ::unity::ClassIdentity>::NAME,
777 "get_Label",
778 )
779 });
780 let __inner: extern "C" fn(
781 RankingSequence_UploadPairsMenu_AddUploadPairsMenuItem,
782 ::unity::OptionalMethod,
783 ) -> crate::app::rankingsequence::RankingSequence_Label = ::core::mem::transmute(__vi.method_ptr);
784 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
785 __inner(__receiver, __mi)
786 }
787 }
788 }
789 #[doc = "`.ctor(crate::app::rankingsequence::RankingSequence_UploadPairsMenu_UploadPersonMenuItem, crate::app::rankingsequence::RankingSequence_UploadPairsMenu_UploadGodMenuItem)` overload"]
790 fn ctor(
791 self,
792 person_item: impl ::core::convert::Into<crate::app::rankingsequence::RankingSequence_UploadPairsMenu_UploadPersonMenuItem>,
793 god_item: impl ::core::convert::Into<crate::app::rankingsequence::RankingSequence_UploadPairsMenu_UploadGodMenuItem>,
794 ) -> () {
795 unsafe {
796 let __receiver = <RankingSequence_UploadPairsMenu_AddUploadPairsMenuItem as ::unity::FromIlInstance>::from_il_instance(
797 <Self as ::unity::SystemObject>::as_instance(self),
798 );
799 ::unity::il2cpp_call!((::unity::module_base()+0x1b7a120usize)as*mut u8,();
800(RankingSequence_UploadPairsMenu_AddUploadPairsMenuItem)__receiver,(crate::app::rankingsequence::RankingSequence_UploadPairsMenu_UploadPersonMenuItem)::core::convert::Into::into(person_item),(crate::app::rankingsequence::RankingSequence_UploadPairsMenu_UploadGodMenuItem)::core::convert::Into::into(god_item))
801 }
802 }
803 #[doc = "`IsEnable()` overload"]
804 fn is_enable(self) -> bool {
805 unsafe {
806 let __receiver = <RankingSequence_UploadPairsMenu_AddUploadPairsMenuItem 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(22usize).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 22usize,
819 __vt.len(),
820 <RankingSequence_UploadPairsMenu_AddUploadPairsMenuItem as ::unity::ClassIdentity>::NAME,
821 "IsEnable",
822 )
823 });
824 let __inner: extern "C" fn(RankingSequence_UploadPairsMenu_AddUploadPairsMenuItem, ::unity::OptionalMethod) -> bool =
825 ::core::mem::transmute(__vi.method_ptr);
826 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
827 __inner(__receiver, __mi)
828 }
829 }
830 }
831}
832
833#[cfg(feature = "app-rankingsequence")]
834impl<__T: IRankingSequence_UploadPairsMenu_AddUploadPairsMenuItem> IRankingSequence_UploadPairsMenu_AddUploadPairsMenuItemMethods for __T {}
835
836#[cfg(feature = "app-rankingsequence")]
837impl RankingSequence_UploadPairsMenu_AddUploadPairsMenuItem {
838 pub fn get_label_method_info() -> &'static ::unity::il2cpp::MethodInfo {
839 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
840 }
841
842 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
843 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
844 }
845
846 pub fn is_enable_method_info() -> &'static ::unity::il2cpp::MethodInfo {
847 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
848 }
849}
850
851#[cfg(feature = "app-rankingsequence")]
852impl RankingSequence_UploadPairsMenu_AddUploadPairsMenuItem {
853 #[doc = "Direct (non-virtual) call to `RankingSequence_UploadPairsMenu_AddUploadPairsMenuItem`'s own `get_Label`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
854 pub unsafe fn get_label(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::rankingsequence::RankingSequence_Label {
855 let __mi = Self::get_label_method_info();
856 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::rankingsequence::RankingSequence_Label =
857 ::core::mem::transmute(__mi.method_ptr);
858 __inner(this.into(), ::core::option::Option::None)
859 }
860
861 #[doc = "Direct (non-virtual) call to `RankingSequence_UploadPairsMenu_AddUploadPairsMenuItem`'s own `IsEnable`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
862 pub unsafe fn is_enable(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
863 let __mi = Self::is_enable_method_info();
864 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
865 __inner(this.into(), ::core::option::Option::None)
866 }
867}
868
869#[cfg(feature = "app-rankingsequence")]
870impl RankingSequence_UploadPairsMenu_AddUploadPairsMenuItem {
871 #[doc = "`.ctor(crate::app::rankingsequence::RankingSequence_UploadPairsMenu_UploadPersonMenuItem, crate::app::rankingsequence::RankingSequence_UploadPairsMenu_UploadGodMenuItem)` — overload selector"]
872 pub fn new(
873 person_item: crate::app::rankingsequence::RankingSequence_UploadPairsMenu_UploadPersonMenuItem,
874 god_item: crate::app::rankingsequence::RankingSequence_UploadPairsMenu_UploadGodMenuItem,
875 ) -> Self {
876 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
877 panic!(
878 "{}
879::{}
880 failed to instantiate",
881 ::core::stringify!(RankingSequence_UploadPairsMenu_AddUploadPairsMenuItem),
882 ::core::stringify!(new),
883 )
884 });
885 <Self as IRankingSequence_UploadPairsMenu_AddUploadPairsMenuItemMethods>::ctor(this, person_item, god_item);
886 this
887 }
888}
889
890#[cfg(feature = "app-rankingsequence")]
891impl RankingSequence_TopMenu {
892 #[doc = "`CreateBind(crate::app::procinst::ProcInst)` overload"]
893 pub fn create_bind(super_: impl ::core::convert::Into<crate::app::procinst::ProcInst>) -> () {
894 unsafe {
895 ::unity::il2cpp_call!((::unity::module_base()+0x1af5a10usize)as*mut u8,();
896(crate::app::procinst::ProcInst)::core::convert::Into::into(super_))
897 }
898 }
899}
900
901#[cfg(feature = "app-rankingsequence")]
902pub trait IRankingSequence_TopMenuMethods: IRankingSequence_TopMenu {
903 #[doc = "`.ctor()` overload"]
904 fn ctor(self) -> () {
905 unsafe {
906 let __receiver =
907 <RankingSequence_TopMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
908 ::unity::il2cpp_call!((::unity::module_base()+0x1af5b70usize)as*mut u8,();
909(RankingSequence_TopMenu)__receiver)
910 }
911 }
912}
913
914#[cfg(feature = "app-rankingsequence")]
915impl<__T: IRankingSequence_TopMenu> IRankingSequence_TopMenuMethods for __T {}
916
917#[cfg(feature = "app-rankingsequence")]
918impl RankingSequence_TopMenu {
919 pub fn create_bind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
920 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
921 }
922
923 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
924 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
925 }
926}
927
928#[cfg(feature = "app-rankingsequence")]
929impl RankingSequence_TopMenu {
930 #[doc = "`.ctor()` — no args"]
931 pub fn new() -> Self {
932 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
933 panic!(
934 "{}
935::{}
936 failed to instantiate",
937 ::core::stringify!(RankingSequence_TopMenu),
938 ::core::stringify!(new),
939 )
940 });
941 <Self as IRankingSequence_TopMenuMethods>::ctor(this);
942 this
943 }
944}
945
946#[cfg(feature = "app-rankingsequence")]
947pub trait IRankingSequence_PairMenuItemMethods: IRankingSequence_PairMenuItem {
948 #[doc = "`.ctor(crate::app::nexranking::NexRanking_Data)` overload"]
949 fn ctor(self, data: impl ::core::convert::Into<crate::app::nexranking::NexRanking_Data>) -> () {
950 unsafe {
951 let __receiver =
952 <RankingSequence_PairMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
953 ::unity::il2cpp_call!((::unity::module_base()+0x1af5750usize)as*mut u8,();
954(RankingSequence_PairMenuItem)__receiver,(crate::app::nexranking::NexRanking_Data)::core::convert::Into::into(data))
955 }
956 }
957 #[doc = "`GetName()` overload"]
958 fn get_name(self) -> ::unity::Il2CppString {
959 unsafe {
960 let __receiver =
961 <RankingSequence_PairMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
962 {
963 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
964 let __vi = *__vt.get(5usize).unwrap_or_else(|| {
965 panic!(
966 "unity: virtual slot {}
967 out of range (vtable len {}
968) on the runtime class behind {}
969 (method `{}
970`)",
971 5usize,
972 __vt.len(),
973 <RankingSequence_PairMenuItem as ::unity::ClassIdentity>::NAME,
974 "GetName",
975 )
976 });
977 let __inner: extern "C" fn(RankingSequence_PairMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
978 ::core::mem::transmute(__vi.method_ptr);
979 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
980 __inner(__receiver, __mi)
981 }
982 }
983 }
984 #[doc = "`GetHelp()` overload"]
985 fn get_help(self) -> ::unity::Il2CppString {
986 unsafe {
987 let __receiver =
988 <RankingSequence_PairMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
989 {
990 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
991 let __vi = *__vt.get(7usize).unwrap_or_else(|| {
992 panic!(
993 "unity: virtual slot {}
994 out of range (vtable len {}
995) on the runtime class behind {}
996 (method `{}
997`)",
998 7usize,
999 __vt.len(),
1000 <RankingSequence_PairMenuItem as ::unity::ClassIdentity>::NAME,
1001 "GetHelp",
1002 )
1003 });
1004 let __inner: extern "C" fn(RankingSequence_PairMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1005 ::core::mem::transmute(__vi.method_ptr);
1006 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1007 __inner(__receiver, __mi)
1008 }
1009 }
1010 }
1011}
1012
1013#[cfg(feature = "app-rankingsequence")]
1014impl<__T: IRankingSequence_PairMenuItem> IRankingSequence_PairMenuItemMethods for __T {}
1015
1016#[cfg(feature = "app-rankingsequence")]
1017impl RankingSequence_PairMenuItem {
1018 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1019 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1020 }
1021
1022 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1023 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1024 }
1025
1026 pub fn get_help_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1027 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1028 }
1029}
1030
1031#[cfg(feature = "app-rankingsequence")]
1032impl RankingSequence_PairMenuItem {
1033 #[doc = "Direct (non-virtual) call to `RankingSequence_PairMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1034 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1035 let __mi = Self::get_name_method_info();
1036 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1037 __inner(this.into(), ::core::option::Option::None)
1038 }
1039
1040 #[doc = "Direct (non-virtual) call to `RankingSequence_PairMenuItem`'s own `GetHelp`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1041 pub unsafe fn get_help(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1042 let __mi = Self::get_help_method_info();
1043 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1044 __inner(this.into(), ::core::option::Option::None)
1045 }
1046}
1047
1048#[cfg(feature = "app-rankingsequence")]
1049impl RankingSequence_PairMenuItem {
1050 #[doc = "`.ctor(crate::app::nexranking::NexRanking_Data)` — overload selector"]
1051 pub fn new(data: crate::app::nexranking::NexRanking_Data) -> Self {
1052 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1053 panic!(
1054 "{}
1055::{}
1056 failed to instantiate",
1057 ::core::stringify!(RankingSequence_PairMenuItem),
1058 ::core::stringify!(new),
1059 )
1060 });
1061 <Self as IRankingSequence_PairMenuItemMethods>::ctor(this, data);
1062 this
1063 }
1064}
1065
1066#[cfg(feature = "app-rankingsequence")]
1067pub trait IRankingSequence_UploadPairsMenu_UploadPairMenuItemMethods: IRankingSequence_UploadPairsMenu_UploadPairMenuItem {
1068 #[doc = "`get_Label()` overload"]
1069 fn get_label(self) -> crate::app::rankingsequence::RankingSequence_Label {
1070 unsafe {
1071 let __receiver = <RankingSequence_UploadPairsMenu_UploadPairMenuItem as ::unity::FromIlInstance>::from_il_instance(
1072 <Self as ::unity::SystemObject>::as_instance(self),
1073 );
1074 {
1075 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1076 let __vi = *__vt.get(72usize).unwrap_or_else(|| {
1077 panic!(
1078 "unity: virtual slot {}
1079 out of range (vtable len {}
1080) on the runtime class behind {}
1081 (method `{}
1082`)",
1083 72usize,
1084 __vt.len(),
1085 <RankingSequence_UploadPairsMenu_UploadPairMenuItem as ::unity::ClassIdentity>::NAME,
1086 "get_Label",
1087 )
1088 });
1089 let __inner: extern "C" fn(
1090 RankingSequence_UploadPairsMenu_UploadPairMenuItem,
1091 ::unity::OptionalMethod,
1092 ) -> crate::app::rankingsequence::RankingSequence_Label = ::core::mem::transmute(__vi.method_ptr);
1093 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1094 __inner(__receiver, __mi)
1095 }
1096 }
1097 }
1098 #[doc = "`GetName()` overload"]
1099 fn get_name(self) -> ::unity::Il2CppString {
1100 unsafe {
1101 let __receiver = <RankingSequence_UploadPairsMenu_UploadPairMenuItem as ::unity::FromIlInstance>::from_il_instance(
1102 <Self as ::unity::SystemObject>::as_instance(self),
1103 );
1104 {
1105 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1106 let __vi = *__vt.get(5usize).unwrap_or_else(|| {
1107 panic!(
1108 "unity: virtual slot {}
1109 out of range (vtable len {}
1110) on the runtime class behind {}
1111 (method `{}
1112`)",
1113 5usize,
1114 __vt.len(),
1115 <RankingSequence_UploadPairsMenu_UploadPairMenuItem as ::unity::ClassIdentity>::NAME,
1116 "GetName",
1117 )
1118 });
1119 let __inner: extern "C" fn(RankingSequence_UploadPairsMenu_UploadPairMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1120 ::core::mem::transmute(__vi.method_ptr);
1121 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1122 __inner(__receiver, __mi)
1123 }
1124 }
1125 }
1126 #[doc = "`IsEnable()` overload"]
1127 fn is_enable(self) -> bool {
1128 unsafe {
1129 let __receiver = <RankingSequence_UploadPairsMenu_UploadPairMenuItem as ::unity::FromIlInstance>::from_il_instance(
1130 <Self as ::unity::SystemObject>::as_instance(self),
1131 );
1132 {
1133 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1134 let __vi = *__vt.get(22usize).unwrap_or_else(|| {
1135 panic!(
1136 "unity: virtual slot {}
1137 out of range (vtable len {}
1138) on the runtime class behind {}
1139 (method `{}
1140`)",
1141 22usize,
1142 __vt.len(),
1143 <RankingSequence_UploadPairsMenu_UploadPairMenuItem as ::unity::ClassIdentity>::NAME,
1144 "IsEnable",
1145 )
1146 });
1147 let __inner: extern "C" fn(RankingSequence_UploadPairsMenu_UploadPairMenuItem, ::unity::OptionalMethod) -> bool =
1148 ::core::mem::transmute(__vi.method_ptr);
1149 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1150 __inner(__receiver, __mi)
1151 }
1152 }
1153 }
1154 #[doc = "`.ctor()` overload"]
1155 fn ctor(self) -> () {
1156 unsafe {
1157 let __receiver = <RankingSequence_UploadPairsMenu_UploadPairMenuItem as ::unity::FromIlInstance>::from_il_instance(
1158 <Self as ::unity::SystemObject>::as_instance(self),
1159 );
1160 ::unity::il2cpp_call!((::unity::module_base()+0x1b7ac40usize)as*mut u8,();
1161(RankingSequence_UploadPairsMenu_UploadPairMenuItem)__receiver)
1162 }
1163 }
1164}
1165
1166#[cfg(feature = "app-rankingsequence")]
1167impl<__T: IRankingSequence_UploadPairsMenu_UploadPairMenuItem> IRankingSequence_UploadPairsMenu_UploadPairMenuItemMethods for __T {}
1168
1169#[cfg(feature = "app-rankingsequence")]
1170impl RankingSequence_UploadPairsMenu_UploadPairMenuItem {
1171 pub fn get_label_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1172 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1173 }
1174
1175 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1176 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1177 }
1178
1179 pub fn is_enable_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1180 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1181 }
1182
1183 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1184 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
1185 }
1186}
1187
1188#[cfg(feature = "app-rankingsequence")]
1189impl RankingSequence_UploadPairsMenu_UploadPairMenuItem {
1190 #[doc = "Direct (non-virtual) call to `RankingSequence_UploadPairsMenu_UploadPairMenuItem`'s own `get_Label`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1191 pub unsafe fn get_label(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::rankingsequence::RankingSequence_Label {
1192 let __mi = Self::get_label_method_info();
1193 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::rankingsequence::RankingSequence_Label =
1194 ::core::mem::transmute(__mi.method_ptr);
1195 __inner(this.into(), ::core::option::Option::None)
1196 }
1197
1198 #[doc = "Direct (non-virtual) call to `RankingSequence_UploadPairsMenu_UploadPairMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1199 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1200 let __mi = Self::get_name_method_info();
1201 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1202 __inner(this.into(), ::core::option::Option::None)
1203 }
1204
1205 #[doc = "Direct (non-virtual) call to `RankingSequence_UploadPairsMenu_UploadPairMenuItem`'s own `IsEnable`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1206 pub unsafe fn is_enable(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
1207 let __mi = Self::is_enable_method_info();
1208 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
1209 __inner(this.into(), ::core::option::Option::None)
1210 }
1211}
1212
1213#[cfg(feature = "app-rankingsequence")]
1214impl RankingSequence_UploadPairsMenu_UploadPairMenuItem {
1215 #[doc = "`.ctor()` — no args"]
1216 pub fn new() -> Self {
1217 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1218 panic!(
1219 "{}
1220::{}
1221 failed to instantiate",
1222 ::core::stringify!(RankingSequence_UploadPairsMenu_UploadPairMenuItem),
1223 ::core::stringify!(new),
1224 )
1225 });
1226 <Self as IRankingSequence_UploadPairsMenu_UploadPairMenuItemMethods>::ctor(this);
1227 this
1228 }
1229}
1230
1231#[cfg(feature = "app-rankingsequence")]
1232pub trait IRankingSequence_UploadPairsMenu_UploadGodMenuItemMethods: IRankingSequence_UploadPairsMenu_UploadGodMenuItem {
1233 #[doc = "`.ctor()` overload"]
1234 fn ctor(self) -> () {
1235 unsafe {
1236 let __receiver = <RankingSequence_UploadPairsMenu_UploadGodMenuItem as ::unity::FromIlInstance>::from_il_instance(
1237 <Self as ::unity::SystemObject>::as_instance(self),
1238 );
1239 ::unity::il2cpp_call!((::unity::module_base()+0x1b7a610usize)as*mut u8,();
1240(RankingSequence_UploadPairsMenu_UploadGodMenuItem)__receiver)
1241 }
1242 }
1243 #[doc = "`IsEnable()` overload"]
1244 fn is_enable(self) -> bool {
1245 unsafe {
1246 let __receiver = <RankingSequence_UploadPairsMenu_UploadGodMenuItem as ::unity::FromIlInstance>::from_il_instance(
1247 <Self as ::unity::SystemObject>::as_instance(self),
1248 );
1249 {
1250 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1251 let __vi = *__vt.get(22usize).unwrap_or_else(|| {
1252 panic!(
1253 "unity: virtual slot {}
1254 out of range (vtable len {}
1255) on the runtime class behind {}
1256 (method `{}
1257`)",
1258 22usize,
1259 __vt.len(),
1260 <RankingSequence_UploadPairsMenu_UploadGodMenuItem as ::unity::ClassIdentity>::NAME,
1261 "IsEnable",
1262 )
1263 });
1264 let __inner: extern "C" fn(RankingSequence_UploadPairsMenu_UploadGodMenuItem, ::unity::OptionalMethod) -> bool =
1265 ::core::mem::transmute(__vi.method_ptr);
1266 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1267 __inner(__receiver, __mi)
1268 }
1269 }
1270 }
1271 #[doc = "`GetName()` overload"]
1272 fn get_name(self) -> ::unity::Il2CppString {
1273 unsafe {
1274 let __receiver = <RankingSequence_UploadPairsMenu_UploadGodMenuItem as ::unity::FromIlInstance>::from_il_instance(
1275 <Self as ::unity::SystemObject>::as_instance(self),
1276 );
1277 {
1278 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1279 let __vi = *__vt.get(5usize).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 5usize,
1287 __vt.len(),
1288 <RankingSequence_UploadPairsMenu_UploadGodMenuItem as ::unity::ClassIdentity>::NAME,
1289 "GetName",
1290 )
1291 });
1292 let __inner: extern "C" fn(RankingSequence_UploadPairsMenu_UploadGodMenuItem, ::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 = "`OnLeftRight(i32, bool)` overload"]
1300 fn on_left_right(self, step: impl ::core::convert::Into<i32>, is_trigger: impl ::core::convert::Into<bool>) -> () {
1301 unsafe {
1302 let __receiver = <RankingSequence_UploadPairsMenu_UploadGodMenuItem as ::unity::FromIlInstance>::from_il_instance(
1303 <Self as ::unity::SystemObject>::as_instance(self),
1304 );
1305 {
1306 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1307 let __vi = *__vt.get(70usize).unwrap_or_else(|| {
1308 panic!(
1309 "unity: virtual slot {}
1310 out of range (vtable len {}
1311) on the runtime class behind {}
1312 (method `{}
1313`)",
1314 70usize,
1315 __vt.len(),
1316 <RankingSequence_UploadPairsMenu_UploadGodMenuItem as ::unity::ClassIdentity>::NAME,
1317 "OnLeftRight",
1318 )
1319 });
1320 let __inner: extern "C" fn(RankingSequence_UploadPairsMenu_UploadGodMenuItem, i32, bool, ::unity::OptionalMethod) -> () =
1321 ::core::mem::transmute(__vi.method_ptr);
1322 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1323 __inner(
1324 __receiver,
1325 ::core::convert::Into::into(step),
1326 ::core::convert::Into::into(is_trigger),
1327 __mi,
1328 )
1329 }
1330 }
1331 }
1332 #[doc = "`GetHelp()` overload"]
1333 fn get_help(self) -> ::unity::Il2CppString {
1334 unsafe {
1335 let __receiver = <RankingSequence_UploadPairsMenu_UploadGodMenuItem as ::unity::FromIlInstance>::from_il_instance(
1336 <Self as ::unity::SystemObject>::as_instance(self),
1337 );
1338 {
1339 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1340 let __vi = *__vt.get(7usize).unwrap_or_else(|| {
1341 panic!(
1342 "unity: virtual slot {}
1343 out of range (vtable len {}
1344) on the runtime class behind {}
1345 (method `{}
1346`)",
1347 7usize,
1348 __vt.len(),
1349 <RankingSequence_UploadPairsMenu_UploadGodMenuItem as ::unity::ClassIdentity>::NAME,
1350 "GetHelp",
1351 )
1352 });
1353 let __inner: extern "C" fn(RankingSequence_UploadPairsMenu_UploadGodMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1354 ::core::mem::transmute(__vi.method_ptr);
1355 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1356 __inner(__receiver, __mi)
1357 }
1358 }
1359 }
1360}
1361
1362#[cfg(feature = "app-rankingsequence")]
1363impl<__T: IRankingSequence_UploadPairsMenu_UploadGodMenuItem> IRankingSequence_UploadPairsMenu_UploadGodMenuItemMethods for __T {}
1364
1365#[cfg(feature = "app-rankingsequence")]
1366impl RankingSequence_UploadPairsMenu_UploadGodMenuItem {
1367 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1368 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1369 }
1370
1371 pub fn is_enable_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1372 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1373 }
1374
1375 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1376 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1377 }
1378
1379 pub fn on_left_right_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1380 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
1381 }
1382
1383 pub fn get_help_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1384 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
1385 }
1386}
1387
1388#[cfg(feature = "app-rankingsequence")]
1389impl RankingSequence_UploadPairsMenu_UploadGodMenuItem {
1390 #[doc = "Direct (non-virtual) call to `RankingSequence_UploadPairsMenu_UploadGodMenuItem`'s own `IsEnable`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1391 pub unsafe fn is_enable(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
1392 let __mi = Self::is_enable_method_info();
1393 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
1394 __inner(this.into(), ::core::option::Option::None)
1395 }
1396
1397 #[doc = "Direct (non-virtual) call to `RankingSequence_UploadPairsMenu_UploadGodMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1398 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1399 let __mi = Self::get_name_method_info();
1400 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1401 __inner(this.into(), ::core::option::Option::None)
1402 }
1403
1404 #[doc = "Direct (non-virtual) call to `RankingSequence_UploadPairsMenu_UploadGodMenuItem`'s own `OnLeftRight`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1405 pub unsafe fn on_left_right(this: impl ::core::convert::Into<::unity::IlInstance>, step: i32, is_trigger: bool) -> () {
1406 let __mi = Self::on_left_right_method_info();
1407 let __inner: extern "C" fn(::unity::IlInstance, i32, bool, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1408 __inner(this.into(), step, is_trigger, ::core::option::Option::None)
1409 }
1410
1411 #[doc = "Direct (non-virtual) call to `RankingSequence_UploadPairsMenu_UploadGodMenuItem`'s own `GetHelp`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1412 pub unsafe fn get_help(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1413 let __mi = Self::get_help_method_info();
1414 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1415 __inner(this.into(), ::core::option::Option::None)
1416 }
1417}
1418
1419#[cfg(feature = "app-rankingsequence")]
1420impl RankingSequence_UploadPairsMenu_UploadGodMenuItem {
1421 #[doc = "`.ctor()` — no args"]
1422 pub fn new() -> Self {
1423 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1424 panic!(
1425 "{}
1426::{}
1427 failed to instantiate",
1428 ::core::stringify!(RankingSequence_UploadPairsMenu_UploadGodMenuItem),
1429 ::core::stringify!(new),
1430 )
1431 });
1432 <Self as IRankingSequence_UploadPairsMenu_UploadGodMenuItemMethods>::ctor(this);
1433 this
1434 }
1435}
1436
1437#[cfg(feature = "app-rankingsequence")]
1438pub trait IRankingSequence_UploadPairsMenu_UploadPersonMenuItemMethods: IRankingSequence_UploadPairsMenu_UploadPersonMenuItem {
1439 #[doc = "`.ctor()` overload"]
1440 fn ctor(self) -> () {
1441 unsafe {
1442 let __receiver = <RankingSequence_UploadPairsMenu_UploadPersonMenuItem as ::unity::FromIlInstance>::from_il_instance(
1443 <Self as ::unity::SystemObject>::as_instance(self),
1444 );
1445 ::unity::il2cpp_call!((::unity::module_base()+0x1b7ac50usize)as*mut u8,();
1446(RankingSequence_UploadPairsMenu_UploadPersonMenuItem)__receiver)
1447 }
1448 }
1449 #[doc = "`IsEnable()` overload"]
1450 fn is_enable(self) -> bool {
1451 unsafe {
1452 let __receiver = <RankingSequence_UploadPairsMenu_UploadPersonMenuItem as ::unity::FromIlInstance>::from_il_instance(
1453 <Self as ::unity::SystemObject>::as_instance(self),
1454 );
1455 {
1456 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1457 let __vi = *__vt.get(22usize).unwrap_or_else(|| {
1458 panic!(
1459 "unity: virtual slot {}
1460 out of range (vtable len {}
1461) on the runtime class behind {}
1462 (method `{}
1463`)",
1464 22usize,
1465 __vt.len(),
1466 <RankingSequence_UploadPairsMenu_UploadPersonMenuItem as ::unity::ClassIdentity>::NAME,
1467 "IsEnable",
1468 )
1469 });
1470 let __inner: extern "C" fn(RankingSequence_UploadPairsMenu_UploadPersonMenuItem, ::unity::OptionalMethod) -> bool =
1471 ::core::mem::transmute(__vi.method_ptr);
1472 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1473 __inner(__receiver, __mi)
1474 }
1475 }
1476 }
1477 #[doc = "`GetName()` overload"]
1478 fn get_name(self) -> ::unity::Il2CppString {
1479 unsafe {
1480 let __receiver = <RankingSequence_UploadPairsMenu_UploadPersonMenuItem as ::unity::FromIlInstance>::from_il_instance(
1481 <Self as ::unity::SystemObject>::as_instance(self),
1482 );
1483 {
1484 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1485 let __vi = *__vt.get(5usize).unwrap_or_else(|| {
1486 panic!(
1487 "unity: virtual slot {}
1488 out of range (vtable len {}
1489) on the runtime class behind {}
1490 (method `{}
1491`)",
1492 5usize,
1493 __vt.len(),
1494 <RankingSequence_UploadPairsMenu_UploadPersonMenuItem as ::unity::ClassIdentity>::NAME,
1495 "GetName",
1496 )
1497 });
1498 let __inner: extern "C" fn(RankingSequence_UploadPairsMenu_UploadPersonMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1499 ::core::mem::transmute(__vi.method_ptr);
1500 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1501 __inner(__receiver, __mi)
1502 }
1503 }
1504 }
1505 #[doc = "`OnLeftRight(i32, bool)` overload"]
1506 fn on_left_right(self, step: impl ::core::convert::Into<i32>, is_trigger: impl ::core::convert::Into<bool>) -> () {
1507 unsafe {
1508 let __receiver = <RankingSequence_UploadPairsMenu_UploadPersonMenuItem as ::unity::FromIlInstance>::from_il_instance(
1509 <Self as ::unity::SystemObject>::as_instance(self),
1510 );
1511 {
1512 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1513 let __vi = *__vt.get(70usize).unwrap_or_else(|| {
1514 panic!(
1515 "unity: virtual slot {}
1516 out of range (vtable len {}
1517) on the runtime class behind {}
1518 (method `{}
1519`)",
1520 70usize,
1521 __vt.len(),
1522 <RankingSequence_UploadPairsMenu_UploadPersonMenuItem as ::unity::ClassIdentity>::NAME,
1523 "OnLeftRight",
1524 )
1525 });
1526 let __inner: extern "C" fn(RankingSequence_UploadPairsMenu_UploadPersonMenuItem, i32, bool, ::unity::OptionalMethod) -> () =
1527 ::core::mem::transmute(__vi.method_ptr);
1528 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1529 __inner(
1530 __receiver,
1531 ::core::convert::Into::into(step),
1532 ::core::convert::Into::into(is_trigger),
1533 __mi,
1534 )
1535 }
1536 }
1537 }
1538 #[doc = "`GetHelp()` overload"]
1539 fn get_help(self) -> ::unity::Il2CppString {
1540 unsafe {
1541 let __receiver = <RankingSequence_UploadPairsMenu_UploadPersonMenuItem as ::unity::FromIlInstance>::from_il_instance(
1542 <Self as ::unity::SystemObject>::as_instance(self),
1543 );
1544 {
1545 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1546 let __vi = *__vt.get(7usize).unwrap_or_else(|| {
1547 panic!(
1548 "unity: virtual slot {}
1549 out of range (vtable len {}
1550) on the runtime class behind {}
1551 (method `{}
1552`)",
1553 7usize,
1554 __vt.len(),
1555 <RankingSequence_UploadPairsMenu_UploadPersonMenuItem as ::unity::ClassIdentity>::NAME,
1556 "GetHelp",
1557 )
1558 });
1559 let __inner: extern "C" fn(RankingSequence_UploadPairsMenu_UploadPersonMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1560 ::core::mem::transmute(__vi.method_ptr);
1561 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1562 __inner(__receiver, __mi)
1563 }
1564 }
1565 }
1566}
1567
1568#[cfg(feature = "app-rankingsequence")]
1569impl<__T: IRankingSequence_UploadPairsMenu_UploadPersonMenuItem> IRankingSequence_UploadPairsMenu_UploadPersonMenuItemMethods for __T {}
1570
1571#[cfg(feature = "app-rankingsequence")]
1572impl RankingSequence_UploadPairsMenu_UploadPersonMenuItem {
1573 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1574 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1575 }
1576
1577 pub fn is_enable_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1578 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1579 }
1580
1581 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1582 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1583 }
1584
1585 pub fn on_left_right_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1586 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
1587 }
1588
1589 pub fn get_help_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1590 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
1591 }
1592}
1593
1594#[cfg(feature = "app-rankingsequence")]
1595impl RankingSequence_UploadPairsMenu_UploadPersonMenuItem {
1596 #[doc = "Direct (non-virtual) call to `RankingSequence_UploadPairsMenu_UploadPersonMenuItem`'s own `IsEnable`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1597 pub unsafe fn is_enable(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
1598 let __mi = Self::is_enable_method_info();
1599 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
1600 __inner(this.into(), ::core::option::Option::None)
1601 }
1602
1603 #[doc = "Direct (non-virtual) call to `RankingSequence_UploadPairsMenu_UploadPersonMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1604 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1605 let __mi = Self::get_name_method_info();
1606 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1607 __inner(this.into(), ::core::option::Option::None)
1608 }
1609
1610 #[doc = "Direct (non-virtual) call to `RankingSequence_UploadPairsMenu_UploadPersonMenuItem`'s own `OnLeftRight`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1611 pub unsafe fn on_left_right(this: impl ::core::convert::Into<::unity::IlInstance>, step: i32, is_trigger: bool) -> () {
1612 let __mi = Self::on_left_right_method_info();
1613 let __inner: extern "C" fn(::unity::IlInstance, i32, bool, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1614 __inner(this.into(), step, is_trigger, ::core::option::Option::None)
1615 }
1616
1617 #[doc = "Direct (non-virtual) call to `RankingSequence_UploadPairsMenu_UploadPersonMenuItem`'s own `GetHelp`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1618 pub unsafe fn get_help(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1619 let __mi = Self::get_help_method_info();
1620 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1621 __inner(this.into(), ::core::option::Option::None)
1622 }
1623}
1624
1625#[cfg(feature = "app-rankingsequence")]
1626impl RankingSequence_UploadPairsMenu_UploadPersonMenuItem {
1627 #[doc = "`.ctor()` — no args"]
1628 pub fn new() -> Self {
1629 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1630 panic!(
1631 "{}
1632::{}
1633 failed to instantiate",
1634 ::core::stringify!(RankingSequence_UploadPairsMenu_UploadPersonMenuItem),
1635 ::core::stringify!(new),
1636 )
1637 });
1638 <Self as IRankingSequence_UploadPairsMenu_UploadPersonMenuItemMethods>::ctor(this);
1639 this
1640 }
1641}
1642
1643#[cfg(feature = "app-rankingsequence")]
1644impl RankingSequence {
1645 #[doc = "`CreateBind(crate::app::procinst::ProcInst)` overload"]
1646 pub fn create_bind(super_: impl ::core::convert::Into<crate::app::procinst::ProcInst>) -> () {
1647 unsafe {
1648 ::unity::il2cpp_call!((::unity::module_base()+0x237d4b0usize)as*mut u8,();
1649(crate::app::procinst::ProcInst)::core::convert::Into::into(super_))
1650 }
1651 }
1652
1653 #[doc = "`CreateBindLastChapter(crate::app::procinst::ProcInst)` overload"]
1654 pub fn create_bind_last_chapter(super_: impl ::core::convert::Into<crate::app::procinst::ProcInst>) -> () {
1655 unsafe {
1656 ::unity::il2cpp_call!((::unity::module_base()+0x237dc40usize)as*mut u8,();
1657(crate::app::procinst::ProcInst)::core::convert::Into::into(super_))
1658 }
1659 }
1660
1661 #[doc = "`GetPersonDebugNameByNetRankingIndex(i32)` overload"]
1662 pub fn get_person_debug_name_by_net_ranking_index(net_ranking_index: impl ::core::convert::Into<i32>) -> ::unity::Il2CppString {
1663 unsafe {
1664 ::unity::il2cpp_call!((::unity::module_base()+0x237ded0usize)as*mut u8, ::unity::Il2CppString;
1665(i32)::core::convert::Into::into(net_ranking_index))
1666 }
1667 }
1668
1669 #[doc = "`GetGodDebugNameByNetRankingIndex(i32)` overload"]
1670 pub fn get_god_debug_name_by_net_ranking_index(net_ranking_index: impl ::core::convert::Into<i32>) -> ::unity::Il2CppString {
1671 unsafe {
1672 ::unity::il2cpp_call!((::unity::module_base()+0x237df40usize)as*mut u8, ::unity::Il2CppString;
1673(i32)::core::convert::Into::into(net_ranking_index))
1674 }
1675 }
1676}
1677
1678#[cfg(feature = "app-rankingsequence")]
1679pub trait IRankingSequenceMethods: IRankingSequence {
1680 #[doc = "`OnCreate()` overload"]
1681 fn on_create(self) -> () {
1682 unsafe {
1683 let __receiver = <RankingSequence as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1684 {
1685 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1686 let __vi = *__vt.get(9usize).unwrap_or_else(|| {
1687 panic!(
1688 "unity: virtual slot {}
1689 out of range (vtable len {}
1690) on the runtime class behind {}
1691 (method `{}
1692`)",
1693 9usize,
1694 __vt.len(),
1695 <RankingSequence as ::unity::ClassIdentity>::NAME,
1696 "OnCreate",
1697 )
1698 });
1699 let __inner: extern "C" fn(RankingSequence, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
1700 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1701 __inner(__receiver, __mi)
1702 }
1703 }
1704 }
1705 #[doc = "`OnDispose()` overload"]
1706 fn on_dispose(self) -> () {
1707 unsafe {
1708 let __receiver = <RankingSequence as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1709 {
1710 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1711 let __vi = *__vt.get(10usize).unwrap_or_else(|| {
1712 panic!(
1713 "unity: virtual slot {}
1714 out of range (vtable len {}
1715) on the runtime class behind {}
1716 (method `{}
1717`)",
1718 10usize,
1719 __vt.len(),
1720 <RankingSequence as ::unity::ClassIdentity>::NAME,
1721 "OnDispose",
1722 )
1723 });
1724 let __inner: extern "C" fn(RankingSequence, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
1725 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1726 __inner(__receiver, __mi)
1727 }
1728 }
1729 }
1730 #[doc = "`GetChapter()` overload"]
1731 fn get_chapter(self) -> crate::app::chapterdata::ChapterData {
1732 unsafe {
1733 let __receiver = <RankingSequence as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1734 ::unity::il2cpp_call!((::unity::module_base()+0x237c770usize)as*mut u8,crate::app::chapterdata::ChapterData;
1735(RankingSequence)__receiver)
1736 }
1737 }
1738 #[doc = "`Menu()` overload"]
1739 fn menu(self) -> () {
1740 unsafe {
1741 let __receiver = <RankingSequence as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1742 ::unity::il2cpp_call!((::unity::module_base()+0x237c920usize)as*mut u8,();
1743(RankingSequence)__receiver)
1744 }
1745 }
1746 #[doc = "`ErrorDialog()` overload"]
1747 fn error_dialog(self) -> () {
1748 unsafe {
1749 let __receiver = <RankingSequence as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1750 ::unity::il2cpp_call!((::unity::module_base()+0x237c930usize)as*mut u8,();
1751(RankingSequence)__receiver)
1752 }
1753 }
1754 #[doc = "`DownloadRanking()` overload"]
1755 fn download_ranking(self) -> () {
1756 unsafe {
1757 let __receiver = <RankingSequence as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1758 ::unity::il2cpp_call!((::unity::module_base()+0x237c9c0usize)as*mut u8,();
1759(RankingSequence)__receiver)
1760 }
1761 }
1762 #[doc = "`IsDownloadSuccess()` overload"]
1763 fn is_download_success(self) -> bool {
1764 unsafe {
1765 let __receiver = <RankingSequence as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1766 ::unity::il2cpp_call!((::unity::module_base()+0x237ca50usize)as*mut u8,bool;
1767(RankingSequence)__receiver)
1768 }
1769 }
1770 #[doc = "`OpenRankingMenu()` overload"]
1771 fn open_ranking_menu(self) -> () {
1772 unsafe {
1773 let __receiver = <RankingSequence as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1774 ::unity::il2cpp_call!((::unity::module_base()+0x237cb60usize)as*mut u8,();
1775(RankingSequence)__receiver)
1776 }
1777 }
1778 #[doc = "`CloseRankingMenu()` overload"]
1779 fn close_ranking_menu(self) -> () {
1780 unsafe {
1781 let __receiver = <RankingSequence as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1782 ::unity::il2cpp_call!((::unity::module_base()+0x237ccb0usize)as*mut u8,();
1783(RankingSequence)__receiver)
1784 }
1785 }
1786 #[doc = "`UploadMenu()` overload"]
1787 fn upload_menu(self) -> () {
1788 unsafe {
1789 let __receiver = <RankingSequence as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1790 ::unity::il2cpp_call!((::unity::module_base()+0x237cd80usize)as*mut u8,();
1791(RankingSequence)__receiver)
1792 }
1793 }
1794 #[doc = "`UploadData()` overload"]
1795 fn upload_data(self) -> () {
1796 unsafe {
1797 let __receiver = <RankingSequence as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1798 ::unity::il2cpp_call!((::unity::module_base()+0x237cd90usize)as*mut u8,();
1799(RankingSequence)__receiver)
1800 }
1801 }
1802 #[doc = "`UploadPairsList()` overload"]
1803 fn upload_pairs_list(self) -> () {
1804 unsafe {
1805 let __receiver = <RankingSequence as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1806 ::unity::il2cpp_call!((::unity::module_base()+0x237ceb0usize)as*mut u8,();
1807(RankingSequence)__receiver)
1808 }
1809 }
1810 #[doc = "`AddUploadPairs()` overload"]
1811 fn add_upload_pairs(self) -> () {
1812 unsafe {
1813 let __receiver = <RankingSequence as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1814 ::unity::il2cpp_call!((::unity::module_base()+0x237cff0usize)as*mut u8,();
1815(RankingSequence)__receiver)
1816 }
1817 }
1818 #[doc = "`RandomAddUploadPairs()` overload"]
1819 fn random_add_upload_pairs(self) -> () {
1820 unsafe {
1821 let __receiver = <RankingSequence as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1822 ::unity::il2cpp_call!((::unity::module_base()+0x237d090usize)as*mut u8,();
1823(RankingSequence)__receiver)
1824 }
1825 }
1826 #[doc = "`ClearUploadPairs()` overload"]
1827 fn clear_upload_pairs(self) -> () {
1828 unsafe {
1829 let __receiver = <RankingSequence as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1830 ::unity::il2cpp_call!((::unity::module_base()+0x237d450usize)as*mut u8,();
1831(RankingSequence)__receiver)
1832 }
1833 }
1834 #[doc = "`.ctor(bool)` overload"]
1835 fn ctor(self, is_last_chapter: impl ::core::convert::Into<bool>) -> () {
1836 unsafe {
1837 let __receiver = <RankingSequence as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1838 ::unity::il2cpp_call!((::unity::module_base()+0x237d5a0usize)as*mut u8,();
1839(RankingSequence)__receiver,(bool)::core::convert::Into::into(is_last_chapter))
1840 }
1841 }
1842 #[doc = "`CreateDesc()` overload"]
1843 fn create_desc(self) -> ::unity::Array<crate::app::procdesc::ProcDesc> {
1844 unsafe {
1845 let __receiver = <RankingSequence as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1846 ::unity::il2cpp_call!((::unity::module_base()+0x237d650usize)as*mut u8, ::unity::Array<crate::app::procdesc::ProcDesc> ;
1847(RankingSequence)__receiver)
1848 }
1849 }
1850 #[doc = "`LoadRes()` overload"]
1851 fn load_res(self) -> () {
1852 unsafe {
1853 let __receiver = <RankingSequence as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1854 ::unity::il2cpp_call!((::unity::module_base()+0x237dd40usize)as*mut u8,();
1855(RankingSequence)__receiver)
1856 }
1857 }
1858 #[doc = "`IsLoadingRes()` overload"]
1859 fn is_loading_res(self) -> bool {
1860 unsafe {
1861 let __receiver = <RankingSequence as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1862 ::unity::il2cpp_call!((::unity::module_base()+0x237dde0usize)as*mut u8,bool;
1863(RankingSequence)__receiver)
1864 }
1865 }
1866 #[doc = "`UnloadRes()` overload"]
1867 fn unload_res(self) -> () {
1868 unsafe {
1869 let __receiver = <RankingSequence as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1870 ::unity::il2cpp_call!((::unity::module_base()+0x237de50usize)as*mut u8,();
1871(RankingSequence)__receiver)
1872 }
1873 }
1874}
1875
1876#[cfg(feature = "app-rankingsequence")]
1877impl<__T: IRankingSequence> IRankingSequenceMethods for __T {}
1878
1879#[cfg(feature = "app-rankingsequence")]
1880impl RankingSequence {
1881 pub fn on_create_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1882 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1883 }
1884
1885 pub fn on_dispose_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1886 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1887 }
1888
1889 pub fn get_chapter_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1890 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1891 }
1892
1893 pub fn menu_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1894 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
1895 }
1896
1897 pub fn error_dialog_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1898 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
1899 }
1900
1901 pub fn download_ranking_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1902 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
1903 }
1904
1905 pub fn is_download_success_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1906 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
1907 }
1908
1909 pub fn open_ranking_menu_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1910 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
1911 }
1912
1913 pub fn close_ranking_menu_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1914 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
1915 }
1916
1917 pub fn upload_menu_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1918 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
1919 }
1920
1921 pub fn upload_data_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1922 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
1923 }
1924
1925 pub fn upload_pairs_list_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1926 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
1927 }
1928
1929 pub fn add_upload_pairs_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1930 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
1931 }
1932
1933 pub fn random_add_upload_pairs_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1934 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
1935 }
1936
1937 pub fn clear_upload_pairs_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1938 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[14]
1939 }
1940
1941 pub fn create_bind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1942 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[15]
1943 }
1944
1945 pub fn create_bind_last_chapter_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1946 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[16]
1947 }
1948
1949 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1950 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[17]
1951 }
1952
1953 pub fn create_desc_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1954 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[18]
1955 }
1956
1957 pub fn load_res_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1958 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[19]
1959 }
1960
1961 pub fn is_loading_res_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1962 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[20]
1963 }
1964
1965 pub fn unload_res_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1966 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[21]
1967 }
1968
1969 pub fn get_person_debug_name_by_net_ranking_index_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1970 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[22]
1971 }
1972
1973 pub fn get_god_debug_name_by_net_ranking_index_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1974 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[23]
1975 }
1976}
1977
1978#[cfg(feature = "app-rankingsequence")]
1979impl RankingSequence {
1980 #[doc = "Direct (non-virtual) call to `RankingSequence`'s own `OnCreate`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1981 pub unsafe fn on_create(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
1982 let __mi = Self::on_create_method_info();
1983 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1984 __inner(this.into(), ::core::option::Option::None)
1985 }
1986
1987 #[doc = "Direct (non-virtual) call to `RankingSequence`'s own `OnDispose`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1988 pub unsafe fn on_dispose(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
1989 let __mi = Self::on_dispose_method_info();
1990 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1991 __inner(this.into(), ::core::option::Option::None)
1992 }
1993}
1994
1995#[cfg(feature = "app-rankingsequence")]
1996impl RankingSequence {
1997 #[doc = "`.ctor(bool)` — overload selector"]
1998 pub fn new(is_last_chapter: bool) -> Self {
1999 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2000 panic!(
2001 "{}
2002::{}
2003 failed to instantiate",
2004 ::core::stringify!(RankingSequence),
2005 ::core::stringify!(new),
2006 )
2007 });
2008 <Self as IRankingSequenceMethods>::ctor(this, is_last_chapter);
2009 this
2010 }
2011}
2012
2013#[cfg(feature = "app-rankingsequence")]
2014pub trait IRankingSequence_TopMenu_RankingMenuItemMethods: IRankingSequence_TopMenu_RankingMenuItem {
2015 #[doc = "`get_Label()` overload"]
2016 fn get_label(self) -> crate::app::rankingsequence::RankingSequence_Label {
2017 unsafe {
2018 let __receiver = <RankingSequence_TopMenu_RankingMenuItem as ::unity::FromIlInstance>::from_il_instance(
2019 <Self as ::unity::SystemObject>::as_instance(self),
2020 );
2021 {
2022 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2023 let __vi = *__vt.get(72usize).unwrap_or_else(|| {
2024 panic!(
2025 "unity: virtual slot {}
2026 out of range (vtable len {}
2027) on the runtime class behind {}
2028 (method `{}
2029`)",
2030 72usize,
2031 __vt.len(),
2032 <RankingSequence_TopMenu_RankingMenuItem as ::unity::ClassIdentity>::NAME,
2033 "get_Label",
2034 )
2035 });
2036 let __inner: extern "C" fn(
2037 RankingSequence_TopMenu_RankingMenuItem,
2038 ::unity::OptionalMethod,
2039 ) -> crate::app::rankingsequence::RankingSequence_Label = ::core::mem::transmute(__vi.method_ptr);
2040 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2041 __inner(__receiver, __mi)
2042 }
2043 }
2044 }
2045 #[doc = "`IsEnable()` overload"]
2046 fn is_enable(self) -> bool {
2047 unsafe {
2048 let __receiver = <RankingSequence_TopMenu_RankingMenuItem as ::unity::FromIlInstance>::from_il_instance(
2049 <Self as ::unity::SystemObject>::as_instance(self),
2050 );
2051 {
2052 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2053 let __vi = *__vt.get(22usize).unwrap_or_else(|| {
2054 panic!(
2055 "unity: virtual slot {}
2056 out of range (vtable len {}
2057) on the runtime class behind {}
2058 (method `{}
2059`)",
2060 22usize,
2061 __vt.len(),
2062 <RankingSequence_TopMenu_RankingMenuItem as ::unity::ClassIdentity>::NAME,
2063 "IsEnable",
2064 )
2065 });
2066 let __inner: extern "C" fn(RankingSequence_TopMenu_RankingMenuItem, ::unity::OptionalMethod) -> bool =
2067 ::core::mem::transmute(__vi.method_ptr);
2068 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2069 __inner(__receiver, __mi)
2070 }
2071 }
2072 }
2073 #[doc = "`.ctor()` overload"]
2074 fn ctor(self) -> () {
2075 unsafe {
2076 let __receiver = <RankingSequence_TopMenu_RankingMenuItem as ::unity::FromIlInstance>::from_il_instance(
2077 <Self as ::unity::SystemObject>::as_instance(self),
2078 );
2079 ::unity::il2cpp_call!((::unity::module_base()+0x1b7a060usize)as*mut u8,();
2080(RankingSequence_TopMenu_RankingMenuItem)__receiver)
2081 }
2082 }
2083}
2084
2085#[cfg(feature = "app-rankingsequence")]
2086impl<__T: IRankingSequence_TopMenu_RankingMenuItem> IRankingSequence_TopMenu_RankingMenuItemMethods for __T {}
2087
2088#[cfg(feature = "app-rankingsequence")]
2089impl RankingSequence_TopMenu_RankingMenuItem {
2090 pub fn get_label_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2091 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2092 }
2093
2094 pub fn is_enable_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2095 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2096 }
2097
2098 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2099 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2100 }
2101}
2102
2103#[cfg(feature = "app-rankingsequence")]
2104impl RankingSequence_TopMenu_RankingMenuItem {
2105 #[doc = "Direct (non-virtual) call to `RankingSequence_TopMenu_RankingMenuItem`'s own `get_Label`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2106 pub unsafe fn get_label(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::rankingsequence::RankingSequence_Label {
2107 let __mi = Self::get_label_method_info();
2108 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::rankingsequence::RankingSequence_Label =
2109 ::core::mem::transmute(__mi.method_ptr);
2110 __inner(this.into(), ::core::option::Option::None)
2111 }
2112
2113 #[doc = "Direct (non-virtual) call to `RankingSequence_TopMenu_RankingMenuItem`'s own `IsEnable`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2114 pub unsafe fn is_enable(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
2115 let __mi = Self::is_enable_method_info();
2116 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
2117 __inner(this.into(), ::core::option::Option::None)
2118 }
2119}
2120
2121#[cfg(feature = "app-rankingsequence")]
2122impl RankingSequence_TopMenu_RankingMenuItem {
2123 #[doc = "`.ctor()` — no args"]
2124 pub fn new() -> Self {
2125 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2126 panic!(
2127 "{}
2128::{}
2129 failed to instantiate",
2130 ::core::stringify!(RankingSequence_TopMenu_RankingMenuItem),
2131 ::core::stringify!(new),
2132 )
2133 });
2134 <Self as IRankingSequence_TopMenu_RankingMenuItemMethods>::ctor(this);
2135 this
2136 }
2137}
2138
2139#[cfg(feature = "app-rankingsequence")]
2140impl RankingSequence_UploadPairsMenu {
2141 #[doc = "`CreateBind(crate::app::procinst::ProcInst)` overload"]
2142 pub fn create_bind(super_: impl ::core::convert::Into<crate::app::procinst::ProcInst>) -> () {
2143 unsafe {
2144 ::unity::il2cpp_call!((::unity::module_base()+0x1af5b80usize)as*mut u8,();
2145(crate::app::procinst::ProcInst)::core::convert::Into::into(super_))
2146 }
2147 }
2148}
2149
2150#[cfg(feature = "app-rankingsequence")]
2151pub trait IRankingSequence_UploadPairsMenuMethods: IRankingSequence_UploadPairsMenu {
2152 #[doc = "`.ctor()` overload"]
2153 fn ctor(self) -> () {
2154 unsafe {
2155 let __receiver =
2156 <RankingSequence_UploadPairsMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2157 ::unity::il2cpp_call!((::unity::module_base()+0x1af5df0usize)as*mut u8,();
2158(RankingSequence_UploadPairsMenu)__receiver)
2159 }
2160 }
2161}
2162
2163#[cfg(feature = "app-rankingsequence")]
2164impl<__T: IRankingSequence_UploadPairsMenu> IRankingSequence_UploadPairsMenuMethods for __T {}
2165
2166#[cfg(feature = "app-rankingsequence")]
2167impl RankingSequence_UploadPairsMenu {
2168 pub fn create_bind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2169 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2170 }
2171
2172 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2173 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2174 }
2175}
2176
2177#[cfg(feature = "app-rankingsequence")]
2178impl RankingSequence_UploadPairsMenu {
2179 #[doc = "`.ctor()` — no args"]
2180 pub fn new() -> Self {
2181 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2182 panic!(
2183 "{}
2184::{}
2185 failed to instantiate",
2186 ::core::stringify!(RankingSequence_UploadPairsMenu),
2187 ::core::stringify!(new),
2188 )
2189 });
2190 <Self as IRankingSequence_UploadPairsMenuMethods>::ctor(this);
2191 this
2192 }
2193}
2194
2195#[cfg(feature = "app-rankingsequence")]
2196pub trait IRankingSequence_UploadPairsMenu_ClearUploadPairsMenuItemMethods: IRankingSequence_UploadPairsMenu_ClearUploadPairsMenuItem {
2197 #[doc = "`get_Label()` overload"]
2198 fn get_label(self) -> crate::app::rankingsequence::RankingSequence_Label {
2199 unsafe {
2200 let __receiver = <RankingSequence_UploadPairsMenu_ClearUploadPairsMenuItem as ::unity::FromIlInstance>::from_il_instance(
2201 <Self as ::unity::SystemObject>::as_instance(self),
2202 );
2203 {
2204 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2205 let __vi = *__vt.get(72usize).unwrap_or_else(|| {
2206 panic!(
2207 "unity: virtual slot {}
2208 out of range (vtable len {}
2209) on the runtime class behind {}
2210 (method `{}
2211`)",
2212 72usize,
2213 __vt.len(),
2214 <RankingSequence_UploadPairsMenu_ClearUploadPairsMenuItem as ::unity::ClassIdentity>::NAME,
2215 "get_Label",
2216 )
2217 });
2218 let __inner: extern "C" fn(
2219 RankingSequence_UploadPairsMenu_ClearUploadPairsMenuItem,
2220 ::unity::OptionalMethod,
2221 ) -> crate::app::rankingsequence::RankingSequence_Label = ::core::mem::transmute(__vi.method_ptr);
2222 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2223 __inner(__receiver, __mi)
2224 }
2225 }
2226 }
2227 #[doc = "`IsEnable()` overload"]
2228 fn is_enable(self) -> bool {
2229 unsafe {
2230 let __receiver = <RankingSequence_UploadPairsMenu_ClearUploadPairsMenuItem as ::unity::FromIlInstance>::from_il_instance(
2231 <Self as ::unity::SystemObject>::as_instance(self),
2232 );
2233 {
2234 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2235 let __vi = *__vt.get(22usize).unwrap_or_else(|| {
2236 panic!(
2237 "unity: virtual slot {}
2238 out of range (vtable len {}
2239) on the runtime class behind {}
2240 (method `{}
2241`)",
2242 22usize,
2243 __vt.len(),
2244 <RankingSequence_UploadPairsMenu_ClearUploadPairsMenuItem as ::unity::ClassIdentity>::NAME,
2245 "IsEnable",
2246 )
2247 });
2248 let __inner: extern "C" fn(RankingSequence_UploadPairsMenu_ClearUploadPairsMenuItem, ::unity::OptionalMethod) -> bool =
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, __mi)
2252 }
2253 }
2254 }
2255 #[doc = "`.ctor()` overload"]
2256 fn ctor(self) -> () {
2257 unsafe {
2258 let __receiver = <RankingSequence_UploadPairsMenu_ClearUploadPairsMenuItem as ::unity::FromIlInstance>::from_il_instance(
2259 <Self as ::unity::SystemObject>::as_instance(self),
2260 );
2261 ::unity::il2cpp_call!((::unity::module_base()+0x1b7a1f0usize)as*mut u8,();
2262(RankingSequence_UploadPairsMenu_ClearUploadPairsMenuItem)__receiver)
2263 }
2264 }
2265}
2266
2267#[cfg(feature = "app-rankingsequence")]
2268impl<__T: IRankingSequence_UploadPairsMenu_ClearUploadPairsMenuItem> IRankingSequence_UploadPairsMenu_ClearUploadPairsMenuItemMethods for __T {}
2269
2270#[cfg(feature = "app-rankingsequence")]
2271impl RankingSequence_UploadPairsMenu_ClearUploadPairsMenuItem {
2272 pub fn get_label_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2273 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2274 }
2275
2276 pub fn is_enable_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2277 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2278 }
2279
2280 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2281 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2282 }
2283}
2284
2285#[cfg(feature = "app-rankingsequence")]
2286impl RankingSequence_UploadPairsMenu_ClearUploadPairsMenuItem {
2287 #[doc = "Direct (non-virtual) call to `RankingSequence_UploadPairsMenu_ClearUploadPairsMenuItem`'s own `get_Label`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2288 pub unsafe fn get_label(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::rankingsequence::RankingSequence_Label {
2289 let __mi = Self::get_label_method_info();
2290 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::rankingsequence::RankingSequence_Label =
2291 ::core::mem::transmute(__mi.method_ptr);
2292 __inner(this.into(), ::core::option::Option::None)
2293 }
2294
2295 #[doc = "Direct (non-virtual) call to `RankingSequence_UploadPairsMenu_ClearUploadPairsMenuItem`'s own `IsEnable`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2296 pub unsafe fn is_enable(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
2297 let __mi = Self::is_enable_method_info();
2298 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
2299 __inner(this.into(), ::core::option::Option::None)
2300 }
2301}
2302
2303#[cfg(feature = "app-rankingsequence")]
2304impl RankingSequence_UploadPairsMenu_ClearUploadPairsMenuItem {
2305 #[doc = "`.ctor()` — no args"]
2306 pub fn new() -> Self {
2307 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2308 panic!(
2309 "{}
2310::{}
2311 failed to instantiate",
2312 ::core::stringify!(RankingSequence_UploadPairsMenu_ClearUploadPairsMenuItem),
2313 ::core::stringify!(new),
2314 )
2315 });
2316 <Self as IRankingSequence_UploadPairsMenu_ClearUploadPairsMenuItemMethods>::ctor(this);
2317 this
2318 }
2319}
2320
2321#[cfg(feature = "app-rankingsequence")]
2322pub trait IRankingSequence_UploadPairsMenu_UploadDataMenuItemMethods: IRankingSequence_UploadPairsMenu_UploadDataMenuItem {
2323 #[doc = "`get_Label()` overload"]
2324 fn get_label(self) -> crate::app::rankingsequence::RankingSequence_Label {
2325 unsafe {
2326 let __receiver = <RankingSequence_UploadPairsMenu_UploadDataMenuItem as ::unity::FromIlInstance>::from_il_instance(
2327 <Self as ::unity::SystemObject>::as_instance(self),
2328 );
2329 {
2330 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2331 let __vi = *__vt.get(72usize).unwrap_or_else(|| {
2332 panic!(
2333 "unity: virtual slot {}
2334 out of range (vtable len {}
2335) on the runtime class behind {}
2336 (method `{}
2337`)",
2338 72usize,
2339 __vt.len(),
2340 <RankingSequence_UploadPairsMenu_UploadDataMenuItem as ::unity::ClassIdentity>::NAME,
2341 "get_Label",
2342 )
2343 });
2344 let __inner: extern "C" fn(
2345 RankingSequence_UploadPairsMenu_UploadDataMenuItem,
2346 ::unity::OptionalMethod,
2347 ) -> crate::app::rankingsequence::RankingSequence_Label = ::core::mem::transmute(__vi.method_ptr);
2348 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2349 __inner(__receiver, __mi)
2350 }
2351 }
2352 }
2353 #[doc = "`GetName()` overload"]
2354 fn get_name(self) -> ::unity::Il2CppString {
2355 unsafe {
2356 let __receiver = <RankingSequence_UploadPairsMenu_UploadDataMenuItem as ::unity::FromIlInstance>::from_il_instance(
2357 <Self as ::unity::SystemObject>::as_instance(self),
2358 );
2359 {
2360 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2361 let __vi = *__vt.get(5usize).unwrap_or_else(|| {
2362 panic!(
2363 "unity: virtual slot {}
2364 out of range (vtable len {}
2365) on the runtime class behind {}
2366 (method `{}
2367`)",
2368 5usize,
2369 __vt.len(),
2370 <RankingSequence_UploadPairsMenu_UploadDataMenuItem as ::unity::ClassIdentity>::NAME,
2371 "GetName",
2372 )
2373 });
2374 let __inner: extern "C" fn(RankingSequence_UploadPairsMenu_UploadDataMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
2375 ::core::mem::transmute(__vi.method_ptr);
2376 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2377 __inner(__receiver, __mi)
2378 }
2379 }
2380 }
2381 #[doc = "`IsEnable()` overload"]
2382 fn is_enable(self) -> bool {
2383 unsafe {
2384 let __receiver = <RankingSequence_UploadPairsMenu_UploadDataMenuItem as ::unity::FromIlInstance>::from_il_instance(
2385 <Self as ::unity::SystemObject>::as_instance(self),
2386 );
2387 {
2388 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2389 let __vi = *__vt.get(22usize).unwrap_or_else(|| {
2390 panic!(
2391 "unity: virtual slot {}
2392 out of range (vtable len {}
2393) on the runtime class behind {}
2394 (method `{}
2395`)",
2396 22usize,
2397 __vt.len(),
2398 <RankingSequence_UploadPairsMenu_UploadDataMenuItem as ::unity::ClassIdentity>::NAME,
2399 "IsEnable",
2400 )
2401 });
2402 let __inner: extern "C" fn(RankingSequence_UploadPairsMenu_UploadDataMenuItem, ::unity::OptionalMethod) -> bool =
2403 ::core::mem::transmute(__vi.method_ptr);
2404 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2405 __inner(__receiver, __mi)
2406 }
2407 }
2408 }
2409 #[doc = "`.ctor()` overload"]
2410 fn ctor(self) -> () {
2411 unsafe {
2412 let __receiver = <RankingSequence_UploadPairsMenu_UploadDataMenuItem as ::unity::FromIlInstance>::from_il_instance(
2413 <Self as ::unity::SystemObject>::as_instance(self),
2414 );
2415 ::unity::il2cpp_call!((::unity::module_base()+0x1b7a600usize)as*mut u8,();
2416(RankingSequence_UploadPairsMenu_UploadDataMenuItem)__receiver)
2417 }
2418 }
2419}
2420
2421#[cfg(feature = "app-rankingsequence")]
2422impl<__T: IRankingSequence_UploadPairsMenu_UploadDataMenuItem> IRankingSequence_UploadPairsMenu_UploadDataMenuItemMethods for __T {}
2423
2424#[cfg(feature = "app-rankingsequence")]
2425impl RankingSequence_UploadPairsMenu_UploadDataMenuItem {
2426 pub fn get_label_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2427 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2428 }
2429
2430 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2431 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2432 }
2433
2434 pub fn is_enable_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2435 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2436 }
2437
2438 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2439 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
2440 }
2441}
2442
2443#[cfg(feature = "app-rankingsequence")]
2444impl RankingSequence_UploadPairsMenu_UploadDataMenuItem {
2445 #[doc = "Direct (non-virtual) call to `RankingSequence_UploadPairsMenu_UploadDataMenuItem`'s own `get_Label`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2446 pub unsafe fn get_label(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::rankingsequence::RankingSequence_Label {
2447 let __mi = Self::get_label_method_info();
2448 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::rankingsequence::RankingSequence_Label =
2449 ::core::mem::transmute(__mi.method_ptr);
2450 __inner(this.into(), ::core::option::Option::None)
2451 }
2452
2453 #[doc = "Direct (non-virtual) call to `RankingSequence_UploadPairsMenu_UploadDataMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2454 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2455 let __mi = Self::get_name_method_info();
2456 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2457 __inner(this.into(), ::core::option::Option::None)
2458 }
2459
2460 #[doc = "Direct (non-virtual) call to `RankingSequence_UploadPairsMenu_UploadDataMenuItem`'s own `IsEnable`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2461 pub unsafe fn is_enable(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
2462 let __mi = Self::is_enable_method_info();
2463 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
2464 __inner(this.into(), ::core::option::Option::None)
2465 }
2466}
2467
2468#[cfg(feature = "app-rankingsequence")]
2469impl RankingSequence_UploadPairsMenu_UploadDataMenuItem {
2470 #[doc = "`.ctor()` — no args"]
2471 pub fn new() -> Self {
2472 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2473 panic!(
2474 "{}
2475::{}
2476 failed to instantiate",
2477 ::core::stringify!(RankingSequence_UploadPairsMenu_UploadDataMenuItem),
2478 ::core::stringify!(new),
2479 )
2480 });
2481 <Self as IRankingSequence_UploadPairsMenu_UploadDataMenuItemMethods>::ctor(this);
2482 this
2483 }
2484}
2485
2486#[cfg(feature = "app-rankingsequence")]
2487pub trait IRankingSequence_TopMenu_UploadMenuItemMethods: IRankingSequence_TopMenu_UploadMenuItem {
2488 #[doc = "`get_Label()` overload"]
2489 fn get_label(self) -> crate::app::rankingsequence::RankingSequence_Label {
2490 unsafe {
2491 let __receiver = <RankingSequence_TopMenu_UploadMenuItem as ::unity::FromIlInstance>::from_il_instance(
2492 <Self as ::unity::SystemObject>::as_instance(self),
2493 );
2494 {
2495 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2496 let __vi = *__vt.get(72usize).unwrap_or_else(|| {
2497 panic!(
2498 "unity: virtual slot {}
2499 out of range (vtable len {}
2500) on the runtime class behind {}
2501 (method `{}
2502`)",
2503 72usize,
2504 __vt.len(),
2505 <RankingSequence_TopMenu_UploadMenuItem as ::unity::ClassIdentity>::NAME,
2506 "get_Label",
2507 )
2508 });
2509 let __inner: extern "C" fn(
2510 RankingSequence_TopMenu_UploadMenuItem,
2511 ::unity::OptionalMethod,
2512 ) -> crate::app::rankingsequence::RankingSequence_Label = ::core::mem::transmute(__vi.method_ptr);
2513 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2514 __inner(__receiver, __mi)
2515 }
2516 }
2517 }
2518 #[doc = "`IsEnable()` overload"]
2519 fn is_enable(self) -> bool {
2520 unsafe {
2521 let __receiver = <RankingSequence_TopMenu_UploadMenuItem as ::unity::FromIlInstance>::from_il_instance(
2522 <Self as ::unity::SystemObject>::as_instance(self),
2523 );
2524 {
2525 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2526 let __vi = *__vt.get(22usize).unwrap_or_else(|| {
2527 panic!(
2528 "unity: virtual slot {}
2529 out of range (vtable len {}
2530) on the runtime class behind {}
2531 (method `{}
2532`)",
2533 22usize,
2534 __vt.len(),
2535 <RankingSequence_TopMenu_UploadMenuItem as ::unity::ClassIdentity>::NAME,
2536 "IsEnable",
2537 )
2538 });
2539 let __inner: extern "C" fn(RankingSequence_TopMenu_UploadMenuItem, ::unity::OptionalMethod) -> bool =
2540 ::core::mem::transmute(__vi.method_ptr);
2541 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2542 __inner(__receiver, __mi)
2543 }
2544 }
2545 }
2546 #[doc = "`.ctor()` overload"]
2547 fn ctor(self) -> () {
2548 unsafe {
2549 let __receiver = <RankingSequence_TopMenu_UploadMenuItem as ::unity::FromIlInstance>::from_il_instance(
2550 <Self as ::unity::SystemObject>::as_instance(self),
2551 );
2552 ::unity::il2cpp_call!((::unity::module_base()+0x1b7a100usize)as*mut u8,();
2553(RankingSequence_TopMenu_UploadMenuItem)__receiver)
2554 }
2555 }
2556}
2557
2558#[cfg(feature = "app-rankingsequence")]
2559impl<__T: IRankingSequence_TopMenu_UploadMenuItem> IRankingSequence_TopMenu_UploadMenuItemMethods for __T {}
2560
2561#[cfg(feature = "app-rankingsequence")]
2562impl RankingSequence_TopMenu_UploadMenuItem {
2563 pub fn get_label_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2564 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2565 }
2566
2567 pub fn is_enable_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2568 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2569 }
2570
2571 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2572 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2573 }
2574}
2575
2576#[cfg(feature = "app-rankingsequence")]
2577impl RankingSequence_TopMenu_UploadMenuItem {
2578 #[doc = "Direct (non-virtual) call to `RankingSequence_TopMenu_UploadMenuItem`'s own `get_Label`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2579 pub unsafe fn get_label(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::rankingsequence::RankingSequence_Label {
2580 let __mi = Self::get_label_method_info();
2581 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::rankingsequence::RankingSequence_Label =
2582 ::core::mem::transmute(__mi.method_ptr);
2583 __inner(this.into(), ::core::option::Option::None)
2584 }
2585
2586 #[doc = "Direct (non-virtual) call to `RankingSequence_TopMenu_UploadMenuItem`'s own `IsEnable`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2587 pub unsafe fn is_enable(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
2588 let __mi = Self::is_enable_method_info();
2589 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
2590 __inner(this.into(), ::core::option::Option::None)
2591 }
2592}
2593
2594#[cfg(feature = "app-rankingsequence")]
2595impl RankingSequence_TopMenu_UploadMenuItem {
2596 #[doc = "`.ctor()` — no args"]
2597 pub fn new() -> Self {
2598 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2599 panic!(
2600 "{}
2601::{}
2602 failed to instantiate",
2603 ::core::stringify!(RankingSequence_TopMenu_UploadMenuItem),
2604 ::core::stringify!(new),
2605 )
2606 });
2607 <Self as IRankingSequence_TopMenu_UploadMenuItemMethods>::ctor(this);
2608 this
2609 }
2610}
2611
2612#[cfg(feature = "app-rankingsequence")]
2613#[doc(hidden)]
2614pub mod prelude {
2615 pub use super::{
2616 IRankingSequence, IRankingSequenceMethods, IRankingSequence_PairMenuItem, IRankingSequence_PairMenuItemMethods, IRankingSequence_TopMenu,
2617 IRankingSequence_TopMenuMethods, IRankingSequence_TopMenu_BaseMenuItem, IRankingSequence_TopMenu_BaseMenuItemMethods,
2618 IRankingSequence_TopMenu_ChapterSelect, IRankingSequence_TopMenu_ChapterSelectMethods, IRankingSequence_TopMenu_RankingMenuItem,
2619 IRankingSequence_TopMenu_RankingMenuItemMethods, IRankingSequence_TopMenu_UploadMenuItem, IRankingSequence_TopMenu_UploadMenuItemMethods,
2620 IRankingSequence_UploadPairsMenu, IRankingSequence_UploadPairsMenuMethods, IRankingSequence_UploadPairsMenu_AddUploadPairsMenuItem,
2621 IRankingSequence_UploadPairsMenu_AddUploadPairsMenuItemMethods, IRankingSequence_UploadPairsMenu_ClearUploadPairsMenuItem,
2622 IRankingSequence_UploadPairsMenu_ClearUploadPairsMenuItemMethods, IRankingSequence_UploadPairsMenu_RandomAddUploadPairsMenuItem,
2623 IRankingSequence_UploadPairsMenu_RandomAddUploadPairsMenuItemMethods, IRankingSequence_UploadPairsMenu_UploadDataMenuItem,
2624 IRankingSequence_UploadPairsMenu_UploadDataMenuItemMethods, IRankingSequence_UploadPairsMenu_UploadGodMenuItem,
2625 IRankingSequence_UploadPairsMenu_UploadGodMenuItemMethods, IRankingSequence_UploadPairsMenu_UploadPairMenuItem,
2626 IRankingSequence_UploadPairsMenu_UploadPairMenuItemMethods, IRankingSequence_UploadPairsMenu_UploadPersonMenuItem,
2627 IRankingSequence_UploadPairsMenu_UploadPersonMenuItemMethods, RankingSequence, RankingSequence_Label, RankingSequence_PairMenuItem,
2628 RankingSequence_TopMenu, RankingSequence_TopMenu_BaseMenuItem, RankingSequence_TopMenu_ChapterSelect,
2629 RankingSequence_TopMenu_RankingMenuItem, RankingSequence_TopMenu_UploadMenuItem, RankingSequence_UploadPairsMenu,
2630 RankingSequence_UploadPairsMenu_AddUploadPairsMenuItem, RankingSequence_UploadPairsMenu_ClearUploadPairsMenuItem,
2631 RankingSequence_UploadPairsMenu_RandomAddUploadPairsMenuItem, RankingSequence_UploadPairsMenu_UploadDataMenuItem,
2632 RankingSequence_UploadPairsMenu_UploadGodMenuItem, RankingSequence_UploadPairsMenu_UploadPairMenuItem,
2633 RankingSequence_UploadPairsMenu_UploadPersonMenuItem,
2634 };
2635 #[cfg(feature = "app-menuitem")]
2636 pub use crate::app::menuitem::IMenuItemMethods;
2637 #[cfg(feature = "app-procinst")]
2638 pub use crate::app::procinst::IProcInstMethods;
2639 #[cfg(feature = "app-singletonprocinst_1")]
2640 pub use crate::app::singletonprocinst_1::ISingletonProcInst_1Methods;
2641 #[cfg(feature = "system-object")]
2642 pub use crate::system::object::IObjectMethods;
2643 #[cfg(feature = "system-enum")]
2644 pub use crate::system::r#enum::IEnumMethods;
2645 #[cfg(feature = "system-valuetype")]
2646 pub use crate::system::valuetype::IValueTypeMethods;
2647 pub use crate::{
2648 app::{menuitem::IMenuItem, procinst::IProcInst, singletonprocinst_1::ISingletonProcInst_1},
2649 system::{object::IObject, r#enum::IEnum, valuetype::IValueType},
2650 };
2651}