mirror of
https://github.com/pret/pokestadium.git
synced 2026-03-21 17:24:20 -05:00
Merge pull request #227 from dplewis/match-various
Some checks failed
C/C++ CI / build (push) Has been cancelled
Some checks failed
C/C++ CI / build (push) Has been cancelled
Match various functions
This commit is contained in:
Revo
GitHub
commit
223521eda8
162
src/2D340.c
162
src/2D340.c
|
|
@ -226,9 +226,167 @@ s32* func_8002CD58(s32* arg0, s32* arg1, s32* arg2, s32 (*arg3)(s32, s32)) {
|
|||
: arg0;
|
||||
}
|
||||
|
||||
#pragma GLOBAL_ASM("asm/us/nonmatchings/2D340/func_8002CE34.s")
|
||||
#ifdef NON_MATCHING
|
||||
void func_8002CE34(void** base, s32 n, s32 (*cmp)(s32, s32)) {
|
||||
void** sp8C;
|
||||
s32 temp_s1;
|
||||
s32 temp_s2;
|
||||
s32 temp_s3;
|
||||
void* temp_s4;
|
||||
s32 temp_s4_2;
|
||||
void* temp_t7_2;
|
||||
void* temp_t8;
|
||||
void* temp_v0;
|
||||
s32 temp_v0_2;
|
||||
void* temp_v0_3;
|
||||
void* temp_v0_4;
|
||||
void* temp_v0_5;
|
||||
s32 temp_v0_6;
|
||||
s32 temp_v0_7;
|
||||
s32 var_a2_2;
|
||||
s32 var_a2_3;
|
||||
s32 var_v0;
|
||||
s32 var_v0_2;
|
||||
void** var_a2;
|
||||
void** temp_t5;
|
||||
void** temp_t7;
|
||||
void** var_s0;
|
||||
void** var_s0_2;
|
||||
void** var_s1;
|
||||
void** var_s1_2;
|
||||
void** var_s2;
|
||||
void** var_s2_2;
|
||||
void** var_s3;
|
||||
s32 pad[1];
|
||||
void** sp44;
|
||||
|
||||
void func_8002CE34(u8*, s32, s32 (*arg1)(s32, s32));
|
||||
while(1) {
|
||||
var_s2 = base;
|
||||
if (n < 7) {
|
||||
temp_t7 = n + base;
|
||||
sp44 = temp_t7;
|
||||
var_s1 = base;
|
||||
if (base < temp_t7) {
|
||||
do {
|
||||
var_s0 = var_s1;
|
||||
if ((base < var_s1) && (cmp(*(var_s1 - 1), *var_s1) > 0)) {
|
||||
while(1) {
|
||||
temp_v0 = *var_s0;
|
||||
temp_t8 = *(var_s0 - 1);
|
||||
var_s0 -= 1;
|
||||
*var_s0 = temp_v0;
|
||||
*(var_s0 + 1) = temp_t8;
|
||||
if (base < var_s0) {
|
||||
if (cmp(*(var_s0 - 1), *var_s0) > 0) {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
var_s1 += 1;
|
||||
} while (var_s1 < sp44);
|
||||
}
|
||||
} else {
|
||||
sp8C = ((n / 2) * 1) + base;
|
||||
if (n >= 8) {
|
||||
var_a2 = ((n * 4) + base) - 4;
|
||||
if (n >= 0x29) {
|
||||
temp_v0_2 = n / 8;
|
||||
temp_s1 = temp_v0_2 * 4;
|
||||
temp_s3 = temp_v0_2 * 8;
|
||||
var_s2 = func_8002CD58(base, temp_s1 + base, temp_s3 + base, cmp);
|
||||
sp8C = func_8002CD58(sp8C - temp_s1, sp8C, &sp8C[temp_v0_2], cmp);
|
||||
var_a2 = func_8002CD58(var_a2 - temp_s3, var_a2 - temp_s1, var_a2, cmp);
|
||||
}
|
||||
sp8C = func_8002CD58(var_s2, sp8C, var_a2, cmp);
|
||||
}
|
||||
temp_t5 = (n * 4) + base;
|
||||
var_s3 = temp_t5 - 4;
|
||||
temp_s4 = *sp8C;
|
||||
sp44 = temp_t5;
|
||||
var_s0_2 = var_s3;
|
||||
var_s2_2 = base;
|
||||
var_s1_2 = base;
|
||||
loop_14:
|
||||
if (var_s0_2 >= var_s1_2) {
|
||||
var_v0 = cmp(*var_s1_2, temp_s4);
|
||||
if (var_v0 <= 0) {
|
||||
loop_16:
|
||||
if (var_v0 == 0) {
|
||||
temp_v0_3 = *var_s2_2;
|
||||
var_s2_2 += 1;
|
||||
*(var_s2_2 - 1) = *var_s1_2;
|
||||
*var_s1_2 = temp_v0_3;
|
||||
}
|
||||
var_s1_2 += 1;
|
||||
if (var_s0_2 >= var_s1_2) {
|
||||
var_v0 = cmp(*var_s1_2, temp_s4);
|
||||
if (var_v0 <= 0) {
|
||||
goto loop_16;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if (var_s0_2 >= var_s1_2) {
|
||||
var_v0_2 = cmp(*var_s0_2, temp_s4);
|
||||
if (var_v0_2 >= 0) {
|
||||
loop_22:
|
||||
if (var_v0_2 == 0) {
|
||||
temp_t7_2 = *var_s3;
|
||||
temp_v0_4 = *var_s0_2;
|
||||
var_s3 -= 1;
|
||||
*var_s0_2 = temp_t7_2;
|
||||
*(var_s3 + 1) = temp_v0_4;
|
||||
}
|
||||
var_s0_2 -= 1;
|
||||
if (var_s0_2 >= var_s1_2) {
|
||||
var_v0_2 = cmp(*var_s0_2, temp_s4);
|
||||
if (var_v0_2 >= 0) {
|
||||
goto loop_22;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if (var_s0_2 >= var_s1_2) {
|
||||
temp_v0_5 = *var_s1_2;
|
||||
var_s1_2 += 1;
|
||||
*(var_s1_2 - 1) = *var_s0_2;
|
||||
var_s0_2 -= 1;
|
||||
*(var_s0_2 + 1) = temp_v0_5;
|
||||
goto loop_14;
|
||||
}
|
||||
temp_s4_2 = (s32) (var_s1_2 - var_s2_2);
|
||||
temp_v0_6 = (s32) (var_s2_2 - base);
|
||||
if (temp_v0_6 < temp_s4_2) {
|
||||
var_a2_2 = temp_v0_6;
|
||||
} else {
|
||||
var_a2_2 = temp_s4_2;
|
||||
}
|
||||
func_8002CCC4(base, var_s1_2 - var_a2_2, var_a2_2);
|
||||
temp_s2 = (s32) (var_s3 - var_s0_2);
|
||||
temp_v0_7 = ((s32) (sp44 - var_s3)) - 1;
|
||||
if (temp_s2 < temp_v0_7) {
|
||||
var_a2_3 = temp_s2;
|
||||
} else {
|
||||
var_a2_3 = temp_v0_7;
|
||||
}
|
||||
func_8002CCC4(var_s1_2, sp44 - var_a2_3, var_a2_3);
|
||||
if (temp_s4_2 >= 2) {
|
||||
func_8002CE34(base, temp_s4_2, cmp);
|
||||
}
|
||||
if (temp_s2 >= 2) {
|
||||
base = sp44 - temp_s2;
|
||||
n = temp_s2;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
}
|
||||
#else
|
||||
#pragma GLOBAL_ASM("asm/us/nonmatchings/2D340/func_8002CE34.s")
|
||||
#endif
|
||||
|
||||
void func_8002D180(unk_func_8830867C_02C_0CC* arg0, s32 (*arg1)(s32, s32)) {
|
||||
func_8002CE34(arg0->unk_00, arg0->unk_08, arg1);
|
||||
|
|
|
|||
165
src/30640.c
165
src/30640.c
|
|
@ -1,6 +1,7 @@
|
|||
#include "30640.h"
|
||||
#include "include/math.h"
|
||||
#include "src/fragments/15/fragment15.h"
|
||||
#include "src/fragments/31/fragment31.h"
|
||||
#include "src/fragments/34/fragment34.h"
|
||||
#include "src/11BA0.h"
|
||||
#include "src/12D80.h"
|
||||
|
|
@ -37,6 +38,11 @@ typedef struct unk_func_8003013C_arg1 {
|
|||
/* 0x1E */ s16 unk_1E;
|
||||
} unk_func_8003013C_arg1; // size >= 0x20
|
||||
|
||||
typedef struct unk_func_80031660_sp24 {
|
||||
/* 0x00 */ u8 pad00[0x18];
|
||||
/* 0x18 */ s32 unk_18;
|
||||
} unk_func_80031660_sp24; // size = 0x1C
|
||||
|
||||
extern unk_func_80031270* D_80075F80;
|
||||
extern unk_func_80031270* D_80075F84;
|
||||
extern u32* D_80075F88;
|
||||
|
|
@ -410,7 +416,7 @@ void func_800302A4(s32 arg0, s32 arg1) {
|
|||
|
||||
#ifdef NON_MATCHING
|
||||
s32 func_800303C8(s32 arg0, UNUSED GraphNode* arg1) {
|
||||
char* sp16C;
|
||||
char* sp16C;
|
||||
u8* sp40;
|
||||
char* temp_s2;
|
||||
s32 temp_v0;
|
||||
|
|
@ -665,8 +671,85 @@ unk_func_80031270* func_80031270(s16 arg0, s16 arg1, unk_D_80068BB0* arg2, unk_D
|
|||
return temp_v0;
|
||||
}
|
||||
|
||||
void func_80031390(unk_func_80031270*);
|
||||
#pragma GLOBAL_ASM("asm/us/nonmatchings/30640/func_80031390.s")
|
||||
typedef union unk_func_80026268_arg0_000_raw {
|
||||
struct {
|
||||
u8 unk_00;
|
||||
u8 unk_01;
|
||||
u16 unk_02;
|
||||
};
|
||||
f32 raw;
|
||||
} unk_func_80026268_arg0_000_raw; // size = 0x4
|
||||
|
||||
typedef struct unk_func_80026268_arg0_raw {
|
||||
/* 0x00 */ unk_func_80026268_arg0_000_raw unk_00;
|
||||
/* 0x04 */ u8 unk_04;
|
||||
/* 0x05 */ u8 unk_05;
|
||||
/* 0x06 */ s16 unk_06;
|
||||
/* 0x08 */ u8 unk_08;
|
||||
/* 0x09 */ u8 unk_09[4];
|
||||
/* 0x0D */ u8 pad0D;
|
||||
/* 0x0E */ u16 unk_0E;
|
||||
/* 0x10 */ u32 unk_10;
|
||||
/* 0x14 */ u16 unk_14;
|
||||
/* 0x16 */ u16 unk_16;
|
||||
/* 0x18 */ u16 unk_18;
|
||||
/* 0x1A */ u16 unk_1A;
|
||||
/* 0x1C */ u16 unk_1C;
|
||||
/* 0x1E */ u16 unk_1E;
|
||||
/* 0x20 */ u8 unk_20[4];
|
||||
/* 0x24 */ u8 unk_24;
|
||||
/* 0x25 */ u8 unk_25;
|
||||
/* 0x26 */ u16 unk_26;
|
||||
/* 0x28 */ u16 unk_28;
|
||||
/* 0x2A */ u16 unk_2A;
|
||||
/* 0x2C */ u16 unk_2C;
|
||||
/* 0x2E */ u16 unk_2E;
|
||||
/* 0x30 */ u8 unk_30[11];
|
||||
/* 0x3B */ u8 unk_3B[11];
|
||||
/* 0x46 */ u8 unk_46[11];
|
||||
/* 0x51 */ char unk51[0x1];
|
||||
/* 0x52 */ u8 unk_52;
|
||||
/* 0x53 */ u8 unk_53;
|
||||
} unk_func_80026268_arg0_raw; // size = 0x54
|
||||
|
||||
typedef struct unk_D_83403C60_raw {
|
||||
/* 0x00 */ unk_func_80026268_arg0_raw unk_00;
|
||||
/* 0x54 */ char unk54[0x18];
|
||||
/* 0x6C */ u8 unk_6C;
|
||||
/* 0x6D */ char unk6D[0x3];
|
||||
/* 0x70 */ unk_D_83407AC8 unk_70;
|
||||
/* 0x8A */ char unk8A[0x2];
|
||||
} unk_D_83403C60_raw; // size = 0x8C
|
||||
|
||||
void func_80031390(unk_func_80031270* arg0) {
|
||||
s32 sp94;
|
||||
arg1_func_80010CA8 sp90;
|
||||
UNUSED s32 pad[3]; // unk_func_80026268_arg0 potentially bigger?
|
||||
unk_func_80026268_arg0 sp30;
|
||||
unk_D_83403C60_raw* temp_s1;
|
||||
void (*sp28)(void*, u32);
|
||||
|
||||
temp_s1 = (unk_D_83403C60_raw*)arg0->unk_18;
|
||||
func_80031140(&sp30, &temp_s1->unk_70);
|
||||
func_8000E88C(&arg0->unk_20->unk_024, 0, temp_s1->unk_00.unk_00.raw, 0); //?
|
||||
arg0->unk_20->unk_0A6 = 0xFE;
|
||||
sp94 = sp30.unk_00.unk_00;
|
||||
if (sp30.unk_00.unk_00 == 0x99) {
|
||||
sp30.unk_00.unk_00 = 0x19;
|
||||
}
|
||||
func_8001BEE8(&sp90, &sp30);
|
||||
sp30.unk_00.unk_00 = sp94;
|
||||
func_800198E4(arg0->unk_10, sp30.unk_00.unk_00, sp90);
|
||||
func_80019CA8(arg0->unk_10);
|
||||
func_8001BCF0(arg0->unk_20);
|
||||
func_8001BC34(arg0->unk_20, 0, sp30.unk_00.unk_00, arg0->unk_10->unk_24->unk_08->unk_00[0]);
|
||||
sp28 = Util_ConvertAddrToVirtAddr(&func_81002260);
|
||||
sp28(arg0->unk_20, Util_ConvertAddrToVirtAddr(&temp_s1->unk_00.unk_09[1]));
|
||||
func_8001BD04(arg0->unk_20, temp_s1->unk_00.unk_05);
|
||||
func_80017464(arg0->unk_20, temp_s1->unk_00.unk_06);
|
||||
func_8001BD9C(arg0->unk_20, temp_s1->unk_00.unk_08);
|
||||
func_80017804(arg0->unk_20, (s16)temp_s1->unk_00.unk_09[0]);
|
||||
}
|
||||
|
||||
void func_800314BC(unk_func_80031270* arg0) {
|
||||
MemoryBlock* sp24;
|
||||
|
|
@ -711,58 +794,56 @@ void func_800314BC(unk_func_80031270* arg0) {
|
|||
temp_v1->unk_01 = (u8) (temp_v1->unk_01 | 1);
|
||||
}
|
||||
|
||||
#ifdef NON_MATCHING
|
||||
u8* func_80031660(unk_func_80031270* arg0) {
|
||||
void* sp24;
|
||||
unk_func_80031660_sp24* sp24;
|
||||
void (*sp20)();
|
||||
u32 temp_v0_2;
|
||||
void* v0_ptr;
|
||||
|
||||
sp24 = (arg0->unk_18 + 0x50);
|
||||
sp24 = (unk_func_80031660_sp24*)((u8*)arg0->unk_18 + 0x50);
|
||||
sp20 = Util_ConvertAddrToVirtAddr(&func_8140C734);
|
||||
D_80075F84 = arg0;
|
||||
if (arg0->unk_00 == 1) {
|
||||
if (arg0->unk_02 != 1) {
|
||||
if (arg0->unk_02 == 2) {
|
||||
switch (arg0->unk_02) {
|
||||
case 2:
|
||||
func_80031390(arg0);
|
||||
func_800314BC(arg0);
|
||||
}
|
||||
} else {
|
||||
func_80006498(&gDisplayListHead, arg0->unk_08);
|
||||
temp_v0_2 = arg0->unk_34;
|
||||
if ((temp_v0_2 == -1U) || (temp_v0_2 == 0)) {
|
||||
func_8000699C(&gDisplayListHead, 1);
|
||||
} else if (temp_v0_2 < 0x10000U) {
|
||||
func_8000699C(&gDisplayListHead, temp_v0_2 & 0xFFFF);
|
||||
} else {
|
||||
func_8000699C(&gDisplayListHead, 0xA6BF);
|
||||
}
|
||||
func_80015348();
|
||||
v0_ptr = Util_ConvertAddrToVirtAddr(&D_8140E6B8);
|
||||
v0_ptr = (s32) sp24;
|
||||
sp20();
|
||||
func_80015094(arg0->unk_1C);
|
||||
break;
|
||||
case 1:
|
||||
func_80006498(&gDisplayListHead, arg0->unk_08);
|
||||
|
||||
if ((arg0->unk_34 == -1) || (arg0->unk_34 == 0)) {
|
||||
func_8000699C(&gDisplayListHead, 1);
|
||||
} else if (arg0->unk_34 < 0x10000U) {
|
||||
func_8000699C(&gDisplayListHead, arg0->unk_34);
|
||||
} else {
|
||||
func_8000699C(&gDisplayListHead, 0xA6BF);
|
||||
}
|
||||
func_80015348();
|
||||
*((s32*)Util_ConvertAddrToVirtAddr(&D_8140E6B8)) = sp24->unk_18;
|
||||
sp20();
|
||||
func_80015094(arg0->unk_1C);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
}
|
||||
switch (arg0->unk_00) { /* irregular */
|
||||
case 0:
|
||||
arg0->unk_00 = 1U;
|
||||
arg0->unk_02 = 2;
|
||||
break;
|
||||
case 1:
|
||||
arg0->unk_02--;
|
||||
if (arg0->unk_02 <= 0) {
|
||||
arg0->unk_00 = 2U;
|
||||
}
|
||||
break;
|
||||
case 2:
|
||||
break;
|
||||
switch (arg0->unk_00) {
|
||||
case 0:
|
||||
arg0->unk_00 = 1;
|
||||
arg0->unk_02 = 2;
|
||||
break;
|
||||
case 1:
|
||||
arg0->unk_02--;
|
||||
if (arg0->unk_02 <= 0) {
|
||||
arg0->unk_00 = 2;
|
||||
}
|
||||
break;
|
||||
case 2:
|
||||
break;
|
||||
}
|
||||
return arg0->unk_08->img_p;
|
||||
}
|
||||
#else
|
||||
#pragma GLOBAL_ASM("asm/us/nonmatchings/30640/func_80031660.s")
|
||||
#endif
|
||||
|
||||
s32 func_800317D8(unk_func_80031270* arg0) {
|
||||
s32 var_v1;
|
||||
s32 sp1C;
|
||||
|
|
|
|||
20
src/38BB0.c
20
src/38BB0.c
|
|
@ -488,9 +488,8 @@ void func_80038B54(u8* arg0, u32 arg1) {
|
|||
*arg0++ = arg1 & 0xFF;
|
||||
}
|
||||
|
||||
#ifdef NON_MATCHING
|
||||
s32 func_80038B68(sp38_func_800373D8* arg0) {
|
||||
UNUSED s32 pad[2];
|
||||
UNUSED s32 pad[1];
|
||||
s32 i;
|
||||
ALSynConfig sp4C;
|
||||
amConfig sp40;
|
||||
|
|
@ -507,18 +506,16 @@ s32 func_80038B68(sp38_func_800373D8* arg0) {
|
|||
func_8003C1D0(arg0->unk_0C, 0, arg0->unk_10);
|
||||
alHeapInit(&D_800FC7B8, arg0->unk_0C, arg0->unk_10);
|
||||
D_800FC810 = &D_800FC7B8;
|
||||
D_800FC7D0 = alHeapAlloc(&D_800FC7B8, 1, D_800FC7CC * sizeof(unk_D_800FC7D0));
|
||||
func_8003C1D0(D_800FC7D0, 0, D_800FC7CC * sizeof(unk_D_800FC7D0));
|
||||
D_800FC7D0 = alHeapDBAlloc(NULL, 0, &D_800FC7B8, 1, D_800FC7CC * sizeof(unk_D_800FC7D0));
|
||||
func_8003C1D0((u8*)D_800FC7D0, 0, D_800FC7CC * sizeof(unk_D_800FC7D0));
|
||||
|
||||
D_800FC7E8 = alHeapAlloc(&D_800FC7B8, 1, arg0->unk_2C);
|
||||
D_800FC7E8 = alHeapDBAlloc(NULL, 0, &D_800FC7B8, 1, arg0->unk_2C);
|
||||
D_800FC7EC = 0;
|
||||
D_800FC7F0 = arg0->unk_2C;
|
||||
|
||||
D_800FC7FC = alHeapAlloc(&D_800FC7B8, arg0->unk_04, sizeof(unk_D_800FC7D0_148));
|
||||
D_800FC804 = NULL;
|
||||
D_800FC800 = NULL;
|
||||
D_800FC808 = NULL;
|
||||
D_800FC80C = NULL;
|
||||
D_800FC7FC = alHeapDBAlloc(NULL, 0, &D_800FC7B8, arg0->unk_04, sizeof(unk_D_800FC7D0_148));
|
||||
D_800FC800 = D_800FC804 = NULL;
|
||||
D_800FC808 = D_800FC80C = NULL;
|
||||
D_800FC818 = 0;
|
||||
D_800FC81C = 0;
|
||||
|
||||
|
|
@ -563,9 +560,6 @@ s32 func_80038B68(sp38_func_800373D8* arg0) {
|
|||
|
||||
return D_800FC7B8.cur - D_800FC7B8.base;
|
||||
}
|
||||
#else
|
||||
#pragma GLOBAL_ASM("asm/us/nonmatchings/38BB0/func_80038B68.s")
|
||||
#endif
|
||||
|
||||
void func_80038E98(s32 arg0, u32 arg1) {
|
||||
u8* temp_a0;
|
||||
|
|
|
|||
|
|
@ -53,7 +53,7 @@ typedef struct unk_D_800FC7D0_148 {
|
|||
/* 0x24 */ s32 unk_24;
|
||||
/* 0x28 */ u16 unk_28;
|
||||
/* 0x2A */ u8 unk_2A;
|
||||
} unk_D_800FC7D0_148; // size >= 0x2C
|
||||
} unk_D_800FC7D0_148; // size = 0x2C
|
||||
|
||||
typedef struct unk_D_800FC7D0 {
|
||||
/* 0x000 */ struct unk_D_800FC7D0* unk_000;
|
||||
|
|
|
|||
|
|
@ -7,6 +7,50 @@ typedef struct unk_func_81206FA0 {
|
|||
/* 0x0C */ s32 unk_0C;
|
||||
} unk_func_81206FA0; // size = 0x10
|
||||
|
||||
typedef struct unk_D_812346EC {
|
||||
/* 0x00 */ s16 unk_00;
|
||||
/* 0x02 */ s16 unk_02;
|
||||
/* 0x04 */ s16 unk_04;
|
||||
} unk_D_812346EC;// size = 0x6
|
||||
|
||||
typedef struct unk_D_81231450 {
|
||||
/* 0x00 */ s32 unk_00;
|
||||
/* 0x04 */ s32 unk_04;
|
||||
} unk_D_81231450;// size = 0x8
|
||||
|
||||
typedef struct unk_D_81234650 {
|
||||
/* 0x00 */ s32 unk_00;
|
||||
/* 0x04 */ s32 unk_04;
|
||||
} unk_D_81234650;// size = 0x8
|
||||
|
||||
typedef struct unk_D_81234690 {
|
||||
/* 0x00 */ u8 pad0[2];
|
||||
/* 0x02 */ s16 unk_02;
|
||||
/* 0x04 */ s16 unk_04;
|
||||
/* 0x06 */ s16 unk_06;
|
||||
/* 0x08 */ s16 unk_08;
|
||||
/* 0x0A */ s16 unk_0A;
|
||||
/* 0x0C */ s16 unk_0C;
|
||||
/* 0x0E */ u8 pad0E[0x2A];
|
||||
} unk_D_81234690; // size = 0x38
|
||||
|
||||
extern s32 D_812286EC;
|
||||
extern s32 D_812286F0;
|
||||
extern f32 D_8122AF70;
|
||||
extern unk_D_81231450 D_81231450[0x640];
|
||||
extern unk_D_81234650 D_81234650[0x6];
|
||||
extern unk_func_81206FA0 D_81234680;
|
||||
extern unk_D_81234690 D_81234690;
|
||||
extern s32 D_812346C8;
|
||||
extern s32 D_812346D4;
|
||||
extern f32 D_812346D8;
|
||||
extern s32 D_812346DC;
|
||||
extern void* D_812346E0;
|
||||
extern unk_D_812346EC D_812346EC;
|
||||
extern s32 D_812346F2;
|
||||
extern s32 D_81234700;
|
||||
extern s32 D_812346FC;
|
||||
|
||||
u32 func_81206FA0(unk_func_81206FA0* arg0, s32 arg1) {
|
||||
s32 temp_v0;
|
||||
u32 temp_a2;
|
||||
|
|
@ -43,11 +87,78 @@ s32 func_81207020(unk_func_81206FA0* arg0, s32 arg1) {
|
|||
|
||||
|
||||
void func_81207078(unk_func_81206FA0* arg0, s32 arg1, s32 arg2) {
|
||||
|
||||
arg0->unk_00 = ALIGN16(arg1);
|
||||
arg0->unk_04 = ALIGN16(arg1);
|
||||
arg0->unk_08 = (s32) (arg2 - (arg1 & 0xF));
|
||||
arg0->unk_0C = 0;
|
||||
}
|
||||
|
||||
#ifdef NON_MATCHING
|
||||
void func_812070A0(void) {
|
||||
unk_D_81231450* var_v0;
|
||||
unk_D_81234650* var_v0_2;
|
||||
unk_D_812346EC* var_v1_2;
|
||||
s32 temp_a0;
|
||||
s32 var_a0;
|
||||
u32 var_v1;
|
||||
unk_D_812346EC* temp_v0;
|
||||
unk_D_812346EC* var_v1_3;
|
||||
unk_D_812346EC** var_s1;
|
||||
|
||||
D_812346FC = 0;
|
||||
temp_a0 = (s32) D_812286EC / 8;
|
||||
if (temp_a0 > 0) {
|
||||
var_v0 = &D_81231450[0];
|
||||
do {
|
||||
var_v0 += 8;
|
||||
var_v0->unk_04 = 0;
|
||||
var_v0->unk_00 = 0;
|
||||
} while ((u32) var_v0 < (u32)&D_81231450[temp_a0]);
|
||||
}
|
||||
var_v0_2 = &D_81234650[0];
|
||||
var_v1 = (u32) (&D_81234700 - (s32)&D_81234650) >> 3;
|
||||
if ((s32) var_v1 >= 0) {
|
||||
do {
|
||||
var_v1 -= 1;
|
||||
var_v0_2->unk_04 = 0;
|
||||
var_v0_2->unk_00 = 0;
|
||||
var_v0_2 += 8;
|
||||
} while ((s32) var_v1 >= 0);
|
||||
}
|
||||
D_812346D8 = D_8122AF70;
|
||||
D_812346DC = 0x3C;
|
||||
D_81234690.unk_02 = 0xBB80U;
|
||||
D_81234690.unk_04 = osAiSetFrequency(0xBB80 & 0xFFFF);
|
||||
D_81234690.unk_06 = (s16) ((((s32) D_81234690.unk_02 / (s32) D_812346DC) + 0xF) & ~0xF);
|
||||
var_v1_2 = &D_812346EC;
|
||||
D_81234690.unk_0A = (s16) (D_81234690.unk_06 - 0x10);
|
||||
D_81234690.unk_08 = (s16) (D_81234690.unk_06 + 0x10);
|
||||
do {
|
||||
var_v1_2 += 2;
|
||||
var_v1_2->unk_02 = 0xA0;
|
||||
} while ((u32) var_v1_2 < (u32) &D_812346F2);
|
||||
D_812346C8 = 0;
|
||||
D_812346D4 = 0;
|
||||
func_81207078(&D_81234680, (s32)&D_81231450, D_812286F0);
|
||||
var_s1 = D_812346E0;
|
||||
do {
|
||||
temp_v0 = func_81207020(&D_81234680, 0xFC0);
|
||||
*var_s1 = temp_v0;
|
||||
var_v1_3 = temp_v0;
|
||||
var_a0 = 0;
|
||||
loop_9:
|
||||
var_a0 += 4;
|
||||
var_v1_3->unk_02 = 0;
|
||||
var_v1_3->unk_04 = 0;
|
||||
var_v1_3->unk_00 = 0;
|
||||
var_v1_3 += 8;
|
||||
var_v1_3->unk_00 = 0;
|
||||
if (var_a0 != 0x7E0) {
|
||||
goto loop_9;
|
||||
}
|
||||
var_s1 += 4;
|
||||
} while (*var_s1 != &D_812346EC);
|
||||
}
|
||||
#else
|
||||
#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/1/fragment1_86920/func_812070A0.s")
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -15,8 +15,24 @@ typedef struct DisplayListState {
|
|||
/* 0x18 */ Gfx* gfx;
|
||||
} DisplayListState; // size = 0x1C
|
||||
|
||||
typedef struct unk_arg0_func_81002174 {
|
||||
/* 0x00 */ s8 unk_00;
|
||||
/* 0x01 */ s8 unk_01;
|
||||
/* 0x02 */ s8 unk_02;
|
||||
/* 0x03 */ s8 unk_03;
|
||||
/* 0x04 */ s8 unk_04;
|
||||
/* 0x05 */ s8 unk_05;
|
||||
/* 0x06 */ s8 unk_06;
|
||||
} unk_arg0_func_81002174; // size >= 0x7
|
||||
|
||||
typedef struct unk_arg0_func_81002260 {
|
||||
/* 0x00 */ char unk00[0x1A];
|
||||
/* 0x1A */ s16 unk_1A;
|
||||
} unk_arg0_func_81002260; // size >= 0x1C
|
||||
|
||||
void func_810007A8(unk_D_86002F58_004_000*);
|
||||
void func_810007F8(void);
|
||||
void func_81002174(unk_D_83402EE0_00A*);
|
||||
void func_81002260(unk_arg0_func_81002260*, unk_arg0_func_81002174*);
|
||||
|
||||
#endif // _FRAGMENT31_H_
|
||||
|
|
|
|||
|
|
@ -1,31 +1,55 @@
|
|||
#include "fragment31.h"
|
||||
#include "32D10.h"
|
||||
#include "12D80.h"
|
||||
#include "6A40.h"
|
||||
|
||||
typedef struct unk_D_810047E0 {
|
||||
/* 0x00 */ s16 unk_00;
|
||||
/* 0x04 */ Vec3f unk_04;
|
||||
/* 0x10 */ Vec3f unk_10;
|
||||
/* 0x1C */ Vec3f unk_1C;
|
||||
/* 0x28 */ s16 unk_28;
|
||||
/* 0x00 */ s16 active;
|
||||
/* 0x02 */ char unk02[0x2];
|
||||
/* 0x04 */ Vec3f position;
|
||||
/* 0x10 */ Vec3f velocity;
|
||||
/* 0x1C */ Vec3f scale;
|
||||
/* 0x28 */ s16 misc;
|
||||
/* 0x2A */ char unk2A[0x2];
|
||||
} unk_D_810047E0; // size = 0x2C
|
||||
|
||||
typedef struct unk_arg2_func_81001D80 {
|
||||
/* 0x00 */ s32 unk_00;
|
||||
/* 0x04 */ char unk04[0x4];
|
||||
/* 0x08 */ s32 unk_08;
|
||||
} unk_arg2_func_81001D80; // size = 0xC
|
||||
|
||||
typedef struct unk_D_81003FE0 {
|
||||
/* 0x00 */ s32 unk_00;
|
||||
/* 0x04 */ s32 unk_04;
|
||||
/* 0x08 */ s32 unk_08;
|
||||
} unk_D_81003FE0; // size = 0xC
|
||||
|
||||
extern unk_D_81003FE0 D_81003FE0[];
|
||||
extern unk_D_81003FE0 D_81003FE2[];
|
||||
extern unk_D_81003FE0 D_81003FEA[];
|
||||
extern s16 D_810040B8[18];
|
||||
extern unk_D_810047E0 D_810047E0[2][10];
|
||||
extern unk_D_810047E0 D_81004998[2][10];
|
||||
extern s32 D_81004B50;
|
||||
extern s32 D_81004B54;
|
||||
extern s16 D_81004B60;
|
||||
extern f32 D_810040DC[12];
|
||||
extern Vec3f D_81004160;
|
||||
extern s32 D_81004170;
|
||||
|
||||
// Matching, just needs data to be done
|
||||
#ifdef NON_MATCHING
|
||||
void func_810005F0(unk_D_86002F58_004_000* arg0, s32 arg1) {
|
||||
u8 var_v0 = arg0->unk_0A6;
|
||||
UNUSED s32 pad[2];
|
||||
s32 pad[2];
|
||||
Vec3f sp50 = { 0.0f, 0.0f, 0.0f };
|
||||
Vec3f sp44 = { 0.0f, 0.0f, 0.0f };
|
||||
Vec3f sp38 = { 1.0f, 1.0f, 1.0f };
|
||||
UNUSED Vec3f sp2C = { 2.0f, 2.0f, 2.0f };
|
||||
UNUSED Vec3f sp20 = { 0.0f, 10.0f, 0.0f };
|
||||
UNUSED Vec3f sp14 = { 10000.0f, 10000.0f, 10000.0f };
|
||||
UNUSED Vec3f sp8 = { -10000.0f, -10000.0f, -10000.0f };
|
||||
Vec3f sp2C = { 2.0f, 2.0f, 2.0f };
|
||||
Vec3f sp20 = { 0.0f, 10.0f, 0.0f };
|
||||
Vec3f sp14 = { 10000.0f, 10000.0f, 10000.0f };
|
||||
Vec3f sp8 = { -10000.0f, -10000.0f, -10000.0f };
|
||||
|
||||
if (var_v0 == 0xFF) {
|
||||
var_v0 = 0;
|
||||
|
|
@ -33,11 +57,11 @@ void func_810005F0(unk_D_86002F58_004_000* arg0, s32 arg1) {
|
|||
var_v0 = 0;
|
||||
}
|
||||
|
||||
D_810047E0[var_v0 & 1][arg1].unk_00 = 0;
|
||||
D_810047E0[var_v0 & 1][arg1].unk_28 = 0;
|
||||
D_810047E0[var_v0 & 1][arg1].unk_04 = sp50;
|
||||
D_810047E0[var_v0 & 1][arg1].unk_10 = sp44;
|
||||
D_810047E0[var_v0 & 1][arg1].unk_1C = sp38;
|
||||
D_810047E0[var_v0 & 1][arg1].active = 0;
|
||||
D_810047E0[var_v0 & 1][arg1].misc = 0;
|
||||
D_810047E0[var_v0 & 1][arg1].position = sp50;
|
||||
D_810047E0[var_v0 & 1][arg1].velocity = sp44;
|
||||
D_810047E0[var_v0 & 1][arg1].scale = sp38;
|
||||
}
|
||||
#else
|
||||
#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/31/fragment31_2558B0/func_810005F0.s")
|
||||
|
|
@ -56,16 +80,351 @@ void func_810007F8(void) {
|
|||
D_81004B54 = 0;
|
||||
}
|
||||
|
||||
#ifdef NON_MATCHING
|
||||
void func_8100080C(unk_D_810047E0* arg0) {
|
||||
s32 var_s1;
|
||||
Vec3f sp90;
|
||||
Vec3f sp84;
|
||||
Vec3f sp78;
|
||||
Vec3f sp64;
|
||||
f32 sp60;
|
||||
f32 sp58;
|
||||
f32 temp_fa1;
|
||||
f32 temp_ft5;
|
||||
f32 temp_fv0;
|
||||
f32 temp_fv0_2;
|
||||
f32 sp5C;
|
||||
f32 temp_fv1;
|
||||
f32 var_fs0;
|
||||
f32 var_ft4;
|
||||
f32 var_ft5;
|
||||
f32 var_fv1;
|
||||
s32 var_v0;
|
||||
unk_D_810047E0* var_s0;
|
||||
|
||||
var_s0 = arg0;
|
||||
var_s1 = 0xA;
|
||||
sp64.x = D_81004160.x;
|
||||
sp64.y = D_81004160.y;
|
||||
sp64.z = D_81004160.z;
|
||||
guMtxXFMF(func_800123D4(-1)->mf, 0, 0, 0, &sp90.x, &sp90.y, &sp90.z);
|
||||
guMtxXFMF(func_800123D4(0)->mf, 0, 0, 0, &sp84.x, &sp84.y, &sp84.z);
|
||||
temp_fv1 = D_8006F09C->unk_030.x;
|
||||
sp5C = D_8006F09C->unk_030.y;
|
||||
sp58 = D_8006F09C->unk_030.z;
|
||||
switch (D_8006F09C->unk_01A) {
|
||||
case 0x6D:
|
||||
case 0x6E:
|
||||
var_fs0 = 0.5f;
|
||||
sp64.x = 0x3F800000;
|
||||
sp64.y = 0x3F800000;
|
||||
sp64.z = 0x3F800000;
|
||||
break;
|
||||
case 0x92:
|
||||
var_fs0 = 1.0f;
|
||||
sp60 = temp_fv1;
|
||||
sp64.x = 0x3DCCCCCD;
|
||||
sp64.y = 0x3DCCCCCD;
|
||||
sp64.z = 0x3DCCCCCD;
|
||||
sp84.x += (f32) ((guRandom() % 10) - 5) * temp_fv1;
|
||||
sp84.y += (f32) ((guRandom() % 10) - 5) * sp5C;
|
||||
sp84.z += (f32) ((guRandom() % 10) - 5) * sp58;
|
||||
break;
|
||||
case 0x4D:
|
||||
var_fs0 = 0.5f;
|
||||
sp60 = temp_fv1;
|
||||
sp64.x = 0x3B03126F;
|
||||
sp64.y = 0x3B03126F;
|
||||
sp64.z = 0x3B03126F;
|
||||
sp84.x += (f32) ((guRandom() % 20) - 0xA) * temp_fv1;
|
||||
sp84.y += (f32) ((guRandom() % 20) - 0xA) * sp5C;
|
||||
sp84.z += (f32) ((guRandom() % 20) - 0xA) * sp58;
|
||||
break;
|
||||
case 0x4E:
|
||||
var_fs0 = 0.5f;
|
||||
sp60 = temp_fv1;
|
||||
sp64.x = 0x3B03126F;
|
||||
sp64.y = 0x3B03126F;
|
||||
sp64.z = 0x3B03126F;
|
||||
sp84.x += (f32) ((guRandom() % 20) - 0xA) * temp_fv1;
|
||||
sp84.y += (f32) ((guRandom() % 10) - 5) * sp5C;
|
||||
sp84.z += (f32) ((guRandom() % 20) - 0xA) * sp58;
|
||||
break;
|
||||
case 0x90:
|
||||
var_fs0 = 0.0f;
|
||||
sp60 = temp_fv1;
|
||||
sp64.x = D_810040DC[0];
|
||||
sp64.y = D_810040DC[1];
|
||||
sp64.z = D_810040DC[2];
|
||||
sp84.x += (f32) ((guRandom() % 20) - 0xA) * temp_fv1;
|
||||
sp84.y += (f32) ((guRandom() % 20) - 0xA) * sp5C;
|
||||
sp84.z += (f32) ((guRandom() % 20) - 0xA) * sp58;
|
||||
break;
|
||||
case 0x86:
|
||||
var_fs0 = 0.0f;
|
||||
sp60 = temp_fv1;
|
||||
sp64.x = D_810040DC[0];
|
||||
sp64.y = D_810040DC[1];
|
||||
sp64.z = D_810040DC[2];
|
||||
sp84.x += (f32) ((guRandom() % 60) - 0x1E) * temp_fv1;
|
||||
sp84.y += (f32) ((guRandom() % 40) - 0xA) * sp5C;
|
||||
sp84.z += (f32) ((guRandom() % 60) - 0x1E) * sp58;
|
||||
break;
|
||||
case 0x5C:
|
||||
var_fs0 = 0.0f;
|
||||
var_s1 = 3;
|
||||
sp64.x = 0x41A00000;
|
||||
sp64.y = 0x41A00000;
|
||||
sp64.z = 0x41A00000;
|
||||
break;
|
||||
default:
|
||||
var_fs0 = 0.0f;
|
||||
break;
|
||||
}
|
||||
var_v0 = 0;
|
||||
loop_11:
|
||||
var_v0 += 1;
|
||||
if (var_v0 < var_s1) {
|
||||
if (var_s0->active == 0) {
|
||||
temp_fv0 = sp84.x - sp90.x;
|
||||
temp_ft5 = sp84.y - sp90.y;
|
||||
sp78.x = temp_fv0;
|
||||
temp_fa1 = sp84.z - sp90.z;
|
||||
sp78.y = temp_ft5;
|
||||
sp78.z = temp_fa1;
|
||||
temp_fv0_2 = sqrtf((temp_fv0 * temp_fv0) + (temp_ft5 * temp_ft5) + (temp_fa1 * temp_fa1));
|
||||
var_fv1 = sp78.z;
|
||||
var_ft4 = sp78.x;
|
||||
var_ft5 = temp_ft5;
|
||||
if (temp_fv0_2 > 0.0f) {
|
||||
var_ft4 /= temp_fv0_2;
|
||||
var_ft5 /= temp_fv0_2;
|
||||
var_fv1 /= temp_fv0_2;
|
||||
}
|
||||
var_s0->velocity.x = (f32) (var_fs0 * var_ft4);
|
||||
var_s0->velocity.y = (f32) (var_fs0 * var_ft5);
|
||||
var_s0->velocity.z = (f32) (var_fs0 * var_fv1);
|
||||
var_s0->position.x = sp84.x;
|
||||
var_s0->position.y = sp84.y;
|
||||
var_s0->position.z = sp84.z;
|
||||
var_s0->scale.x = sp64.x;
|
||||
var_s0->scale.y = sp64.y;
|
||||
var_s0->scale.z = sp64.z;
|
||||
var_s0->misc = 0;
|
||||
var_s0->active = 1;
|
||||
return;
|
||||
}
|
||||
var_s0 += 0x2C;
|
||||
if (var_v0 == 0xA) {
|
||||
|
||||
} else {
|
||||
goto loop_11;
|
||||
}
|
||||
}
|
||||
}
|
||||
#else
|
||||
#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/31/fragment31_2558B0/func_8100080C.s")
|
||||
#endif
|
||||
|
||||
#ifdef NON_MATCHING
|
||||
void func_81000E78(unk_D_810047E0* arg0) {
|
||||
s16 temp_a0;
|
||||
unk_D_81003FE0* var_v1;
|
||||
s16 temp_v1;
|
||||
s32 var_a1;
|
||||
s32 var_v0;
|
||||
|
||||
var_a1 = D_8006F09C->unk_040.unk_08 >> 0x10;
|
||||
switch (D_8006F09C->unk_01A) {
|
||||
case 0x6D:
|
||||
case 0x6E:
|
||||
temp_v1 = D_8006F09C->unk_040.unk_00;
|
||||
temp_a0 = D_810040B8[D_81004B54 % 18];
|
||||
if (temp_v1 != 2) {
|
||||
var_v0 = 0;
|
||||
if (temp_v1 != 3) {
|
||||
if (temp_v1 == 4) {
|
||||
if (var_a1 == D_81003FE2[temp_a0].unk_00) {
|
||||
func_8100080C(arg0);
|
||||
return;
|
||||
}
|
||||
} else if (var_a1 == D_81003FE0[temp_a0].unk_00) {
|
||||
func_8100080C(arg0);
|
||||
return;
|
||||
}
|
||||
} else {
|
||||
var_v1 = &D_81003FE0[temp_a0];
|
||||
do {
|
||||
if (var_a1 == var_v1->unk_04) {
|
||||
func_8100080C(arg0);
|
||||
}
|
||||
var_v0 += 2;
|
||||
var_v1 += 2;
|
||||
} while (var_v0 != 6);
|
||||
return;
|
||||
}
|
||||
} else {
|
||||
if (var_a1 == D_81003FEA[temp_a0].unk_00) {
|
||||
func_8100080C(arg0);
|
||||
return;
|
||||
}
|
||||
default:
|
||||
return;
|
||||
}
|
||||
break;
|
||||
case 0x92:
|
||||
if ((guRandom() % 60) == 0) {
|
||||
func_8100080C(arg0);
|
||||
return;
|
||||
}
|
||||
break;
|
||||
case 0x90:
|
||||
if ((guRandom() % 30) == 0) {
|
||||
func_8100080C(arg0);
|
||||
return;
|
||||
}
|
||||
break;
|
||||
case 0x86:
|
||||
if ((guRandom() % 7) == 0) {
|
||||
func_8100080C(arg0);
|
||||
return;
|
||||
}
|
||||
break;
|
||||
case 0x5C:
|
||||
func_8100080C(arg0);
|
||||
return;
|
||||
case 0x4D:
|
||||
case 0x4E:
|
||||
if ((guRandom() % 7) == 0) {
|
||||
func_8100080C(arg0);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
#else
|
||||
#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/31/fragment31_2558B0/func_81000E78.s")
|
||||
#endif
|
||||
|
||||
Gfx* func_810010BC(Gfx*, unk_D_810047E0*, unk_arg2_func_81001D80*, s16);
|
||||
#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/31/fragment31_2558B0/func_810010BC.s")
|
||||
|
||||
#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/31/fragment31_2558B0/func_81001D80.s")
|
||||
Gfx* func_81001D80(Gfx* gfx, unk_D_810047E0* arg1, unk_arg2_func_81001D80* arg2, s16 arg3) {
|
||||
s32 i;
|
||||
|
||||
for (i = 0; i < 10; i++, arg1++) {
|
||||
if (arg1->active == 1) {
|
||||
gfx = func_810010BC(gfx, arg1, arg2, arg3);
|
||||
}
|
||||
}
|
||||
return gfx;
|
||||
}
|
||||
|
||||
#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/31/fragment31_2558B0/func_81001E24.s")
|
||||
|
||||
#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/31/fragment31_2558B0/func_81002174.s")
|
||||
#ifdef NON_MATCHING
|
||||
void func_81002174(unk_D_83402EE0_00A* arg0) {
|
||||
s32 i;
|
||||
s16 var_a1;
|
||||
s16 var_a2;
|
||||
s16 var_a3;
|
||||
u8 var_a0;
|
||||
u8 var_v0;
|
||||
|
||||
for (i = 0; i != 10; ) {
|
||||
if (D_810047E0[0][i].active == 1) {
|
||||
var_v0 = 0x80;
|
||||
var_a0 = D_810047E0[0][i].misc & 0x7F;
|
||||
var_a1 = D_810047E0[0][i].position.x * 10.0f;
|
||||
var_a2 = D_810047E0[0][i].position.y * 10.0f;
|
||||
var_a3 = D_810047E0[0][i].position.z * 10.0f;
|
||||
} else {
|
||||
var_v0 = 0;
|
||||
var_a0 = 0;
|
||||
var_a1 = 0;
|
||||
var_a2 = 0;
|
||||
var_a3 = 0;
|
||||
}
|
||||
|
||||
arg0->unk_00[0] = ((var_v0 & 0x80) | (var_a0 & 0x7F));
|
||||
i++;
|
||||
arg0->unk_00[1] = var_a1;
|
||||
arg0->unk_00[2] = (var_a1 >> 8);
|
||||
arg0->unk_00[3] = var_a2;
|
||||
arg0->unk_00[4] = (var_a2 >> 8);
|
||||
arg0->unk_00[5] = var_a3;
|
||||
arg0->unk_00[6] = (var_a3 >> 8);
|
||||
arg0 += 1;
|
||||
}
|
||||
|
||||
// FAKE - Stops unroll
|
||||
i = 0;
|
||||
}
|
||||
#else
|
||||
#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/31/fragment31_2558B0/func_81002174.s")
|
||||
#endif
|
||||
|
||||
#ifdef NON_MATCHING
|
||||
void func_81002260(unk_arg0_func_81002260* arg0, unk_arg0_func_81002174* arg1) {
|
||||
unk_D_810047E0* temp_v0;
|
||||
f32 var_fv0;
|
||||
s16 var_a2;
|
||||
s16 var_t0;
|
||||
s32 temp_a0;
|
||||
s32 var_a0;
|
||||
s32 i;
|
||||
u8 temp_a3;
|
||||
unk_arg0_func_81002174* temp_a1;
|
||||
|
||||
for (i = 0; i < 10; i++) {
|
||||
temp_a3 = arg1->unk_00;
|
||||
temp_a1 = arg1 + 1;
|
||||
if (!(temp_a3 & 0x80)) {
|
||||
D_810047E0[0][i].active = 0;
|
||||
var_a0 = 0;
|
||||
var_a2 = 0;
|
||||
var_t0 = 0;
|
||||
arg1 = temp_a1 + 6;
|
||||
} else {
|
||||
D_810047E0[0][i].active = 1;
|
||||
temp_a0 = ((arg1->unk_01 | (temp_a1->unk_01 << 8)) & 0xFFFF) << 0x10;
|
||||
arg1 = temp_a1 + 6;
|
||||
var_a0 = temp_a0 >> 0x10;
|
||||
var_a2 = (temp_a1->unk_02 | (temp_a1->unk_03 << 8)) & 0xFFFF;
|
||||
var_t0 = (temp_a1->unk_04 | (temp_a1->unk_05 << 8)) & 0xFFFF;
|
||||
}
|
||||
D_810047E0[0][i].misc = (s16) (temp_a3);
|
||||
switch (arg0->unk_1A) {
|
||||
case 0x92:
|
||||
var_fv0 = ((f32) D_810047E0[0][i].misc * 0.005f) + 0.1f;
|
||||
break;
|
||||
case 0x4D:
|
||||
case 0x4E:
|
||||
var_fv0 = ((f32) D_810047E0[0][i].misc * 0.005f) + 0.002f;
|
||||
break;
|
||||
case 0x86:
|
||||
case 0x90:
|
||||
var_fv0 = D_810040DC[D_810047E0[0][i].misc % 12];
|
||||
break;
|
||||
case 0x6D:
|
||||
case 0x6E:
|
||||
var_fv0 = ((f32) D_810047E0[0][i].misc * 0.1f) + 1.0f;
|
||||
break;
|
||||
case 0x5C:
|
||||
var_fv0 = 20.0f;
|
||||
break;
|
||||
default:
|
||||
var_fv0 = 1.0f;
|
||||
break;
|
||||
}
|
||||
// var_v1 += 0x2C;
|
||||
temp_v0->scale.x = var_fv0;
|
||||
temp_v0->scale.y = var_fv0;
|
||||
temp_v0->scale.z = var_fv0;
|
||||
temp_v0->position.x = (f32) ((f32) var_a0 / 10.0f);
|
||||
temp_v0->position.y = (f32) ((f32) var_a2 / 10.0f);
|
||||
temp_v0->position.z = (f32) ((f32) var_t0 / 10.0f);
|
||||
};
|
||||
}
|
||||
#else
|
||||
#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/31/fragment31_2558B0/func_81002260.s")
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -1,7 +1,9 @@
|
|||
#include "fragment31.h"
|
||||
#include "src/fragments/7/fragment7.h"
|
||||
#include "src/fragments/8/fragment8.h"
|
||||
#include "src/fragments/50/fragment50.h"
|
||||
#include "src/6A40.h"
|
||||
#include "src/12D80.h"
|
||||
#include "src/32D10.h"
|
||||
|
||||
typedef struct {
|
||||
|
|
@ -12,12 +14,14 @@ typedef struct {
|
|||
} Keyframe; // size = 0x08
|
||||
|
||||
extern Keyframe* D_8100419C[];
|
||||
extern s32 D_810041D0;
|
||||
extern s32 D_810041D0[20];
|
||||
extern char D_810047D0[3];
|
||||
extern s32 D_81004B70;
|
||||
extern s32 D_81004B80;
|
||||
extern s32 D_81004B90;
|
||||
extern s32 D_81004BA0;
|
||||
extern s32 D_81004BB0;
|
||||
extern char D_81004BB8[0x28];
|
||||
|
||||
#ifdef NON_MATCHING
|
||||
void func_81002DC0(Gfx* gfx, s32 arg1, s32 arg2) {
|
||||
|
|
@ -309,8 +313,50 @@ s32 func_81003A24(s8* arg0) {
|
|||
return var_v1;
|
||||
}
|
||||
|
||||
void func_81003A54(Gfx*);
|
||||
#ifdef NON_MATCHING
|
||||
void func_81003A54(Gfx* gfx) {
|
||||
u8 sp4D;
|
||||
char* sp34;
|
||||
Mtx* sp30;
|
||||
s32 sp2C;
|
||||
u8 temp_t0;
|
||||
u8 var_v1;
|
||||
|
||||
temp_t0 = D_800AF770[(D_8006F09C->unk_0A6 % 5) & 0xFF];
|
||||
switch (D_81004BB0) {
|
||||
case 0:
|
||||
var_v1 = (((s32) (temp_t0 + 1) / 100) + 0x10) & 0xFF;
|
||||
break;
|
||||
case 1:
|
||||
var_v1 = (((s32) ((s32) (temp_t0 + 1) % 100) / 10) + 0x10) & 0xFF;
|
||||
break;
|
||||
case 2:
|
||||
var_v1 = (((s32) (temp_t0 + 1) % 10) + 0x10) & 0xFF;
|
||||
break;
|
||||
default:
|
||||
sp34 = func_8002D7C0(0, 0, D_8267E760, temp_t0);;
|
||||
sprintf(D_81004BB8, D_810047D0, sp34);
|
||||
sp4D = func_8001E730((u8) D_81004BB8[(D_81004BB0 - 3) & 0xFFFF]);
|
||||
sp2C = 0xA - func_81003A24((s8*)sp34);
|
||||
sp30 = func_80005F5C(0x40);;
|
||||
guTranslate(sp30, (f32) sp2C * 32.0f, 0.0f, 0.0f);
|
||||
var_v1 = sp4D;
|
||||
{ Gfx *_gfx = (Gfx *)(gfx++); _gfx->words.w0 = 0xDA380001; _gfx->words.w1 = sp30; }
|
||||
break;
|
||||
}
|
||||
{ Gfx *_gfx = (Gfx *)(gfx++); _gfx->words.w0 = 0xFD6800FF; _gfx->words.w1 = Util_ConvertAddrToVirtAddr(D_3000000[((var_v1 & 0xF) * 0x10) + (((s32) (var_v1 & 0xF0) >> 4) << 0xC)]); }
|
||||
{ Gfx *_gfx = (Gfx *)(gfx++); _gfx->words.w0 = 0xF5680600; _gfx->words.w1 = 0x07094250; }
|
||||
{ Gfx *_gfx = (Gfx *)(gfx++); _gfx->words.w0 = 0xE6000000; _gfx->words.w1 = 0; }
|
||||
{ Gfx *_gfx = (Gfx *)(gfx++); _gfx->words.w0 = 0xF4000000; _gfx->words.w1 = 0x07040040; }
|
||||
{ Gfx *_gfx = (Gfx *)(gfx++); _gfx->words.w0 = 0xE7000000; _gfx->words.w1 = 0; }
|
||||
{ Gfx *_gfx = (Gfx *)(gfx++); _gfx->words.w0 = 0xF5680600; _gfx->words.w1 = 0x94250; }
|
||||
{ Gfx *_gfx = (Gfx *)(gfx++); _gfx->words.w0 = 0xF2000000; _gfx->words.w1 = 0x40040; }
|
||||
{ Gfx *_gfx = (Gfx *)(gfx++); _gfx->words.w0 = 0xDF000000; _gfx->words.w1 = 0; }
|
||||
D_81004BB0 += 1;
|
||||
}
|
||||
#else
|
||||
#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/31/fragment31_258080/func_81003A54.s")
|
||||
#endif
|
||||
|
||||
void func_81003CF0(s32 arg0, DisplayListState* state) {
|
||||
Gfx* gfx;
|
||||
|
|
|
|||
|
|
@ -77,7 +77,6 @@ static s32 D_8267E750;
|
|||
static s32 D_8267E754;
|
||||
static s32 D_8267E758;
|
||||
static char** D_8267E75C;
|
||||
static char** D_8267E760;
|
||||
|
||||
static u32 D_82603E80[] = {
|
||||
0xA4CAA4DE, 0xA4A80000, 0xA5ECA5D9, 0xA5EB0000, 0xA4AAA4E4, 0x00000000, 0xA4C7A4F3, 0xA4C9A4A6, 0xA4A4A4EA,
|
||||
|
|
|
|||
|
|
@ -3,6 +3,8 @@
|
|||
|
||||
#include "global.h"
|
||||
|
||||
extern char** D_8267E760;
|
||||
|
||||
void func_82600020(void);
|
||||
s32 func_82600094(s8* arg0, s8* arg1);
|
||||
s32 func_826000D8(void);
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user