diff --git a/Jenkinsfile b/Jenkinsfile index c4fa0d4a5a..cdc3dee554 100644 --- a/Jenkinsfile +++ b/Jenkinsfile @@ -13,7 +13,7 @@ pipeline { sh 'curl -L "https://github.com/ethteck/ido-static-recomp/releases/download/per-function/ido-5.3-recomp-ubuntu-latest.tar.gz" | tar zx -C tools/build/cc/ido5.3' sh 'curl -L "https://github.com/decompals/mips-gcc-2.7.2/releases/download/main/gcc-2.7.2-linux.tar.gz" | tar zx -C tools/build/cc/gcc2.7.2' sh 'curl -L "https://github.com/decompals/mips-binutils-2.6/releases/download/main/binutils-2.6-linux.tar.gz" | tar zx -C tools/build/cc/gcc2.7.2' - sh 'pip install -r requirements.txt' + sh 'pip install -U -r requirements.txt' sh './configure' } } diff --git a/include/effects.h b/include/effects.h index b523267ce0..f72a6ee313 100644 --- a/include/effects.h +++ b/include/effects.h @@ -1424,7 +1424,9 @@ typedef struct WaterfallFXData { } WaterfallFXData; // size = unknown typedef struct WaterFountainFXData { - /* 0x00 */ char unk_00[0x18]; + /* 0x00 */ char unk_00[0x4]; + /* 0x04 */ Vec3f unk_04; + /* 0x10 */ char unk_10[0x8]; /* 0x18 */ s32 unk_18; /* 0x1C */ s32 unk_1C; /* 0x20 */ s32 unk_20; @@ -1434,6 +1436,8 @@ typedef struct WaterFountainFXData { /* 0x30 */ s32 unk_30; /* 0x34 */ char unk_34[0x4]; /* 0x38 */ f32 unk_38; + /* 0x3C */ f32 unk_3C; + /* 0x40 */ f32 unk_40; } WaterFountainFXData; // size = ? typedef struct UnderwaterFXData { diff --git a/include/enums.h b/include/enums.h index 4ccda51ef0..8141bd4e68 100644 --- a/include/enums.h +++ b/include/enums.h @@ -849,6 +849,9 @@ enum SoundIDs { SOUND_295 = 0x00000295, SOUND_299 = 0x00000299, SOUND_29A = 0x0000029A, + SOUND_29B = 0x0000029B, + SOUND_29C = 0x0000029C, + SOUND_29D = 0x0000029D, SOUND_2A0 = 0x000002A0, SOUND_2A1 = 0x000002A1, SOUND_2A2 = 0x000002A2, @@ -1111,6 +1114,7 @@ enum SoundIDs { SOUND_2005 = 0x00002005, SOUND_2009 = 0x00002009, SOUND_200A = 0x0000200A, + SOUND_200B = 0x0000200B, SOUND_200C = 0x0000200C, SOUND_200D = 0x0000200D, SOUND_BOW_VANISH = 0x0000200E, diff --git a/src/E20110.c b/src/E20110.c index 2a1767939e..0bf6e6ccde 100644 --- a/src/E20110.c +++ b/src/E20110.c @@ -31,8 +31,6 @@ TempE20110* D_802B7CB8_E20DC8 = &D_802B7DA0; void func_802B7728_E20838(void); void func_802B79C8_E20AD8(void); -// floatz -#ifdef NON_MATCHING void func_802B70B4_E201C4(void) { PlayerStatus* playerStatus = &gPlayerStatus; f32 new_var; @@ -40,15 +38,11 @@ void func_802B70B4_E201C4(void) { if (playerStatus->animFlags & 0x10) { mem_clear(D_802B7CB8_E20DC8, sizeof(*D_802B7CB8_E20DC8)); D_8010C950 = -1; - D_802B7CB8_E20DC8->unk_00.x = playerStatus->position.x; - new_var = playerStatus->position.y + playerStatus->colliderHeight; - if (!(playerStatus->animFlags & 0x1000)) { - D_802B7CB8_E20DC8->unk_00.y = new_var + 8.0f; - } else { - D_802B7CB8_E20DC8->unk_00.y = new_var + 2.0f; - } - D_802B7CB8_E20DC8->unk_00.z = playerStatus->position.z; - D_802B7CB8_E20DC8->unk_10 = 0.4f; + D_802B7CB8_E20DC8->pos.x = playerStatus->position.x; + D_802B7CB8_E20DC8->pos.y = playerStatus->position.y + playerStatus->colliderHeight + + (!(playerStatus->animFlags & 0x1000) ? 8.0f : 2.0f); + D_802B7CB8_E20DC8->pos.z = playerStatus->position.z; + D_802B7CB8_E20DC8->scale = 0.4f; D_802B7CB8_E20DC8->unk_23 = 0; D_802B7CB8_E20DC8->unk_0C = -gCameras[gCurrentCameraID].currentYaw; D_8010C958 = func_802B7728_E20838; @@ -56,9 +50,6 @@ void func_802B70B4_E201C4(void) { D_802B7CB8_E20DC8->unk_1C = 0xFF; } } -#else -INCLUDE_ASM(s32, "E20110", func_802B70B4_E201C4); -#endif void func_802B71E8_E202F8(void) { FoldImageRecPart sp20; diff --git a/src/battle/partner/goombario.c b/src/battle/partner/goombario.c index bc28713bb3..f33cb0b8a4 100644 --- a/src/battle/partner/goombario.c +++ b/src/battle/partner/goombario.c @@ -74,7 +74,180 @@ ApiStatus func_802380E4_6F11C4(Evt* script, s32 isInitialCall) { return ApiStatus_DONE2; } -INCLUDE_ASM(s32, "battle/partner/goombario", func_8023817C_6F125C); +ApiStatus func_8023817C_6F125C(Evt* script, s32 isInitialCall) { + Bytecode* args = script->ptrReadPos; + BattleStatus* battleStatus = &gBattleStatus; + Actor* actor = battleStatus->partnerActor; + ActorState* state = &actor->state; + f32 stateCurrentX; + f32 stateCurrentZ; + f32 stateGoalX; + f32 stateGoalZ; + f32 oldActorY; + f32 oldActorX; + f64 currentPosX64; + f64 acc1, acc2; + f64 acc3, acc4; + f64 vel1, vel2; + f64 vel3, vel4; + f32 temp; + + if (isInitialCall) { + actor->state.moveTime = evt_get_variable(script, *args++); + actor->state.moveArcAmplitude = evt_get_variable(script, *args++); + script->functionTemp[1] = 0; + script->functionTemp[0] = 0; + if (actor->state.moveArcAmplitude == 1) { + script->functionTemp[0] = 2; + } + } + + if (script->functionTemp[0] == 0) { + state->currentPos.x = actor->currentPos.x; + state->currentPos.y = actor->currentPos.y; + stateGoalX = state->goalPos.x; + stateGoalZ = state->goalPos.z; + stateCurrentX = state->currentPos.x; + stateCurrentZ = actor->currentPos.z; + state->currentPos.z = stateCurrentZ; + state->angle = atan2(stateCurrentX, stateCurrentZ, stateGoalX, stateGoalZ); + state->distance = dist2D(stateCurrentX, stateCurrentZ, stateGoalX, stateGoalZ); + if (state->moveTime == 0) { + state->moveTime = state->distance / state->speed; + temp = state->distance - (state->moveTime * state->speed); + } else { + state->speed = state->distance / state->moveTime; + temp = state->distance - (state->moveTime * state->speed); + } + + if (state->moveTime == 0) { + return ApiStatus_DONE2; + } + + state->unk_30.x = (state->goalPos.x - state->currentPos.x) / state->moveTime; + state->unk_30.y = (state->goalPos.y - state->currentPos.y) / state->moveTime; + state->unk_30.z = (state->goalPos.z - state->currentPos.z) / state->moveTime; + state->acceleration = PI_S / state->moveTime; + state->velocity = 0.0f; + state->speed += temp / state->moveTime; + + if (state->moveArcAmplitude < 3) { + state->unk_24 = 90.0f; + state->unk_28 = 360 / state->moveTime; + temp = state->distance; + temp -= 20.0; + temp /= 6.0; + temp += 47.0; + state->bounceDivisor = temp; + if (state->moveArcAmplitude == 2) { + state->bounceDivisor *= 1.12; + } + state->unk_18.x = 0.0f; + state->unk_18.y = 0.0f; + vel3 = state->velocity; + acc3 = state->acceleration; + state->velocity = vel3 + ((sin_rad(DEG_TO_RAD(state->unk_24)) * 0.53 * acc3) + acc3); + } else { + state->unk_24 = 90.0f; + state->unk_28 = 360 / state->moveTime; + temp = state->distance; + temp -= 20.0; + temp /= 6.0; + temp += 47.0; + state->bounceDivisor = temp; + if (state->moveArcAmplitude == 4) { + state->bounceDivisor *= 1.25; + } + state->unk_18.x = 0.0f; + state->unk_18.y = 0.0f; + vel4 = state->velocity; + acc4 = state->acceleration; + state->velocity = vel4 + ((sin_rad(DEG_TO_RAD(state->unk_24)) * 0.8 * acc4) + acc4); + } + set_animation(ACTOR_PARTNER, 1, state->animJumpRise); + script->functionTemp[0] = 1; + } + + switch (script->functionTemp[0]) { + case 1: + if (state->velocity > PI_S / 2) { + set_animation(ACTOR_PARTNER, 1, state->animJumpFall); + } + oldActorX = actor->currentPos.x; + oldActorY = actor->currentPos.y; + state->currentPos.x += state->unk_30.x; + state->currentPos.y = state->currentPos.y + state->unk_30.y; + state->currentPos.z = state->currentPos.z + state->unk_30.z; + state->unk_18.x = actor->currentPos.y; + actor->currentPos.x = state->currentPos.x; + actor->currentPos.y = state->currentPos.y + (state->bounceDivisor * sin_rad(state->velocity)); + actor->currentPos.z = state->currentPos.z; + if (state->goalPos.y > actor->currentPos.y && state->moveTime < 3) { + actor->currentPos.y = state->goalPos.y; + } + + actor->rotation.z = -atan2(oldActorX, -oldActorY, actor->currentPos.x, -actor->currentPos.y); + state->unk_18.y = actor->currentPos.y; + if (state->moveArcAmplitude < 3) { + vel1 = state->velocity; + acc1 = state->acceleration; + state->velocity = vel1 + ((sin_rad(DEG_TO_RAD(state->unk_24)) * 0.53 * acc1) + acc1); + } else { + vel2 = state->velocity; + acc2 = state->acceleration; + state->velocity = vel2 + ((sin_rad(DEG_TO_RAD(state->unk_24)) * 0.8 * acc2) + acc2); + } + + state->unk_24 += state->unk_28; + state->unk_24 = clamp_angle(state->unk_24); + state->moveTime--; + if (state->moveTime == 0) { + actor->currentPos.y = state->goalPos.y; + state->acceleration = 1.8f; + state->velocity = -(state->unk_18.x - state->unk_18.y); + set_animation(ACTOR_PARTNER, 1, state->animJumpLand); + return ApiStatus_DONE1; + } + break; + case 2: + if (battleStatus->unk_83 == 0) { + return ApiStatus_DONE2; + } + state->moveTime = 1; + state->acceleration = 1.8f; + state->unk_24 = 90.0f; + state->velocity = -(state->unk_18.x - state->unk_18.y); + state->bounceDivisor = fabsf(state->unk_18.x - state->unk_18.y) / 16.5; + state->unk_28 = 360 / state->moveTime; + state->currentPos.x = actor->currentPos.x; + state->currentPos.y = actor->currentPos.y; + state->currentPos.z = actor->currentPos.z; + script->functionTemp[0] = 3; + // fallthrough + case 3: + currentPosX64 = state->currentPos.x; // required to match + state->currentPos.x = currentPosX64 + state->bounceDivisor * sin_rad(DEG_TO_RAD(state->unk_24)) / 33.0; + state->currentPos.y -= state->bounceDivisor * sin_rad(DEG_TO_RAD(state->unk_24)); + state->unk_24 += state->unk_28; + state->unk_24 = clamp_angle(state->unk_24); + actor->currentPos.x = state->currentPos.x; + actor->currentPos.y = state->currentPos.y; + actor->currentPos.z = state->currentPos.z; + + if (gBattleStatus.flags1 & BS_FLAGS1_2000) { + return ApiStatus_DONE2; + } + + state->moveTime--; + if (state->moveTime == 0) { + return ApiStatus_DONE1; + } + break; + } + + return ApiStatus_BLOCK; +} + ApiStatus N(func_80238A20_6F1B00)(Evt* script, s32 isInitialCall) { BattleStatus* battleStatus = &gBattleStatus; diff --git a/src/battle/partner/lakilester.c b/src/battle/partner/lakilester.c index 79240ff50d..01a3bc27df 100644 --- a/src/battle/partner/lakilester.c +++ b/src/battle/partner/lakilester.c @@ -4,7 +4,16 @@ #include "hud_element.h" extern s32 (*D_8023AB80_70E890)[0]; + extern f32 D_8023D1E0; +extern EffectInstance* D_8023D1E4; +extern s32 D_8023D26C; +extern s32 D_8023D270; +extern s32 D_8023D274; +extern s32 D_8023D278; +extern s32 D_8023D27C; +extern s32 D_8023D280; +extern s32 D_8023D284; extern s32 D_8023D288; extern s32 D_8023D28C; extern s32 D_8023D290; @@ -25,6 +34,7 @@ extern s32 D_8023D2C8; extern s32 D_8023D2D0[]; extern s32 D_8023D330; extern s32 D_8023D334; +extern s32 D_8023D338; extern HudScript HES_AimReticle; extern HudScript HES_AimTarget; @@ -142,7 +152,7 @@ ApiStatus func_8023803C_70BD4C(Evt* script, s32 isInitialCall) { if (D_8023D298 != 0) { D_8023D298--; } else { - D_8023D298 = 0x50; + D_8023D298 = 80; hud_element_set_script(D_8023D2BC, HES_StickTapRight); sfx_play_sound_at_position(0x312, 0, 0.0f, 0.0f, 0.0f); script->functionTemp[0] = 2; @@ -150,8 +160,8 @@ ApiStatus func_8023803C_70BD4C(Evt* script, s32 isInitialCall) { break; case 2: dpadY = battleStatus->dpadY; - if (dpadY > 0x50) { - dpadY = 0x50; + if (dpadY > 80) { + dpadY = 80; } dpadX = battleStatus->dpadX; if (dpadY < 35) { @@ -490,6 +500,23 @@ ApiStatus func_8023906C_70CD7C(Evt* script, s32 isInitialCall) { return ApiStatus_DONE2; } +typedef struct UnkLak { + /* 0x00 */ char unk_00[0x44]; + /* 0x44 */ s16 unk_44; + /* 0x46 */ s16 unk_46; + /* 0x48 */ char unk_48[0xC]; + /* 0x54 */ s16 unk_54; + /* 0x56 */ char unk_56[0x4]; + /* 0x5A */ s16 unk_5A; + /* 0x5C */ s8 unk_5C; + /* 0x5D */ s8 unk_5D; + /* 0x5E */ char unk_5E[0x12]; + /* 0x70 */ s16 unk_70; + /* 0x72 */ s16 unk_72; +} UnkLak; + +extern UnkLak* D_8023CCC0_7109D0; + INCLUDE_ASM(s32, "battle/partner/lakilester", func_80239140_70CE50); ApiStatus func_80239F84_70DC94(Evt* script, s32 isInitialCall) { diff --git a/src/battle/partner/parakarry.c b/src/battle/partner/parakarry.c index 59e37085f1..8609df7c57 100644 --- a/src/battle/partner/parakarry.c +++ b/src/battle/partner/parakarry.c @@ -3,6 +3,7 @@ #include "hud_element.h" #include "effects.h" +extern EffectInstance* D_8023BD70; extern s32 D_8023BD78[7]; extern s32 D_8023BD98[6]; extern s32 D_8023BDB4; @@ -433,7 +434,152 @@ ApiStatus func_80238E24_700BA4(Evt* evt, s32 isInitialCall) { return ApiStatus_BLOCK; } -INCLUDE_ASM(s32, "battle/partner/parakarry", func_802390B4_700E34); +ApiStatus func_802390B4_700E34(Evt* script, s32 isInitialCall) { + Actor* partner = gBattleStatus.partnerActor; + ActorState* state = &partner->state; + + if (isInitialCall) { + script->functionTemp[0] = 0; + } + + switch (script->functionTemp[0]) { + case 0: + state->currentPos.x = partner->currentPos.x; + state->currentPos.y = partner->currentPos.y; + state->currentPos.z = partner->currentPos.z; + state->angle = 60 - rand_int(10); + state->bounceDivisor = 0.0f; + state->moveTime = 90; + state->speed = 48.0f; + script->functionTemp[1] = 0; + script->functionTemp[2] = 0; + script->functionTemp[3] = 0; + D_8023BD70 = fx_65(0, state->currentPos.x, state->currentPos.y, state->currentPos.z, 1.0f, 0); + script->functionTemp[0] = 1; + break; + case 1: + add_vec2D_polar(&state->currentPos.x, &state->currentPos.y, state->speed, state->angle); + D_8023BD70->data.unk_65->pos.x = state->currentPos.x; + D_8023BD70->data.unk_65->pos.y = state->currentPos.y; + D_8023BD70->data.unk_65->pos.z = state->currentPos.z; + if (state->currentPos.x < -190.0f) { + if (script->functionTemp[1] != 0) { + script->functionTemp[0] = 2; + break; + } + if (state->angle >= 270.0f && state->angle < 360.0f) { + state->angle = 90.0f + (90.0f - clamp_angle(state->angle + 180.0f)); + state->bounceDivisor = rand_int(4) - 2; + } + if (state->angle >= 180.0f && state->angle < 270.0f) { + state->angle = 90.0f - (clamp_angle(state->angle + 180.0f) - 90.0f); + state->bounceDivisor = rand_int(4) - 2; + } + + if (script->functionTemp[3] != 0) { + sfx_play_sound_at_position(SOUND_200A, 0, state->currentPos.x, state->currentPos.y, state->currentPos.z); + } else { + sfx_play_sound_at_position(SOUND_200B, 0, state->currentPos.x, state->currentPos.y, state->currentPos.z); + } + script->functionTemp[3] = 1 - script->functionTemp[3]; + } + + if (state->currentPos.x > 190.0f) { + if (script->functionTemp[1] != 0) { + script->functionTemp[0] = 2; + break; + } + + do { + if (state->angle >= 0.0f && state->angle < 90.0f) { + state->angle = 270.0f + (270.0f - clamp_angle(state->angle + 180.0f)); + } else if (state->angle >= 90.0f && state->angle < 180.0f) { + state->angle = 270.0f - (clamp_angle(state->angle + 180.0f) - 270.0f); + } + } while (0); + + if (script->functionTemp[3] != 0) { + sfx_play_sound_at_position(SOUND_200A, 0, state->currentPos.x, state->currentPos.y, state->currentPos.z); + } else { + sfx_play_sound_at_position(SOUND_200B, 0, state->currentPos.x, state->currentPos.y, state->currentPos.z); + } + script->functionTemp[3] = 1 - script->functionTemp[3]; + } + + if (state->currentPos.y < -30.0f) { + if (script->functionTemp[1] != 0) { + script->functionTemp[0] = 2; + break; + } + + do { + if (state->angle >= 270.0f && state->angle < 360.0f) { + state->angle = 180.0f + (180.0f - clamp_angle(state->angle + 180.0f)); + } else if (state->angle >= 0.0f && state->angle < 90.0f) { + state->angle = 180.0f - (clamp_angle(state->angle + 180.0f) - 180.0f); + } + } while (0); // TODO macro? + + if (script->functionTemp[3] != 0) { + sfx_play_sound_at_position(SOUND_200A, 0, state->currentPos.x, state->currentPos.y, state->currentPos.z); + } else { + sfx_play_sound_at_position(SOUND_200B, 0, state->currentPos.x, state->currentPos.y, state->currentPos.z); + } + script->functionTemp[3] = 1 - script->functionTemp[3]; + } + + if (state->currentPos.y > 160.0f) { + if (script->functionTemp[1] != 0) { + script->functionTemp[0] = 2; + break; + } + + do { + if (state->angle >= 90.0f && state->angle < 180.0f) { + state->angle = 360.0f + (360.0f - clamp_angle(state->angle + 180.0f)); + } else if (state->angle >= 180.0f && state->angle < 270.0f) { + state->angle = 360.0f - (clamp_angle(state->angle + 180.0f) - 360.0f); + } + } while (0); // TODO macro? + + if (script->functionTemp[3] != 0) { + sfx_play_sound_at_position(SOUND_200A, 0, state->currentPos.x, state->currentPos.y, state->currentPos.z); + } else { + sfx_play_sound_at_position(SOUND_200B, 0, state->currentPos.x, state->currentPos.y, state->currentPos.z); + } + script->functionTemp[3] = 1 - script->functionTemp[3]; + } + + state->angle = clamp_angle(state->angle + (state->bounceDivisor * 0.5)); + if (state->moveTime != 0) { + state->moveTime--; + } else { + script->functionTemp[1] = 1; + } + break; + } + + switch (script->functionTemp[0]) { + case 2: + state->moveTime = 5; + script->functionTemp[0] = 3; + D_8023BD70->flags |= 0x10; + // fallthrough + case 3: + add_vec2D_polar(&state->currentPos.x, &state->currentPos.y, state->speed, state->angle); + if (state->moveTime == 0) { + partner->rotation.z = 0.0f; + return ApiStatus_DONE2; + } + state->moveTime--; + // fallthrough + default: + partner->currentPos.x = state->currentPos.x; + partner->currentPos.y = state->currentPos.y; + partner->currentPos.z = state->currentPos.z; + return ApiStatus_BLOCK; + } +} ApiStatus func_802397C8_701548(Evt* script, s32 isInitialCall) { script->varTable[15] = ((script->varTable[0] * 100) / 2499) + 2; diff --git a/src/battle/partner/sushie.c b/src/battle/partner/sushie.c index e0aa86e6dd..4abf51000c 100644 --- a/src/battle/partner/sushie.c +++ b/src/battle/partner/sushie.c @@ -6,8 +6,8 @@ extern EffectInstance* D_8023C070; ApiStatus func_80238000_707CA0(Evt* script, s32 isInitialCall) { ActorPart* targetPart; - Actor* partner = gBattleStatus.partnerActor; + set_goal_pos_to_part(&partner->state, partner->targetActorID, partner->targetPartIndex); targetPart = get_actor_part(get_actor(partner->targetActorID), partner->targetPartIndex); @@ -33,7 +33,58 @@ ApiStatus func_80238000_707CA0(Evt* script, s32 isInitialCall) { return ApiStatus_DONE2; } -INCLUDE_ASM(s32, "battle/partner/sushie", func_80238114_707DB4); +ApiStatus func_80238114_707DB4(Evt* script, s32 isInitialCall) { + Actor* partner = gBattleStatus.partnerActor; + s32 vt0 = script->varTable[0]; + s32 vt15 = 0; + + script->varTable[0] = 0; + + switch (partner->actorBlueprint->level) { + case 0: + vt15 = 3; + if (vt0 > 40) { + vt15 = 4; + if (vt0 > 75) { + vt15 = 5; + script->varTable[0] = 1; + } + } + break; + case 1: + vt15 = 3; + if (vt0 > 35) { + vt15 = 4; + if (vt0 > 60) { + vt15 = 5; + if (vt0 > 80) { + vt15 = 6; + script->varTable[0] = 1; + } + } + } + break; + case 2: + vt15 = 3; + if (vt0 > 20) { + vt15 = 4; + if (vt0 > 30) { + vt15 = 5; + if (vt0 > 60) { + vt15 = 6; + if (vt0 > 80) { + vt15 = 7; + script->varTable[0] = 1; + } + } + } + } + break; + } + + script->varTable[15] = vt15; + return ApiStatus_DONE2; +} ApiStatus func_802381EC_707E8C(Evt* script, s32 isInitialCall) { BattleStatus* battleStatus = &gBattleStatus; @@ -41,7 +92,6 @@ ApiStatus func_802381EC_707E8C(Evt* script, s32 isInitialCall) { f32 xScale; f32 yScale; f32 zScale; - s32 temp_v0; if (isInitialCall) { script->functionTemp[0] = 0; @@ -55,17 +105,14 @@ ApiStatus func_802381EC_707E8C(Evt* script, s32 isInitialCall) { partnerActor->scale.y = yScale + ((1.0 - yScale) / 3.0); partnerActor->scale.z = zScale + ((1.0 - zScale) / 3.0); - temp_v0 = script->functionTemp[1]; - if (temp_v0) { - script->functionTemp[1] = temp_v0 - 1; - + if (script->functionTemp[1] != 0) { + script->functionTemp[1]--; return ApiStatus_BLOCK; } partnerActor->scale.x = 1.0f; partnerActor->scale.y = 1.0f; partnerActor->scale.z = 1.0f; - return ApiStatus_DONE2; } @@ -129,7 +176,178 @@ ApiStatus func_80238480_708120(Evt* script, s32 isInitialCall) { return ApiStatus_DONE2; } -INCLUDE_ASM(s32, "battle/partner/sushie", func_80238540_7081E0); +ApiStatus func_80238540_7081E0(Evt* script, s32 isInitialCall) { + Actor* partner = gBattleStatus.partnerActor; + ActorState* state = &partner->state; + f32 x, y; + + if (isInitialCall) { + script->functionTemp[0] = 0; + } + + switch (script->functionTemp[0]) { + case 0: + state->currentPos.x = partner->currentPos.x; + state->currentPos.y = partner->currentPos.y; + state->currentPos.z = partner->currentPos.z; + state->angle = 315.0f; + state->bounceDivisor = 0.0f; + state->moveTime = 90; + state->speed = 32.0f; + script->functionTemp[1] = 0; + script->functionTemp[2] = 0; + D_8023C070 = fx_water_fountain(1, state->currentPos.x, state->currentPos.y, state->currentPos.z, 1.0f, 0); + D_8023C070->data.waterFountain->unk_38 = state->angle; + D_8023C070->data.waterFountain->unk_3C = partner->scale.x; + D_8023C070->data.waterFountain->unk_40 = partner->scale.x; + script->functionTemp[0] = 1; + break; + case 1: + add_vec2D_polar(&state->currentPos.x, &state->currentPos.y, state->speed, state->angle); + if (state->currentPos.x < -160.0f) { + if (script->functionTemp[1] != 0) { + script->functionTemp[0] = 2; + break; + } + if (state->angle >= 270.0f && state->angle < 360.0f) { + state->angle = 90.0f + (90.0f - clamp_angle(state->angle + 180.0f)); + state->bounceDivisor = rand_int(4) - 2; + } + if (state->angle >= 180.0f && state->angle < 270.0f) { + state->angle = 90.0f - (clamp_angle(state->angle + 180.0f) - 90.0f); + state->bounceDivisor = rand_int(4) - 2; + } + } + + if (state->currentPos.x > 160.0f) { + if (script->functionTemp[1] != 0) { + script->functionTemp[0] = 2; + break; + } + + do { + if (state->angle >= 0.0f && state->angle < 90.0f) { + state->angle = 270.0f + (270.0f - clamp_angle(state->angle + 180.0f)); + state->bounceDivisor = rand_int(4) - 2; + } else if (state->angle >= 90.0f && state->angle < 180.0f) { + state->angle = 270.0f - (clamp_angle(state->angle + 180.0f) - 270.0f); + state->bounceDivisor = rand_int(4) - 2; + } + } while (0); + + if (script->functionTemp[2] != 0) { + sfx_play_sound_at_position(SOUND_29B, 0, state->currentPos.x, state->currentPos.y, state->currentPos.z); + } else { + sfx_play_sound_at_position(SOUND_29C, 0, state->currentPos.x, state->currentPos.y, state->currentPos.z); + } + script->functionTemp[2] = 1 - script->functionTemp[2]; + } + + if (state->currentPos.y < 0.0f) { + if (script->functionTemp[1] != 0) { + script->functionTemp[0] = 2; + break; + } + + do { + if (state->angle >= 270.0f && state->angle < 360.0f) { + state->angle = 180.0f + (180.0f - clamp_angle(state->angle + 180.0f)); + state->bounceDivisor = rand_int(4) - 2; + } else if (state->angle >= 0.0f && state->angle < 90.0f) { + state->angle = 180.0f - (clamp_angle(state->angle + 180.0f) - 180.0f); + state->bounceDivisor = rand_int(4) - 2; + } + } while (0); // TODO macro? + + if (script->functionTemp[2] != 0) { + sfx_play_sound_at_position(SOUND_29B, 0, state->currentPos.x, state->currentPos.y, state->currentPos.z); + } else { + sfx_play_sound_at_position(SOUND_29C, 0, state->currentPos.x, state->currentPos.y, state->currentPos.z); + } + script->functionTemp[2] = 1 - script->functionTemp[2]; + } + + if (state->currentPos.y > 130.0f) { + if (script->functionTemp[1] != 0) { + script->functionTemp[0] = 2; + break; + } + + do { + if (state->angle >= 90.0f && state->angle < 180.0f) { + state->angle = 360.0f + (360.0f - clamp_angle(state->angle + 180.0f)); + state->bounceDivisor = rand_int(4) - 2; + } else if (state->angle >= 180.0f && state->angle < 270.0f) { + state->angle = 360.0f - (clamp_angle(state->angle + 180.0f) - 360.0f); + state->bounceDivisor = rand_int(4) - 2; + } + } while (0); // TODO macro? + + if (script->functionTemp[2] != 0) { + sfx_play_sound_at_position(SOUND_29B, 0, state->currentPos.x, state->currentPos.y, state->currentPos.z); + } else { + sfx_play_sound_at_position(SOUND_29C, 0, state->currentPos.x, state->currentPos.y, state->currentPos.z); + } + script->functionTemp[2] = 1 - script->functionTemp[2]; + } + + state->angle = clamp_angle(state->angle + (state->bounceDivisor * 0.5)); + partner->rotation.z = clamp_angle(state->angle - 315.0f); + partner->scale.z = partner->scale.y = partner->scale.x = partner->scale.x - 0.06; + if (partner->scale.x < 1.0) { + partner->scale.x = 1.0f; + partner->scale.y = 1.0f; + partner->scale.z = 1.0f; + } + x = 0.0f; + y = 0.0f; + add_vec2D_polar(&x, &y, partner->scale.x * -15.0f, state->angle); + D_8023C070->data.waterFountain->unk_04.x = state->currentPos.x + x; + D_8023C070->data.waterFountain->unk_04.y = state->currentPos.y + y; + D_8023C070->data.waterFountain->unk_04.z = state->currentPos.z + 5.0f; + D_8023C070->data.waterFountain->unk_38 = state->angle; + D_8023C070->data.waterFountain->unk_3C = partner->scale.x; + D_8023C070->data.waterFountain->unk_40 = partner->scale.x; + if (state->moveTime == 0x46) { + sfx_play_sound_at_position(SOUND_29D, 0, 0.0f, 0.0f, 0.0f); + fx_underwater(0, -50.0f, 20.0f, 0.0f, 1.0f, 120); + } + + if (state->moveTime != 0) { + state->moveTime--; + } else { + script->functionTemp[1] = 1; + } + break; + } + + switch (script->functionTemp[0]) { + case 2: + state->moveTime = 5; + script->functionTemp[0] = 3; + case 3: + add_vec2D_polar(&state->currentPos.x, &state->currentPos.y, state->speed, state->angle); + D_8023C070->data.waterFountain->unk_04.x = state->currentPos.x; + D_8023C070->data.waterFountain->unk_04.y = state->currentPos.y; + D_8023C070->data.waterFountain->unk_04.z = state->currentPos.z; + D_8023C070->data.waterFountain->unk_38 = state->angle; + D_8023C070->data.waterFountain->unk_3C = partner->scale.x; + D_8023C070->data.waterFountain->unk_40 = partner->scale.x; + if (state->moveTime == 0) { + partner->rotation.z = 0.0f; + D_8023C070->flags |= ACTOR_FLAG_10; + return ApiStatus_DONE2; + } + state->moveTime--; + default: + partner->currentPos.x = state->currentPos.x; + partner->currentPos.y = state->currentPos.y; + partner->currentPos.z = state->currentPos.z; + fx_water_splash(3, partner->currentPos.x, partner->currentPos.y, partner->currentPos.z, 1.0f, 10); + break; + } + return ApiStatus_BLOCK; +} ApiStatus func_80238E30_708AD0(Evt* script, s32 isInitialCall) { BattleStatus* battleStatus = &gBattleStatus; diff --git a/src/battle/partner/watt.c b/src/battle/partner/watt.c index a40489d398..002dcbbf53 100644 --- a/src/battle/partner/watt.c +++ b/src/battle/partner/watt.c @@ -16,7 +16,77 @@ extern s32 D_8023C1C8; extern EffectInstance* D_8023C1CC; extern EffectInstance* D_8023C1D0; -INCLUDE_ASM(s32, "battle/partner/watt", func_80238000_703AF0); +ApiStatus func_80238000_703AF0(Evt* script, s32 isInitialCall) { + Actor* partner = gBattleStatus.partnerActor; + f32 x, y, z; + + if (isInitialCall) { + D_8023C1BC = 1; + D_8023C1C0 = 0; + D_8023C1C4 = 1; + D_8023C1C8 = 0; + D_8023C1CC = fx_static_status(0, partner->currentPos.x, partner->currentPos.y, partner->currentPos.z, 1.0f, 5, 0); + D_8023C1D0 = fx_static_status(1, partner->currentPos.x, -1000.0f, partner->currentPos.z, 1.0f, 5, 0); + D_8023C1B8 = 1; + } + + if (D_8023C1B8 == 0) { + return ApiStatus_DONE2; + } + + if (D_8023C1BC != 0) { + D_8023C1C0 += 15; + D_8023C1C0 = clamp_angle(D_8023C1C0); + } + + partner->unk_19A = sin_rad(DEG_TO_RAD(D_8023C1C0)) * 3.0f; + x = partner->currentPos.x + partner->headOffset.x; + y = partner->currentPos.y + partner->headOffset.y + partner->unk_19A + 12.0f; + z = partner->currentPos.z + partner->headOffset.z; + if ((gBattleStatus.flags2 & (BS_FLAGS2_10 | BS_FLAGS2_4)) == BS_FLAGS2_4) { + y = -1000.0f; + } + + if (D_8023C1C4 != 0) { + switch (D_8023C1C8) { + case 0: + if (D_8023C1CC == NULL) { + D_8023C1CC = fx_static_status(0, x, y, z, 1.0f, 5, 0); + } + if (D_8023C1D0 != NULL) { + D_8023C1D0->flags |= 0x10; + D_8023C1D0 = NULL; + } + D_8023C1CC->data.staticStatus->unk_04 = x; + D_8023C1CC->data.staticStatus->unk_08 = y; + D_8023C1CC->data.staticStatus->unk_0C = z; + break; + case 1: + if (D_8023C1CC != NULL) { + D_8023C1CC->flags |= 0x10; + D_8023C1CC = NULL; + } + if (D_8023C1D0 == NULL) { + D_8023C1D0 = fx_static_status(1, x, y, z, 1.0f, 5, 0); + } + D_8023C1D0->data.staticStatus->unk_04 = x; + D_8023C1D0->data.staticStatus->unk_08 = y; + D_8023C1D0->data.staticStatus->unk_0C = z; + break; + } + } else { + if (D_8023C1CC != NULL) { + D_8023C1CC->flags |= 0x10; + D_8023C1CC = NULL; + } + if (D_8023C1D0 != NULL) { + D_8023C1D0->flags |= 0x10; + D_8023C1D0 = NULL; + } + } + + return ApiStatus_BLOCK; +} ApiStatus func_80238370_703E60(Evt* script, s32 isInitialCall) { D_8023C1B8 = 0; diff --git a/src/de740_len_23f0.c b/src/de740_len_23f0.c index bd0a91c05f..36ec80ffcb 100644 --- a/src/de740_len_23f0.c +++ b/src/de740_len_23f0.c @@ -294,6 +294,7 @@ void appendGfx_shading_palette( f32 var_f8; f32 abc; f32 ex, ey, ez; + f32 t1; var_f12 = (shadowX * shadowX) + (shadowY * shadowY) + (shadowZ * shadowZ); @@ -323,8 +324,10 @@ void appendGfx_shading_palette( ez = mtx[2][2]; } + temp_f6 = ex * shadowX; temp_f6_2 = (shadowX * -camera->perspectiveMatrix[2][2]) + (shadowZ * camera->perspectiveMatrix[0][2]); - if ((ex * shadowX) + (ey * shadowY) + (ez * shadowZ) > 0.0f) { + t1 = temp_f6 + (ey * shadowY) + (ez * shadowZ); + if (t1 > 0.0f) { var_f26 = ambientPower * temp_f6_2; } else { var_f26 = ambientPower; @@ -406,10 +409,16 @@ void appendGfx_shading_palette( COMBINED, 0, 0, 0, COMBINED); } - // abc = var_f30 * var_f26; abc = var_f26; - abc = var_f30 * abc; - gDPSetTileSize(gMasterGfxPos++, 0, ((uls + 0x100) << 2) + (s32)abc, ((ult + 0x100) << 2) + (s32)temp_f28, ((lrs + 0x100 - 1) << 2) + (s32)abc, ((lrt + 0x100 - 1) << 2) + (s32)temp_f28); + abc *= var_f30; + gDPSetTileSize( + gMasterGfxPos++, + 0, + ((uls + 0x100) << 2) + (s32)abc, + ((ult + 0x100) << 2) + (s32)temp_f28, + ((lrs + 0x100 - 1) << 2) + (s32)abc, + ((lrt + 0x100 - 1) << 2) + (s32)temp_f28 + ); } #else INCLUDE_ASM(s32, "de740_len_23f0", appendGfx_shading_palette); diff --git a/src/main_loop.c b/src/main_loop.c index 8eabcb51ab..c175ef2ecd 100644 --- a/src/main_loop.c +++ b/src/main_loop.c @@ -363,26 +363,213 @@ void gfx_init_state(void) { gSPDisplayList(gMasterGfxPos++, OS_K0_TO_PHYSICAL(D_80074210)); } -s32 gfx_frame_filter_pass_0(const u16* frameBuffer0, const u16* frameBuffer1, s32 y, s32 x, u8* out) { +s32 gfx_frame_filter_pass_0(const u16* frameBuffer0, const u16* frameBuffer1, s32 y, s32 x, Color_RGBA8* out) { s32 pixel = SCREEN_WIDTH * y + x; - out[3] = (frameBuffer1[pixel] >> 2) & 0xF; - out[0] = frameBuffer0[pixel] >> 11; // red - out[1] = (frameBuffer0[pixel] >> 6) & 0x1F; // green - out[2] = (frameBuffer0[pixel] >> 1) & 0x1F; // blue + out->a = (frameBuffer1[pixel] >> 2) & 0xF; + out->r = (frameBuffer0[pixel] >> 11); + out->g = (frameBuffer0[pixel] >> 6) & 0x1F; + out->b = (frameBuffer0[pixel] >> 1) & 0x1F; } -void gfx_frame_filter_pass_1(u8* filterBuf0, u32 filterBuf1, u16* out); -INCLUDE_ASM(void, "main_loop", gfx_frame_filter_pass_1, u8* filterBuf0, u32 filterBuf1, u16* out); +void gfx_frame_filter_pass_1(Color_RGBA8* filterBuf0, Color_RGBA8 filterBuf1, u16* out) { + Color_RGBA8 sp0; + Color_RGBA8 sp8; + Color_RGBA8 final; + u8 rs[0x20]; + u8 gs[0x20]; + u8 bs[0x20]; + s32 i; -INCLUDE_ASM(s32, "main_loop", func_80027600); + sp8 = filterBuf1; + sp0 = filterBuf1; -INCLUDE_ASM(s32, "main_loop", func_80027774); + for (i = 0; i < ARRAY_COUNT(rs); i++) { + rs[i] = 0; + gs[i] = 0; + bs[i] = 0; + } + + for (i = 0; i < 6; i++) { + if (filterBuf0[i].a == 8) { + rs[filterBuf0[i].r]++; + gs[filterBuf0[i].g]++; + bs[filterBuf0[i].b]++; + } + } + + for (i = 0; i < ARRAY_COUNT(rs); i++) { + if (rs[i] != 0) { + rs[i]--; + break; + } + } + for (; i < ARRAY_COUNT(rs); i++) { + if (rs[i] != 0) { + break; + } + } + if (sp0.r > i) { + sp0.r = i; + } + + for (i = 0; i < ARRAY_COUNT(gs); i++) { + if (gs[i] != 0) { + gs[i]--; + break; + } + } + for (; i < ARRAY_COUNT(gs); i++) { + if (gs[i] != 0) { + break; + } + } + if (sp0.g > i) { + sp0.g = i; + } + + for (i = 0; i < ARRAY_COUNT(bs); i++) { + if (bs[i] != 0) { + bs[i]--; + break; + } + } + for (; i < ARRAY_COUNT(bs); i++) { + if (bs[i] != 0) { + break; + } + } + if (sp0.b > i) { + sp0.b = i; + } + + for (i = ARRAY_COUNT(rs) - 1; i >= 0; i--) { + if (rs[i] != 0) { + break; + } + } + if (sp8.r < i) { + sp8.r = i; + } + + for (i = ARRAY_COUNT(gs) - 1; i >= 0; i--) { + if (gs[i] != 0) { + break; + } + } + if (sp8.g < i) { + sp8.g = i; + } + + for (i = ARRAY_COUNT(bs) - 1; i >= 0; i--) { + if (bs[i] != 0) { + break; + } + } + if (sp8.b < i) { + sp8.b = i; + } + + final.r = (sp8.r + sp0.r) - filterBuf1.r; + final.g = (sp8.g + sp0.g) - filterBuf1.g; + final.b = (sp8.b + sp0.b) - filterBuf1.b; + + final.r = ((filterBuf1.r * filterBuf1.a) + (final.r * (8 - filterBuf1.a))) >> 3; + final.g = ((filterBuf1.g * filterBuf1.a) + (final.g * (8 - filterBuf1.a))) >> 3; + final.b = ((filterBuf1.b * filterBuf1.a) + (final.b * (8 - filterBuf1.a))) >> 3; + + *out = (final.r << 11) + (final.g << 6) + (final.b << 1) + 1; +} + +void func_80027600(Color_RGBA8* arg0, s16* out) { + Color_RGBA8 final; + u8 rs[0x20]; + u8 gs[0x20]; + u8 bs[0x20]; + s32 i; + s32 sum; + + for (i = 0; i < ARRAY_COUNT(rs); i++) { + rs[i] = 0; + gs[i] = 0; + bs[i] = 0; + } + + for (i = 0; i < 9; i++) { + rs[arg0[i].r]++; + gs[arg0[i].g]++; + bs[arg0[i].b]++; + } + + sum = 0; + for (i = 0; i < ARRAY_COUNT(rs); i++) { + sum += rs[i]; + if (sum >= 5) { + break; + } + } + final.r = i; + + sum = 0; + for (i = 0; i < ARRAY_COUNT(gs); i++) { + sum += gs[i]; + if (sum >= 5) { + break; + } + } + final.g = i; + + sum = 0; + for (i = 0; i < ARRAY_COUNT(bs); i++) { + sum += bs[i]; + if (sum >= 5) { + break; + } + } + final.b = i; + + *out = (final.r << 11) + (final.g << 6) + (final.b << 1) + 1; +} + +void func_80027774(u16* frameBuffer0, u16* frameBuffer1, u16* zBuffer) { + Color_RGBA8 filterBuf0[9]; + s32 x, y; + + for (y = 1; y < SCREEN_HEIGHT - 1; y++) { + for (x = 1; x < SCREEN_WIDTH - 1; x++) { + + /* + The application of gfx_frame_filter_pass_0 is done to the following pixels, where x is the current pixel. + ... + .x. + ... + */ + if ( + (((frameBuffer1[(SCREEN_WIDTH * y) + x - 1] >> 2) & 0xF) < 8) || + (((frameBuffer1[(SCREEN_WIDTH * y) + x + 0] >> 2) & 0xF) < 8) || + (((frameBuffer1[(SCREEN_WIDTH * y) + x + 1] >> 2) & 0xF) < 8)) + { + gfx_frame_filter_pass_0(frameBuffer0, frameBuffer1, y - 1, x - 1, &filterBuf0[0]); + gfx_frame_filter_pass_0(frameBuffer0, frameBuffer1, y - 1, x, &filterBuf0[1]); + gfx_frame_filter_pass_0(frameBuffer0, frameBuffer1, y - 1, x + 1, &filterBuf0[2]); + gfx_frame_filter_pass_0(frameBuffer0, frameBuffer1, y , x - 1, &filterBuf0[3]); + gfx_frame_filter_pass_0(frameBuffer0, frameBuffer1, y , x, &filterBuf0[4]); + gfx_frame_filter_pass_0(frameBuffer0, frameBuffer1, y , x + 1, &filterBuf0[5]); + gfx_frame_filter_pass_0(frameBuffer0, frameBuffer1, y + 1, x - 1, &filterBuf0[6]); + gfx_frame_filter_pass_0(frameBuffer0, frameBuffer1, y + 1, x, &filterBuf0[7]); + gfx_frame_filter_pass_0(frameBuffer0, frameBuffer1, y + 1, x + 1, &filterBuf0[8]); + func_80027600(filterBuf0, &zBuffer[(SCREEN_WIDTH * y) + x]); + } else { + zBuffer[(SCREEN_WIDTH * y) + x] = frameBuffer0[(SCREEN_WIDTH * y) + x] | 1; + } + } + } +} // transfers the framebuffer into the depth buffer and applies filters void gfx_transfer_frame_to_depth(u16* frameBuffer0, u16* frameBuffer1, u16* zBuffer) { - u8 filterBuf0[24]; - u8 filterBuf1[4]; + Color_RGBA8 filterBuf0[6]; + Color_RGBA8 filterBuf1; s32 y; s32 x; @@ -398,16 +585,13 @@ void gfx_transfer_frame_to_depth(u16* frameBuffer0, u16* frameBuffer1, u16* zBuf */ if (((frameBuffer1[pixel] >> 2) & 0xF) < 8) { gfx_frame_filter_pass_0(frameBuffer0, frameBuffer1, y - 1, x - 1, &filterBuf0[0]); - gfx_frame_filter_pass_0(frameBuffer0, frameBuffer1, y - 1, x + 1, &filterBuf0[4]); - gfx_frame_filter_pass_0(frameBuffer0, frameBuffer1, y, x - 2, &filterBuf0[8]); - gfx_frame_filter_pass_0(frameBuffer0, frameBuffer1, y, x + 2, &filterBuf0[12]); - gfx_frame_filter_pass_0(frameBuffer0, frameBuffer1, y + 1, x - 1, &filterBuf0[16]); - gfx_frame_filter_pass_0(frameBuffer0, frameBuffer1, y + 1, x + 1, &filterBuf0[20]); - gfx_frame_filter_pass_0(frameBuffer0, frameBuffer1, y, x, &filterBuf1[0]); - gfx_frame_filter_pass_1(filterBuf0, (filterBuf1[0] << 24) | - (filterBuf1[1] << 16) | - (filterBuf1[2] << 8) | - (filterBuf1[3] << 0), &zBuffer[pixel]); + gfx_frame_filter_pass_0(frameBuffer0, frameBuffer1, y - 1, x + 1, &filterBuf0[1]); + gfx_frame_filter_pass_0(frameBuffer0, frameBuffer1, y, x - 2, &filterBuf0[2]); + gfx_frame_filter_pass_0(frameBuffer0, frameBuffer1, y, x + 2, &filterBuf0[3]); + gfx_frame_filter_pass_0(frameBuffer0, frameBuffer1, y + 1, x - 1, &filterBuf0[4]); + gfx_frame_filter_pass_0(frameBuffer0, frameBuffer1, y + 1, x + 1, &filterBuf0[5]); + gfx_frame_filter_pass_0(frameBuffer0, frameBuffer1, y, x, &filterBuf1); + gfx_frame_filter_pass_1(filterBuf0, filterBuf1, &zBuffer[pixel]); } else { // Don't apply any filters to the edges of the screen zBuffer[pixel] = frameBuffer0[pixel] | 1; diff --git a/src/npc.c b/src/npc.c index 777752b550..df908e366b 100644 --- a/src/npc.c +++ b/src/npc.c @@ -1844,41 +1844,46 @@ Npc* npc_find_closest_simple(f32 x, f32 y, f32 z, f32 radius) { // Needs work #ifdef NON_EQUIVALENT s32 npc_find_standing_on_entity(s32 arg0) { - s32 entityIndex = arg0 | 0x4000; - Entity* entity = get_entity_by_index(entityIndex); - s32 y = entity->position.y - 10.0f; - s32 floorID; + Npc* npc; + s32 y; s32 i; + s32 var_v1; + + var_v1 = arg0 | 0x4000; + y = get_entity_by_index(var_v1)->position.y - 10.0f; for (i = 0; i < ARRAY_COUNT(*gCurrentNpcListPtr); i++) { - Npc* npc = (*gCurrentNpcListPtr)[i]; + npc = (*gCurrentNpcListPtr)[i]; - if (npc != NULL) { - if (npc->flags != 0) { - if (!(npc->flags & 0x80000004)) { - if (!(npc->pos.y < y)) { - if (npc->flags & 0x8008) { - floorID = npc_get_collider_below(npc); - if (floorID == 0) { - continue; - } - } else { - floorID = npc->currentFloor; - - if (!(floorID & COLLISION_WITH_ENTITY_BIT)) { - continue; - } - } - - if (entityIndex == floorID) { - return i; - } - } + if (npc == NULL) { + continue; + } + if (npc->flags == 0) { + continue; + } + if (npc->flags & (0x80000000 | 0x4)) { + continue; + } + if (npc->pos.y < y) { + continue; + } + if (npc->flags & (0x8000 | 0x8)) { + var_v1 = npc_get_collider_below(npc); + if (var_v1 != 0) { + if ((arg0 | 0x4000) == var_v1) { + return i; } } + } else { + var_v1 = npc->currentFloor; + if (npc->currentFloor & 0x4000) { + if ((arg0 | 0x4000) == var_v1) { + return i; + } + } + } } - return -1; } #else diff --git a/src/world/area_tst/tst_13/tst_13_1_main.c b/src/world/area_tst/tst_13/tst_13_1_main.c index 8b8956c724..58cd0209dc 100644 --- a/src/world/area_tst/tst_13/tst_13_1_main.c +++ b/src/world/area_tst/tst_13/tst_13_1_main.c @@ -2,12 +2,6 @@ void mdl_project_tex_coords(s32 modelID, Gfx* destGfx, Matrix4f destMtx, void* destVertices); -//TODO remove these when splat can deal with vtx arrays better -// also remove them from undefined_syms -extern Vtx D_802423D0[]; -extern Vtx D_80242310[]; -extern Vtx flo_23_ConsumableChoiceList[]; - extern EvtScript N(EVS_Main); extern EvtScript N(D_80240510_B1DC70); extern EvtScript N(D_80240894_B1DFF4); @@ -489,7 +483,7 @@ Gfx N(dummy_gfx)[] = { s32 N(D_80242BF8_B20358) = 0; s32 N(D_80242BFC_B2035C)[] = { - 5, 4, -35, 0, -45, 342 + 5, 4, -35, 0, -45, 342 }; EvtScript N(EVS_Main) = { diff --git a/tools/splat/.gitrepo b/tools/splat/.gitrepo index 06b6c07cb3..fa3514eb14 100644 --- a/tools/splat/.gitrepo +++ b/tools/splat/.gitrepo @@ -6,7 +6,7 @@ [subrepo] remote = https://github.com/ethteck/splat.git branch = master - commit = 4e5fca24a53f6ec443ed87a6cb365f7985cd6f3a - parent = 59421ff6eeb64cd96ca3ba0699a6d683febcc047 + commit = 6c228fc53a8f1da47775c9807401710d06495e71 + parent = 198ed0efc54dc06e8a86325bd52b29b7a37f39aa method = merge cmdver = 0.4.5 diff --git a/tools/splat/create_config.py b/tools/splat/create_config.py index edf55a7668..3e2993b055 100755 --- a/tools/splat/create_config.py +++ b/tools/splat/create_config.py @@ -43,6 +43,8 @@ options: # mips_abi_float_regs: o32 # section_order: [".text", ".data", ".rodata", ".bss"] # auto_all_sections: [".data", ".rodata", ".bss"] + # libultra_symbols: True + # hardware_regs: True """ first_section_end = find_code_length.run(rom_bytes, 0x1000, rom.entry_point) diff --git a/tools/splat/platforms/n64.py b/tools/splat/platforms/n64.py new file mode 100644 index 0000000000..ed3ee1c31a --- /dev/null +++ b/tools/splat/platforms/n64.py @@ -0,0 +1,10 @@ +from util import compiler, log, options, palettes, symbols + + +def init(target_bytes: bytes): + symbols.spim_context.fillDefaultBannedSymbols() + + if options.opts.libultra_symbols: + symbols.spim_context.globalSegment.fillLibultraSymbols() + if options.opts.hardware_regs: + symbols.spim_context.globalSegment.fillHardwareRegs(True) diff --git a/tools/splat/platforms/psx.py b/tools/splat/platforms/psx.py new file mode 100644 index 0000000000..09da192fac --- /dev/null +++ b/tools/splat/platforms/psx.py @@ -0,0 +1,2 @@ +def init(target_bytes: bytes): + pass diff --git a/tools/splat/segtypes/common/asm.py b/tools/splat/segtypes/common/asm.py index f07ac9c24f..25b0be004d 100644 --- a/tools/splat/segtypes/common/asm.py +++ b/tools/splat/segtypes/common/asm.py @@ -15,7 +15,7 @@ class CommonSegAsm(CommonSegCodeSubsegment): and self.rom_end != "auto" and self.rom_start != self.rom_end ): - self.scan_code(rom_bytes, is_asm=True) + self.scan_code(rom_bytes) def get_file_header(self): return [] diff --git a/tools/splat/segtypes/common/code.py b/tools/splat/segtypes/common/code.py index c2f9fb5b54..87fa7b4f82 100644 --- a/tools/splat/segtypes/common/code.py +++ b/tools/splat/segtypes/common/code.py @@ -55,19 +55,27 @@ class CommonSegCode(CommonSegGroup): else: return None - # Prepare symbol for migration to the function - def check_rodata_sym(self, func_addr: int, sym: Symbol): - if self.section_boundaries[".rodata"].is_complete(): - assert self.section_boundaries[".rodata"].start is not None - assert self.section_boundaries[".rodata"].end is not None + def check_rodata_sym_impl(self, func_addr: int, sym: Symbol, rodata_section: Range): + if rodata_section.is_complete(): + assert rodata_section.start is not None + assert rodata_section.end is not None - rodata_start: int = self.section_boundaries[".rodata"].start - rodata_end: int = self.section_boundaries[".rodata"].end + rodata_start: int = rodata_section.start + rodata_end: int = rodata_section.end if rodata_start <= sym.vram_start < rodata_end: if func_addr not in self.rodata_syms: self.rodata_syms[func_addr] = [] self.rodata_syms[func_addr].append(sym) + # Prepare symbol for migration to the function + def check_rodata_sym(self, func_addr: int, sym: Symbol): + rodata_section = self.section_boundaries.get(".rodata") + if rodata_section is not None: + self.check_rodata_sym_impl(func_addr, sym, rodata_section) + rodata_section = self.section_boundaries.get(".rdata") + if rodata_section is not None: + self.check_rodata_sym_impl(func_addr, sym, rodata_section) + def handle_alls(self, segs: List[Segment], base_segs) -> bool: for i, elem in enumerate(segs): if elem.type.startswith("all_"): @@ -137,6 +145,13 @@ class CommonSegCode(CommonSegGroup): return inserts def parse_subsegments(self, segment_yaml) -> List[Segment]: + if "subsegments" not in segment_yaml: + if not self.parent: + raise Exception( + f"No subsegments provided in top-level code segment {self.name}" + ) + return [] + base_segments: OrderedDict[str, Segment] = OrderedDict() ret = [] prev_start: RomAddr = -1 @@ -155,14 +170,11 @@ class CommonSegCode(CommonSegGroup): ) # Stores yaml index where a section was first found found_sections.pop(".text") - if "subsegments" not in segment_yaml: - return [] - # Mark any manually added dot types cur_section = None for i, subsection_yaml in enumerate(segment_yaml["subsegments"]): - # rompos marker + # endpos marker if isinstance(subsection_yaml, list) and len(subsection_yaml) == 1: continue @@ -202,7 +214,7 @@ class CommonSegCode(CommonSegGroup): inserts = self.find_inserts(found_sections) for i, subsection_yaml in enumerate(segment_yaml["subsegments"]): - # rompos marker + # endpos marker if isinstance(subsection_yaml, list) and len(subsection_yaml) == 1: continue @@ -308,12 +320,16 @@ class CommonSegCode(CommonSegGroup): check = self.handle_alls(ret, base_segments) # TODO why is this necessary? + rodata_section = self.section_boundaries.get( + ".rodata" + ) or self.section_boundaries.get(".rdata") if ( - self.section_boundaries[".rodata"].has_start() - and not self.section_boundaries[".rodata"].has_end() + rodata_section is not None + and rodata_section.has_start() + and not rodata_section.has_end() ): assert self.vram_end is not None - self.section_boundaries[".rodata"].end = self.vram_end + rodata_section.end = self.vram_end return ret diff --git a/tools/splat/segtypes/common/codesubsegment.py b/tools/splat/segtypes/common/codesubsegment.py index 590cb1360c..9c76d7cec1 100644 --- a/tools/splat/segtypes/common/codesubsegment.py +++ b/tools/splat/segtypes/common/codesubsegment.py @@ -36,7 +36,7 @@ class CommonSegCodeSubsegment(Segment): def get_linker_section(self) -> str: return ".text" - def scan_code(self, rom_bytes, is_asm=False): + def scan_code(self, rom_bytes, is_hasm=False): assert isinstance(self.rom_start, int) assert isinstance(self.rom_end, int) @@ -54,7 +54,7 @@ class CommonSegCodeSubsegment(Segment): self.get_exclusive_ram_id(), ) - self.spim_section.isHandwritten = is_asm + self.spim_section.isHandwritten = is_hasm self.spim_section.analyze() self.spim_section.setCommentOffset(self.rom_start) diff --git a/tools/splat/segtypes/common/data.py b/tools/splat/segtypes/common/data.py index 7a1392ddee..5dfbf62a50 100644 --- a/tools/splat/segtypes/common/data.py +++ b/tools/splat/segtypes/common/data.py @@ -43,6 +43,9 @@ class CommonSegData(CommonSegCodeSubsegment, CommonSegGroup): with open(path, "w", newline="\n") as f: f.write('.include "macro.inc"\n\n') + preamble = options.opts.generated_s_preamble + if preamble: + f.write(preamble + "\n") f.write(f".section {self.get_linker_section()}\n\n") f.write(self.spim_section.disassemble()) diff --git a/tools/splat/segtypes/common/group.py b/tools/splat/segtypes/common/group.py index e5a0c374d7..26295fc383 100644 --- a/tools/splat/segtypes/common/group.py +++ b/tools/splat/segtypes/common/group.py @@ -43,7 +43,7 @@ class CommonSegGroup(CommonSegment): prev_start: RomAddr = -1 for i, subsection_yaml in enumerate(yaml["subsegments"]): - # End of previous segment + # endpos marker if isinstance(subsection_yaml, list) and len(subsection_yaml) == 1: continue diff --git a/tools/splat/segtypes/common/hasm.py b/tools/splat/segtypes/common/hasm.py index e0087f7629..933a20eb0a 100644 --- a/tools/splat/segtypes/common/hasm.py +++ b/tools/splat/segtypes/common/hasm.py @@ -2,6 +2,14 @@ from segtypes.common.asm import CommonSegAsm class CommonSegHasm(CommonSegAsm): + def scan(self, rom_bytes: bytes): + if ( + self.rom_start != "auto" + and self.rom_end != "auto" + and self.rom_start != self.rom_end + ): + self.scan_code(rom_bytes, is_hasm=True) + def split(self, rom_bytes: bytes): if not self.rom_start == self.rom_end and self.spim_section is not None: out_path = self.out_path() diff --git a/tools/splat/segtypes/common/rodata.py b/tools/splat/segtypes/common/rodata.py index 99d3203e70..59a8deb705 100644 --- a/tools/splat/segtypes/common/rodata.py +++ b/tools/splat/segtypes/common/rodata.py @@ -1,7 +1,7 @@ import spimdisasm from segtypes.common.data import CommonSegData -from util import symbols, options +from util import symbols, options, compiler class CommonSegRodata(CommonSegData): @@ -60,6 +60,10 @@ class CommonSegRodata(CommonSegData): path = path_folder / f"{rodataSym.getName()}.s" with open(path, "w", newline="\n") as f: - f.write('.include "macro.inc"\n\n') - f.write(".section .rodata\n\n") + if options.opts.compiler.include_macro_inc: + f.write('.include "macro.inc"\n\n') + preamble = options.opts.generated_s_preamble + if preamble: + f.write(preamble + "\n") + f.write(f".section {self.get_linker_section()}\n\n") f.write(rodataSym.disassemble()) diff --git a/tools/splat/segtypes/linker_entry.py b/tools/splat/segtypes/linker_entry.py index 0dd5937798..e7f36d35f5 100644 --- a/tools/splat/segtypes/linker_entry.py +++ b/tools/splat/segtypes/linker_entry.py @@ -108,7 +108,7 @@ class LinkerEntry: class LinkerWriter: def __init__(self): self.linker_discard_section: bool = options.opts.ld_discard_section - self.entries: List[LinkerEntry] = [] + self.entries: List[LinkerEntry] = [] # Used to store all the linker entries - build tools may want this information self.buffer: List[str] = [] self.symbols: List[str] = [] @@ -164,7 +164,7 @@ class LinkerWriter: for entry in entries: entering_bss = False leaving_bss = False - cur_section = entry.section + cur_section = entry.section_type if cur_section == "linker": self._end_block() @@ -231,10 +231,10 @@ class LinkerWriter: section_labels[cur_section].started = True # Write THIS linker entry - self._writeln(f"{entry.object_path}({cur_section});") + self._writeln(f"{entry.object_path}({entry.section});") else: # Write THIS linker entry - self._writeln(f"{entry.object_path}({cur_section});") + self._writeln(f"{entry.object_path}({entry.section});") # If this is the last entry of its type, add the END marker for the section we're ending if entry in last_seen_sections: diff --git a/tools/splat/segtypes/n64/gfx.py b/tools/splat/segtypes/n64/gfx.py index 64f04ef020..6e45c2bdf1 100644 --- a/tools/splat/segtypes/n64/gfx.py +++ b/tools/splat/segtypes/n64/gfx.py @@ -117,7 +117,7 @@ class N64SegGfx(CommonSegCodeSubsegment): def vtx_handler(self, addr, count): sym = self.create_symbol( - addr=addr, in_segment=True, type="data", reference=True, offsets=True + addr=addr, in_segment=True, type="data", reference=True, search_ranges=True ) index = int((addr - sym.vram_start) / 0x10) gfxd_printf(f"&{sym.name}[{index}]") diff --git a/tools/splat/segtypes/segment.py b/tools/splat/segtypes/segment.py index 8e1e7b9b27..f43a837195 100644 --- a/tools/splat/segtypes/segment.py +++ b/tools/splat/segtypes/segment.py @@ -8,6 +8,7 @@ from util import log from util import options from util import symbols from util.symbols import Symbol +from intervaltree import Interval, IntervalTree # circular import if TYPE_CHECKING: @@ -160,6 +161,12 @@ class Segment: else: return options.opts.symbol_name_format_no_rom + @staticmethod + def parse_segment_file_path(segment: Union[dict, list]) -> Optional[Path]: + if isinstance(segment, dict) and "path" in segment: + return Path(segment["path"]) + return None + def __init__( self, rom_start: RomAddr, @@ -184,6 +191,10 @@ class Segment: # Symbols known to be in this segment self.given_seg_symbols: Dict[int, List[Symbol]] = {} + # Ranges for faster symbol lookup + self.symbol_ranges_ram: IntervalTree = IntervalTree() + self.symbol_ranges_rom: IntervalTree = IntervalTree() + self.given_section_order: List[str] = options.opts.section_order self.follows_vram: Optional[str] = None self.follows_vram_symbol: Optional[str] = None @@ -196,6 +207,7 @@ class Segment: self.parent: Optional[Segment] = None self.sibling: Optional[Segment] = None self.follows_vram_segment: Optional[Segment] = None + self.file_path: Optional[Path] = None self.args: List[str] = args self.yaml = yaml @@ -248,6 +260,7 @@ class Segment: ret.given_symbol_name_format_no_rom = ( Segment.parse_segment_symbol_name_format_no_rom(yaml) ) + ret.file_path = Segment.parse_segment_file_path(yaml) if not ret.follows_vram: ret.follows_vram = parse_segment_follows_vram(yaml) @@ -295,6 +308,12 @@ class Segment: self.given_seg_symbols[symbol.vram_start] = [] self.given_seg_symbols[symbol.vram_start].append(symbol) + # For larger symbols, add their ranges to interval trees for faster lookup + if symbol.size > 4: + self.symbol_ranges_ram.addi(symbol.vram_start, symbol.vram_end, symbol) + if symbol.rom and isinstance(symbol.rom, int): + self.symbol_ranges_rom.addi(symbol.rom, symbol.rom_end, symbol) + @property def seg_symbols(self) -> Dict[int, List[Symbol]]: if self.parent: @@ -468,7 +487,7 @@ class Segment: create: bool = False, define: bool = False, reference: bool = False, - offsets: bool = False, + search_ranges: bool = False, local_only: bool = False, dead: bool = True, ) -> Optional[Symbol]: @@ -481,12 +500,25 @@ class Segment: # If the vram address is within this segment, we can calculate the symbol's rom address rom = most_parent.ram_to_rom(addr) ret = most_parent.retrieve_symbol(most_parent.seg_symbols, addr) + + if not ret and search_ranges: + # Search ranges first, starting with rom + if rom is not None: + cands: set[Interval] = most_parent.symbol_ranges_rom[rom] + if cands: + ret = cands.pop().data + # and then vram if we can't find a rom match + if not ret: + cands = most_parent.symbol_ranges_ram[addr] + if cands: + ret = cands.pop().data elif not local_only: ret = most_parent.retrieve_symbol(symbols.all_symbols_dict, addr) - # Search for symbol ranges - if not ret and offsets: - ret = symbols.retrieve_from_ranges(addr, rom) + if not ret and search_ranges: + cands = symbols.all_symbols_ranges[addr] + if cands: + ret = cands.pop().data # Reject dead symbols unless we allow them if not dead and ret and ret.dead: @@ -525,7 +557,7 @@ class Segment: type: Optional[str] = None, define: bool = False, reference: bool = False, - offsets: bool = False, + search_ranges: bool = False, local_only: bool = False, dead: bool = True, ) -> Symbol: @@ -536,7 +568,7 @@ class Segment: create=True, define=define, reference=reference, - offsets=offsets, + search_ranges=search_ranges, local_only=local_only, dead=dead, ) diff --git a/tools/splat/split.py b/tools/splat/split.py index 4e65cbbfcc..e31654dec0 100755 --- a/tools/splat/split.py +++ b/tools/splat/split.py @@ -4,6 +4,7 @@ import argparse import hashlib import pickle from typing import Any, Dict, List, Optional, Set, Union +import importlib import rabbitizer import spimdisasm @@ -17,6 +18,8 @@ from segtypes.segment import Segment from util import compiler, log, options, palettes, symbols VERSION = "0.12.2" +# This value should be keep in sync with the version listed on requirements.txt +SPIMDISASM_MIN = (1, 5, 6) parser = argparse.ArgumentParser( description="Split a rom given a rom, a config, and output directory" @@ -55,7 +58,7 @@ def initialize_segments(config_segments: Union[dict, list]) -> List[Segment]: ret = [] for i, seg_yaml in enumerate(config_segments): - # rompos marker + # end marker if isinstance(seg_yaml, list) and len(seg_yaml) == 1: continue @@ -103,6 +106,9 @@ def initialize_segments(config_segments: Union[dict, list]) -> List[Segment]: def assign_symbols_to_segments(): for symbol in symbols.all_symbols: + if symbol.segment: + continue + if symbol.rom: cands = segment_roms[symbol.rom] if len(cands) > 1: @@ -235,14 +241,11 @@ def configure_disassembler(): spimdisasm.common.GlobalConfig.ASM_TEXT_ENT_LABEL = ".ent" spimdisasm.common.GlobalConfig.ASM_TEXT_FUNC_AS_LABEL = True - if spimdisasm.common.GlobalConfig.ASM_TEXT_LABEL == ".globl": + if spimdisasm.common.GlobalConfig.ASM_DATA_LABEL == ".globl": spimdisasm.common.GlobalConfig.ASM_DATA_SYM_AS_LABEL = True spimdisasm.common.GlobalConfig.LINE_ENDS = options.opts.c_newline - if options.opts.platform == "n64": - symbols.spim_context.fillDefaultBannedSymbols() - def brief_seg_name(seg: Segment, limit: int, ellipsis="…") -> str: s = seg.name.strip() @@ -254,6 +257,11 @@ def brief_seg_name(seg: Segment, limit: int, ellipsis="…") -> str: def main(config_path, modes, verbose, use_cache=True): global config + if spimdisasm.__version_info__ < SPIMDISASM_MIN: + log.error( + f"splat {VERSION} requires as minimum spimdisasm {SPIMDISASM_MIN}, but the installed version is {spimdisasm.__version_info__}" + ) + log.write(f"splat {VERSION} (powered by spimdisasm {spimdisasm.__version__})") # Load config @@ -307,6 +315,10 @@ def main(config_path, modes, verbose, use_cache=True): configure_disassembler() + platform_module = importlib.import_module(f"platforms.{options.opts.platform}") + platform_init = getattr(platform_module, "init") + platform_init(rom_bytes) + # Initialize segments all_segments = initialize_segments(config["segments"]) @@ -354,35 +366,42 @@ def main(config_path, modes, verbose, use_cache=True): symbols.mark_c_funcs_as_defined() # Split - for segment in tqdm.tqdm( + split_bar = tqdm.tqdm( all_segments, total=len(all_segments), - desc=f"Splitting {brief_seg_name(segment, 20)}", - ): + ) + for segment in split_bar: + split_bar.set_description(f"Splitting {brief_seg_name(segment, 20)}") + if use_cache: cached = segment.cache() if cached == cache.get(segment.unique_id()): # Cache hit - seg_cached[typ] += 1 + if segment.type not in seg_cached: + seg_cached[segment.type] = 0 + seg_cached[segment.type] += 1 continue else: # Cache miss; split cache[segment.unique_id()] = cached if segment.should_split(): - segment.split(rom_bytes) + segment_bytes = rom_bytes + if segment.file_path: + with open(segment.file_path, "rb") as segment_input_file: + segment_bytes = segment_input_file.read() + segment.split(segment_bytes) if options.opts.is_mode_active("ld"): global linker_writer linker_writer = LinkerWriter() - for i, segment in enumerate( - tqdm.tqdm( - all_segments, - total=len(all_segments), - desc=f"Writing linker script {brief_seg_name(segment, 20)}", - ) - ): + linker_bar = tqdm.tqdm( + all_segments, + total=len(all_segments), + ) + for i, segment in enumerate(linker_bar): + linker_bar.set_description(f"Linker script {brief_seg_name(segment, 20)}") next_segment: Optional[Segment] = None if i < len(all_segments) - 1: next_segment = all_segments[i + 1] diff --git a/tools/splat/util/compiler.py b/tools/splat/util/compiler.py index e2ab5333f3..205af0a771 100644 --- a/tools/splat/util/compiler.py +++ b/tools/splat/util/compiler.py @@ -9,6 +9,7 @@ class Compiler: asm_end_label: str = "" c_newline: str = "\n" asm_inc_header: str = "" + include_macro_inc: bool = True GCC = Compiler( @@ -22,6 +23,7 @@ SN64 = Compiler( asm_data_macro=".globl", asm_end_label=".end", c_newline="\r\n", + include_macro_inc=False, ) IDO = Compiler("IDO") diff --git a/tools/splat/util/options.py b/tools/splat/util/options.py index 92187566d9..71b602f272 100644 --- a/tools/splat/util/options.py +++ b/tools/splat/util/options.py @@ -155,6 +155,10 @@ class SplatOpts: # Determines the type gfx ucode (used by gfx segments) # Valid options are ['f3d', 'f3db', 'f3dex', 'f3dexb', 'f3dex2'] gfx_ucode: str + # Use named libultra symbols by default. Those will need to be added to a linker script manually by the user + libultra_symbols: bool + # Use named hardware register symbols by default. Those will need to be added to a linker script manually by the user + hardware_regs: bool ################################################################################ # Compiler-specific options @@ -366,6 +370,8 @@ def parse_yaml( ["f3d", "f3db", "f3dex", "f3dexb", "f3dex2"], "f3dex2", ), + libultra_symbols=parse_opt(yaml, "libultra_symbols", bool, False), + hardware_regs=parse_opt(yaml, "hardware_regs", bool, False), use_legacy_include_asm=parse_opt(yaml, "use_legacy_include_asm", bool, True), ) diff --git a/tools/splat/util/symbols.py b/tools/splat/util/symbols.py index 9fd9150686..035e47320e 100644 --- a/tools/splat/util/symbols.py +++ b/tools/splat/util/symbols.py @@ -2,6 +2,7 @@ from typing import Dict, List, Optional, TYPE_CHECKING, Set import spimdisasm import tqdm from dataclasses import dataclass +from intervaltree import IntervalTree, Interval # circular import if TYPE_CHECKING: @@ -11,8 +12,8 @@ from util import options, log all_symbols: List["Symbol"] = [] all_symbols_dict: Dict[int, List["Symbol"]] = {} +all_symbols_ranges = IntervalTree() ignored_addresses: Set[int] = set() -symbol_ranges: List["Symbol"] = [] to_mark_as_defined: Set[str] = set() # Initialize a spimdisasm context, used to store symbols and functions @@ -37,15 +38,19 @@ def add_symbol(sym: "Symbol"): all_symbols_dict[sym.vram_start] = [] all_symbols_dict[sym.vram_start].append(sym) + # For larger symbols, add their ranges to interval trees for faster lookup + if sym.size > 4: + all_symbols_ranges.addi(sym.vram_start, sym.vram_end, sym) + def initialize(all_segments: "List[Segment]"): global all_symbols global all_symbols_dict - global symbol_ranges + global all_symbols_ranges all_symbols = [] all_symbols_dict = {} - symbol_ranges = [] + all_symbols_ranges = IntervalTree() def get_seg_for_name(name: str) -> Optional["Segment"]: for segment in all_segments: @@ -183,10 +188,6 @@ def initialize(all_segments: "List[Segment]"): sym.user_declared = True add_symbol(sym) - # Symbol ranges - if sym.size > 4: - symbol_ranges.append(sym) - def initialize_spim_context(all_segments: "List[Segment]") -> None: global_vrom_start = None @@ -383,6 +384,9 @@ def create_symbol_from_spim_symbol( context_sym.vram, in_segment, type=sym_type, reference=True ) + if sym.given_name is None and context_sym.name is not None: + sym.given_name = context_sym.name + # To keep the symbol name in sync between splat and spimdisasm context_sym.setNameGetCallback(lambda _: sym.name) @@ -398,25 +402,6 @@ def create_symbol_from_spim_symbol( return sym -def retrieve_from_ranges(vram, rom=None): - rom_matches = [] - ram_matches = [] - - for symbol in symbol_ranges: - if symbol.contains_vram(vram): - if symbol.rom and rom and symbol.contains_rom(rom): - rom_matches.append(symbol) - else: - ram_matches.append(symbol) - - ret = rom_matches + ram_matches - - if len(ret) > 0: - return ret[0] - else: - return None - - def mark_c_funcs_as_defined(): for symbol in all_symbols: if len(to_mark_as_defined) == 0: @@ -449,6 +434,15 @@ class Symbol: def __str__(self): return self.name + def __eq__(self, other: object) -> bool: + if not isinstance(other, Symbol): + return False + return self.vram_start == other.vram_start and self.segment == other.segment + + # https://stackoverflow.com/a/56915493/6292472 + def __hash__(self): + return hash((self.vram_start, self.segment)) + def format_name(self, format: str) -> str: ret = format diff --git a/ver/us/asm/nonmatchings/E20110/func_802B70B4_E201C4.s b/ver/us/asm/nonmatchings/E20110/func_802B70B4_E201C4.s deleted file mode 100644 index 813e6593a0..0000000000 --- a/ver/us/asm/nonmatchings/E20110/func_802B70B4_E201C4.s +++ /dev/null @@ -1,83 +0,0 @@ -.set noat # allow manual use of $at -.set noreorder # don't insert nops after branches - -glabel func_802B70B4_E201C4 -/* E201C4 802B70B4 27BDFFE0 */ addiu $sp, $sp, -0x20 -/* E201C8 802B70B8 AFB10014 */ sw $s1, 0x14($sp) -/* E201CC 802B70BC 3C118011 */ lui $s1, %hi(gPlayerStatus) -/* E201D0 802B70C0 2631EFC8 */ addiu $s1, $s1, %lo(gPlayerStatus) -/* E201D4 802B70C4 AFBF0018 */ sw $ra, 0x18($sp) -/* E201D8 802B70C8 AFB00010 */ sw $s0, 0x10($sp) -/* E201DC 802B70CC 8E220004 */ lw $v0, 4($s1) -/* E201E0 802B70D0 30420010 */ andi $v0, $v0, 0x10 -/* E201E4 802B70D4 1040003F */ beqz $v0, .L802B71D4 -/* E201E8 802B70D8 00000000 */ nop -/* E201EC 802B70DC 3C10802B */ lui $s0, %hi(D_802B7CB8_E20DC8) -/* E201F0 802B70E0 26107CB8 */ addiu $s0, $s0, %lo(D_802B7CB8_E20DC8) -/* E201F4 802B70E4 8E040000 */ lw $a0, ($s0) -/* E201F8 802B70E8 0C00A580 */ jal mem_clear -/* E201FC 802B70EC 24050028 */ addiu $a1, $zero, 0x28 -/* E20200 802B70F0 8E030000 */ lw $v1, ($s0) -/* E20204 802B70F4 C6200028 */ lwc1 $f0, 0x28($s1) -/* E20208 802B70F8 2402FFFF */ addiu $v0, $zero, -1 -/* E2020C 802B70FC 3C018011 */ lui $at, %hi(D_8010C950) -/* E20210 802B7100 AC22C950 */ sw $v0, %lo(D_8010C950)($at) -/* E20214 802B7104 E4600000 */ swc1 $f0, ($v1) -/* E20218 802B7108 862200B0 */ lh $v0, 0xb0($s1) -/* E2021C 802B710C C620002C */ lwc1 $f0, 0x2c($s1) -/* E20220 802B7110 44821000 */ mtc1 $v0, $f2 -/* E20224 802B7114 00000000 */ nop -/* E20228 802B7118 468010A0 */ cvt.s.w $f2, $f2 -/* E2022C 802B711C 8E220004 */ lw $v0, 4($s1) -/* E20230 802B7120 46020080 */ add.s $f2, $f0, $f2 -/* E20234 802B7124 30421000 */ andi $v0, $v0, 0x1000 -/* E20238 802B7128 3C014000 */ lui $at, 0x4000 -/* E2023C 802B712C 44810000 */ mtc1 $at, $f0 -/* E20240 802B7130 14400004 */ bnez $v0, .L802B7144 -/* E20244 802B7134 24630004 */ addiu $v1, $v1, 4 -/* E20248 802B7138 3C014100 */ lui $at, 0x4100 -/* E2024C 802B713C 44810000 */ mtc1 $at, $f0 -/* E20250 802B7140 00000000 */ nop -.L802B7144: -/* E20254 802B7144 46001000 */ add.s $f0, $f2, $f0 -/* E20258 802B7148 3C04802B */ lui $a0, %hi(D_802B7CB8_E20DC8) -/* E2025C 802B714C 24847CB8 */ addiu $a0, $a0, %lo(D_802B7CB8_E20DC8) -/* E20260 802B7150 E4600000 */ swc1 $f0, ($v1) -/* E20264 802B7154 8C820000 */ lw $v0, ($a0) -/* E20268 802B7158 C6200030 */ lwc1 $f0, 0x30($s1) -/* E2026C 802B715C 3C013ECC */ lui $at, 0x3ecc -/* E20270 802B7160 3421CCCD */ ori $at, $at, 0xcccd -/* E20274 802B7164 44811000 */ mtc1 $at, $f2 -/* E20278 802B7168 A0400023 */ sb $zero, 0x23($v0) -/* E2027C 802B716C 3C038007 */ lui $v1, %hi(gCurrentCameraID) -/* E20280 802B7170 8C637410 */ lw $v1, %lo(gCurrentCameraID)($v1) -/* E20284 802B7174 E4400008 */ swc1 $f0, 8($v0) -/* E20288 802B7178 E4420010 */ swc1 $f2, 0x10($v0) -/* E2028C 802B717C 3C02802B */ lui $v0, %hi(func_802B7728_E20838) -/* E20290 802B7180 24427728 */ addiu $v0, $v0, %lo(func_802B7728_E20838) -/* E20294 802B7184 3C018011 */ lui $at, %hi(D_8010C958) -/* E20298 802B7188 AC22C958 */ sw $v0, %lo(D_8010C958)($at) -/* E2029C 802B718C 00031080 */ sll $v0, $v1, 2 -/* E202A0 802B7190 00431021 */ addu $v0, $v0, $v1 -/* E202A4 802B7194 00021080 */ sll $v0, $v0, 2 -/* E202A8 802B7198 00431023 */ subu $v0, $v0, $v1 -/* E202AC 802B719C 000218C0 */ sll $v1, $v0, 3 -/* E202B0 802B71A0 00431021 */ addu $v0, $v0, $v1 -/* E202B4 802B71A4 000210C0 */ sll $v0, $v0, 3 -/* E202B8 802B71A8 3C01800B */ lui $at, %hi(gCameras+0x6C) -/* E202BC 802B71AC 00220821 */ addu $at, $at, $v0 -/* E202C0 802B71B0 C4201DEC */ lwc1 $f0, %lo(gCameras+0x6C)($at) -/* E202C4 802B71B4 240200FF */ addiu $v0, $zero, 0xff -/* E202C8 802B71B8 8C830000 */ lw $v1, ($a0) -/* E202CC 802B71BC 46000007 */ neg.s $f0, $f0 -/* E202D0 802B71C0 A0620024 */ sb $v0, 0x24($v1) -/* E202D4 802B71C4 E460000C */ swc1 $f0, 0xc($v1) -/* E202D8 802B71C8 8C830000 */ lw $v1, ($a0) -/* E202DC 802B71CC 240200FF */ addiu $v0, $zero, 0xff -/* E202E0 802B71D0 AC62001C */ sw $v0, 0x1c($v1) -.L802B71D4: -/* E202E4 802B71D4 8FBF0018 */ lw $ra, 0x18($sp) -/* E202E8 802B71D8 8FB10014 */ lw $s1, 0x14($sp) -/* E202EC 802B71DC 8FB00010 */ lw $s0, 0x10($sp) -/* E202F0 802B71E0 03E00008 */ jr $ra -/* E202F4 802B71E4 27BD0020 */ addiu $sp, $sp, 0x20 diff --git a/ver/us/asm/nonmatchings/battle/partner/goombario/func_8023817C_6F125C.s b/ver/us/asm/nonmatchings/battle/partner/goombario/func_8023817C_6F125C.s deleted file mode 100644 index ad2649e159..0000000000 --- a/ver/us/asm/nonmatchings/battle/partner/goombario/func_8023817C_6F125C.s +++ /dev/null @@ -1,613 +0,0 @@ -.set noat # allow manual use of $at -.set noreorder # don't insert nops after branches - -.section .rodata -dlabel D_8023CD50_6F5E30 -.double 47.0 - -dlabel D_8023CD58_6F5E38 -.double 1.12 - -dlabel D_8023CD60_6F5E40 -.double 0.53 - -dlabel D_8023CD68_6F5E48 -.double 47.0 - -dlabel D_8023CD70_6F5E50 -.double 0.8 - -dlabel D_8023CD78_6F5E58 -.double 0.53 - -dlabel D_8023CD80_6F5E60 -.double 0.8 - -dlabel D_8023CD88_6F5E68 -.double 16.5 - -dlabel D_8023CD90_6F5E70 -.double 33.0, 0.0 - -.section .text - -glabel func_8023817C_6F125C -/* 6F125C 8023817C 27BDFFB8 */ addiu $sp, $sp, -0x48 -/* 6F1260 80238180 AFB3001C */ sw $s3, 0x1c($sp) -/* 6F1264 80238184 0080982D */ daddu $s3, $a0, $zero -/* 6F1268 80238188 AFB40020 */ sw $s4, 0x20($sp) -/* 6F126C 8023818C 3C14800E */ lui $s4, %hi(gBattleStatus) -/* 6F1270 80238190 2694C070 */ addiu $s4, $s4, %lo(gBattleStatus) -/* 6F1274 80238194 AFBF0024 */ sw $ra, 0x24($sp) -/* 6F1278 80238198 AFB20018 */ sw $s2, 0x18($sp) -/* 6F127C 8023819C AFB10014 */ sw $s1, 0x14($sp) -/* 6F1280 802381A0 AFB00010 */ sw $s0, 0x10($sp) -/* 6F1284 802381A4 F7BA0040 */ sdc1 $f26, 0x40($sp) -/* 6F1288 802381A8 F7B80038 */ sdc1 $f24, 0x38($sp) -/* 6F128C 802381AC F7B60030 */ sdc1 $f22, 0x30($sp) -/* 6F1290 802381B0 F7B40028 */ sdc1 $f20, 0x28($sp) -/* 6F1294 802381B4 8E9200DC */ lw $s2, 0xdc($s4) -/* 6F1298 802381B8 8E71000C */ lw $s1, 0xc($s3) -/* 6F129C 802381BC 10A00010 */ beqz $a1, .L80238200 -/* 6F12A0 802381C0 2650000C */ addiu $s0, $s2, 0xc -/* 6F12A4 802381C4 8E250000 */ lw $a1, ($s1) -/* 6F12A8 802381C8 0C0B1EAF */ jal evt_get_variable -/* 6F12AC 802381CC 26310004 */ addiu $s1, $s1, 4 -/* 6F12B0 802381D0 A6420070 */ sh $v0, 0x70($s2) -/* 6F12B4 802381D4 8E250000 */ lw $a1, ($s1) -/* 6F12B8 802381D8 0C0B1EAF */ jal evt_get_variable -/* 6F12BC 802381DC 0260202D */ daddu $a0, $s3, $zero -/* 6F12C0 802381E0 A6420072 */ sh $v0, 0x72($s2) -/* 6F12C4 802381E4 AE600074 */ sw $zero, 0x74($s3) -/* 6F12C8 802381E8 AE600070 */ sw $zero, 0x70($s3) -/* 6F12CC 802381EC 86430072 */ lh $v1, 0x72($s2) -/* 6F12D0 802381F0 24020001 */ addiu $v0, $zero, 1 -/* 6F12D4 802381F4 14620002 */ bne $v1, $v0, .L80238200 -/* 6F12D8 802381F8 24020002 */ addiu $v0, $zero, 2 -/* 6F12DC 802381FC AE620070 */ sw $v0, 0x70($s3) -.L80238200: -/* 6F12E0 80238200 8E620070 */ lw $v0, 0x70($s3) -/* 6F12E4 80238204 144000F5 */ bnez $v0, .L802385DC -/* 6F12E8 80238208 00000000 */ nop -/* 6F12EC 8023820C C6400144 */ lwc1 $f0, 0x144($s2) -/* 6F12F0 80238210 C618000C */ lwc1 $f24, 0xc($s0) -/* 6F12F4 80238214 C61A0014 */ lwc1 $f26, 0x14($s0) -/* 6F12F8 80238218 E6000000 */ swc1 $f0, ($s0) -/* 6F12FC 8023821C C6400148 */ lwc1 $f0, 0x148($s2) -/* 6F1300 80238220 4406C000 */ mfc1 $a2, $f24 -/* 6F1304 80238224 4407D000 */ mfc1 $a3, $f26 -/* 6F1308 80238228 C6160000 */ lwc1 $f22, ($s0) -/* 6F130C 8023822C E6000004 */ swc1 $f0, 4($s0) -/* 6F1310 80238230 C654014C */ lwc1 $f20, 0x14c($s2) -/* 6F1314 80238234 4600B306 */ mov.s $f12, $f22 -/* 6F1318 80238238 4600A386 */ mov.s $f14, $f20 -/* 6F131C 8023823C 0C00A720 */ jal atan2 -/* 6F1320 80238240 E6140008 */ swc1 $f20, 8($s0) -/* 6F1324 80238244 4600B306 */ mov.s $f12, $f22 -/* 6F1328 80238248 4406C000 */ mfc1 $a2, $f24 -/* 6F132C 8023824C 4407D000 */ mfc1 $a3, $f26 -/* 6F1330 80238250 4600A386 */ mov.s $f14, $f20 -/* 6F1334 80238254 0C00A7B5 */ jal dist2D -/* 6F1338 80238258 E6000048 */ swc1 $f0, 0x48($s0) -/* 6F133C 8023825C 86020064 */ lh $v0, 0x64($s0) -/* 6F1340 80238260 46000106 */ mov.s $f4, $f0 -/* 6F1344 80238264 14400012 */ bnez $v0, .L802382B0 -/* 6F1348 80238268 E604004C */ swc1 $f4, 0x4c($s0) -/* 6F134C 8023826C C6000040 */ lwc1 $f0, 0x40($s0) -/* 6F1350 80238270 C6020040 */ lwc1 $f2, 0x40($s0) -/* 6F1354 80238274 46002003 */ div.s $f0, $f4, $f0 -/* 6F1358 80238278 4600028D */ trunc.w.s $f10, $f0 -/* 6F135C 8023827C 44035000 */ mfc1 $v1, $f10 -/* 6F1360 80238280 00000000 */ nop -/* 6F1364 80238284 00031400 */ sll $v0, $v1, 0x10 -/* 6F1368 80238288 00021403 */ sra $v0, $v0, 0x10 -/* 6F136C 8023828C 44820000 */ mtc1 $v0, $f0 -/* 6F1370 80238290 00000000 */ nop -/* 6F1374 80238294 46800020 */ cvt.s.w $f0, $f0 -/* 6F1378 80238298 46020002 */ mul.s $f0, $f0, $f2 -/* 6F137C 8023829C 00000000 */ nop -/* 6F1380 802382A0 46002086 */ mov.s $f2, $f4 -/* 6F1384 802382A4 A6030064 */ sh $v1, 0x64($s0) -/* 6F1388 802382A8 0808E0B9 */ j .L802382E4 -/* 6F138C 802382AC 46001201 */ sub.s $f8, $f2, $f0 -.L802382B0: -/* 6F1390 802382B0 44821000 */ mtc1 $v0, $f2 -/* 6F1394 802382B4 00000000 */ nop -/* 6F1398 802382B8 468010A0 */ cvt.s.w $f2, $f2 -/* 6F139C 802382BC 86020064 */ lh $v0, 0x64($s0) -/* 6F13A0 802382C0 46022083 */ div.s $f2, $f4, $f2 -/* 6F13A4 802382C4 44820000 */ mtc1 $v0, $f0 -/* 6F13A8 802382C8 00000000 */ nop -/* 6F13AC 802382CC 46800020 */ cvt.s.w $f0, $f0 -/* 6F13B0 802382D0 46020002 */ mul.s $f0, $f0, $f2 -/* 6F13B4 802382D4 00000000 */ nop -/* 6F13B8 802382D8 C604004C */ lwc1 $f4, 0x4c($s0) -/* 6F13BC 802382DC E6020040 */ swc1 $f2, 0x40($s0) -/* 6F13C0 802382E0 46002201 */ sub.s $f8, $f4, $f0 -.L802382E4: -/* 6F13C4 802382E4 86030064 */ lh $v1, 0x64($s0) -/* 6F13C8 802382E8 106001C1 */ beqz $v1, .L802389F0 -/* 6F13CC 802382EC 24020002 */ addiu $v0, $zero, 2 -/* 6F13D0 802382F0 86020064 */ lh $v0, 0x64($s0) -/* 6F13D4 802382F4 C602000C */ lwc1 $f2, 0xc($s0) -/* 6F13D8 802382F8 3C014049 */ lui $at, 0x4049 -/* 6F13DC 802382FC 34210FD0 */ ori $at, $at, 0xfd0 -/* 6F13E0 80238300 44810000 */ mtc1 $at, $f0 -/* 6F13E4 80238304 C6040000 */ lwc1 $f4, ($s0) -/* 6F13E8 80238308 44823000 */ mtc1 $v0, $f6 -/* 6F13EC 8023830C 00000000 */ nop -/* 6F13F0 80238310 468031A0 */ cvt.s.w $f6, $f6 -/* 6F13F4 80238314 46060003 */ div.s $f0, $f0, $f6 -/* 6F13F8 80238318 46041081 */ sub.s $f2, $f2, $f4 -/* 6F13FC 8023831C E600003C */ swc1 $f0, 0x3c($s0) -/* 6F1400 80238320 44830000 */ mtc1 $v1, $f0 -/* 6F1404 80238324 00000000 */ nop -/* 6F1408 80238328 46800020 */ cvt.s.w $f0, $f0 -/* 6F140C 8023832C 46001083 */ div.s $f2, $f2, $f0 -/* 6F1410 80238330 C6000010 */ lwc1 $f0, 0x10($s0) -/* 6F1414 80238334 E6020030 */ swc1 $f2, 0x30($s0) -/* 6F1418 80238338 C6020004 */ lwc1 $f2, 4($s0) -/* 6F141C 8023833C AE000044 */ sw $zero, 0x44($s0) -/* 6F1420 80238340 46020001 */ sub.s $f0, $f0, $f2 -/* 6F1424 80238344 C6040014 */ lwc1 $f4, 0x14($s0) -/* 6F1428 80238348 46003086 */ mov.s $f2, $f6 -/* 6F142C 8023834C 46020003 */ div.s $f0, $f0, $f2 -/* 6F1430 80238350 E6000034 */ swc1 $f0, 0x34($s0) -/* 6F1434 80238354 46003006 */ mov.s $f0, $f6 -/* 6F1438 80238358 46004003 */ div.s $f0, $f8, $f0 -/* 6F143C 8023835C C6020008 */ lwc1 $f2, 8($s0) -/* 6F1440 80238360 86020066 */ lh $v0, 0x66($s0) -/* 6F1444 80238364 46022101 */ sub.s $f4, $f4, $f2 -/* 6F1448 80238368 C6020040 */ lwc1 $f2, 0x40($s0) -/* 6F144C 8023836C 28420003 */ slti $v0, $v0, 3 -/* 6F1450 80238370 46001080 */ add.s $f2, $f2, $f0 -/* 6F1454 80238374 46062103 */ div.s $f4, $f4, $f6 -/* 6F1458 80238378 E6040038 */ swc1 $f4, 0x38($s0) -/* 6F145C 8023837C 10400045 */ beqz $v0, .L80238494 -/* 6F1460 80238380 E6020040 */ swc1 $f2, 0x40($s0) -/* 6F1464 80238384 86020064 */ lh $v0, 0x64($s0) -/* 6F1468 80238388 24030168 */ addiu $v1, $zero, 0x168 -/* 6F146C 8023838C 14400002 */ bnez $v0, .L80238398 -/* 6F1470 80238390 0062001A */ div $zero, $v1, $v0 -/* 6F1474 80238394 0007000D */ break 7 -.L80238398: -/* 6F1478 80238398 2401FFFF */ addiu $at, $zero, -1 -/* 6F147C 8023839C 14410004 */ bne $v0, $at, .L802383B0 -/* 6F1480 802383A0 3C018000 */ lui $at, 0x8000 -/* 6F1484 802383A4 14610002 */ bne $v1, $at, .L802383B0 -/* 6F1488 802383A8 00000000 */ nop -/* 6F148C 802383AC 0006000D */ break 6 -.L802383B0: -/* 6F1490 802383B0 00001812 */ mflo $v1 -/* 6F1494 802383B4 C608004C */ lwc1 $f8, 0x4c($s0) -/* 6F1498 802383B8 3C014034 */ lui $at, 0x4034 -/* 6F149C 802383BC 44811800 */ mtc1 $at, $f3 -/* 6F14A0 802383C0 44801000 */ mtc1 $zero, $f2 -/* 6F14A4 802383C4 46004021 */ cvt.d.s $f0, $f8 -/* 6F14A8 802383C8 46220001 */ sub.d $f0, $f0, $f2 -/* 6F14AC 802383CC 3C014018 */ lui $at, 0x4018 -/* 6F14B0 802383D0 44811800 */ mtc1 $at, $f3 -/* 6F14B4 802383D4 44801000 */ mtc1 $zero, $f2 -/* 6F14B8 802383D8 46200220 */ cvt.s.d $f8, $f0 -/* 6F14BC 802383DC 46004021 */ cvt.d.s $f0, $f8 -/* 6F14C0 802383E0 46220003 */ div.d $f0, $f0, $f2 -/* 6F14C4 802383E4 46200220 */ cvt.s.d $f8, $f0 -/* 6F14C8 802383E8 3C018024 */ lui $at, %hi(D_8023CD50_6F5E30) -/* 6F14CC 802383EC D422CD50 */ ldc1 $f2, %lo(D_8023CD50_6F5E30)($at) -/* 6F14D0 802383F0 46004021 */ cvt.d.s $f0, $f8 -/* 6F14D4 802383F4 46220000 */ add.d $f0, $f0, $f2 -/* 6F14D8 802383F8 3C0142B4 */ lui $at, 0x42b4 -/* 6F14DC 802383FC 44811000 */ mtc1 $at, $f2 -/* 6F14E0 80238400 46200220 */ cvt.s.d $f8, $f0 -/* 6F14E4 80238404 44830000 */ mtc1 $v1, $f0 -/* 6F14E8 80238408 00000000 */ nop -/* 6F14EC 8023840C 46800020 */ cvt.s.w $f0, $f0 -/* 6F14F0 80238410 86030066 */ lh $v1, 0x66($s0) -/* 6F14F4 80238414 24020002 */ addiu $v0, $zero, 2 -/* 6F14F8 80238418 E6020024 */ swc1 $f2, 0x24($s0) -/* 6F14FC 8023841C E6080050 */ swc1 $f8, 0x50($s0) -/* 6F1500 80238420 14620008 */ bne $v1, $v0, .L80238444 -/* 6F1504 80238424 E6000028 */ swc1 $f0, 0x28($s0) -/* 6F1508 80238428 3C018024 */ lui $at, %hi(D_8023CD58_6F5E38) -/* 6F150C 8023842C D422CD58 */ ldc1 $f2, %lo(D_8023CD58_6F5E38)($at) -/* 6F1510 80238430 46004021 */ cvt.d.s $f0, $f8 -/* 6F1514 80238434 46220002 */ mul.d $f0, $f0, $f2 -/* 6F1518 80238438 00000000 */ nop -/* 6F151C 8023843C 46200020 */ cvt.s.d $f0, $f0 -/* 6F1520 80238440 E6000050 */ swc1 $f0, 0x50($s0) -.L80238444: -/* 6F1524 80238444 C60C0024 */ lwc1 $f12, 0x24($s0) -/* 6F1528 80238448 3C0140C9 */ lui $at, 0x40c9 -/* 6F152C 8023844C 34210FD0 */ ori $at, $at, 0xfd0 -/* 6F1530 80238450 44810000 */ mtc1 $at, $f0 -/* 6F1534 80238454 C6140044 */ lwc1 $f20, 0x44($s0) -/* 6F1538 80238458 C616003C */ lwc1 $f22, 0x3c($s0) -/* 6F153C 8023845C AE000018 */ sw $zero, 0x18($s0) -/* 6F1540 80238460 46006302 */ mul.s $f12, $f12, $f0 -/* 6F1544 80238464 00000000 */ nop -/* 6F1548 80238468 AE00001C */ sw $zero, 0x1c($s0) -/* 6F154C 8023846C 4600A521 */ cvt.d.s $f20, $f20 -/* 6F1550 80238470 3C0143B4 */ lui $at, 0x43b4 -/* 6F1554 80238474 44810000 */ mtc1 $at, $f0 -/* 6F1558 80238478 4600B5A1 */ cvt.d.s $f22, $f22 -/* 6F155C 8023847C 0C00A85B */ jal sin_rad -/* 6F1560 80238480 46006303 */ div.s $f12, $f12, $f0 -/* 6F1564 80238484 3C018024 */ lui $at, %hi(D_8023CD60_6F5E40) -/* 6F1568 80238488 D422CD60 */ ldc1 $f2, %lo(D_8023CD60_6F5E40)($at) -/* 6F156C 8023848C 0808E169 */ j .L802385A4 -/* 6F1570 80238490 46000021 */ cvt.d.s $f0, $f0 -.L80238494: -/* 6F1574 80238494 86020064 */ lh $v0, 0x64($s0) -/* 6F1578 80238498 24030168 */ addiu $v1, $zero, 0x168 -/* 6F157C 8023849C 14400002 */ bnez $v0, .L802384A8 -/* 6F1580 802384A0 0062001A */ div $zero, $v1, $v0 -/* 6F1584 802384A4 0007000D */ break 7 -.L802384A8: -/* 6F1588 802384A8 2401FFFF */ addiu $at, $zero, -1 -/* 6F158C 802384AC 14410004 */ bne $v0, $at, .L802384C0 -/* 6F1590 802384B0 3C018000 */ lui $at, 0x8000 -/* 6F1594 802384B4 14610002 */ bne $v1, $at, .L802384C0 -/* 6F1598 802384B8 00000000 */ nop -/* 6F159C 802384BC 0006000D */ break 6 -.L802384C0: -/* 6F15A0 802384C0 00001812 */ mflo $v1 -/* 6F15A4 802384C4 C608004C */ lwc1 $f8, 0x4c($s0) -/* 6F15A8 802384C8 3C014034 */ lui $at, 0x4034 -/* 6F15AC 802384CC 44811800 */ mtc1 $at, $f3 -/* 6F15B0 802384D0 44801000 */ mtc1 $zero, $f2 -/* 6F15B4 802384D4 46004021 */ cvt.d.s $f0, $f8 -/* 6F15B8 802384D8 46220001 */ sub.d $f0, $f0, $f2 -/* 6F15BC 802384DC 3C014018 */ lui $at, 0x4018 -/* 6F15C0 802384E0 44811800 */ mtc1 $at, $f3 -/* 6F15C4 802384E4 44801000 */ mtc1 $zero, $f2 -/* 6F15C8 802384E8 46200220 */ cvt.s.d $f8, $f0 -/* 6F15CC 802384EC 46004021 */ cvt.d.s $f0, $f8 -/* 6F15D0 802384F0 46220003 */ div.d $f0, $f0, $f2 -/* 6F15D4 802384F4 46200220 */ cvt.s.d $f8, $f0 -/* 6F15D8 802384F8 3C018024 */ lui $at, %hi(D_8023CD68_6F5E48) -/* 6F15DC 802384FC D422CD68 */ ldc1 $f2, %lo(D_8023CD68_6F5E48)($at) -/* 6F15E0 80238500 46004021 */ cvt.d.s $f0, $f8 -/* 6F15E4 80238504 46220000 */ add.d $f0, $f0, $f2 -/* 6F15E8 80238508 3C0142B4 */ lui $at, 0x42b4 -/* 6F15EC 8023850C 44811000 */ mtc1 $at, $f2 -/* 6F15F0 80238510 46200220 */ cvt.s.d $f8, $f0 -/* 6F15F4 80238514 44830000 */ mtc1 $v1, $f0 -/* 6F15F8 80238518 00000000 */ nop -/* 6F15FC 8023851C 46800020 */ cvt.s.w $f0, $f0 -/* 6F1600 80238520 86030066 */ lh $v1, 0x66($s0) -/* 6F1604 80238524 24020004 */ addiu $v0, $zero, 4 -/* 6F1608 80238528 E6020024 */ swc1 $f2, 0x24($s0) -/* 6F160C 8023852C E6080050 */ swc1 $f8, 0x50($s0) -/* 6F1610 80238530 14620009 */ bne $v1, $v0, .L80238558 -/* 6F1614 80238534 E6000028 */ swc1 $f0, 0x28($s0) -/* 6F1618 80238538 3C013FF4 */ lui $at, 0x3ff4 -/* 6F161C 8023853C 44811800 */ mtc1 $at, $f3 -/* 6F1620 80238540 44801000 */ mtc1 $zero, $f2 -/* 6F1624 80238544 46004021 */ cvt.d.s $f0, $f8 -/* 6F1628 80238548 46220002 */ mul.d $f0, $f0, $f2 -/* 6F162C 8023854C 00000000 */ nop -/* 6F1630 80238550 46200020 */ cvt.s.d $f0, $f0 -/* 6F1634 80238554 E6000050 */ swc1 $f0, 0x50($s0) -.L80238558: -/* 6F1638 80238558 C60C0024 */ lwc1 $f12, 0x24($s0) -/* 6F163C 8023855C 3C0140C9 */ lui $at, 0x40c9 -/* 6F1640 80238560 34210FD0 */ ori $at, $at, 0xfd0 -/* 6F1644 80238564 44810000 */ mtc1 $at, $f0 -/* 6F1648 80238568 C6140044 */ lwc1 $f20, 0x44($s0) -/* 6F164C 8023856C C616003C */ lwc1 $f22, 0x3c($s0) -/* 6F1650 80238570 AE000018 */ sw $zero, 0x18($s0) -/* 6F1654 80238574 46006302 */ mul.s $f12, $f12, $f0 -/* 6F1658 80238578 00000000 */ nop -/* 6F165C 8023857C AE00001C */ sw $zero, 0x1c($s0) -/* 6F1660 80238580 4600A521 */ cvt.d.s $f20, $f20 -/* 6F1664 80238584 3C0143B4 */ lui $at, 0x43b4 -/* 6F1668 80238588 44810000 */ mtc1 $at, $f0 -/* 6F166C 8023858C 4600B5A1 */ cvt.d.s $f22, $f22 -/* 6F1670 80238590 0C00A85B */ jal sin_rad -/* 6F1674 80238594 46006303 */ div.s $f12, $f12, $f0 -/* 6F1678 80238598 3C018024 */ lui $at, %hi(D_8023CD70_6F5E50) -/* 6F167C 8023859C D422CD70 */ ldc1 $f2, %lo(D_8023CD70_6F5E50)($at) -/* 6F1680 802385A0 46000021 */ cvt.d.s $f0, $f0 -.L802385A4: -/* 6F1684 802385A4 46220002 */ mul.d $f0, $f0, $f2 -/* 6F1688 802385A8 00000000 */ nop -/* 6F168C 802385AC 46360002 */ mul.d $f0, $f0, $f22 -/* 6F1690 802385B0 00000000 */ nop -/* 6F1694 802385B4 46360000 */ add.d $f0, $f0, $f22 -/* 6F1698 802385B8 4620A500 */ add.d $f20, $f20, $f0 -/* 6F169C 802385BC 4620A520 */ cvt.s.d $f20, $f20 -/* 6F16A0 802385C0 E6140044 */ swc1 $f20, 0x44($s0) -/* 6F16A4 802385C4 24040100 */ addiu $a0, $zero, 0x100 -/* 6F16A8 802385C8 8E060058 */ lw $a2, 0x58($s0) -/* 6F16AC 802385CC 0C098F3F */ jal set_animation -/* 6F16B0 802385D0 24050001 */ addiu $a1, $zero, 1 -/* 6F16B4 802385D4 24020001 */ addiu $v0, $zero, 1 -/* 6F16B8 802385D8 AE620070 */ sw $v0, 0x70($s3) -.L802385DC: -/* 6F16BC 802385DC 8E630070 */ lw $v1, 0x70($s3) -/* 6F16C0 802385E0 24020002 */ addiu $v0, $zero, 2 -/* 6F16C4 802385E4 10620094 */ beq $v1, $v0, .L80238838 -/* 6F16C8 802385E8 28620003 */ slti $v0, $v1, 3 -/* 6F16CC 802385EC 10400005 */ beqz $v0, .L80238604 -/* 6F16D0 802385F0 24020001 */ addiu $v0, $zero, 1 -/* 6F16D4 802385F4 10620008 */ beq $v1, $v0, .L80238618 -/* 6F16D8 802385F8 0000102D */ daddu $v0, $zero, $zero -/* 6F16DC 802385FC 0808E27C */ j .L802389F0 -/* 6F16E0 80238600 00000000 */ nop -.L80238604: -/* 6F16E4 80238604 24020003 */ addiu $v0, $zero, 3 -/* 6F16E8 80238608 106200BD */ beq $v1, $v0, .L80238900 -/* 6F16EC 8023860C 0000102D */ daddu $v0, $zero, $zero -/* 6F16F0 80238610 0808E27C */ j .L802389F0 -/* 6F16F4 80238614 00000000 */ nop -.L80238618: -/* 6F16F8 80238618 C6020044 */ lwc1 $f2, 0x44($s0) -/* 6F16FC 8023861C 3C013FC9 */ lui $at, 0x3fc9 -/* 6F1700 80238620 34210FD0 */ ori $at, $at, 0xfd0 -/* 6F1704 80238624 44810000 */ mtc1 $at, $f0 -/* 6F1708 80238628 00000000 */ nop -/* 6F170C 8023862C 4602003C */ c.lt.s $f0, $f2 -/* 6F1710 80238630 00000000 */ nop -/* 6F1714 80238634 45000004 */ bc1f .L80238648 -/* 6F1718 80238638 24040100 */ addiu $a0, $zero, 0x100 -/* 6F171C 8023863C 8E06005C */ lw $a2, 0x5c($s0) -/* 6F1720 80238640 0C098F3F */ jal set_animation -/* 6F1724 80238644 24050001 */ addiu $a1, $zero, 1 -.L80238648: -/* 6F1728 80238648 C6060000 */ lwc1 $f6, ($s0) -/* 6F172C 8023864C C6000030 */ lwc1 $f0, 0x30($s0) -/* 6F1730 80238650 C6040004 */ lwc1 $f4, 4($s0) -/* 6F1734 80238654 C6560144 */ lwc1 $f22, 0x144($s2) -/* 6F1738 80238658 46003180 */ add.s $f6, $f6, $f0 -/* 6F173C 8023865C C6000034 */ lwc1 $f0, 0x34($s0) -/* 6F1740 80238660 C6020038 */ lwc1 $f2, 0x38($s0) -/* 6F1744 80238664 46002100 */ add.s $f4, $f4, $f0 -/* 6F1748 80238668 C6000008 */ lwc1 $f0, 8($s0) -/* 6F174C 8023866C C6540148 */ lwc1 $f20, 0x148($s2) -/* 6F1750 80238670 46020000 */ add.s $f0, $f0, $f2 -/* 6F1754 80238674 E6060000 */ swc1 $f6, ($s0) -/* 6F1758 80238678 E6040004 */ swc1 $f4, 4($s0) -/* 6F175C 8023867C E6000008 */ swc1 $f0, 8($s0) -/* 6F1760 80238680 C6400148 */ lwc1 $f0, 0x148($s2) -/* 6F1764 80238684 46003086 */ mov.s $f2, $f6 -/* 6F1768 80238688 E6000018 */ swc1 $f0, 0x18($s0) -/* 6F176C 8023868C E6420144 */ swc1 $f2, 0x144($s2) -/* 6F1770 80238690 0C00A85B */ jal sin_rad -/* 6F1774 80238694 C60C0044 */ lwc1 $f12, 0x44($s0) -/* 6F1778 80238698 C6020050 */ lwc1 $f2, 0x50($s0) -/* 6F177C 8023869C 46001082 */ mul.s $f2, $f2, $f0 -/* 6F1780 802386A0 00000000 */ nop -/* 6F1784 802386A4 C6000004 */ lwc1 $f0, 4($s0) -/* 6F1788 802386A8 46020000 */ add.s $f0, $f0, $f2 -/* 6F178C 802386AC E6400148 */ swc1 $f0, 0x148($s2) -/* 6F1790 802386B0 C6000008 */ lwc1 $f0, 8($s0) -/* 6F1794 802386B4 E640014C */ swc1 $f0, 0x14c($s2) -/* 6F1798 802386B8 C6020010 */ lwc1 $f2, 0x10($s0) -/* 6F179C 802386BC C6400148 */ lwc1 $f0, 0x148($s2) -/* 6F17A0 802386C0 4602003C */ c.lt.s $f0, $f2 -/* 6F17A4 802386C4 00000000 */ nop -/* 6F17A8 802386C8 45000007 */ bc1f .L802386E8 -/* 6F17AC 802386CC 4600B306 */ mov.s $f12, $f22 -/* 6F17B0 802386D0 86020064 */ lh $v0, 0x64($s0) -/* 6F17B4 802386D4 28420003 */ slti $v0, $v0, 3 -/* 6F17B8 802386D8 54400002 */ bnel $v0, $zero, .L802386E4 -/* 6F17BC 802386DC E6420148 */ swc1 $f2, 0x148($s2) -/* 6F17C0 802386E0 4600B306 */ mov.s $f12, $f22 -.L802386E4: -/* 6F17C4 802386E4 C6400148 */ lwc1 $f0, 0x148($s2) -.L802386E8: -/* 6F17C8 802386E8 8E460144 */ lw $a2, 0x144($s2) -/* 6F17CC 802386EC 46000007 */ neg.s $f0, $f0 -/* 6F17D0 802386F0 44070000 */ mfc1 $a3, $f0 -/* 6F17D4 802386F4 0C00A720 */ jal atan2 -/* 6F17D8 802386F8 4600A387 */ neg.s $f14, $f20 -/* 6F17DC 802386FC 46000007 */ neg.s $f0, $f0 -/* 6F17E0 80238700 E6400164 */ swc1 $f0, 0x164($s2) -/* 6F17E4 80238704 86020066 */ lh $v0, 0x66($s0) -/* 6F17E8 80238708 C6400148 */ lwc1 $f0, 0x148($s2) -/* 6F17EC 8023870C 28420003 */ slti $v0, $v0, 3 -/* 6F17F0 80238710 10400013 */ beqz $v0, .L80238760 -/* 6F17F4 80238714 E600001C */ swc1 $f0, 0x1c($s0) -/* 6F17F8 80238718 C60C0024 */ lwc1 $f12, 0x24($s0) -/* 6F17FC 8023871C 3C0140C9 */ lui $at, 0x40c9 -/* 6F1800 80238720 34210FD0 */ ori $at, $at, 0xfd0 -/* 6F1804 80238724 44810000 */ mtc1 $at, $f0 -/* 6F1808 80238728 C6140044 */ lwc1 $f20, 0x44($s0) -/* 6F180C 8023872C 46006302 */ mul.s $f12, $f12, $f0 -/* 6F1810 80238730 00000000 */ nop -/* 6F1814 80238734 C616003C */ lwc1 $f22, 0x3c($s0) -/* 6F1818 80238738 4600A521 */ cvt.d.s $f20, $f20 -/* 6F181C 8023873C 3C0143B4 */ lui $at, 0x43b4 -/* 6F1820 80238740 44810000 */ mtc1 $at, $f0 -/* 6F1824 80238744 4600B5A1 */ cvt.d.s $f22, $f22 -/* 6F1828 80238748 0C00A85B */ jal sin_rad -/* 6F182C 8023874C 46006303 */ div.s $f12, $f12, $f0 -/* 6F1830 80238750 3C018024 */ lui $at, %hi(D_8023CD78_6F5E58) -/* 6F1834 80238754 D422CD78 */ ldc1 $f2, %lo(D_8023CD78_6F5E58)($at) -/* 6F1838 80238758 0808E1E9 */ j .L802387A4 -/* 6F183C 8023875C 46000021 */ cvt.d.s $f0, $f0 -.L80238760: -/* 6F1840 80238760 C60C0024 */ lwc1 $f12, 0x24($s0) -/* 6F1844 80238764 3C0140C9 */ lui $at, 0x40c9 -/* 6F1848 80238768 34210FD0 */ ori $at, $at, 0xfd0 -/* 6F184C 8023876C 44810000 */ mtc1 $at, $f0 -/* 6F1850 80238770 C6140044 */ lwc1 $f20, 0x44($s0) -/* 6F1854 80238774 46006302 */ mul.s $f12, $f12, $f0 -/* 6F1858 80238778 00000000 */ nop -/* 6F185C 8023877C C616003C */ lwc1 $f22, 0x3c($s0) -/* 6F1860 80238780 4600A521 */ cvt.d.s $f20, $f20 -/* 6F1864 80238784 3C0143B4 */ lui $at, 0x43b4 -/* 6F1868 80238788 44810000 */ mtc1 $at, $f0 -/* 6F186C 8023878C 4600B5A1 */ cvt.d.s $f22, $f22 -/* 6F1870 80238790 0C00A85B */ jal sin_rad -/* 6F1874 80238794 46006303 */ div.s $f12, $f12, $f0 -/* 6F1878 80238798 3C018024 */ lui $at, %hi(D_8023CD80_6F5E60) -/* 6F187C 8023879C D422CD80 */ ldc1 $f2, %lo(D_8023CD80_6F5E60)($at) -/* 6F1880 802387A0 46000021 */ cvt.d.s $f0, $f0 -.L802387A4: -/* 6F1884 802387A4 46220002 */ mul.d $f0, $f0, $f2 -/* 6F1888 802387A8 00000000 */ nop -/* 6F188C 802387AC 46360002 */ mul.d $f0, $f0, $f22 -/* 6F1890 802387B0 00000000 */ nop -/* 6F1894 802387B4 46360000 */ add.d $f0, $f0, $f22 -/* 6F1898 802387B8 4620A500 */ add.d $f20, $f20, $f0 -/* 6F189C 802387BC 4620A520 */ cvt.s.d $f20, $f20 -/* 6F18A0 802387C0 E6140044 */ swc1 $f20, 0x44($s0) -/* 6F18A4 802387C4 C60C0024 */ lwc1 $f12, 0x24($s0) -/* 6F18A8 802387C8 C6000028 */ lwc1 $f0, 0x28($s0) -/* 6F18AC 802387CC 46006300 */ add.s $f12, $f12, $f0 -/* 6F18B0 802387D0 0C00A6C9 */ jal clamp_angle -/* 6F18B4 802387D4 E60C0024 */ swc1 $f12, 0x24($s0) -/* 6F18B8 802387D8 96020064 */ lhu $v0, 0x64($s0) -/* 6F18BC 802387DC E6000024 */ swc1 $f0, 0x24($s0) -/* 6F18C0 802387E0 2442FFFF */ addiu $v0, $v0, -1 -/* 6F18C4 802387E4 A6020064 */ sh $v0, 0x64($s0) -/* 6F18C8 802387E8 00021400 */ sll $v0, $v0, 0x10 -/* 6F18CC 802387EC 14400080 */ bnez $v0, .L802389F0 -/* 6F18D0 802387F0 0000102D */ daddu $v0, $zero, $zero -/* 6F18D4 802387F4 C6000010 */ lwc1 $f0, 0x10($s0) -/* 6F18D8 802387F8 24040100 */ addiu $a0, $zero, 0x100 -/* 6F18DC 802387FC E6400148 */ swc1 $f0, 0x148($s2) -/* 6F18E0 80238800 C6000018 */ lwc1 $f0, 0x18($s0) -/* 6F18E4 80238804 C602001C */ lwc1 $f2, 0x1c($s0) -/* 6F18E8 80238808 8E060060 */ lw $a2, 0x60($s0) -/* 6F18EC 8023880C 46020001 */ sub.s $f0, $f0, $f2 -/* 6F18F0 80238810 3C013FE6 */ lui $at, 0x3fe6 -/* 6F18F4 80238814 34216666 */ ori $at, $at, 0x6666 -/* 6F18F8 80238818 44811000 */ mtc1 $at, $f2 -/* 6F18FC 8023881C 24050001 */ addiu $a1, $zero, 1 -/* 6F1900 80238820 E602003C */ swc1 $f2, 0x3c($s0) -/* 6F1904 80238824 46000007 */ neg.s $f0, $f0 -/* 6F1908 80238828 0C098F3F */ jal set_animation -/* 6F190C 8023882C E6000044 */ swc1 $f0, 0x44($s0) -/* 6F1910 80238830 0808E27C */ j .L802389F0 -/* 6F1914 80238834 24020001 */ addiu $v0, $zero, 1 -.L80238838: -/* 6F1918 80238838 82820083 */ lb $v0, 0x83($s4) -/* 6F191C 8023883C 10400063 */ beqz $v0, .L802389CC -/* 6F1920 80238840 24020001 */ addiu $v0, $zero, 1 -/* 6F1924 80238844 A6020064 */ sh $v0, 0x64($s0) -/* 6F1928 80238848 86020064 */ lh $v0, 0x64($s0) -/* 6F192C 8023884C 24030168 */ addiu $v1, $zero, 0x168 -/* 6F1930 80238850 14400002 */ bnez $v0, .L8023885C -/* 6F1934 80238854 0062001A */ div $zero, $v1, $v0 -/* 6F1938 80238858 0007000D */ break 7 -.L8023885C: -/* 6F193C 8023885C 2401FFFF */ addiu $at, $zero, -1 -/* 6F1940 80238860 14410004 */ bne $v0, $at, .L80238874 -/* 6F1944 80238864 3C018000 */ lui $at, 0x8000 -/* 6F1948 80238868 14610002 */ bne $v1, $at, .L80238874 -/* 6F194C 8023886C 00000000 */ nop -/* 6F1950 80238870 0006000D */ break 6 -.L80238874: -/* 6F1954 80238874 00001812 */ mflo $v1 -/* 6F1958 80238878 C6020018 */ lwc1 $f2, 0x18($s0) -/* 6F195C 8023887C C600001C */ lwc1 $f0, 0x1c($s0) -/* 6F1960 80238880 3C013FE6 */ lui $at, 0x3fe6 -/* 6F1964 80238884 34216666 */ ori $at, $at, 0x6666 -/* 6F1968 80238888 44814000 */ mtc1 $at, $f8 -/* 6F196C 8023888C C604001C */ lwc1 $f4, 0x1c($s0) -/* 6F1970 80238890 46001081 */ sub.s $f2, $f2, $f0 -/* 6F1974 80238894 C6000018 */ lwc1 $f0, 0x18($s0) -/* 6F1978 80238898 3C0142B4 */ lui $at, 0x42b4 -/* 6F197C 8023889C 44813000 */ mtc1 $at, $f6 -/* 6F1980 802388A0 46040001 */ sub.s $f0, $f0, $f4 -/* 6F1984 802388A4 E608003C */ swc1 $f8, 0x3c($s0) -/* 6F1988 802388A8 E6060024 */ swc1 $f6, 0x24($s0) -/* 6F198C 802388AC 46001087 */ neg.s $f2, $f2 -/* 6F1990 802388B0 E6020044 */ swc1 $f2, 0x44($s0) -/* 6F1994 802388B4 3C018024 */ lui $at, %hi(D_8023CD88_6F5E68) -/* 6F1998 802388B8 D422CD88 */ ldc1 $f2, %lo(D_8023CD88_6F5E68)($at) -/* 6F199C 802388BC 46000005 */ abs.s $f0, $f0 -/* 6F19A0 802388C0 46000021 */ cvt.d.s $f0, $f0 -/* 6F19A4 802388C4 46220003 */ div.d $f0, $f0, $f2 -/* 6F19A8 802388C8 46200020 */ cvt.s.d $f0, $f0 -/* 6F19AC 802388CC E6000050 */ swc1 $f0, 0x50($s0) -/* 6F19B0 802388D0 44830000 */ mtc1 $v1, $f0 -/* 6F19B4 802388D4 00000000 */ nop -/* 6F19B8 802388D8 46800020 */ cvt.s.w $f0, $f0 -/* 6F19BC 802388DC E6000028 */ swc1 $f0, 0x28($s0) -/* 6F19C0 802388E0 C6400144 */ lwc1 $f0, 0x144($s2) -/* 6F19C4 802388E4 E6000000 */ swc1 $f0, ($s0) -/* 6F19C8 802388E8 C6400148 */ lwc1 $f0, 0x148($s2) -/* 6F19CC 802388EC E6000004 */ swc1 $f0, 4($s0) -/* 6F19D0 802388F0 C640014C */ lwc1 $f0, 0x14c($s2) -/* 6F19D4 802388F4 24020003 */ addiu $v0, $zero, 3 -/* 6F19D8 802388F8 E6000008 */ swc1 $f0, 8($s0) -/* 6F19DC 802388FC AE620070 */ sw $v0, 0x70($s3) -.L80238900: -/* 6F19E0 80238900 C60C0024 */ lwc1 $f12, 0x24($s0) -/* 6F19E4 80238904 3C0140C9 */ lui $at, 0x40c9 -/* 6F19E8 80238908 34210FD0 */ ori $at, $at, 0xfd0 -/* 6F19EC 8023890C 4481B000 */ mtc1 $at, $f22 -/* 6F19F0 80238910 00000000 */ nop -/* 6F19F4 80238914 46166302 */ mul.s $f12, $f12, $f22 -/* 6F19F8 80238918 00000000 */ nop -/* 6F19FC 8023891C C6140000 */ lwc1 $f20, ($s0) -/* 6F1A00 80238920 3C0143B4 */ lui $at, 0x43b4 -/* 6F1A04 80238924 4481C000 */ mtc1 $at, $f24 -/* 6F1A08 80238928 4600A521 */ cvt.d.s $f20, $f20 -/* 6F1A0C 8023892C 0C00A85B */ jal sin_rad -/* 6F1A10 80238930 46186303 */ div.s $f12, $f12, $f24 -/* 6F1A14 80238934 C6020050 */ lwc1 $f2, 0x50($s0) -/* 6F1A18 80238938 46001082 */ mul.s $f2, $f2, $f0 -/* 6F1A1C 8023893C 00000000 */ nop -/* 6F1A20 80238940 C60C0024 */ lwc1 $f12, 0x24($s0) -/* 6F1A24 80238944 46166302 */ mul.s $f12, $f12, $f22 -/* 6F1A28 80238948 00000000 */ nop -/* 6F1A2C 8023894C 3C018024 */ lui $at, %hi(D_8023CD90_6F5E70) -/* 6F1A30 80238950 D420CD90 */ ldc1 $f0, %lo(D_8023CD90_6F5E70)($at) -/* 6F1A34 80238954 460010A1 */ cvt.d.s $f2, $f2 -/* 6F1A38 80238958 46201083 */ div.d $f2, $f2, $f0 -/* 6F1A3C 8023895C 4622A500 */ add.d $f20, $f20, $f2 -/* 6F1A40 80238960 46186303 */ div.s $f12, $f12, $f24 -/* 6F1A44 80238964 4620A520 */ cvt.s.d $f20, $f20 -/* 6F1A48 80238968 0C00A85B */ jal sin_rad -/* 6F1A4C 8023896C E6140000 */ swc1 $f20, ($s0) -/* 6F1A50 80238970 C6020050 */ lwc1 $f2, 0x50($s0) -/* 6F1A54 80238974 46001082 */ mul.s $f2, $f2, $f0 -/* 6F1A58 80238978 00000000 */ nop -/* 6F1A5C 8023897C C60C0024 */ lwc1 $f12, 0x24($s0) -/* 6F1A60 80238980 C6000028 */ lwc1 $f0, 0x28($s0) -/* 6F1A64 80238984 46006300 */ add.s $f12, $f12, $f0 -/* 6F1A68 80238988 C6000004 */ lwc1 $f0, 4($s0) -/* 6F1A6C 8023898C 46020001 */ sub.s $f0, $f0, $f2 -/* 6F1A70 80238990 E60C0024 */ swc1 $f12, 0x24($s0) -/* 6F1A74 80238994 0C00A6C9 */ jal clamp_angle -/* 6F1A78 80238998 E6000004 */ swc1 $f0, 4($s0) -/* 6F1A7C 8023899C C6020000 */ lwc1 $f2, ($s0) -/* 6F1A80 802389A0 E6000024 */ swc1 $f0, 0x24($s0) -/* 6F1A84 802389A4 E6420144 */ swc1 $f2, 0x144($s2) -/* 6F1A88 802389A8 C6000004 */ lwc1 $f0, 4($s0) -/* 6F1A8C 802389AC E6400148 */ swc1 $f0, 0x148($s2) -/* 6F1A90 802389B0 C6000008 */ lwc1 $f0, 8($s0) -/* 6F1A94 802389B4 E640014C */ swc1 $f0, 0x14c($s2) -/* 6F1A98 802389B8 3C02800E */ lui $v0, %hi(gBattleStatus) -/* 6F1A9C 802389BC 8C42C070 */ lw $v0, %lo(gBattleStatus)($v0) -/* 6F1AA0 802389C0 30422000 */ andi $v0, $v0, 0x2000 -/* 6F1AA4 802389C4 10400003 */ beqz $v0, .L802389D4 -/* 6F1AA8 802389C8 00000000 */ nop -.L802389CC: -/* 6F1AAC 802389CC 0808E27C */ j .L802389F0 -/* 6F1AB0 802389D0 24020002 */ addiu $v0, $zero, 2 -.L802389D4: -/* 6F1AB4 802389D4 96030064 */ lhu $v1, 0x64($s0) -/* 6F1AB8 802389D8 2463FFFF */ addiu $v1, $v1, -1 -/* 6F1ABC 802389DC A6030064 */ sh $v1, 0x64($s0) -/* 6F1AC0 802389E0 00031C00 */ sll $v1, $v1, 0x10 -/* 6F1AC4 802389E4 10600002 */ beqz $v1, .L802389F0 -/* 6F1AC8 802389E8 24020001 */ addiu $v0, $zero, 1 -/* 6F1ACC 802389EC 0000102D */ daddu $v0, $zero, $zero -.L802389F0: -/* 6F1AD0 802389F0 8FBF0024 */ lw $ra, 0x24($sp) -/* 6F1AD4 802389F4 8FB40020 */ lw $s4, 0x20($sp) -/* 6F1AD8 802389F8 8FB3001C */ lw $s3, 0x1c($sp) -/* 6F1ADC 802389FC 8FB20018 */ lw $s2, 0x18($sp) -/* 6F1AE0 80238A00 8FB10014 */ lw $s1, 0x14($sp) -/* 6F1AE4 80238A04 8FB00010 */ lw $s0, 0x10($sp) -/* 6F1AE8 80238A08 D7BA0040 */ ldc1 $f26, 0x40($sp) -/* 6F1AEC 80238A0C D7B80038 */ ldc1 $f24, 0x38($sp) -/* 6F1AF0 80238A10 D7B60030 */ ldc1 $f22, 0x30($sp) -/* 6F1AF4 80238A14 D7B40028 */ ldc1 $f20, 0x28($sp) -/* 6F1AF8 80238A18 03E00008 */ jr $ra -/* 6F1AFC 80238A1C 27BD0048 */ addiu $sp, $sp, 0x48 diff --git a/ver/us/asm/nonmatchings/battle/partner/parakarry/func_802390B4_700E34.s b/ver/us/asm/nonmatchings/battle/partner/parakarry/func_802390B4_700E34.s deleted file mode 100644 index 8ef2072d75..0000000000 --- a/ver/us/asm/nonmatchings/battle/partner/parakarry/func_802390B4_700E34.s +++ /dev/null @@ -1,495 +0,0 @@ -.set noat # allow manual use of $at -.set noreorder # don't insert nops after branches - -glabel func_802390B4_700E34 -/* 700E34 802390B4 27BDFFD0 */ addiu $sp, $sp, -0x30 -/* 700E38 802390B8 AFB1001C */ sw $s1, 0x1c($sp) -/* 700E3C 802390BC 3C11800E */ lui $s1, %hi(gBattleStatus+0xDC) -/* 700E40 802390C0 8E31C14C */ lw $s1, %lo(gBattleStatus+0xDC)($s1) -/* 700E44 802390C4 AFB20020 */ sw $s2, 0x20($sp) -/* 700E48 802390C8 0080902D */ daddu $s2, $a0, $zero -/* 700E4C 802390CC AFBF0024 */ sw $ra, 0x24($sp) -/* 700E50 802390D0 AFB00018 */ sw $s0, 0x18($sp) -/* 700E54 802390D4 F7B40028 */ sdc1 $f20, 0x28($sp) -/* 700E58 802390D8 10A00002 */ beqz $a1, .L802390E4 -/* 700E5C 802390DC 2630000C */ addiu $s0, $s1, 0xc -/* 700E60 802390E0 AE400070 */ sw $zero, 0x70($s2) -.L802390E4: -/* 700E64 802390E4 8E430070 */ lw $v1, 0x70($s2) -/* 700E68 802390E8 10600005 */ beqz $v1, .L80239100 -/* 700E6C 802390EC 24020001 */ addiu $v0, $zero, 1 -/* 700E70 802390F0 10620028 */ beq $v1, $v0, .L80239194 -/* 700E74 802390F4 24020002 */ addiu $v0, $zero, 2 -/* 700E78 802390F8 0808E5C8 */ j .L80239720 -/* 700E7C 802390FC 00000000 */ nop -.L80239100: -/* 700E80 80239100 C6200144 */ lwc1 $f0, 0x144($s1) -/* 700E84 80239104 C6220148 */ lwc1 $f2, 0x148($s1) -/* 700E88 80239108 C624014C */ lwc1 $f4, 0x14c($s1) -/* 700E8C 8023910C 2404000A */ addiu $a0, $zero, 0xa -/* 700E90 80239110 E620000C */ swc1 $f0, 0xc($s1) -/* 700E94 80239114 E6220010 */ swc1 $f2, 0x10($s1) -/* 700E98 80239118 0C00A67F */ jal rand_int -/* 700E9C 8023911C E6240014 */ swc1 $f4, 0x14($s1) -/* 700EA0 80239120 2403003C */ addiu $v1, $zero, 0x3c -/* 700EA4 80239124 00621823 */ subu $v1, $v1, $v0 -/* 700EA8 80239128 44830000 */ mtc1 $v1, $f0 -/* 700EAC 8023912C 00000000 */ nop -/* 700EB0 80239130 46800020 */ cvt.s.w $f0, $f0 -/* 700EB4 80239134 E6200054 */ swc1 $f0, 0x54($s1) -/* 700EB8 80239138 3C014240 */ lui $at, 0x4240 -/* 700EBC 8023913C 44810000 */ mtc1 $at, $f0 -/* 700EC0 80239140 3C013F80 */ lui $at, 0x3f80 -/* 700EC4 80239144 44811000 */ mtc1 $at, $f2 -/* 700EC8 80239148 2402005A */ addiu $v0, $zero, 0x5a -/* 700ECC 8023914C AE20005C */ sw $zero, 0x5c($s1) -/* 700ED0 80239150 A6220070 */ sh $v0, 0x70($s1) -/* 700ED4 80239154 E620004C */ swc1 $f0, 0x4c($s1) -/* 700ED8 80239158 AE400074 */ sw $zero, 0x74($s2) -/* 700EDC 8023915C AE400078 */ sw $zero, 0x78($s2) -/* 700EE0 80239160 AE40007C */ sw $zero, 0x7c($s2) -/* 700EE4 80239164 E7A20010 */ swc1 $f2, 0x10($sp) -/* 700EE8 80239168 AFA00014 */ sw $zero, 0x14($sp) -/* 700EEC 8023916C 8E25000C */ lw $a1, 0xc($s1) -/* 700EF0 80239170 8E260010 */ lw $a2, 0x10($s1) -/* 700EF4 80239174 8E270014 */ lw $a3, 0x14($s1) -/* 700EF8 80239178 0C01C79C */ jal fx_65 -/* 700EFC 8023917C 0000202D */ daddu $a0, $zero, $zero -/* 700F00 80239180 3C018024 */ lui $at, %hi(D_8023BD70) -/* 700F04 80239184 AC22BD70 */ sw $v0, %lo(D_8023BD70)($at) -/* 700F08 80239188 24020001 */ addiu $v0, $zero, 1 -/* 700F0C 8023918C 0808E5C6 */ j .L80239718 -/* 700F10 80239190 AE420070 */ sw $v0, 0x70($s2) -.L80239194: -/* 700F14 80239194 0200202D */ daddu $a0, $s0, $zero -/* 700F18 80239198 8E26004C */ lw $a2, 0x4c($s1) -/* 700F1C 8023919C 8E270054 */ lw $a3, 0x54($s1) -/* 700F20 802391A0 0C00A7E7 */ jal add_vec2D_polar -/* 700F24 802391A4 26250010 */ addiu $a1, $s1, 0x10 -/* 700F28 802391A8 3C028024 */ lui $v0, %hi(D_8023BD70) -/* 700F2C 802391AC 8C42BD70 */ lw $v0, %lo(D_8023BD70)($v0) -/* 700F30 802391B0 C620000C */ lwc1 $f0, 0xc($s1) -/* 700F34 802391B4 8C43000C */ lw $v1, 0xc($v0) -/* 700F38 802391B8 E4600038 */ swc1 $f0, 0x38($v1) -/* 700F3C 802391BC 8C43000C */ lw $v1, 0xc($v0) -/* 700F40 802391C0 C6200010 */ lwc1 $f0, 0x10($s1) -/* 700F44 802391C4 E460003C */ swc1 $f0, 0x3c($v1) -/* 700F48 802391C8 8C42000C */ lw $v0, 0xc($v0) -/* 700F4C 802391CC C6200014 */ lwc1 $f0, 0x14($s1) -/* 700F50 802391D0 E4400040 */ swc1 $f0, 0x40($v0) -/* 700F54 802391D4 C622000C */ lwc1 $f2, 0xc($s1) -/* 700F58 802391D8 3C01C33E */ lui $at, 0xc33e -/* 700F5C 802391DC 44810000 */ mtc1 $at, $f0 -/* 700F60 802391E0 00000000 */ nop -/* 700F64 802391E4 4600103C */ c.lt.s $f2, $f0 -/* 700F68 802391E8 00000000 */ nop -/* 700F6C 802391EC 45000053 */ bc1f .L8023933C -/* 700F70 802391F0 00000000 */ nop -/* 700F74 802391F4 8E420074 */ lw $v0, 0x74($s2) -/* 700F78 802391F8 544000F1 */ bnel $v0, $zero, .L802395C0 -/* 700F7C 802391FC 24020002 */ addiu $v0, $zero, 2 -/* 700F80 80239200 C6220054 */ lwc1 $f2, 0x54($s1) -/* 700F84 80239204 3C014387 */ lui $at, 0x4387 -/* 700F88 80239208 44810000 */ mtc1 $at, $f0 -/* 700F8C 8023920C 00000000 */ nop -/* 700F90 80239210 4602003E */ c.le.s $f0, $f2 -/* 700F94 80239214 00000000 */ nop -/* 700F98 80239218 45000019 */ bc1f .L80239280 -/* 700F9C 8023921C 00000000 */ nop -/* 700FA0 80239220 3C0143B4 */ lui $at, 0x43b4 -/* 700FA4 80239224 44810000 */ mtc1 $at, $f0 -/* 700FA8 80239228 00000000 */ nop -/* 700FAC 8023922C 4600103C */ c.lt.s $f2, $f0 -/* 700FB0 80239230 00000000 */ nop -/* 700FB4 80239234 45000012 */ bc1f .L80239280 -/* 700FB8 80239238 00000000 */ nop -/* 700FBC 8023923C 3C014334 */ lui $at, 0x4334 -/* 700FC0 80239240 44816000 */ mtc1 $at, $f12 -/* 700FC4 80239244 0C00A6C9 */ jal clamp_angle -/* 700FC8 80239248 460C1300 */ add.s $f12, $f2, $f12 -/* 700FCC 8023924C 3C0142B4 */ lui $at, 0x42b4 -/* 700FD0 80239250 44811000 */ mtc1 $at, $f2 -/* 700FD4 80239254 00000000 */ nop -/* 700FD8 80239258 46001001 */ sub.s $f0, $f2, $f0 -/* 700FDC 8023925C 46020000 */ add.s $f0, $f0, $f2 -/* 700FE0 80239260 24040004 */ addiu $a0, $zero, 4 -/* 700FE4 80239264 0C00A67F */ jal rand_int -/* 700FE8 80239268 E6200054 */ swc1 $f0, 0x54($s1) -/* 700FEC 8023926C 2442FFFE */ addiu $v0, $v0, -2 -/* 700FF0 80239270 44820000 */ mtc1 $v0, $f0 -/* 700FF4 80239274 00000000 */ nop -/* 700FF8 80239278 46800020 */ cvt.s.w $f0, $f0 -/* 700FFC 8023927C E620005C */ swc1 $f0, 0x5c($s1) -.L80239280: -/* 701000 80239280 C60C0048 */ lwc1 $f12, 0x48($s0) -/* 701004 80239284 3C014334 */ lui $at, 0x4334 -/* 701008 80239288 44811000 */ mtc1 $at, $f2 -/* 70100C 8023928C 00000000 */ nop -/* 701010 80239290 460C103E */ c.le.s $f2, $f12 -/* 701014 80239294 00000000 */ nop -/* 701018 80239298 45000017 */ bc1f .L802392F8 -/* 70101C 8023929C 00000000 */ nop -/* 701020 802392A0 3C014387 */ lui $at, 0x4387 -/* 701024 802392A4 44810000 */ mtc1 $at, $f0 -/* 701028 802392A8 00000000 */ nop -/* 70102C 802392AC 4600603C */ c.lt.s $f12, $f0 -/* 701030 802392B0 00000000 */ nop -/* 701034 802392B4 45000010 */ bc1f .L802392F8 -/* 701038 802392B8 00000000 */ nop -/* 70103C 802392BC 0C00A6C9 */ jal clamp_angle -/* 701040 802392C0 46026300 */ add.s $f12, $f12, $f2 -/* 701044 802392C4 3C0142B4 */ lui $at, 0x42b4 -/* 701048 802392C8 44811000 */ mtc1 $at, $f2 -/* 70104C 802392CC 00000000 */ nop -/* 701050 802392D0 46020001 */ sub.s $f0, $f0, $f2 -/* 701054 802392D4 46001081 */ sub.s $f2, $f2, $f0 -/* 701058 802392D8 24040004 */ addiu $a0, $zero, 4 -/* 70105C 802392DC 0C00A67F */ jal rand_int -/* 701060 802392E0 E6020048 */ swc1 $f2, 0x48($s0) -/* 701064 802392E4 2442FFFE */ addiu $v0, $v0, -2 -/* 701068 802392E8 44820000 */ mtc1 $v0, $f0 -/* 70106C 802392EC 00000000 */ nop -/* 701070 802392F0 46800020 */ cvt.s.w $f0, $f0 -/* 701074 802392F4 E6000050 */ swc1 $f0, 0x50($s0) -.L802392F8: -/* 701078 802392F8 8E42007C */ lw $v0, 0x7c($s2) -/* 70107C 802392FC 10400004 */ beqz $v0, .L80239310 -/* 701080 80239300 2404200A */ addiu $a0, $zero, 0x200a -/* 701084 80239304 C6000008 */ lwc1 $f0, 8($s0) -/* 701088 80239308 0808E4C7 */ j .L8023931C -/* 70108C 8023930C E7A00010 */ swc1 $f0, 0x10($sp) -.L80239310: -/* 701090 80239310 C6000008 */ lwc1 $f0, 8($s0) -/* 701094 80239314 2404200B */ addiu $a0, $zero, 0x200b -/* 701098 80239318 E7A00010 */ swc1 $f0, 0x10($sp) -.L8023931C: -/* 70109C 8023931C 8E060000 */ lw $a2, ($s0) -/* 7010A0 80239320 8E070004 */ lw $a3, 4($s0) -/* 7010A4 80239324 0C052757 */ jal sfx_play_sound_at_position -/* 7010A8 80239328 0000282D */ daddu $a1, $zero, $zero -/* 7010AC 8023932C 8E43007C */ lw $v1, 0x7c($s2) -/* 7010B0 80239330 24020001 */ addiu $v0, $zero, 1 -/* 7010B4 80239334 00431023 */ subu $v0, $v0, $v1 -/* 7010B8 80239338 AE42007C */ sw $v0, 0x7c($s2) -.L8023933C: -/* 7010BC 8023933C C6020000 */ lwc1 $f2, ($s0) -/* 7010C0 80239340 3C01433E */ lui $at, 0x433e -/* 7010C4 80239344 44810000 */ mtc1 $at, $f0 -/* 7010C8 80239348 00000000 */ nop -/* 7010CC 8023934C 4602003C */ c.lt.s $f0, $f2 -/* 7010D0 80239350 00000000 */ nop -/* 7010D4 80239354 45000046 */ bc1f .L80239470 -/* 7010D8 80239358 00000000 */ nop -/* 7010DC 8023935C 8E420074 */ lw $v0, 0x74($s2) -/* 7010E0 80239360 1040000E */ beqz $v0, .L8023939C -/* 7010E4 80239364 24020002 */ addiu $v0, $zero, 2 -/* 7010E8 80239368 0808E5C6 */ j .L80239718 -/* 7010EC 8023936C AE420070 */ sw $v0, 0x70($s2) -.L80239370: -/* 7010F0 80239370 3C014334 */ lui $at, 0x4334 -/* 7010F4 80239374 44816000 */ mtc1 $at, $f12 -/* 7010F8 80239378 0C00A6C9 */ jal clamp_angle -/* 7010FC 8023937C 460C1300 */ add.s $f12, $f2, $f12 -/* 701100 80239380 3C014387 */ lui $at, 0x4387 -/* 701104 80239384 44811000 */ mtc1 $at, $f2 -/* 701108 80239388 00000000 */ nop -/* 70110C 8023938C 46001001 */ sub.s $f0, $f2, $f0 -/* 701110 80239390 46020000 */ add.s $f0, $f0, $f2 -/* 701114 80239394 0808E50B */ j .L8023942C -/* 701118 80239398 E6000048 */ swc1 $f0, 0x48($s0) -.L8023939C: -/* 70111C 8023939C C6020048 */ lwc1 $f2, 0x48($s0) -/* 701120 802393A0 44800000 */ mtc1 $zero, $f0 -/* 701124 802393A4 00000000 */ nop -/* 701128 802393A8 4602003E */ c.le.s $f0, $f2 -/* 70112C 802393AC 00000000 */ nop -/* 701130 802393B0 45000008 */ bc1f .L802393D4 -/* 701134 802393B4 00000000 */ nop -/* 701138 802393B8 3C0142B4 */ lui $at, 0x42b4 -/* 70113C 802393BC 44810000 */ mtc1 $at, $f0 -/* 701140 802393C0 00000000 */ nop -/* 701144 802393C4 4600103C */ c.lt.s $f2, $f0 -/* 701148 802393C8 00000000 */ nop -/* 70114C 802393CC 4501FFE8 */ bc1t .L80239370 -/* 701150 802393D0 00000000 */ nop -.L802393D4: -/* 701154 802393D4 3C0142B4 */ lui $at, 0x42b4 -/* 701158 802393D8 44810000 */ mtc1 $at, $f0 -/* 70115C 802393DC 00000000 */ nop -/* 701160 802393E0 4602003E */ c.le.s $f0, $f2 -/* 701164 802393E4 00000000 */ nop -/* 701168 802393E8 45000010 */ bc1f .L8023942C -/* 70116C 802393EC 00000000 */ nop -/* 701170 802393F0 3C014334 */ lui $at, 0x4334 -/* 701174 802393F4 44810000 */ mtc1 $at, $f0 -/* 701178 802393F8 00000000 */ nop -/* 70117C 802393FC 4600103C */ c.lt.s $f2, $f0 -/* 701180 80239400 00000000 */ nop -/* 701184 80239404 45000009 */ bc1f .L8023942C -/* 701188 80239408 00000000 */ nop -/* 70118C 8023940C 0C00A6C9 */ jal clamp_angle -/* 701190 80239410 46001300 */ add.s $f12, $f2, $f0 -/* 701194 80239414 3C014387 */ lui $at, 0x4387 -/* 701198 80239418 44811000 */ mtc1 $at, $f2 -/* 70119C 8023941C 00000000 */ nop -/* 7011A0 80239420 46020001 */ sub.s $f0, $f0, $f2 -/* 7011A4 80239424 46001081 */ sub.s $f2, $f2, $f0 -/* 7011A8 80239428 E6020048 */ swc1 $f2, 0x48($s0) -.L8023942C: -/* 7011AC 8023942C 8E42007C */ lw $v0, 0x7c($s2) -/* 7011B0 80239430 10400004 */ beqz $v0, .L80239444 -/* 7011B4 80239434 2404200A */ addiu $a0, $zero, 0x200a -/* 7011B8 80239438 C6000008 */ lwc1 $f0, 8($s0) -/* 7011BC 8023943C 0808E514 */ j .L80239450 -/* 7011C0 80239440 E7A00010 */ swc1 $f0, 0x10($sp) -.L80239444: -/* 7011C4 80239444 C6000008 */ lwc1 $f0, 8($s0) -/* 7011C8 80239448 2404200B */ addiu $a0, $zero, 0x200b -/* 7011CC 8023944C E7A00010 */ swc1 $f0, 0x10($sp) -.L80239450: -/* 7011D0 80239450 8E060000 */ lw $a2, ($s0) -/* 7011D4 80239454 8E070004 */ lw $a3, 4($s0) -/* 7011D8 80239458 0C052757 */ jal sfx_play_sound_at_position -/* 7011DC 8023945C 0000282D */ daddu $a1, $zero, $zero -/* 7011E0 80239460 8E43007C */ lw $v1, 0x7c($s2) -/* 7011E4 80239464 24020001 */ addiu $v0, $zero, 1 -/* 7011E8 80239468 00431023 */ subu $v0, $v0, $v1 -/* 7011EC 8023946C AE42007C */ sw $v0, 0x7c($s2) -.L80239470: -/* 7011F0 80239470 C6020004 */ lwc1 $f2, 4($s0) -/* 7011F4 80239474 3C01C1F0 */ lui $at, 0xc1f0 -/* 7011F8 80239478 44810000 */ mtc1 $at, $f0 -/* 7011FC 8023947C 00000000 */ nop -/* 701200 80239480 4600103C */ c.lt.s $f2, $f0 -/* 701204 80239484 00000000 */ nop -/* 701208 80239488 45000043 */ bc1f .L80239598 -/* 70120C 8023948C 00000000 */ nop -/* 701210 80239490 8E420074 */ lw $v0, 0x74($s2) -/* 701214 80239494 1040000B */ beqz $v0, .L802394C4 -/* 701218 80239498 24020002 */ addiu $v0, $zero, 2 -/* 70121C 8023949C 0808E5C6 */ j .L80239718 -/* 701220 802394A0 AE420070 */ sw $v0, 0x70($s2) -.L802394A4: -/* 701224 802394A4 3C014334 */ lui $at, 0x4334 -/* 701228 802394A8 4481A000 */ mtc1 $at, $f20 -/* 70122C 802394AC 0C00A6C9 */ jal clamp_angle -/* 701230 802394B0 46146300 */ add.s $f12, $f12, $f20 -/* 701234 802394B4 4600A001 */ sub.s $f0, $f20, $f0 -/* 701238 802394B8 46140000 */ add.s $f0, $f0, $f20 -/* 70123C 802394BC 0808E554 */ j .L80239550 -/* 701240 802394C0 E6000048 */ swc1 $f0, 0x48($s0) -.L802394C4: -/* 701244 802394C4 C60C0048 */ lwc1 $f12, 0x48($s0) -/* 701248 802394C8 3C014387 */ lui $at, 0x4387 -/* 70124C 802394CC 44810000 */ mtc1 $at, $f0 -/* 701250 802394D0 00000000 */ nop -/* 701254 802394D4 460C003E */ c.le.s $f0, $f12 -/* 701258 802394D8 00000000 */ nop -/* 70125C 802394DC 45000008 */ bc1f .L80239500 -/* 701260 802394E0 00000000 */ nop -/* 701264 802394E4 3C0143B4 */ lui $at, 0x43b4 -/* 701268 802394E8 44810000 */ mtc1 $at, $f0 -/* 70126C 802394EC 00000000 */ nop -/* 701270 802394F0 4600603C */ c.lt.s $f12, $f0 -/* 701274 802394F4 00000000 */ nop -/* 701278 802394F8 4501FFEA */ bc1t .L802394A4 -/* 70127C 802394FC 00000000 */ nop -.L80239500: -/* 701280 80239500 44800000 */ mtc1 $zero, $f0 -/* 701284 80239504 00000000 */ nop -/* 701288 80239508 460C003E */ c.le.s $f0, $f12 -/* 70128C 8023950C 00000000 */ nop -/* 701290 80239510 4500000F */ bc1f .L80239550 -/* 701294 80239514 00000000 */ nop -/* 701298 80239518 3C0142B4 */ lui $at, 0x42b4 -/* 70129C 8023951C 44810000 */ mtc1 $at, $f0 -/* 7012A0 80239520 00000000 */ nop -/* 7012A4 80239524 4600603C */ c.lt.s $f12, $f0 -/* 7012A8 80239528 00000000 */ nop -/* 7012AC 8023952C 45000008 */ bc1f .L80239550 -/* 7012B0 80239530 00000000 */ nop -/* 7012B4 80239534 3C014334 */ lui $at, 0x4334 -/* 7012B8 80239538 4481A000 */ mtc1 $at, $f20 -/* 7012BC 8023953C 0C00A6C9 */ jal clamp_angle -/* 7012C0 80239540 46146300 */ add.s $f12, $f12, $f20 -/* 7012C4 80239544 46140001 */ sub.s $f0, $f0, $f20 -/* 7012C8 80239548 4600A501 */ sub.s $f20, $f20, $f0 -/* 7012CC 8023954C E6140048 */ swc1 $f20, 0x48($s0) -.L80239550: -/* 7012D0 80239550 8E42007C */ lw $v0, 0x7c($s2) -/* 7012D4 80239554 10400004 */ beqz $v0, .L80239568 -/* 7012D8 80239558 2404200A */ addiu $a0, $zero, 0x200a -/* 7012DC 8023955C C6000008 */ lwc1 $f0, 8($s0) -/* 7012E0 80239560 0808E55D */ j .L80239574 -/* 7012E4 80239564 E7A00010 */ swc1 $f0, 0x10($sp) -.L80239568: -/* 7012E8 80239568 C6000008 */ lwc1 $f0, 8($s0) -/* 7012EC 8023956C 2404200B */ addiu $a0, $zero, 0x200b -/* 7012F0 80239570 E7A00010 */ swc1 $f0, 0x10($sp) -.L80239574: -/* 7012F4 80239574 8E060000 */ lw $a2, ($s0) -/* 7012F8 80239578 8E070004 */ lw $a3, 4($s0) -/* 7012FC 8023957C 0C052757 */ jal sfx_play_sound_at_position -/* 701300 80239580 0000282D */ daddu $a1, $zero, $zero -/* 701304 80239584 8E43007C */ lw $v1, 0x7c($s2) -/* 701308 80239588 24020001 */ addiu $v0, $zero, 1 -/* 70130C 8023958C 00431023 */ subu $v0, $v0, $v1 -/* 701310 80239590 AE42007C */ sw $v0, 0x7c($s2) -/* 701314 80239594 C6020004 */ lwc1 $f2, 4($s0) -.L80239598: -/* 701318 80239598 3C014320 */ lui $at, 0x4320 -/* 70131C 8023959C 44810000 */ mtc1 $at, $f0 -/* 701320 802395A0 00000000 */ nop -/* 701324 802395A4 4602003C */ c.lt.s $f0, $f2 -/* 701328 802395A8 00000000 */ nop -/* 70132C 802395AC 45000045 */ bc1f .L802396C4 -/* 701330 802395B0 00000000 */ nop -/* 701334 802395B4 8E420074 */ lw $v0, 0x74($s2) -/* 701338 802395B8 1040000C */ beqz $v0, .L802395EC -/* 70133C 802395BC 24020002 */ addiu $v0, $zero, 2 -.L802395C0: -/* 701340 802395C0 0808E5C6 */ j .L80239718 -/* 701344 802395C4 AE420070 */ sw $v0, 0x70($s2) -.L802395C8: -/* 701348 802395C8 0C00A6C9 */ jal clamp_angle -/* 70134C 802395CC 46006300 */ add.s $f12, $f12, $f0 -/* 701350 802395D0 3C0143B4 */ lui $at, 0x43b4 -/* 701354 802395D4 44811000 */ mtc1 $at, $f2 -/* 701358 802395D8 00000000 */ nop -/* 70135C 802395DC 46001001 */ sub.s $f0, $f2, $f0 -/* 701360 802395E0 46020000 */ add.s $f0, $f0, $f2 -/* 701364 802395E4 0808E5A0 */ j .L80239680 -/* 701368 802395E8 E6000048 */ swc1 $f0, 0x48($s0) -.L802395EC: -/* 70136C 802395EC C60C0048 */ lwc1 $f12, 0x48($s0) -/* 701370 802395F0 3C0142B4 */ lui $at, 0x42b4 -/* 701374 802395F4 44810000 */ mtc1 $at, $f0 -/* 701378 802395F8 00000000 */ nop -/* 70137C 802395FC 460C003E */ c.le.s $f0, $f12 -/* 701380 80239600 00000000 */ nop -/* 701384 80239604 45000008 */ bc1f .L80239628 -/* 701388 80239608 00000000 */ nop -/* 70138C 8023960C 3C014334 */ lui $at, 0x4334 -/* 701390 80239610 44810000 */ mtc1 $at, $f0 -/* 701394 80239614 00000000 */ nop -/* 701398 80239618 4600603C */ c.lt.s $f12, $f0 -/* 70139C 8023961C 00000000 */ nop -/* 7013A0 80239620 4501FFE9 */ bc1t .L802395C8 -/* 7013A4 80239624 00000000 */ nop -.L80239628: -/* 7013A8 80239628 3C014334 */ lui $at, 0x4334 -/* 7013AC 8023962C 44811000 */ mtc1 $at, $f2 -/* 7013B0 80239630 00000000 */ nop -/* 7013B4 80239634 460C103E */ c.le.s $f2, $f12 -/* 7013B8 80239638 00000000 */ nop -/* 7013BC 8023963C 45000010 */ bc1f .L80239680 -/* 7013C0 80239640 00000000 */ nop -/* 7013C4 80239644 3C014387 */ lui $at, 0x4387 -/* 7013C8 80239648 44810000 */ mtc1 $at, $f0 -/* 7013CC 8023964C 00000000 */ nop -/* 7013D0 80239650 4600603C */ c.lt.s $f12, $f0 -/* 7013D4 80239654 00000000 */ nop -/* 7013D8 80239658 45000009 */ bc1f .L80239680 -/* 7013DC 8023965C 00000000 */ nop -/* 7013E0 80239660 0C00A6C9 */ jal clamp_angle -/* 7013E4 80239664 46026300 */ add.s $f12, $f12, $f2 -/* 7013E8 80239668 3C0143B4 */ lui $at, 0x43b4 -/* 7013EC 8023966C 44811000 */ mtc1 $at, $f2 -/* 7013F0 80239670 00000000 */ nop -/* 7013F4 80239674 46020001 */ sub.s $f0, $f0, $f2 -/* 7013F8 80239678 46001081 */ sub.s $f2, $f2, $f0 -/* 7013FC 8023967C E6020048 */ swc1 $f2, 0x48($s0) -.L80239680: -/* 701400 80239680 8E42007C */ lw $v0, 0x7c($s2) -/* 701404 80239684 10400004 */ beqz $v0, .L80239698 -/* 701408 80239688 2404200A */ addiu $a0, $zero, 0x200a -/* 70140C 8023968C C6000008 */ lwc1 $f0, 8($s0) -/* 701410 80239690 0808E5A9 */ j .L802396A4 -/* 701414 80239694 E7A00010 */ swc1 $f0, 0x10($sp) -.L80239698: -/* 701418 80239698 C6000008 */ lwc1 $f0, 8($s0) -/* 70141C 8023969C 2404200B */ addiu $a0, $zero, 0x200b -/* 701420 802396A0 E7A00010 */ swc1 $f0, 0x10($sp) -.L802396A4: -/* 701424 802396A4 8E060000 */ lw $a2, ($s0) -/* 701428 802396A8 8E070004 */ lw $a3, 4($s0) -/* 70142C 802396AC 0C052757 */ jal sfx_play_sound_at_position -/* 701430 802396B0 0000282D */ daddu $a1, $zero, $zero -/* 701434 802396B4 8E43007C */ lw $v1, 0x7c($s2) -/* 701438 802396B8 24020001 */ addiu $v0, $zero, 1 -/* 70143C 802396BC 00431023 */ subu $v0, $v0, $v1 -/* 701440 802396C0 AE42007C */ sw $v0, 0x7c($s2) -.L802396C4: -/* 701444 802396C4 C6000050 */ lwc1 $f0, 0x50($s0) -/* 701448 802396C8 3C013FE0 */ lui $at, 0x3fe0 -/* 70144C 802396CC 44811800 */ mtc1 $at, $f3 -/* 701450 802396D0 44801000 */ mtc1 $zero, $f2 -/* 701454 802396D4 46000021 */ cvt.d.s $f0, $f0 -/* 701458 802396D8 46220002 */ mul.d $f0, $f0, $f2 -/* 70145C 802396DC 00000000 */ nop -/* 701460 802396E0 C60C0048 */ lwc1 $f12, 0x48($s0) -/* 701464 802396E4 46006321 */ cvt.d.s $f12, $f12 -/* 701468 802396E8 46206300 */ add.d $f12, $f12, $f0 -/* 70146C 802396EC 0C00A6C9 */ jal clamp_angle -/* 701470 802396F0 46206320 */ cvt.s.d $f12, $f12 -/* 701474 802396F4 86020064 */ lh $v0, 0x64($s0) -/* 701478 802396F8 96030064 */ lhu $v1, 0x64($s0) -/* 70147C 802396FC 10400004 */ beqz $v0, .L80239710 -/* 701480 80239700 E6000048 */ swc1 $f0, 0x48($s0) -/* 701484 80239704 2462FFFF */ addiu $v0, $v1, -1 -/* 701488 80239708 0808E5C6 */ j .L80239718 -/* 70148C 8023970C A6020064 */ sh $v0, 0x64($s0) -.L80239710: -/* 701490 80239710 24020001 */ addiu $v0, $zero, 1 -/* 701494 80239714 AE420074 */ sw $v0, 0x74($s2) -.L80239718: -/* 701498 80239718 8E430070 */ lw $v1, 0x70($s2) -/* 70149C 8023971C 24020002 */ addiu $v0, $zero, 2 -.L80239720: -/* 7014A0 80239720 10620005 */ beq $v1, $v0, .L80239738 -/* 7014A4 80239724 24020003 */ addiu $v0, $zero, 3 -/* 7014A8 80239728 1062000D */ beq $v1, $v0, .L80239760 -/* 7014AC 8023972C 0200202D */ daddu $a0, $s0, $zero -/* 7014B0 80239730 0808E5E4 */ j .L80239790 -/* 7014B4 80239734 00000000 */ nop -.L80239738: -/* 7014B8 80239738 3C038024 */ lui $v1, %hi(D_8023BD70) -/* 7014BC 8023973C 8C63BD70 */ lw $v1, %lo(D_8023BD70)($v1) -/* 7014C0 80239740 24020005 */ addiu $v0, $zero, 5 -/* 7014C4 80239744 A6020064 */ sh $v0, 0x64($s0) -/* 7014C8 80239748 24020003 */ addiu $v0, $zero, 3 -/* 7014CC 8023974C AE420070 */ sw $v0, 0x70($s2) -/* 7014D0 80239750 8C620000 */ lw $v0, ($v1) -/* 7014D4 80239754 34420010 */ ori $v0, $v0, 0x10 -/* 7014D8 80239758 AC620000 */ sw $v0, ($v1) -/* 7014DC 8023975C 0200202D */ daddu $a0, $s0, $zero -.L80239760: -/* 7014E0 80239760 8E060040 */ lw $a2, 0x40($s0) -/* 7014E4 80239764 8E070048 */ lw $a3, 0x48($s0) -/* 7014E8 80239768 0C00A7E7 */ jal add_vec2D_polar -/* 7014EC 8023976C 26050004 */ addiu $a1, $s0, 4 -/* 7014F0 80239770 86020064 */ lh $v0, 0x64($s0) -/* 7014F4 80239774 96030064 */ lhu $v1, 0x64($s0) -/* 7014F8 80239778 14400004 */ bnez $v0, .L8023978C -/* 7014FC 8023977C 2462FFFF */ addiu $v0, $v1, -1 -/* 701500 80239780 AE200164 */ sw $zero, 0x164($s1) -/* 701504 80239784 0808E5EB */ j .L802397AC -/* 701508 80239788 24020002 */ addiu $v0, $zero, 2 -.L8023978C: -/* 70150C 8023978C A6020064 */ sh $v0, 0x64($s0) -.L80239790: -/* 701510 80239790 C6000000 */ lwc1 $f0, ($s0) -/* 701514 80239794 E6200144 */ swc1 $f0, 0x144($s1) -/* 701518 80239798 C6000004 */ lwc1 $f0, 4($s0) -/* 70151C 8023979C E6200148 */ swc1 $f0, 0x148($s1) -/* 701520 802397A0 C6000008 */ lwc1 $f0, 8($s0) -/* 701524 802397A4 0000102D */ daddu $v0, $zero, $zero -/* 701528 802397A8 E620014C */ swc1 $f0, 0x14c($s1) -.L802397AC: -/* 70152C 802397AC 8FBF0024 */ lw $ra, 0x24($sp) -/* 701530 802397B0 8FB20020 */ lw $s2, 0x20($sp) -/* 701534 802397B4 8FB1001C */ lw $s1, 0x1c($sp) -/* 701538 802397B8 8FB00018 */ lw $s0, 0x18($sp) -/* 70153C 802397BC D7B40028 */ ldc1 $f20, 0x28($sp) -/* 701540 802397C0 03E00008 */ jr $ra -/* 701544 802397C4 27BD0030 */ addiu $sp, $sp, 0x30 diff --git a/ver/us/asm/nonmatchings/battle/partner/sushie/func_80238114_707DB4.s b/ver/us/asm/nonmatchings/battle/partner/sushie/func_80238114_707DB4.s deleted file mode 100644 index cdd298d4a6..0000000000 --- a/ver/us/asm/nonmatchings/battle/partner/sushie/func_80238114_707DB4.s +++ /dev/null @@ -1,65 +0,0 @@ -.set noat # allow manual use of $at -.set noreorder # don't insert nops after branches - -glabel func_80238114_707DB4 -/* 707DB4 80238114 3C02800E */ lui $v0, %hi(gBattleStatus+0xDC) -/* 707DB8 80238118 8C42C14C */ lw $v0, %lo(gBattleStatus+0xDC)($v0) -/* 707DBC 8023811C 8C860084 */ lw $a2, 0x84($a0) -/* 707DC0 80238120 AC800084 */ sw $zero, 0x84($a0) -/* 707DC4 80238124 8C420008 */ lw $v0, 8($v0) -/* 707DC8 80238128 90430006 */ lbu $v1, 6($v0) -/* 707DCC 8023812C 24070001 */ addiu $a3, $zero, 1 -/* 707DD0 80238130 10670013 */ beq $v1, $a3, .L80238180 -/* 707DD4 80238134 0000282D */ daddu $a1, $zero, $zero -/* 707DD8 80238138 28620002 */ slti $v0, $v1, 2 -/* 707DDC 8023813C 10400005 */ beqz $v0, .L80238154 -/* 707DE0 80238140 24020002 */ addiu $v0, $zero, 2 -/* 707DE4 80238144 10600007 */ beqz $v1, .L80238164 -/* 707DE8 80238148 28C20029 */ slti $v0, $a2, 0x29 -/* 707DEC 8023814C 0808E079 */ j .L802381E4 -/* 707DF0 80238150 AC8500C0 */ sw $a1, 0xc0($a0) -.L80238154: -/* 707DF4 80238154 10620015 */ beq $v1, $v0, .L802381AC -/* 707DF8 80238158 28C20015 */ slti $v0, $a2, 0x15 -/* 707DFC 8023815C 03E00008 */ jr $ra -/* 707E00 80238160 AC8500C0 */ sw $a1, 0xc0($a0) -.L80238164: -/* 707E04 80238164 1440001E */ bnez $v0, .L802381E0 -/* 707E08 80238168 24050003 */ addiu $a1, $zero, 3 -/* 707E0C 8023816C 28C2004C */ slti $v0, $a2, 0x4c -/* 707E10 80238170 1440001B */ bnez $v0, .L802381E0 -/* 707E14 80238174 24050004 */ addiu $a1, $zero, 4 -/* 707E18 80238178 0808E077 */ j .L802381DC -/* 707E1C 8023817C 24050005 */ addiu $a1, $zero, 5 -.L80238180: -/* 707E20 80238180 28C20024 */ slti $v0, $a2, 0x24 -/* 707E24 80238184 14400016 */ bnez $v0, .L802381E0 -/* 707E28 80238188 24050003 */ addiu $a1, $zero, 3 -/* 707E2C 8023818C 28C2003D */ slti $v0, $a2, 0x3d -/* 707E30 80238190 14400013 */ bnez $v0, .L802381E0 -/* 707E34 80238194 24050004 */ addiu $a1, $zero, 4 -/* 707E38 80238198 28C20051 */ slti $v0, $a2, 0x51 -/* 707E3C 8023819C 14400010 */ bnez $v0, .L802381E0 -/* 707E40 802381A0 24050005 */ addiu $a1, $zero, 5 -/* 707E44 802381A4 0808E077 */ j .L802381DC -/* 707E48 802381A8 24050006 */ addiu $a1, $zero, 6 -.L802381AC: -/* 707E4C 802381AC 1440000C */ bnez $v0, .L802381E0 -/* 707E50 802381B0 24050003 */ addiu $a1, $zero, 3 -/* 707E54 802381B4 28C2001F */ slti $v0, $a2, 0x1f -/* 707E58 802381B8 14400009 */ bnez $v0, .L802381E0 -/* 707E5C 802381BC 24050004 */ addiu $a1, $zero, 4 -/* 707E60 802381C0 28C2003D */ slti $v0, $a2, 0x3d -/* 707E64 802381C4 14400006 */ bnez $v0, .L802381E0 -/* 707E68 802381C8 24050005 */ addiu $a1, $zero, 5 -/* 707E6C 802381CC 28C20051 */ slti $v0, $a2, 0x51 -/* 707E70 802381D0 14400003 */ bnez $v0, .L802381E0 -/* 707E74 802381D4 24050006 */ addiu $a1, $zero, 6 -/* 707E78 802381D8 24050007 */ addiu $a1, $zero, 7 -.L802381DC: -/* 707E7C 802381DC AC870084 */ sw $a3, 0x84($a0) -.L802381E0: -/* 707E80 802381E0 AC8500C0 */ sw $a1, 0xc0($a0) -.L802381E4: -/* 707E84 802381E4 03E00008 */ jr $ra -/* 707E88 802381E8 24020002 */ addiu $v0, $zero, 2 diff --git a/ver/us/asm/nonmatchings/battle/partner/sushie/func_80238540_7081E0.s b/ver/us/asm/nonmatchings/battle/partner/sushie/func_80238540_7081E0.s deleted file mode 100644 index 56c14aeb84..0000000000 --- a/ver/us/asm/nonmatchings/battle/partner/sushie/func_80238540_7081E0.s +++ /dev/null @@ -1,623 +0,0 @@ -.set noat # allow manual use of $at -.set noreorder # don't insert nops after branches - -.section .rodata - -dlabel D_8023C068_70BD08 -.double 0.06 - -.section .text - -glabel func_80238540_7081E0 -/* 7081E0 80238540 27BDFFC8 */ addiu $sp, $sp, -0x38 -/* 7081E4 80238544 AFB10024 */ sw $s1, 0x24($sp) -/* 7081E8 80238548 3C11800E */ lui $s1, %hi(gBattleStatus+0xDC) -/* 7081EC 8023854C 8E31C14C */ lw $s1, %lo(gBattleStatus+0xDC)($s1) -/* 7081F0 80238550 AFB20028 */ sw $s2, 0x28($sp) -/* 7081F4 80238554 0080902D */ daddu $s2, $a0, $zero -/* 7081F8 80238558 AFBF002C */ sw $ra, 0x2c($sp) -/* 7081FC 8023855C AFB00020 */ sw $s0, 0x20($sp) -/* 708200 80238560 F7B40030 */ sdc1 $f20, 0x30($sp) -/* 708204 80238564 10A00002 */ beqz $a1, .L80238570 -/* 708208 80238568 2630000C */ addiu $s0, $s1, 0xc -/* 70820C 8023856C AE400070 */ sw $zero, 0x70($s2) -.L80238570: -/* 708210 80238570 8E430070 */ lw $v1, 0x70($s2) -/* 708214 80238574 10600005 */ beqz $v1, .L8023858C -/* 708218 80238578 24020001 */ addiu $v0, $zero, 1 -/* 70821C 8023857C 1062002C */ beq $v1, $v0, .L80238630 -/* 708220 80238580 24020002 */ addiu $v0, $zero, 2 -/* 708224 80238584 0808E346 */ j .L80238D18 -/* 708228 80238588 00000000 */ nop -.L8023858C: -/* 70822C 8023858C C6200144 */ lwc1 $f0, 0x144($s1) -/* 708230 80238590 C6220148 */ lwc1 $f2, 0x148($s1) -/* 708234 80238594 C624014C */ lwc1 $f4, 0x14c($s1) -/* 708238 80238598 3C01439D */ lui $at, 0x439d -/* 70823C 8023859C 34218000 */ ori $at, $at, 0x8000 -/* 708240 802385A0 44813000 */ mtc1 $at, $f6 -/* 708244 802385A4 3C014200 */ lui $at, 0x4200 -/* 708248 802385A8 44814000 */ mtc1 $at, $f8 -/* 70824C 802385AC 3C013F80 */ lui $at, 0x3f80 -/* 708250 802385B0 44815000 */ mtc1 $at, $f10 -/* 708254 802385B4 2402005A */ addiu $v0, $zero, 0x5a -/* 708258 802385B8 AE20005C */ sw $zero, 0x5c($s1) -/* 70825C 802385BC A6220070 */ sh $v0, 0x70($s1) -/* 708260 802385C0 E620000C */ swc1 $f0, 0xc($s1) -/* 708264 802385C4 E6220010 */ swc1 $f2, 0x10($s1) -/* 708268 802385C8 E6240014 */ swc1 $f4, 0x14($s1) -/* 70826C 802385CC E6260054 */ swc1 $f6, 0x54($s1) -/* 708270 802385D0 E628004C */ swc1 $f8, 0x4c($s1) -/* 708274 802385D4 AE400074 */ sw $zero, 0x74($s2) -/* 708278 802385D8 AE400078 */ sw $zero, 0x78($s2) -/* 70827C 802385DC E7AA0010 */ swc1 $f10, 0x10($sp) -/* 708280 802385E0 AFA00014 */ sw $zero, 0x14($sp) -/* 708284 802385E4 8E25000C */ lw $a1, 0xc($s1) -/* 708288 802385E8 8E260010 */ lw $a2, 0x10($s1) -/* 70828C 802385EC 8E270014 */ lw $a3, 0x14($s1) -/* 708290 802385F0 0C01C6C4 */ jal fx_water_fountain -/* 708294 802385F4 24040001 */ addiu $a0, $zero, 1 -/* 708298 802385F8 8C43000C */ lw $v1, 0xc($v0) -/* 70829C 802385FC C6200054 */ lwc1 $f0, 0x54($s1) -/* 7082A0 80238600 E4600038 */ swc1 $f0, 0x38($v1) -/* 7082A4 80238604 8C43000C */ lw $v1, 0xc($v0) -/* 7082A8 80238608 C6200170 */ lwc1 $f0, 0x170($s1) -/* 7082AC 8023860C 3C018024 */ lui $at, %hi(D_8023C070) -/* 7082B0 80238610 AC22C070 */ sw $v0, %lo(D_8023C070)($at) -/* 7082B4 80238614 E460003C */ swc1 $f0, 0x3c($v1) -/* 7082B8 80238618 8C43000C */ lw $v1, 0xc($v0) -/* 7082BC 8023861C C6200170 */ lwc1 $f0, 0x170($s1) -/* 7082C0 80238620 24020001 */ addiu $v0, $zero, 1 -/* 7082C4 80238624 E4600040 */ swc1 $f0, 0x40($v1) -/* 7082C8 80238628 0808E344 */ j .L80238D10 -/* 7082CC 8023862C AE420070 */ sw $v0, 0x70($s2) -.L80238630: -/* 7082D0 80238630 0200202D */ daddu $a0, $s0, $zero -/* 7082D4 80238634 8E26004C */ lw $a2, 0x4c($s1) -/* 7082D8 80238638 8E270054 */ lw $a3, 0x54($s1) -/* 7082DC 8023863C 0C00A7E7 */ jal add_vec2D_polar -/* 7082E0 80238640 26250010 */ addiu $a1, $s1, 0x10 -/* 7082E4 80238644 C622000C */ lwc1 $f2, 0xc($s1) -/* 7082E8 80238648 3C01C320 */ lui $at, 0xc320 -/* 7082EC 8023864C 44810000 */ mtc1 $at, $f0 -/* 7082F0 80238650 00000000 */ nop -/* 7082F4 80238654 4600103C */ c.lt.s $f2, $f0 -/* 7082F8 80238658 00000000 */ nop -/* 7082FC 8023865C 45000042 */ bc1f .L80238768 -/* 708300 80238660 00000000 */ nop -/* 708304 80238664 8E420074 */ lw $v0, 0x74($s2) -/* 708308 80238668 544000EF */ bnel $v0, $zero, .L80238A28 -/* 70830C 8023866C 24020002 */ addiu $v0, $zero, 2 -/* 708310 80238670 C6220054 */ lwc1 $f2, 0x54($s1) -/* 708314 80238674 3C014387 */ lui $at, 0x4387 -/* 708318 80238678 44810000 */ mtc1 $at, $f0 -/* 70831C 8023867C 00000000 */ nop -/* 708320 80238680 4602003E */ c.le.s $f0, $f2 -/* 708324 80238684 00000000 */ nop -/* 708328 80238688 45000019 */ bc1f .L802386F0 -/* 70832C 8023868C 00000000 */ nop -/* 708330 80238690 3C0143B4 */ lui $at, 0x43b4 -/* 708334 80238694 44810000 */ mtc1 $at, $f0 -/* 708338 80238698 00000000 */ nop -/* 70833C 8023869C 4600103C */ c.lt.s $f2, $f0 -/* 708340 802386A0 00000000 */ nop -/* 708344 802386A4 45000012 */ bc1f .L802386F0 -/* 708348 802386A8 00000000 */ nop -/* 70834C 802386AC 3C014334 */ lui $at, 0x4334 -/* 708350 802386B0 44816000 */ mtc1 $at, $f12 -/* 708354 802386B4 0C00A6C9 */ jal clamp_angle -/* 708358 802386B8 460C1300 */ add.s $f12, $f2, $f12 -/* 70835C 802386BC 3C0142B4 */ lui $at, 0x42b4 -/* 708360 802386C0 44811000 */ mtc1 $at, $f2 -/* 708364 802386C4 00000000 */ nop -/* 708368 802386C8 46001001 */ sub.s $f0, $f2, $f0 -/* 70836C 802386CC 46020000 */ add.s $f0, $f0, $f2 -/* 708370 802386D0 24040004 */ addiu $a0, $zero, 4 -/* 708374 802386D4 0C00A67F */ jal rand_int -/* 708378 802386D8 E6200054 */ swc1 $f0, 0x54($s1) -/* 70837C 802386DC 2442FFFE */ addiu $v0, $v0, -2 -/* 708380 802386E0 44820000 */ mtc1 $v0, $f0 -/* 708384 802386E4 00000000 */ nop -/* 708388 802386E8 46800020 */ cvt.s.w $f0, $f0 -/* 70838C 802386EC E620005C */ swc1 $f0, 0x5c($s1) -.L802386F0: -/* 708390 802386F0 C60C0048 */ lwc1 $f12, 0x48($s0) -/* 708394 802386F4 3C014334 */ lui $at, 0x4334 -/* 708398 802386F8 44811000 */ mtc1 $at, $f2 -/* 70839C 802386FC 00000000 */ nop -/* 7083A0 80238700 460C103E */ c.le.s $f2, $f12 -/* 7083A4 80238704 00000000 */ nop -/* 7083A8 80238708 45000017 */ bc1f .L80238768 -/* 7083AC 8023870C 00000000 */ nop -/* 7083B0 80238710 3C014387 */ lui $at, 0x4387 -/* 7083B4 80238714 44810000 */ mtc1 $at, $f0 -/* 7083B8 80238718 00000000 */ nop -/* 7083BC 8023871C 4600603C */ c.lt.s $f12, $f0 -/* 7083C0 80238720 00000000 */ nop -/* 7083C4 80238724 45000010 */ bc1f .L80238768 -/* 7083C8 80238728 00000000 */ nop -/* 7083CC 8023872C 0C00A6C9 */ jal clamp_angle -/* 7083D0 80238730 46026300 */ add.s $f12, $f12, $f2 -/* 7083D4 80238734 3C0142B4 */ lui $at, 0x42b4 -/* 7083D8 80238738 44811000 */ mtc1 $at, $f2 -/* 7083DC 8023873C 00000000 */ nop -/* 7083E0 80238740 46020001 */ sub.s $f0, $f0, $f2 -/* 7083E4 80238744 46001081 */ sub.s $f2, $f2, $f0 -/* 7083E8 80238748 24040004 */ addiu $a0, $zero, 4 -/* 7083EC 8023874C 0C00A67F */ jal rand_int -/* 7083F0 80238750 E6020048 */ swc1 $f2, 0x48($s0) -/* 7083F4 80238754 2442FFFE */ addiu $v0, $v0, -2 -/* 7083F8 80238758 44820000 */ mtc1 $v0, $f0 -/* 7083FC 8023875C 00000000 */ nop -/* 708400 80238760 46800020 */ cvt.s.w $f0, $f0 -/* 708404 80238764 E6000050 */ swc1 $f0, 0x50($s0) -.L80238768: -/* 708408 80238768 C6020000 */ lwc1 $f2, ($s0) -/* 70840C 8023876C 3C014320 */ lui $at, 0x4320 -/* 708410 80238770 44810000 */ mtc1 $at, $f0 -/* 708414 80238774 00000000 */ nop -/* 708418 80238778 4602003C */ c.lt.s $f0, $f2 -/* 70841C 8023877C 00000000 */ nop -/* 708420 80238780 4500004F */ bc1f .L802388C0 -/* 708424 80238784 00000000 */ nop -/* 708428 80238788 8E420074 */ lw $v0, 0x74($s2) -/* 70842C 8023878C 1040000F */ beqz $v0, .L802387CC -/* 708430 80238790 24020002 */ addiu $v0, $zero, 2 -/* 708434 80238794 0808E344 */ j .L80238D10 -/* 708438 80238798 AE420070 */ sw $v0, 0x70($s2) -.L8023879C: -/* 70843C 8023879C 3C014334 */ lui $at, 0x4334 -/* 708440 802387A0 44816000 */ mtc1 $at, $f12 -/* 708444 802387A4 0C00A6C9 */ jal clamp_angle -/* 708448 802387A8 460C1300 */ add.s $f12, $f2, $f12 -/* 70844C 802387AC 3C014387 */ lui $at, 0x4387 -/* 708450 802387B0 44811000 */ mtc1 $at, $f2 -/* 708454 802387B4 00000000 */ nop -/* 708458 802387B8 46001001 */ sub.s $f0, $f2, $f0 -/* 70845C 802387BC 46020000 */ add.s $f0, $f0, $f2 -/* 708460 802387C0 24040004 */ addiu $a0, $zero, 4 -/* 708464 802387C4 0808E218 */ j .L80238860 -/* 708468 802387C8 E6000048 */ swc1 $f0, 0x48($s0) -.L802387CC: -/* 70846C 802387CC C6020048 */ lwc1 $f2, 0x48($s0) -/* 708470 802387D0 44800000 */ mtc1 $zero, $f0 -/* 708474 802387D4 00000000 */ nop -/* 708478 802387D8 4602003E */ c.le.s $f0, $f2 -/* 70847C 802387DC 00000000 */ nop -/* 708480 802387E0 45000008 */ bc1f .L80238804 -/* 708484 802387E4 00000000 */ nop -/* 708488 802387E8 3C0142B4 */ lui $at, 0x42b4 -/* 70848C 802387EC 44810000 */ mtc1 $at, $f0 -/* 708490 802387F0 00000000 */ nop -/* 708494 802387F4 4600103C */ c.lt.s $f2, $f0 -/* 708498 802387F8 00000000 */ nop -/* 70849C 802387FC 4501FFE7 */ bc1t .L8023879C -/* 7084A0 80238800 00000000 */ nop -.L80238804: -/* 7084A4 80238804 3C0142B4 */ lui $at, 0x42b4 -/* 7084A8 80238808 44810000 */ mtc1 $at, $f0 -/* 7084AC 8023880C 00000000 */ nop -/* 7084B0 80238810 4602003E */ c.le.s $f0, $f2 -/* 7084B4 80238814 00000000 */ nop -/* 7084B8 80238818 45000018 */ bc1f .L8023887C -/* 7084BC 8023881C 00000000 */ nop -/* 7084C0 80238820 3C014334 */ lui $at, 0x4334 -/* 7084C4 80238824 44810000 */ mtc1 $at, $f0 -/* 7084C8 80238828 00000000 */ nop -/* 7084CC 8023882C 4600103C */ c.lt.s $f2, $f0 -/* 7084D0 80238830 00000000 */ nop -/* 7084D4 80238834 45000011 */ bc1f .L8023887C -/* 7084D8 80238838 00000000 */ nop -/* 7084DC 8023883C 0C00A6C9 */ jal clamp_angle -/* 7084E0 80238840 46001300 */ add.s $f12, $f2, $f0 -/* 7084E4 80238844 3C014387 */ lui $at, 0x4387 -/* 7084E8 80238848 44811000 */ mtc1 $at, $f2 -/* 7084EC 8023884C 00000000 */ nop -/* 7084F0 80238850 46020001 */ sub.s $f0, $f0, $f2 -/* 7084F4 80238854 46001081 */ sub.s $f2, $f2, $f0 -/* 7084F8 80238858 24040004 */ addiu $a0, $zero, 4 -/* 7084FC 8023885C E6020048 */ swc1 $f2, 0x48($s0) -.L80238860: -/* 708500 80238860 0C00A67F */ jal rand_int -/* 708504 80238864 00000000 */ nop -/* 708508 80238868 2442FFFE */ addiu $v0, $v0, -2 -/* 70850C 8023886C 44820000 */ mtc1 $v0, $f0 -/* 708510 80238870 00000000 */ nop -/* 708514 80238874 46800020 */ cvt.s.w $f0, $f0 -/* 708518 80238878 E6000050 */ swc1 $f0, 0x50($s0) -.L8023887C: -/* 70851C 8023887C 8E420078 */ lw $v0, 0x78($s2) -/* 708520 80238880 10400004 */ beqz $v0, .L80238894 -/* 708524 80238884 2404029B */ addiu $a0, $zero, 0x29b -/* 708528 80238888 C6000008 */ lwc1 $f0, 8($s0) -/* 70852C 8023888C 0808E228 */ j .L802388A0 -/* 708530 80238890 E7A00010 */ swc1 $f0, 0x10($sp) -.L80238894: -/* 708534 80238894 C6000008 */ lwc1 $f0, 8($s0) -/* 708538 80238898 2404029C */ addiu $a0, $zero, 0x29c -/* 70853C 8023889C E7A00010 */ swc1 $f0, 0x10($sp) -.L802388A0: -/* 708540 802388A0 8E060000 */ lw $a2, ($s0) -/* 708544 802388A4 8E070004 */ lw $a3, 4($s0) -/* 708548 802388A8 0C052757 */ jal sfx_play_sound_at_position -/* 70854C 802388AC 0000282D */ daddu $a1, $zero, $zero -/* 708550 802388B0 8E430078 */ lw $v1, 0x78($s2) -/* 708554 802388B4 24020001 */ addiu $v0, $zero, 1 -/* 708558 802388B8 00431023 */ subu $v0, $v0, $v1 -/* 70855C 802388BC AE420078 */ sw $v0, 0x78($s2) -.L802388C0: -/* 708560 802388C0 C6000004 */ lwc1 $f0, 4($s0) -/* 708564 802388C4 44801000 */ mtc1 $zero, $f2 -/* 708568 802388C8 00000000 */ nop -/* 70856C 802388CC 4602003C */ c.lt.s $f0, $f2 -/* 708570 802388D0 00000000 */ nop -/* 708574 802388D4 45000049 */ bc1f .L802389FC -/* 708578 802388D8 00000000 */ nop -/* 70857C 802388DC 8E420074 */ lw $v0, 0x74($s2) -/* 708580 802388E0 1040000C */ beqz $v0, .L80238914 -/* 708584 802388E4 24020002 */ addiu $v0, $zero, 2 -/* 708588 802388E8 0808E344 */ j .L80238D10 -/* 70858C 802388EC AE420070 */ sw $v0, 0x70($s2) -.L802388F0: -/* 708590 802388F0 3C014334 */ lui $at, 0x4334 -/* 708594 802388F4 4481A000 */ mtc1 $at, $f20 -/* 708598 802388F8 0C00A6C9 */ jal clamp_angle -/* 70859C 802388FC 46146300 */ add.s $f12, $f12, $f20 -/* 7085A0 80238900 4600A001 */ sub.s $f0, $f20, $f0 -/* 7085A4 80238904 46140000 */ add.s $f0, $f0, $f20 -/* 7085A8 80238908 24040004 */ addiu $a0, $zero, 4 -/* 7085AC 8023890C 0808E267 */ j .L8023899C -/* 7085B0 80238910 E6000048 */ swc1 $f0, 0x48($s0) -.L80238914: -/* 7085B4 80238914 C60C0048 */ lwc1 $f12, 0x48($s0) -/* 7085B8 80238918 3C014387 */ lui $at, 0x4387 -/* 7085BC 8023891C 44810000 */ mtc1 $at, $f0 -/* 7085C0 80238920 00000000 */ nop -/* 7085C4 80238924 460C003E */ c.le.s $f0, $f12 -/* 7085C8 80238928 00000000 */ nop -/* 7085CC 8023892C 45000008 */ bc1f .L80238950 -/* 7085D0 80238930 00000000 */ nop -/* 7085D4 80238934 3C0143B4 */ lui $at, 0x43b4 -/* 7085D8 80238938 44810000 */ mtc1 $at, $f0 -/* 7085DC 8023893C 00000000 */ nop -/* 7085E0 80238940 4600603C */ c.lt.s $f12, $f0 -/* 7085E4 80238944 00000000 */ nop -/* 7085E8 80238948 4501FFE9 */ bc1t .L802388F0 -/* 7085EC 8023894C 00000000 */ nop -.L80238950: -/* 7085F0 80238950 460C103E */ c.le.s $f2, $f12 -/* 7085F4 80238954 00000000 */ nop -/* 7085F8 80238958 45000017 */ bc1f .L802389B8 -/* 7085FC 8023895C 00000000 */ nop -/* 708600 80238960 3C0142B4 */ lui $at, 0x42b4 -/* 708604 80238964 44810000 */ mtc1 $at, $f0 -/* 708608 80238968 00000000 */ nop -/* 70860C 8023896C 4600603C */ c.lt.s $f12, $f0 -/* 708610 80238970 00000000 */ nop -/* 708614 80238974 45000010 */ bc1f .L802389B8 -/* 708618 80238978 00000000 */ nop -/* 70861C 8023897C 3C014334 */ lui $at, 0x4334 -/* 708620 80238980 4481A000 */ mtc1 $at, $f20 -/* 708624 80238984 0C00A6C9 */ jal clamp_angle -/* 708628 80238988 46146300 */ add.s $f12, $f12, $f20 -/* 70862C 8023898C 46140001 */ sub.s $f0, $f0, $f20 -/* 708630 80238990 4600A501 */ sub.s $f20, $f20, $f0 -/* 708634 80238994 24040004 */ addiu $a0, $zero, 4 -/* 708638 80238998 E6140048 */ swc1 $f20, 0x48($s0) -.L8023899C: -/* 70863C 8023899C 0C00A67F */ jal rand_int -/* 708640 802389A0 00000000 */ nop -/* 708644 802389A4 2442FFFE */ addiu $v0, $v0, -2 -/* 708648 802389A8 44820000 */ mtc1 $v0, $f0 -/* 70864C 802389AC 00000000 */ nop -/* 708650 802389B0 46800020 */ cvt.s.w $f0, $f0 -/* 708654 802389B4 E6000050 */ swc1 $f0, 0x50($s0) -.L802389B8: -/* 708658 802389B8 8E420078 */ lw $v0, 0x78($s2) -/* 70865C 802389BC 10400004 */ beqz $v0, .L802389D0 -/* 708660 802389C0 2404029B */ addiu $a0, $zero, 0x29b -/* 708664 802389C4 C6000008 */ lwc1 $f0, 8($s0) -/* 708668 802389C8 0808E277 */ j .L802389DC -/* 70866C 802389CC E7A00010 */ swc1 $f0, 0x10($sp) -.L802389D0: -/* 708670 802389D0 C6000008 */ lwc1 $f0, 8($s0) -/* 708674 802389D4 2404029C */ addiu $a0, $zero, 0x29c -/* 708678 802389D8 E7A00010 */ swc1 $f0, 0x10($sp) -.L802389DC: -/* 70867C 802389DC 8E060000 */ lw $a2, ($s0) -/* 708680 802389E0 8E070004 */ lw $a3, 4($s0) -/* 708684 802389E4 0C052757 */ jal sfx_play_sound_at_position -/* 708688 802389E8 0000282D */ daddu $a1, $zero, $zero -/* 70868C 802389EC 8E430078 */ lw $v1, 0x78($s2) -/* 708690 802389F0 24020001 */ addiu $v0, $zero, 1 -/* 708694 802389F4 00431023 */ subu $v0, $v0, $v1 -/* 708698 802389F8 AE420078 */ sw $v0, 0x78($s2) -.L802389FC: -/* 70869C 802389FC C6020004 */ lwc1 $f2, 4($s0) -/* 7086A0 80238A00 3C014302 */ lui $at, 0x4302 -/* 7086A4 80238A04 44810000 */ mtc1 $at, $f0 -/* 7086A8 80238A08 00000000 */ nop -/* 7086AC 80238A0C 4602003C */ c.lt.s $f0, $f2 -/* 7086B0 80238A10 00000000 */ nop -/* 7086B4 80238A14 4500004E */ bc1f .L80238B50 -/* 7086B8 80238A18 00000000 */ nop -/* 7086BC 80238A1C 8E420074 */ lw $v0, 0x74($s2) -/* 7086C0 80238A20 1040000D */ beqz $v0, .L80238A58 -/* 7086C4 80238A24 24020002 */ addiu $v0, $zero, 2 -.L80238A28: -/* 7086C8 80238A28 0808E344 */ j .L80238D10 -/* 7086CC 80238A2C AE420070 */ sw $v0, 0x70($s2) -.L80238A30: -/* 7086D0 80238A30 0C00A6C9 */ jal clamp_angle -/* 7086D4 80238A34 46006300 */ add.s $f12, $f12, $f0 -/* 7086D8 80238A38 3C0143B4 */ lui $at, 0x43b4 -/* 7086DC 80238A3C 44811000 */ mtc1 $at, $f2 -/* 7086E0 80238A40 00000000 */ nop -/* 7086E4 80238A44 46001001 */ sub.s $f0, $f2, $f0 -/* 7086E8 80238A48 46020000 */ add.s $f0, $f0, $f2 -/* 7086EC 80238A4C 24040004 */ addiu $a0, $zero, 4 -/* 7086F0 80238A50 0808E2BC */ j .L80238AF0 -/* 7086F4 80238A54 E6000048 */ swc1 $f0, 0x48($s0) -.L80238A58: -/* 7086F8 80238A58 C60C0048 */ lwc1 $f12, 0x48($s0) -/* 7086FC 80238A5C 3C0142B4 */ lui $at, 0x42b4 -/* 708700 80238A60 44810000 */ mtc1 $at, $f0 -/* 708704 80238A64 00000000 */ nop -/* 708708 80238A68 460C003E */ c.le.s $f0, $f12 -/* 70870C 80238A6C 00000000 */ nop -/* 708710 80238A70 45000008 */ bc1f .L80238A94 -/* 708714 80238A74 00000000 */ nop -/* 708718 80238A78 3C014334 */ lui $at, 0x4334 -/* 70871C 80238A7C 44810000 */ mtc1 $at, $f0 -/* 708720 80238A80 00000000 */ nop -/* 708724 80238A84 4600603C */ c.lt.s $f12, $f0 -/* 708728 80238A88 00000000 */ nop -/* 70872C 80238A8C 4501FFE8 */ bc1t .L80238A30 -/* 708730 80238A90 00000000 */ nop -.L80238A94: -/* 708734 80238A94 3C014334 */ lui $at, 0x4334 -/* 708738 80238A98 44811000 */ mtc1 $at, $f2 -/* 70873C 80238A9C 00000000 */ nop -/* 708740 80238AA0 460C103E */ c.le.s $f2, $f12 -/* 708744 80238AA4 00000000 */ nop -/* 708748 80238AA8 45000018 */ bc1f .L80238B0C -/* 70874C 80238AAC 00000000 */ nop -/* 708750 80238AB0 3C014387 */ lui $at, 0x4387 -/* 708754 80238AB4 44810000 */ mtc1 $at, $f0 -/* 708758 80238AB8 00000000 */ nop -/* 70875C 80238ABC 4600603C */ c.lt.s $f12, $f0 -/* 708760 80238AC0 00000000 */ nop -/* 708764 80238AC4 45000011 */ bc1f .L80238B0C -/* 708768 80238AC8 00000000 */ nop -/* 70876C 80238ACC 0C00A6C9 */ jal clamp_angle -/* 708770 80238AD0 46026300 */ add.s $f12, $f12, $f2 -/* 708774 80238AD4 3C0143B4 */ lui $at, 0x43b4 -/* 708778 80238AD8 44811000 */ mtc1 $at, $f2 -/* 70877C 80238ADC 00000000 */ nop -/* 708780 80238AE0 46020001 */ sub.s $f0, $f0, $f2 -/* 708784 80238AE4 46001081 */ sub.s $f2, $f2, $f0 -/* 708788 80238AE8 24040004 */ addiu $a0, $zero, 4 -/* 70878C 80238AEC E6020048 */ swc1 $f2, 0x48($s0) -.L80238AF0: -/* 708790 80238AF0 0C00A67F */ jal rand_int -/* 708794 80238AF4 00000000 */ nop -/* 708798 80238AF8 2442FFFE */ addiu $v0, $v0, -2 -/* 70879C 80238AFC 44820000 */ mtc1 $v0, $f0 -/* 7087A0 80238B00 00000000 */ nop -/* 7087A4 80238B04 46800020 */ cvt.s.w $f0, $f0 -/* 7087A8 80238B08 E6000050 */ swc1 $f0, 0x50($s0) -.L80238B0C: -/* 7087AC 80238B0C 8E420078 */ lw $v0, 0x78($s2) -/* 7087B0 80238B10 10400004 */ beqz $v0, .L80238B24 -/* 7087B4 80238B14 2404029B */ addiu $a0, $zero, 0x29b -/* 7087B8 80238B18 C6000008 */ lwc1 $f0, 8($s0) -/* 7087BC 80238B1C 0808E2CC */ j .L80238B30 -/* 7087C0 80238B20 E7A00010 */ swc1 $f0, 0x10($sp) -.L80238B24: -/* 7087C4 80238B24 C6000008 */ lwc1 $f0, 8($s0) -/* 7087C8 80238B28 2404029C */ addiu $a0, $zero, 0x29c -/* 7087CC 80238B2C E7A00010 */ swc1 $f0, 0x10($sp) -.L80238B30: -/* 7087D0 80238B30 8E060000 */ lw $a2, ($s0) -/* 7087D4 80238B34 8E070004 */ lw $a3, 4($s0) -/* 7087D8 80238B38 0C052757 */ jal sfx_play_sound_at_position -/* 7087DC 80238B3C 0000282D */ daddu $a1, $zero, $zero -/* 7087E0 80238B40 8E430078 */ lw $v1, 0x78($s2) -/* 7087E4 80238B44 24020001 */ addiu $v0, $zero, 1 -/* 7087E8 80238B48 00431023 */ subu $v0, $v0, $v1 -/* 7087EC 80238B4C AE420078 */ sw $v0, 0x78($s2) -.L80238B50: -/* 7087F0 80238B50 C6000050 */ lwc1 $f0, 0x50($s0) -/* 7087F4 80238B54 3C013FE0 */ lui $at, 0x3fe0 -/* 7087F8 80238B58 44811800 */ mtc1 $at, $f3 -/* 7087FC 80238B5C 44801000 */ mtc1 $zero, $f2 -/* 708800 80238B60 46000021 */ cvt.d.s $f0, $f0 -/* 708804 80238B64 46220002 */ mul.d $f0, $f0, $f2 -/* 708808 80238B68 00000000 */ nop -/* 70880C 80238B6C C60C0048 */ lwc1 $f12, 0x48($s0) -/* 708810 80238B70 46006321 */ cvt.d.s $f12, $f12 -/* 708814 80238B74 46206300 */ add.d $f12, $f12, $f0 -/* 708818 80238B78 0C00A6C9 */ jal clamp_angle -/* 70881C 80238B7C 46206320 */ cvt.s.d $f12, $f12 -/* 708820 80238B80 3C01439D */ lui $at, 0x439d -/* 708824 80238B84 34218000 */ ori $at, $at, 0x8000 -/* 708828 80238B88 44816000 */ mtc1 $at, $f12 -/* 70882C 80238B8C 00000000 */ nop -/* 708830 80238B90 460C0301 */ sub.s $f12, $f0, $f12 -/* 708834 80238B94 0C00A6C9 */ jal clamp_angle -/* 708838 80238B98 E6000048 */ swc1 $f0, 0x48($s0) -/* 70883C 80238B9C C6220170 */ lwc1 $f2, 0x170($s1) -/* 708840 80238BA0 3C018024 */ lui $at, %hi(D_8023C068_70BD08) -/* 708844 80238BA4 D424C068 */ ldc1 $f4, %lo(D_8023C068_70BD08)($at) -/* 708848 80238BA8 460010A1 */ cvt.d.s $f2, $f2 -/* 70884C 80238BAC 46241081 */ sub.d $f2, $f2, $f4 -/* 708850 80238BB0 E6200164 */ swc1 $f0, 0x164($s1) -/* 708854 80238BB4 462010A0 */ cvt.s.d $f2, $f2 -/* 708858 80238BB8 E6220170 */ swc1 $f2, 0x170($s1) -/* 70885C 80238BBC 46001006 */ mov.s $f0, $f2 -/* 708860 80238BC0 E6220174 */ swc1 $f2, 0x174($s1) -/* 708864 80238BC4 E6220178 */ swc1 $f2, 0x178($s1) -/* 708868 80238BC8 3C013FF0 */ lui $at, 0x3ff0 -/* 70886C 80238BCC 44811800 */ mtc1 $at, $f3 -/* 708870 80238BD0 44801000 */ mtc1 $zero, $f2 -/* 708874 80238BD4 46000021 */ cvt.d.s $f0, $f0 -/* 708878 80238BD8 4622003C */ c.lt.d $f0, $f2 -/* 70887C 80238BDC 00000000 */ nop -/* 708880 80238BE0 45000007 */ bc1f .L80238C00 -/* 708884 80238BE4 00000000 */ nop -/* 708888 80238BE8 3C013F80 */ lui $at, 0x3f80 -/* 70888C 80238BEC 44810000 */ mtc1 $at, $f0 -/* 708890 80238BF0 00000000 */ nop -/* 708894 80238BF4 E6200170 */ swc1 $f0, 0x170($s1) -/* 708898 80238BF8 E6200174 */ swc1 $f0, 0x174($s1) -/* 70889C 80238BFC E6200178 */ swc1 $f0, 0x178($s1) -.L80238C00: -/* 7088A0 80238C00 C6220170 */ lwc1 $f2, 0x170($s1) -/* 7088A4 80238C04 3C01C170 */ lui $at, 0xc170 -/* 7088A8 80238C08 44810000 */ mtc1 $at, $f0 -/* 7088AC 80238C0C 00000000 */ nop -/* 7088B0 80238C10 46001082 */ mul.s $f2, $f2, $f0 -/* 7088B4 80238C14 00000000 */ nop -/* 7088B8 80238C18 27A40018 */ addiu $a0, $sp, 0x18 -/* 7088BC 80238C1C 8E070048 */ lw $a3, 0x48($s0) -/* 7088C0 80238C20 4480A000 */ mtc1 $zero, $f20 -/* 7088C4 80238C24 44061000 */ mfc1 $a2, $f2 -/* 7088C8 80238C28 27A5001C */ addiu $a1, $sp, 0x1c -/* 7088CC 80238C2C E7B40018 */ swc1 $f20, 0x18($sp) -/* 7088D0 80238C30 0C00A7E7 */ jal add_vec2D_polar -/* 7088D4 80238C34 E7B4001C */ swc1 $f20, 0x1c($sp) -/* 7088D8 80238C38 C6000000 */ lwc1 $f0, ($s0) -/* 7088DC 80238C3C C7A20018 */ lwc1 $f2, 0x18($sp) -/* 7088E0 80238C40 3C038024 */ lui $v1, %hi(D_8023C070) -/* 7088E4 80238C44 8C63C070 */ lw $v1, %lo(D_8023C070)($v1) -/* 7088E8 80238C48 46020000 */ add.s $f0, $f0, $f2 -/* 7088EC 80238C4C 8C62000C */ lw $v0, 0xc($v1) -/* 7088F0 80238C50 E4400004 */ swc1 $f0, 4($v0) -/* 7088F4 80238C54 C6000004 */ lwc1 $f0, 4($s0) -/* 7088F8 80238C58 C7A2001C */ lwc1 $f2, 0x1c($sp) -/* 7088FC 80238C5C 8C62000C */ lw $v0, 0xc($v1) -/* 708900 80238C60 46020000 */ add.s $f0, $f0, $f2 -/* 708904 80238C64 3C0140A0 */ lui $at, 0x40a0 -/* 708908 80238C68 44811000 */ mtc1 $at, $f2 -/* 70890C 80238C6C E4400008 */ swc1 $f0, 8($v0) -/* 708910 80238C70 C6000008 */ lwc1 $f0, 8($s0) -/* 708914 80238C74 46020000 */ add.s $f0, $f0, $f2 -/* 708918 80238C78 8C62000C */ lw $v0, 0xc($v1) -/* 70891C 80238C7C E440000C */ swc1 $f0, 0xc($v0) -/* 708920 80238C80 8C62000C */ lw $v0, 0xc($v1) -/* 708924 80238C84 C6000048 */ lwc1 $f0, 0x48($s0) -/* 708928 80238C88 E4400038 */ swc1 $f0, 0x38($v0) -/* 70892C 80238C8C 8C62000C */ lw $v0, 0xc($v1) -/* 708930 80238C90 C6200170 */ lwc1 $f0, 0x170($s1) -/* 708934 80238C94 E440003C */ swc1 $f0, 0x3c($v0) -/* 708938 80238C98 8C62000C */ lw $v0, 0xc($v1) -/* 70893C 80238C9C C6200170 */ lwc1 $f0, 0x170($s1) -/* 708940 80238CA0 E4400040 */ swc1 $f0, 0x40($v0) -/* 708944 80238CA4 86030064 */ lh $v1, 0x64($s0) -/* 708948 80238CA8 24020046 */ addiu $v0, $zero, 0x46 -/* 70894C 80238CAC 14620010 */ bne $v1, $v0, .L80238CF0 -/* 708950 80238CB0 2404029D */ addiu $a0, $zero, 0x29d -/* 708954 80238CB4 4406A000 */ mfc1 $a2, $f20 -/* 708958 80238CB8 4407A000 */ mfc1 $a3, $f20 -/* 70895C 80238CBC 0000282D */ daddu $a1, $zero, $zero -/* 708960 80238CC0 0C052757 */ jal sfx_play_sound_at_position -/* 708964 80238CC4 E7B40010 */ swc1 $f20, 0x10($sp) -/* 708968 80238CC8 0000202D */ daddu $a0, $zero, $zero -/* 70896C 80238CCC 3C05C248 */ lui $a1, 0xc248 -/* 708970 80238CD0 3C0641A0 */ lui $a2, 0x41a0 -/* 708974 80238CD4 4407A000 */ mfc1 $a3, $f20 -/* 708978 80238CD8 3C013F80 */ lui $at, 0x3f80 -/* 70897C 80238CDC 44810000 */ mtc1 $at, $f0 -/* 708980 80238CE0 24020078 */ addiu $v0, $zero, 0x78 -/* 708984 80238CE4 AFA20014 */ sw $v0, 0x14($sp) -/* 708988 80238CE8 0C01C6DC */ jal fx_underwater -/* 70898C 80238CEC E7A00010 */ swc1 $f0, 0x10($sp) -.L80238CF0: -/* 708990 80238CF0 86020064 */ lh $v0, 0x64($s0) -/* 708994 80238CF4 96030064 */ lhu $v1, 0x64($s0) -/* 708998 80238CF8 10400003 */ beqz $v0, .L80238D08 -/* 70899C 80238CFC 2462FFFF */ addiu $v0, $v1, -1 -/* 7089A0 80238D00 0808E344 */ j .L80238D10 -/* 7089A4 80238D04 A6020064 */ sh $v0, 0x64($s0) -.L80238D08: -/* 7089A8 80238D08 24020001 */ addiu $v0, $zero, 1 -/* 7089AC 80238D0C AE420074 */ sw $v0, 0x74($s2) -.L80238D10: -/* 7089B0 80238D10 8E430070 */ lw $v1, 0x70($s2) -/* 7089B4 80238D14 24020002 */ addiu $v0, $zero, 2 -.L80238D18: -/* 7089B8 80238D18 10620005 */ beq $v1, $v0, .L80238D30 -/* 7089BC 80238D1C 24020003 */ addiu $v0, $zero, 3 -/* 7089C0 80238D20 10620008 */ beq $v1, $v0, .L80238D44 -/* 7089C4 80238D24 0200202D */ daddu $a0, $s0, $zero -/* 7089C8 80238D28 0808E374 */ j .L80238DD0 -/* 7089CC 80238D2C 00000000 */ nop -.L80238D30: -/* 7089D0 80238D30 24020005 */ addiu $v0, $zero, 5 -/* 7089D4 80238D34 A6020064 */ sh $v0, 0x64($s0) -/* 7089D8 80238D38 24020003 */ addiu $v0, $zero, 3 -/* 7089DC 80238D3C AE420070 */ sw $v0, 0x70($s2) -/* 7089E0 80238D40 0200202D */ daddu $a0, $s0, $zero -.L80238D44: -/* 7089E4 80238D44 8E060040 */ lw $a2, 0x40($s0) -/* 7089E8 80238D48 8E070048 */ lw $a3, 0x48($s0) -/* 7089EC 80238D4C 0C00A7E7 */ jal add_vec2D_polar -/* 7089F0 80238D50 26050004 */ addiu $a1, $s0, 4 -/* 7089F4 80238D54 3C048024 */ lui $a0, %hi(D_8023C070) -/* 7089F8 80238D58 8C84C070 */ lw $a0, %lo(D_8023C070)($a0) -/* 7089FC 80238D5C C6000000 */ lwc1 $f0, ($s0) -/* 708A00 80238D60 8C82000C */ lw $v0, 0xc($a0) -/* 708A04 80238D64 E4400004 */ swc1 $f0, 4($v0) -/* 708A08 80238D68 8C82000C */ lw $v0, 0xc($a0) -/* 708A0C 80238D6C C6000004 */ lwc1 $f0, 4($s0) -/* 708A10 80238D70 E4400008 */ swc1 $f0, 8($v0) -/* 708A14 80238D74 8C82000C */ lw $v0, 0xc($a0) -/* 708A18 80238D78 C6000008 */ lwc1 $f0, 8($s0) -/* 708A1C 80238D7C E440000C */ swc1 $f0, 0xc($v0) -/* 708A20 80238D80 8C82000C */ lw $v0, 0xc($a0) -/* 708A24 80238D84 C6000048 */ lwc1 $f0, 0x48($s0) -/* 708A28 80238D88 E4400038 */ swc1 $f0, 0x38($v0) -/* 708A2C 80238D8C 8C82000C */ lw $v0, 0xc($a0) -/* 708A30 80238D90 C6200170 */ lwc1 $f0, 0x170($s1) -/* 708A34 80238D94 E440003C */ swc1 $f0, 0x3c($v0) -/* 708A38 80238D98 8C82000C */ lw $v0, 0xc($a0) -/* 708A3C 80238D9C C6200170 */ lwc1 $f0, 0x170($s1) -/* 708A40 80238DA0 E4400040 */ swc1 $f0, 0x40($v0) -/* 708A44 80238DA4 86020064 */ lh $v0, 0x64($s0) -/* 708A48 80238DA8 96030064 */ lhu $v1, 0x64($s0) -/* 708A4C 80238DAC 14400007 */ bnez $v0, .L80238DCC -/* 708A50 80238DB0 2462FFFF */ addiu $v0, $v1, -1 -/* 708A54 80238DB4 AE200164 */ sw $zero, 0x164($s1) -/* 708A58 80238DB8 8C830000 */ lw $v1, ($a0) -/* 708A5C 80238DBC 24020002 */ addiu $v0, $zero, 2 -/* 708A60 80238DC0 34630010 */ ori $v1, $v1, 0x10 -/* 708A64 80238DC4 0808E385 */ j .L80238E14 -/* 708A68 80238DC8 AC830000 */ sw $v1, ($a0) -.L80238DCC: -/* 708A6C 80238DCC A6020064 */ sh $v0, 0x64($s0) -.L80238DD0: -/* 708A70 80238DD0 C6000000 */ lwc1 $f0, ($s0) -/* 708A74 80238DD4 3C013F80 */ lui $at, 0x3f80 -/* 708A78 80238DD8 44811000 */ mtc1 $at, $f2 -/* 708A7C 80238DDC E6200144 */ swc1 $f0, 0x144($s1) -/* 708A80 80238DE0 C6000004 */ lwc1 $f0, 4($s0) -/* 708A84 80238DE4 E6200148 */ swc1 $f0, 0x148($s1) -/* 708A88 80238DE8 C6000008 */ lwc1 $f0, 8($s0) -/* 708A8C 80238DEC 2402000A */ addiu $v0, $zero, 0xa -/* 708A90 80238DF0 E620014C */ swc1 $f0, 0x14c($s1) -/* 708A94 80238DF4 E7A20010 */ swc1 $f2, 0x10($sp) -/* 708A98 80238DF8 AFA20014 */ sw $v0, 0x14($sp) -/* 708A9C 80238DFC 8E250144 */ lw $a1, 0x144($s1) -/* 708AA0 80238E00 8E260148 */ lw $a2, 0x148($s1) -/* 708AA4 80238E04 8E27014C */ lw $a3, 0x14c($s1) -/* 708AA8 80238E08 0C01C70C */ jal fx_water_splash -/* 708AAC 80238E0C 24040003 */ addiu $a0, $zero, 3 -/* 708AB0 80238E10 0000102D */ daddu $v0, $zero, $zero -.L80238E14: -/* 708AB4 80238E14 8FBF002C */ lw $ra, 0x2c($sp) -/* 708AB8 80238E18 8FB20028 */ lw $s2, 0x28($sp) -/* 708ABC 80238E1C 8FB10024 */ lw $s1, 0x24($sp) -/* 708AC0 80238E20 8FB00020 */ lw $s0, 0x20($sp) -/* 708AC4 80238E24 D7B40030 */ ldc1 $f20, 0x30($sp) -/* 708AC8 80238E28 03E00008 */ jr $ra -/* 708ACC 80238E2C 27BD0038 */ addiu $sp, $sp, 0x38 diff --git a/ver/us/asm/nonmatchings/battle/partner/watt/func_80238000_703AF0.s b/ver/us/asm/nonmatchings/battle/partner/watt/func_80238000_703AF0.s deleted file mode 100644 index b0eaa80084..0000000000 --- a/ver/us/asm/nonmatchings/battle/partner/watt/func_80238000_703AF0.s +++ /dev/null @@ -1,236 +0,0 @@ -.set noat # allow manual use of $at -.set noreorder # don't insert nops after branches - -glabel func_80238000_703AF0 -/* 703AF0 80238000 27BDFFB0 */ addiu $sp, $sp, -0x50 -/* 703AF4 80238004 AFB3002C */ sw $s3, 0x2c($sp) -/* 703AF8 80238008 3C13800E */ lui $s3, %hi(gBattleStatus) -/* 703AFC 8023800C 2673C070 */ addiu $s3, $s3, %lo(gBattleStatus) -/* 703B00 80238010 AFBF0030 */ sw $ra, 0x30($sp) -/* 703B04 80238014 AFB20028 */ sw $s2, 0x28($sp) -/* 703B08 80238018 AFB10024 */ sw $s1, 0x24($sp) -/* 703B0C 8023801C AFB00020 */ sw $s0, 0x20($sp) -/* 703B10 80238020 F7B80048 */ sdc1 $f24, 0x48($sp) -/* 703B14 80238024 F7B60040 */ sdc1 $f22, 0x40($sp) -/* 703B18 80238028 F7B40038 */ sdc1 $f20, 0x38($sp) -/* 703B1C 8023802C 8E7200DC */ lw $s2, 0xdc($s3) -/* 703B20 80238030 10A00022 */ beqz $a1, .L802380BC -/* 703B24 80238034 24110005 */ addiu $s1, $zero, 5 -/* 703B28 80238038 3C013F80 */ lui $at, 0x3f80 -/* 703B2C 8023803C 4481A000 */ mtc1 $at, $f20 -/* 703B30 80238040 AFB10014 */ sw $s1, 0x14($sp) -/* 703B34 80238044 AFA00018 */ sw $zero, 0x18($sp) -/* 703B38 80238048 E7B40010 */ swc1 $f20, 0x10($sp) -/* 703B3C 8023804C 8E450144 */ lw $a1, 0x144($s2) -/* 703B40 80238050 8E460148 */ lw $a2, 0x148($s2) -/* 703B44 80238054 8E47014C */ lw $a3, 0x14c($s2) -/* 703B48 80238058 24100001 */ addiu $s0, $zero, 1 -/* 703B4C 8023805C 3C018024 */ lui $at, %hi(D_8023C1BC) -/* 703B50 80238060 AC30C1BC */ sw $s0, %lo(D_8023C1BC)($at) -/* 703B54 80238064 3C018024 */ lui $at, %hi(D_8023C1C0) -/* 703B58 80238068 AC20C1C0 */ sw $zero, %lo(D_8023C1C0)($at) -/* 703B5C 8023806C 3C018024 */ lui $at, %hi(D_8023C1C4) -/* 703B60 80238070 AC30C1C4 */ sw $s0, %lo(D_8023C1C4)($at) -/* 703B64 80238074 3C018024 */ lui $at, %hi(D_8023C1C8) -/* 703B68 80238078 AC20C1C8 */ sw $zero, %lo(D_8023C1C8)($at) -/* 703B6C 8023807C 0C01C8EC */ jal fx_static_status -/* 703B70 80238080 0000202D */ daddu $a0, $zero, $zero -/* 703B74 80238084 E7B40010 */ swc1 $f20, 0x10($sp) -/* 703B78 80238088 AFB10014 */ sw $s1, 0x14($sp) -/* 703B7C 8023808C AFA00018 */ sw $zero, 0x18($sp) -/* 703B80 80238090 8E450144 */ lw $a1, 0x144($s2) -/* 703B84 80238094 3C06C47A */ lui $a2, 0xc47a -/* 703B88 80238098 8E47014C */ lw $a3, 0x14c($s2) -/* 703B8C 8023809C 3C018024 */ lui $at, %hi(D_8023C1CC) -/* 703B90 802380A0 AC22C1CC */ sw $v0, %lo(D_8023C1CC)($at) -/* 703B94 802380A4 0C01C8EC */ jal fx_static_status -/* 703B98 802380A8 0200202D */ daddu $a0, $s0, $zero -/* 703B9C 802380AC 3C018024 */ lui $at, %hi(D_8023C1D0) -/* 703BA0 802380B0 AC22C1D0 */ sw $v0, %lo(D_8023C1D0)($at) -/* 703BA4 802380B4 3C018024 */ lui $at, %hi(D_8023C1B8) -/* 703BA8 802380B8 AC30C1B8 */ sw $s0, %lo(D_8023C1B8)($at) -.L802380BC: -/* 703BAC 802380BC 3C028024 */ lui $v0, %hi(D_8023C1B8) -/* 703BB0 802380C0 8C42C1B8 */ lw $v0, %lo(D_8023C1B8)($v0) -/* 703BB4 802380C4 104000A0 */ beqz $v0, .L80238348 -/* 703BB8 802380C8 24020002 */ addiu $v0, $zero, 2 -/* 703BBC 802380CC 3C028024 */ lui $v0, %hi(D_8023C1BC) -/* 703BC0 802380D0 8C42C1BC */ lw $v0, %lo(D_8023C1BC)($v0) -/* 703BC4 802380D4 1040000C */ beqz $v0, .L80238108 -/* 703BC8 802380D8 00000000 */ nop -/* 703BCC 802380DC 3C108024 */ lui $s0, %hi(D_8023C1C0) -/* 703BD0 802380E0 2610C1C0 */ addiu $s0, $s0, %lo(D_8023C1C0) -/* 703BD4 802380E4 8E020000 */ lw $v0, ($s0) -/* 703BD8 802380E8 2442000F */ addiu $v0, $v0, 0xf -/* 703BDC 802380EC 44826000 */ mtc1 $v0, $f12 -/* 703BE0 802380F0 00000000 */ nop -/* 703BE4 802380F4 46806320 */ cvt.s.w $f12, $f12 -/* 703BE8 802380F8 0C00A6C9 */ jal clamp_angle -/* 703BEC 802380FC AE020000 */ sw $v0, ($s0) -/* 703BF0 80238100 4600018D */ trunc.w.s $f6, $f0 -/* 703BF4 80238104 E6060000 */ swc1 $f6, ($s0) -.L80238108: -/* 703BF8 80238108 3C0140C9 */ lui $at, 0x40c9 -/* 703BFC 8023810C 34210FD0 */ ori $at, $at, 0xfd0 -/* 703C00 80238110 44810000 */ mtc1 $at, $f0 -/* 703C04 80238114 3C018024 */ lui $at, %hi(D_8023C1C0) -/* 703C08 80238118 C42CC1C0 */ lwc1 $f12, %lo(D_8023C1C0)($at) -/* 703C0C 8023811C 46806320 */ cvt.s.w $f12, $f12 -/* 703C10 80238120 46006302 */ mul.s $f12, $f12, $f0 -/* 703C14 80238124 00000000 */ nop -/* 703C18 80238128 3C0143B4 */ lui $at, 0x43b4 -/* 703C1C 8023812C 44810000 */ mtc1 $at, $f0 -/* 703C20 80238130 0C00A85B */ jal sin_rad -/* 703C24 80238134 46006303 */ div.s $f12, $f12, $f0 -/* 703C28 80238138 3C014040 */ lui $at, 0x4040 -/* 703C2C 8023813C 44811000 */ mtc1 $at, $f2 -/* 703C30 80238140 00000000 */ nop -/* 703C34 80238144 46020002 */ mul.s $f0, $f0, $f2 -/* 703C38 80238148 00000000 */ nop -/* 703C3C 8023814C 86420152 */ lh $v0, 0x152($s2) -/* 703C40 80238150 3C014140 */ lui $at, 0x4140 -/* 703C44 80238154 44812000 */ mtc1 $at, $f4 -/* 703C48 80238158 44821000 */ mtc1 $v0, $f2 -/* 703C4C 8023815C 00000000 */ nop -/* 703C50 80238160 468010A0 */ cvt.s.w $f2, $f2 -/* 703C54 80238164 4600018D */ trunc.w.s $f6, $f0 -/* 703C58 80238168 44033000 */ mfc1 $v1, $f6 -/* 703C5C 8023816C 00000000 */ nop -/* 703C60 80238170 00031600 */ sll $v0, $v1, 0x18 -/* 703C64 80238174 C6400148 */ lwc1 $f0, 0x148($s2) -/* 703C68 80238178 00021603 */ sra $v0, $v0, 0x18 -/* 703C6C 8023817C A243019A */ sb $v1, 0x19a($s2) -/* 703C70 80238180 46020000 */ add.s $f0, $f0, $f2 -/* 703C74 80238184 44821000 */ mtc1 $v0, $f2 -/* 703C78 80238188 00000000 */ nop -/* 703C7C 8023818C 468010A0 */ cvt.s.w $f2, $f2 -/* 703C80 80238190 86420150 */ lh $v0, 0x150($s2) -/* 703C84 80238194 46020000 */ add.s $f0, $f0, $f2 -/* 703C88 80238198 44821000 */ mtc1 $v0, $f2 -/* 703C8C 8023819C 00000000 */ nop -/* 703C90 802381A0 468010A0 */ cvt.s.w $f2, $f2 -/* 703C94 802381A4 8E620004 */ lw $v0, 4($s3) -/* 703C98 802381A8 86430154 */ lh $v1, 0x154($s2) -/* 703C9C 802381AC 30420014 */ andi $v0, $v0, 0x14 -/* 703CA0 802381B0 46040580 */ add.s $f22, $f0, $f4 -/* 703CA4 802381B4 C6400144 */ lwc1 $f0, 0x144($s2) -/* 703CA8 802381B8 44832000 */ mtc1 $v1, $f4 -/* 703CAC 802381BC 00000000 */ nop -/* 703CB0 802381C0 46802120 */ cvt.s.w $f4, $f4 -/* 703CB4 802381C4 46020500 */ add.s $f20, $f0, $f2 -/* 703CB8 802381C8 C640014C */ lwc1 $f0, 0x14c($s2) -/* 703CBC 802381CC 24030004 */ addiu $v1, $zero, 4 -/* 703CC0 802381D0 14430003 */ bne $v0, $v1, .L802381E0 -/* 703CC4 802381D4 46040600 */ add.s $f24, $f0, $f4 -/* 703CC8 802381D8 3C01C47A */ lui $at, 0xc47a -/* 703CCC 802381DC 4481B000 */ mtc1 $at, $f22 -.L802381E0: -/* 703CD0 802381E0 3C028024 */ lui $v0, %hi(D_8023C1C4) -/* 703CD4 802381E4 8C42C1C4 */ lw $v0, %lo(D_8023C1C4)($v0) -/* 703CD8 802381E8 10400044 */ beqz $v0, .L802382FC -/* 703CDC 802381EC 00000000 */ nop -/* 703CE0 802381F0 3C038024 */ lui $v1, %hi(D_8023C1C8) -/* 703CE4 802381F4 8C63C1C8 */ lw $v1, %lo(D_8023C1C8)($v1) -/* 703CE8 802381F8 10600005 */ beqz $v1, .L80238210 -/* 703CEC 802381FC 24020001 */ addiu $v0, $zero, 1 -/* 703CF0 80238200 1062001D */ beq $v1, $v0, .L80238278 -/* 703CF4 80238204 0000102D */ daddu $v0, $zero, $zero -/* 703CF8 80238208 0808E0D2 */ j .L80238348 -/* 703CFC 8023820C 00000000 */ nop -.L80238210: -/* 703D00 80238210 3C108024 */ lui $s0, %hi(D_8023C1CC) -/* 703D04 80238214 2610C1CC */ addiu $s0, $s0, %lo(D_8023C1CC) -/* 703D08 80238218 8E020000 */ lw $v0, ($s0) -/* 703D0C 8023821C 1440000C */ bnez $v0, .L80238250 -/* 703D10 80238220 0000202D */ daddu $a0, $zero, $zero -/* 703D14 80238224 4405A000 */ mfc1 $a1, $f20 -/* 703D18 80238228 4406B000 */ mfc1 $a2, $f22 -/* 703D1C 8023822C 4407C000 */ mfc1 $a3, $f24 -/* 703D20 80238230 3C013F80 */ lui $at, 0x3f80 -/* 703D24 80238234 44810000 */ mtc1 $at, $f0 -/* 703D28 80238238 24020005 */ addiu $v0, $zero, 5 -/* 703D2C 8023823C AFA20014 */ sw $v0, 0x14($sp) -/* 703D30 80238240 AFA00018 */ sw $zero, 0x18($sp) -/* 703D34 80238244 0C01C8EC */ jal fx_static_status -/* 703D38 80238248 E7A00010 */ swc1 $f0, 0x10($sp) -/* 703D3C 8023824C AE020000 */ sw $v0, ($s0) -.L80238250: -/* 703D40 80238250 3C048024 */ lui $a0, %hi(D_8023C1D0) -/* 703D44 80238254 2484C1D0 */ addiu $a0, $a0, %lo(D_8023C1D0) -/* 703D48 80238258 8C830000 */ lw $v1, ($a0) -/* 703D4C 8023825C 1060001F */ beqz $v1, .L802382DC -/* 703D50 80238260 00000000 */ nop -/* 703D54 80238264 8C620000 */ lw $v0, ($v1) -/* 703D58 80238268 AC800000 */ sw $zero, ($a0) -/* 703D5C 8023826C 34420010 */ ori $v0, $v0, 0x10 -/* 703D60 80238270 0808E0B7 */ j .L802382DC -/* 703D64 80238274 AC620000 */ sw $v0, ($v1) -.L80238278: -/* 703D68 80238278 3C048024 */ lui $a0, %hi(D_8023C1CC) -/* 703D6C 8023827C 2484C1CC */ addiu $a0, $a0, %lo(D_8023C1CC) -/* 703D70 80238280 8C830000 */ lw $v1, ($a0) -/* 703D74 80238284 10600005 */ beqz $v1, .L8023829C -/* 703D78 80238288 00000000 */ nop -/* 703D7C 8023828C 8C620000 */ lw $v0, ($v1) -/* 703D80 80238290 AC800000 */ sw $zero, ($a0) -/* 703D84 80238294 34420010 */ ori $v0, $v0, 0x10 -/* 703D88 80238298 AC620000 */ sw $v0, ($v1) -.L8023829C: -/* 703D8C 8023829C 3C108024 */ lui $s0, %hi(D_8023C1D0) -/* 703D90 802382A0 2610C1D0 */ addiu $s0, $s0, %lo(D_8023C1D0) -/* 703D94 802382A4 8E020000 */ lw $v0, ($s0) -/* 703D98 802382A8 1440000C */ bnez $v0, .L802382DC -/* 703D9C 802382AC 24040001 */ addiu $a0, $zero, 1 -/* 703DA0 802382B0 4405A000 */ mfc1 $a1, $f20 -/* 703DA4 802382B4 4406B000 */ mfc1 $a2, $f22 -/* 703DA8 802382B8 4407C000 */ mfc1 $a3, $f24 -/* 703DAC 802382BC 3C013F80 */ lui $at, 0x3f80 -/* 703DB0 802382C0 44810000 */ mtc1 $at, $f0 -/* 703DB4 802382C4 24020005 */ addiu $v0, $zero, 5 -/* 703DB8 802382C8 AFA20014 */ sw $v0, 0x14($sp) -/* 703DBC 802382CC AFA00018 */ sw $zero, 0x18($sp) -/* 703DC0 802382D0 0C01C8EC */ jal fx_static_status -/* 703DC4 802382D4 E7A00010 */ swc1 $f0, 0x10($sp) -/* 703DC8 802382D8 AE020000 */ sw $v0, ($s0) -.L802382DC: -/* 703DCC 802382DC 8E030000 */ lw $v1, ($s0) -/* 703DD0 802382E0 8C62000C */ lw $v0, 0xc($v1) -/* 703DD4 802382E4 E4540004 */ swc1 $f20, 4($v0) -/* 703DD8 802382E8 8C62000C */ lw $v0, 0xc($v1) -/* 703DDC 802382EC E4560008 */ swc1 $f22, 8($v0) -/* 703DE0 802382F0 8C62000C */ lw $v0, 0xc($v1) -/* 703DE4 802382F4 0808E0D1 */ j .L80238344 -/* 703DE8 802382F8 E458000C */ swc1 $f24, 0xc($v0) -.L802382FC: -/* 703DEC 802382FC 3C048024 */ lui $a0, %hi(D_8023C1CC) -/* 703DF0 80238300 2484C1CC */ addiu $a0, $a0, %lo(D_8023C1CC) -/* 703DF4 80238304 8C830000 */ lw $v1, ($a0) -/* 703DF8 80238308 10600005 */ beqz $v1, .L80238320 -/* 703DFC 8023830C 00000000 */ nop -/* 703E00 80238310 8C620000 */ lw $v0, ($v1) -/* 703E04 80238314 AC800000 */ sw $zero, ($a0) -/* 703E08 80238318 34420010 */ ori $v0, $v0, 0x10 -/* 703E0C 8023831C AC620000 */ sw $v0, ($v1) -.L80238320: -/* 703E10 80238320 3C048024 */ lui $a0, %hi(D_8023C1D0) -/* 703E14 80238324 2484C1D0 */ addiu $a0, $a0, %lo(D_8023C1D0) -/* 703E18 80238328 8C830000 */ lw $v1, ($a0) -/* 703E1C 8023832C 10600006 */ beqz $v1, .L80238348 -/* 703E20 80238330 0000102D */ daddu $v0, $zero, $zero -/* 703E24 80238334 8C620000 */ lw $v0, ($v1) -/* 703E28 80238338 AC800000 */ sw $zero, ($a0) -/* 703E2C 8023833C 34420010 */ ori $v0, $v0, 0x10 -/* 703E30 80238340 AC620000 */ sw $v0, ($v1) -.L80238344: -/* 703E34 80238344 0000102D */ daddu $v0, $zero, $zero -.L80238348: -/* 703E38 80238348 8FBF0030 */ lw $ra, 0x30($sp) -/* 703E3C 8023834C 8FB3002C */ lw $s3, 0x2c($sp) -/* 703E40 80238350 8FB20028 */ lw $s2, 0x28($sp) -/* 703E44 80238354 8FB10024 */ lw $s1, 0x24($sp) -/* 703E48 80238358 8FB00020 */ lw $s0, 0x20($sp) -/* 703E4C 8023835C D7B80048 */ ldc1 $f24, 0x48($sp) -/* 703E50 80238360 D7B60040 */ ldc1 $f22, 0x40($sp) -/* 703E54 80238364 D7B40038 */ ldc1 $f20, 0x38($sp) -/* 703E58 80238368 03E00008 */ jr $ra -/* 703E5C 8023836C 27BD0050 */ addiu $sp, $sp, 0x50 diff --git a/ver/us/asm/nonmatchings/main_loop/func_80027600.s b/ver/us/asm/nonmatchings/main_loop/func_80027600.s deleted file mode 100644 index fabc5e5ca2..0000000000 --- a/ver/us/asm/nonmatchings/main_loop/func_80027600.s +++ /dev/null @@ -1,105 +0,0 @@ -.set noat # allow manual use of $at -.set noreorder # don't insert nops after branches - -glabel func_80027600 -/* 2A00 80027600 27BDFF98 */ addiu $sp, $sp, -0x68 -/* 2A04 80027604 0080502D */ daddu $t2, $a0, $zero -/* 2A08 80027608 0000302D */ daddu $a2, $zero, $zero -/* 2A0C 8002760C 27A90008 */ addiu $t1, $sp, 8 -/* 2A10 80027610 27A80028 */ addiu $t0, $sp, 0x28 -/* 2A14 80027614 27A70048 */ addiu $a3, $sp, 0x48 -.L80027618: -/* 2A18 80027618 01261021 */ addu $v0, $t1, $a2 -/* 2A1C 8002761C 01061821 */ addu $v1, $t0, $a2 -/* 2A20 80027620 00E62021 */ addu $a0, $a3, $a2 -/* 2A24 80027624 24C60001 */ addiu $a2, $a2, 1 -/* 2A28 80027628 A0400000 */ sb $zero, ($v0) -/* 2A2C 8002762C 28C20020 */ slti $v0, $a2, 0x20 -/* 2A30 80027630 A0600000 */ sb $zero, ($v1) -/* 2A34 80027634 1440FFF8 */ bnez $v0, .L80027618 -/* 2A38 80027638 A0800000 */ sb $zero, ($a0) -/* 2A3C 8002763C 0000302D */ daddu $a2, $zero, $zero -/* 2A40 80027640 27A90008 */ addiu $t1, $sp, 8 -/* 2A44 80027644 27A80028 */ addiu $t0, $sp, 0x28 -/* 2A48 80027648 27A70048 */ addiu $a3, $sp, 0x48 -/* 2A4C 8002764C 0140202D */ daddu $a0, $t2, $zero -.L80027650: -/* 2A50 80027650 90830000 */ lbu $v1, ($a0) -/* 2A54 80027654 01231821 */ addu $v1, $t1, $v1 -/* 2A58 80027658 90620000 */ lbu $v0, ($v1) -/* 2A5C 8002765C 24420001 */ addiu $v0, $v0, 1 -/* 2A60 80027660 A0620000 */ sb $v0, ($v1) -/* 2A64 80027664 90830001 */ lbu $v1, 1($a0) -/* 2A68 80027668 01031821 */ addu $v1, $t0, $v1 -/* 2A6C 8002766C 90620000 */ lbu $v0, ($v1) -/* 2A70 80027670 24420001 */ addiu $v0, $v0, 1 -/* 2A74 80027674 A0620000 */ sb $v0, ($v1) -/* 2A78 80027678 90830002 */ lbu $v1, 2($a0) -/* 2A7C 8002767C 24C60001 */ addiu $a2, $a2, 1 -/* 2A80 80027680 00E31821 */ addu $v1, $a3, $v1 -/* 2A84 80027684 90620000 */ lbu $v0, ($v1) -/* 2A88 80027688 24420001 */ addiu $v0, $v0, 1 -/* 2A8C 8002768C A0620000 */ sb $v0, ($v1) -/* 2A90 80027690 28C20009 */ slti $v0, $a2, 9 -/* 2A94 80027694 1440FFEE */ bnez $v0, .L80027650 -/* 2A98 80027698 24840004 */ addiu $a0, $a0, 4 -/* 2A9C 8002769C 0000182D */ daddu $v1, $zero, $zero -/* 2AA0 800276A0 0060302D */ daddu $a2, $v1, $zero -/* 2AA4 800276A4 27A40008 */ addiu $a0, $sp, 8 -/* 2AA8 800276A8 00861021 */ addu $v0, $a0, $a2 -.L800276AC: -/* 2AAC 800276AC 90420000 */ lbu $v0, ($v0) -/* 2AB0 800276B0 00621821 */ addu $v1, $v1, $v0 -/* 2AB4 800276B4 28620005 */ slti $v0, $v1, 5 -/* 2AB8 800276B8 50400006 */ beql $v0, $zero, .L800276D4 -/* 2ABC 800276BC A3A60000 */ sb $a2, ($sp) -/* 2AC0 800276C0 24C60001 */ addiu $a2, $a2, 1 -/* 2AC4 800276C4 28C20020 */ slti $v0, $a2, 0x20 -/* 2AC8 800276C8 1440FFF8 */ bnez $v0, .L800276AC -/* 2ACC 800276CC 00861021 */ addu $v0, $a0, $a2 -/* 2AD0 800276D0 A3A60000 */ sb $a2, ($sp) -.L800276D4: -/* 2AD4 800276D4 0000182D */ daddu $v1, $zero, $zero -/* 2AD8 800276D8 0060302D */ daddu $a2, $v1, $zero -/* 2ADC 800276DC 27A40028 */ addiu $a0, $sp, 0x28 -/* 2AE0 800276E0 00861021 */ addu $v0, $a0, $a2 -.L800276E4: -/* 2AE4 800276E4 90420000 */ lbu $v0, ($v0) -/* 2AE8 800276E8 00621821 */ addu $v1, $v1, $v0 -/* 2AEC 800276EC 28620005 */ slti $v0, $v1, 5 -/* 2AF0 800276F0 50400006 */ beql $v0, $zero, .L8002770C -/* 2AF4 800276F4 A3A60001 */ sb $a2, 1($sp) -/* 2AF8 800276F8 24C60001 */ addiu $a2, $a2, 1 -/* 2AFC 800276FC 28C20020 */ slti $v0, $a2, 0x20 -/* 2B00 80027700 1440FFF8 */ bnez $v0, .L800276E4 -/* 2B04 80027704 00861021 */ addu $v0, $a0, $a2 -/* 2B08 80027708 A3A60001 */ sb $a2, 1($sp) -.L8002770C: -/* 2B0C 8002770C 0000182D */ daddu $v1, $zero, $zero -/* 2B10 80027710 0060302D */ daddu $a2, $v1, $zero -/* 2B14 80027714 27A40048 */ addiu $a0, $sp, 0x48 -/* 2B18 80027718 00861021 */ addu $v0, $a0, $a2 -.L8002771C: -/* 2B1C 8002771C 90420000 */ lbu $v0, ($v0) -/* 2B20 80027720 00621821 */ addu $v1, $v1, $v0 -/* 2B24 80027724 28620005 */ slti $v0, $v1, 5 -/* 2B28 80027728 50400006 */ beql $v0, $zero, .L80027744 -/* 2B2C 8002772C A3A60002 */ sb $a2, 2($sp) -/* 2B30 80027730 24C60001 */ addiu $a2, $a2, 1 -/* 2B34 80027734 28C20020 */ slti $v0, $a2, 0x20 -/* 2B38 80027738 1440FFF8 */ bnez $v0, .L8002771C -/* 2B3C 8002773C 00861021 */ addu $v0, $a0, $a2 -/* 2B40 80027740 A3A60002 */ sb $a2, 2($sp) -.L80027744: -/* 2B44 80027744 30C300FF */ andi $v1, $a2, 0xff -/* 2B48 80027748 00031840 */ sll $v1, $v1, 1 -/* 2B4C 8002774C 93A20000 */ lbu $v0, ($sp) -/* 2B50 80027750 93A40001 */ lbu $a0, 1($sp) -/* 2B54 80027754 000212C0 */ sll $v0, $v0, 0xb -/* 2B58 80027758 00042180 */ sll $a0, $a0, 6 -/* 2B5C 8002775C 00441021 */ addu $v0, $v0, $a0 -/* 2B60 80027760 00431021 */ addu $v0, $v0, $v1 -/* 2B64 80027764 24420001 */ addiu $v0, $v0, 1 -/* 2B68 80027768 A4A20000 */ sh $v0, ($a1) -/* 2B6C 8002776C 03E00008 */ jr $ra -/* 2B70 80027770 27BD0068 */ addiu $sp, $sp, 0x68 diff --git a/ver/us/asm/nonmatchings/main_loop/func_80027774.s b/ver/us/asm/nonmatchings/main_loop/func_80027774.s deleted file mode 100644 index e5bc6969a6..0000000000 --- a/ver/us/asm/nonmatchings/main_loop/func_80027774.s +++ /dev/null @@ -1,153 +0,0 @@ -.set noat # allow manual use of $at -.set noreorder # don't insert nops after branches - -glabel func_80027774 -/* 2B74 80027774 27BDFF90 */ addiu $sp, $sp, -0x70 -/* 2B78 80027778 AFB40058 */ sw $s4, 0x58($sp) -/* 2B7C 8002777C 0080A02D */ daddu $s4, $a0, $zero -/* 2B80 80027780 AFB5005C */ sw $s5, 0x5c($sp) -/* 2B84 80027784 00A0A82D */ daddu $s5, $a1, $zero -/* 2B88 80027788 AFB30054 */ sw $s3, 0x54($sp) -/* 2B8C 8002778C 24130001 */ addiu $s3, $zero, 1 -/* 2B90 80027790 27A80018 */ addiu $t0, $sp, 0x18 -/* 2B94 80027794 AFA80040 */ sw $t0, 0x40($sp) -/* 2B98 80027798 24080140 */ addiu $t0, $zero, 0x140 -/* 2B9C 8002779C AFBF006C */ sw $ra, 0x6c($sp) -/* 2BA0 800277A0 AFBE0068 */ sw $fp, 0x68($sp) -/* 2BA4 800277A4 AFB70064 */ sw $s7, 0x64($sp) -/* 2BA8 800277A8 AFB60060 */ sw $s6, 0x60($sp) -/* 2BAC 800277AC AFB20050 */ sw $s2, 0x50($sp) -/* 2BB0 800277B0 AFB1004C */ sw $s1, 0x4c($sp) -/* 2BB4 800277B4 AFB00048 */ sw $s0, 0x48($sp) -/* 2BB8 800277B8 AFA60078 */ sw $a2, 0x78($sp) -/* 2BBC 800277BC AFA80044 */ sw $t0, 0x44($sp) -.L800277C0: -/* 2BC0 800277C0 24120001 */ addiu $s2, $zero, 1 -/* 2BC4 800277C4 267EFFFF */ addiu $fp, $s3, -1 -/* 2BC8 800277C8 8FA80044 */ lw $t0, 0x44($sp) -/* 2BCC 800277CC 0272B821 */ addu $s7, $s3, $s2 -/* 2BD0 800277D0 0112B021 */ addu $s6, $t0, $s2 -/* 2BD4 800277D4 00161840 */ sll $v1, $s6, 1 -.L800277D8: -/* 2BD8 800277D8 00752021 */ addu $a0, $v1, $s5 -/* 2BDC 800277DC 9482FFFE */ lhu $v0, -2($a0) -/* 2BE0 800277E0 00021082 */ srl $v0, $v0, 2 -/* 2BE4 800277E4 3042000F */ andi $v0, $v0, 0xf -/* 2BE8 800277E8 2C420008 */ sltiu $v0, $v0, 8 -/* 2BEC 800277EC 5440000D */ bnel $v0, $zero, .L80027824 -/* 2BF0 800277F0 0280202D */ daddu $a0, $s4, $zero -/* 2BF4 800277F4 94820000 */ lhu $v0, ($a0) -/* 2BF8 800277F8 00021082 */ srl $v0, $v0, 2 -/* 2BFC 800277FC 3042000F */ andi $v0, $v0, 0xf -/* 2C00 80027800 2C420008 */ sltiu $v0, $v0, 8 -/* 2C04 80027804 54400007 */ bnel $v0, $zero, .L80027824 -/* 2C08 80027808 0280202D */ daddu $a0, $s4, $zero -/* 2C0C 8002780C 94820002 */ lhu $v0, 2($a0) -/* 2C10 80027810 00021082 */ srl $v0, $v0, 2 -/* 2C14 80027814 3042000F */ andi $v0, $v0, 0xf -/* 2C18 80027818 2C420008 */ sltiu $v0, $v0, 8 -/* 2C1C 8002781C 10400048 */ beqz $v0, .L80027940 -/* 2C20 80027820 0280202D */ daddu $a0, $s4, $zero -.L80027824: -/* 2C24 80027824 02A0282D */ daddu $a1, $s5, $zero -/* 2C28 80027828 03C0302D */ daddu $a2, $fp, $zero -/* 2C2C 8002782C 2650FFFF */ addiu $s0, $s2, -1 -/* 2C30 80027830 8FA80040 */ lw $t0, 0x40($sp) -/* 2C34 80027834 0200382D */ daddu $a3, $s0, $zero -/* 2C38 80027838 0C009C7F */ jal gfx_frame_filter_pass_0 -/* 2C3C 8002783C AFA80010 */ sw $t0, 0x10($sp) -/* 2C40 80027840 0280202D */ daddu $a0, $s4, $zero -/* 2C44 80027844 02A0282D */ daddu $a1, $s5, $zero -/* 2C48 80027848 03C0302D */ daddu $a2, $fp, $zero -/* 2C4C 8002784C 0240382D */ daddu $a3, $s2, $zero -/* 2C50 80027850 27A2001C */ addiu $v0, $sp, 0x1c -/* 2C54 80027854 0C009C7F */ jal gfx_frame_filter_pass_0 -/* 2C58 80027858 AFA20010 */ sw $v0, 0x10($sp) -/* 2C5C 8002785C 0280202D */ daddu $a0, $s4, $zero -/* 2C60 80027860 02A0282D */ daddu $a1, $s5, $zero -/* 2C64 80027864 03C0302D */ daddu $a2, $fp, $zero -/* 2C68 80027868 26510001 */ addiu $s1, $s2, 1 -/* 2C6C 8002786C 0220382D */ daddu $a3, $s1, $zero -/* 2C70 80027870 27A20020 */ addiu $v0, $sp, 0x20 -/* 2C74 80027874 0C009C7F */ jal gfx_frame_filter_pass_0 -/* 2C78 80027878 AFA20010 */ sw $v0, 0x10($sp) -/* 2C7C 8002787C 0280202D */ daddu $a0, $s4, $zero -/* 2C80 80027880 02A0282D */ daddu $a1, $s5, $zero -/* 2C84 80027884 0260302D */ daddu $a2, $s3, $zero -/* 2C88 80027888 0200382D */ daddu $a3, $s0, $zero -/* 2C8C 8002788C 27A20024 */ addiu $v0, $sp, 0x24 -/* 2C90 80027890 0C009C7F */ jal gfx_frame_filter_pass_0 -/* 2C94 80027894 AFA20010 */ sw $v0, 0x10($sp) -/* 2C98 80027898 0280202D */ daddu $a0, $s4, $zero -/* 2C9C 8002789C 02A0282D */ daddu $a1, $s5, $zero -/* 2CA0 800278A0 0260302D */ daddu $a2, $s3, $zero -/* 2CA4 800278A4 0240382D */ daddu $a3, $s2, $zero -/* 2CA8 800278A8 27A20028 */ addiu $v0, $sp, 0x28 -/* 2CAC 800278AC 0C009C7F */ jal gfx_frame_filter_pass_0 -/* 2CB0 800278B0 AFA20010 */ sw $v0, 0x10($sp) -/* 2CB4 800278B4 0280202D */ daddu $a0, $s4, $zero -/* 2CB8 800278B8 02A0282D */ daddu $a1, $s5, $zero -/* 2CBC 800278BC 0260302D */ daddu $a2, $s3, $zero -/* 2CC0 800278C0 0220382D */ daddu $a3, $s1, $zero -/* 2CC4 800278C4 27A2002C */ addiu $v0, $sp, 0x2c -/* 2CC8 800278C8 0C009C7F */ jal gfx_frame_filter_pass_0 -/* 2CCC 800278CC AFA20010 */ sw $v0, 0x10($sp) -/* 2CD0 800278D0 0280202D */ daddu $a0, $s4, $zero -/* 2CD4 800278D4 02A0282D */ daddu $a1, $s5, $zero -/* 2CD8 800278D8 02E0302D */ daddu $a2, $s7, $zero -/* 2CDC 800278DC 0200382D */ daddu $a3, $s0, $zero -/* 2CE0 800278E0 27A20030 */ addiu $v0, $sp, 0x30 -/* 2CE4 800278E4 0C009C7F */ jal gfx_frame_filter_pass_0 -/* 2CE8 800278E8 AFA20010 */ sw $v0, 0x10($sp) -/* 2CEC 800278EC 0280202D */ daddu $a0, $s4, $zero -/* 2CF0 800278F0 02A0282D */ daddu $a1, $s5, $zero -/* 2CF4 800278F4 02E0302D */ daddu $a2, $s7, $zero -/* 2CF8 800278F8 0240382D */ daddu $a3, $s2, $zero -/* 2CFC 800278FC 27A20034 */ addiu $v0, $sp, 0x34 -/* 2D00 80027900 0C009C7F */ jal gfx_frame_filter_pass_0 -/* 2D04 80027904 AFA20010 */ sw $v0, 0x10($sp) -/* 2D08 80027908 0280202D */ daddu $a0, $s4, $zero -/* 2D0C 8002790C 02A0282D */ daddu $a1, $s5, $zero -/* 2D10 80027910 02E0302D */ daddu $a2, $s7, $zero -/* 2D14 80027914 0220382D */ daddu $a3, $s1, $zero -/* 2D18 80027918 27A20038 */ addiu $v0, $sp, 0x38 -/* 2D1C 8002791C 0C009C7F */ jal gfx_frame_filter_pass_0 -/* 2D20 80027920 AFA20010 */ sw $v0, 0x10($sp) -/* 2D24 80027924 00162840 */ sll $a1, $s6, 1 -/* 2D28 80027928 8FA80078 */ lw $t0, 0x78($sp) -/* 2D2C 8002792C 8FA40040 */ lw $a0, 0x40($sp) -/* 2D30 80027930 0C009D80 */ jal func_80027600 -/* 2D34 80027934 01052821 */ addu $a1, $t0, $a1 -/* 2D38 80027938 08009E57 */ j .L8002795C -/* 2D3C 8002793C 26D60001 */ addiu $s6, $s6, 1 -.L80027940: -/* 2D40 80027940 00741021 */ addu $v0, $v1, $s4 -/* 2D44 80027944 8FA80078 */ lw $t0, 0x78($sp) -/* 2D48 80027948 94420000 */ lhu $v0, ($v0) -/* 2D4C 8002794C 00681821 */ addu $v1, $v1, $t0 -/* 2D50 80027950 34420001 */ ori $v0, $v0, 1 -/* 2D54 80027954 A4620000 */ sh $v0, ($v1) -/* 2D58 80027958 26D60001 */ addiu $s6, $s6, 1 -.L8002795C: -/* 2D5C 8002795C 26520001 */ addiu $s2, $s2, 1 -/* 2D60 80027960 2A42013F */ slti $v0, $s2, 0x13f -/* 2D64 80027964 1440FF9C */ bnez $v0, .L800277D8 -/* 2D68 80027968 00161840 */ sll $v1, $s6, 1 -/* 2D6C 8002796C 26730001 */ addiu $s3, $s3, 1 -/* 2D70 80027970 8FA80044 */ lw $t0, 0x44($sp) -/* 2D74 80027974 2A6200EF */ slti $v0, $s3, 0xef -/* 2D78 80027978 25080140 */ addiu $t0, $t0, 0x140 -/* 2D7C 8002797C 1440FF90 */ bnez $v0, .L800277C0 -/* 2D80 80027980 AFA80044 */ sw $t0, 0x44($sp) -/* 2D84 80027984 8FBF006C */ lw $ra, 0x6c($sp) -/* 2D88 80027988 8FBE0068 */ lw $fp, 0x68($sp) -/* 2D8C 8002798C 8FB70064 */ lw $s7, 0x64($sp) -/* 2D90 80027990 8FB60060 */ lw $s6, 0x60($sp) -/* 2D94 80027994 8FB5005C */ lw $s5, 0x5c($sp) -/* 2D98 80027998 8FB40058 */ lw $s4, 0x58($sp) -/* 2D9C 8002799C 8FB30054 */ lw $s3, 0x54($sp) -/* 2DA0 800279A0 8FB20050 */ lw $s2, 0x50($sp) -/* 2DA4 800279A4 8FB1004C */ lw $s1, 0x4c($sp) -/* 2DA8 800279A8 8FB00048 */ lw $s0, 0x48($sp) -/* 2DAC 800279AC 03E00008 */ jr $ra -/* 2DB0 800279B0 27BD0070 */ addiu $sp, $sp, 0x70 diff --git a/ver/us/asm/nonmatchings/main_loop/gfx_frame_filter_pass_1.s b/ver/us/asm/nonmatchings/main_loop/gfx_frame_filter_pass_1.s deleted file mode 100644 index 8cc192c780..0000000000 --- a/ver/us/asm/nonmatchings/main_loop/gfx_frame_filter_pass_1.s +++ /dev/null @@ -1,267 +0,0 @@ -.set noat # allow manual use of $at -.set noreorder # don't insert nops after branches - -glabel gfx_frame_filter_pass_1 -/* 265C 8002725C 27BDFF88 */ addiu $sp, $sp, -0x78 -/* 2660 80027260 0080582D */ daddu $t3, $a0, $zero -/* 2664 80027264 AFA5007C */ sw $a1, 0x7c($sp) -/* 2668 80027268 0000282D */ daddu $a1, $zero, $zero -/* 266C 8002726C 27A90018 */ addiu $t1, $sp, 0x18 -/* 2670 80027270 27A80038 */ addiu $t0, $sp, 0x38 -/* 2674 80027274 27A70058 */ addiu $a3, $sp, 0x58 -/* 2678 80027278 8BAC007C */ lwl $t4, 0x7c($sp) -/* 267C 8002727C 9BAC007F */ lwr $t4, 0x7f($sp) -/* 2680 80027280 ABAC0008 */ swl $t4, 8($sp) -/* 2684 80027284 BBAC000B */ swr $t4, 0xb($sp) -/* 2688 80027288 8BAC007C */ lwl $t4, 0x7c($sp) -/* 268C 8002728C 9BAC007F */ lwr $t4, 0x7f($sp) -/* 2690 80027290 ABAC0000 */ swl $t4, ($sp) -/* 2694 80027294 BBAC0003 */ swr $t4, 3($sp) -.L80027298: -/* 2698 80027298 01251021 */ addu $v0, $t1, $a1 -/* 269C 8002729C 01051821 */ addu $v1, $t0, $a1 -/* 26A0 800272A0 00E52021 */ addu $a0, $a3, $a1 -/* 26A4 800272A4 24A50001 */ addiu $a1, $a1, 1 -/* 26A8 800272A8 A0400000 */ sb $zero, ($v0) -/* 26AC 800272AC 28A20020 */ slti $v0, $a1, 0x20 -/* 26B0 800272B0 A0600000 */ sb $zero, ($v1) -/* 26B4 800272B4 1440FFF8 */ bnez $v0, .L80027298 -/* 26B8 800272B8 A0800000 */ sb $zero, ($a0) -/* 26BC 800272BC 0000282D */ daddu $a1, $zero, $zero -/* 26C0 800272C0 240A0008 */ addiu $t2, $zero, 8 -/* 26C4 800272C4 27A90018 */ addiu $t1, $sp, 0x18 -/* 26C8 800272C8 27A80038 */ addiu $t0, $sp, 0x38 -/* 26CC 800272CC 27A70058 */ addiu $a3, $sp, 0x58 -/* 26D0 800272D0 0160202D */ daddu $a0, $t3, $zero -.L800272D4: -/* 26D4 800272D4 90820003 */ lbu $v0, 3($a0) -/* 26D8 800272D8 144A0010 */ bne $v0, $t2, .L8002731C -/* 26DC 800272DC 24A50001 */ addiu $a1, $a1, 1 -/* 26E0 800272E0 90830000 */ lbu $v1, ($a0) -/* 26E4 800272E4 01231821 */ addu $v1, $t1, $v1 -/* 26E8 800272E8 90620000 */ lbu $v0, ($v1) -/* 26EC 800272EC 24420001 */ addiu $v0, $v0, 1 -/* 26F0 800272F0 A0620000 */ sb $v0, ($v1) -/* 26F4 800272F4 90830001 */ lbu $v1, 1($a0) -/* 26F8 800272F8 01031821 */ addu $v1, $t0, $v1 -/* 26FC 800272FC 90620000 */ lbu $v0, ($v1) -/* 2700 80027300 24420001 */ addiu $v0, $v0, 1 -/* 2704 80027304 A0620000 */ sb $v0, ($v1) -/* 2708 80027308 90830002 */ lbu $v1, 2($a0) -/* 270C 8002730C 00E31821 */ addu $v1, $a3, $v1 -/* 2710 80027310 90620000 */ lbu $v0, ($v1) -/* 2714 80027314 24420001 */ addiu $v0, $v0, 1 -/* 2718 80027318 A0620000 */ sb $v0, ($v1) -.L8002731C: -/* 271C 8002731C 28A20006 */ slti $v0, $a1, 6 -/* 2720 80027320 1440FFEC */ bnez $v0, .L800272D4 -/* 2724 80027324 24840004 */ addiu $a0, $a0, 4 -/* 2728 80027328 0000282D */ daddu $a1, $zero, $zero -/* 272C 8002732C 27A40018 */ addiu $a0, $sp, 0x18 -/* 2730 80027330 00851821 */ addu $v1, $a0, $a1 -.L80027334: -/* 2734 80027334 90620000 */ lbu $v0, ($v1) -/* 2738 80027338 50400004 */ beql $v0, $zero, .L8002734C -/* 273C 8002733C 24A50001 */ addiu $a1, $a1, 1 -/* 2740 80027340 2442FFFF */ addiu $v0, $v0, -1 -/* 2744 80027344 08009CD6 */ j .L80027358 -/* 2748 80027348 A0620000 */ sb $v0, ($v1) -.L8002734C: -/* 274C 8002734C 28A20020 */ slti $v0, $a1, 0x20 -/* 2750 80027350 1440FFF8 */ bnez $v0, .L80027334 -/* 2754 80027354 00851821 */ addu $v1, $a0, $a1 -.L80027358: -/* 2758 80027358 28A20020 */ slti $v0, $a1, 0x20 -/* 275C 8002735C 10400009 */ beqz $v0, .L80027384 -/* 2760 80027360 27A30018 */ addiu $v1, $sp, 0x18 -/* 2764 80027364 00651021 */ addu $v0, $v1, $a1 -.L80027368: -/* 2768 80027368 90420000 */ lbu $v0, ($v0) -/* 276C 8002736C 14400005 */ bnez $v0, .L80027384 -/* 2770 80027370 00000000 */ nop -/* 2774 80027374 24A50001 */ addiu $a1, $a1, 1 -/* 2778 80027378 28A20020 */ slti $v0, $a1, 0x20 -/* 277C 8002737C 1440FFFA */ bnez $v0, .L80027368 -/* 2780 80027380 00651021 */ addu $v0, $v1, $a1 -.L80027384: -/* 2784 80027384 93A20000 */ lbu $v0, ($sp) -/* 2788 80027388 00A2102A */ slt $v0, $a1, $v0 -/* 278C 8002738C 54400001 */ bnel $v0, $zero, .L80027394 -/* 2790 80027390 A3A50000 */ sb $a1, ($sp) -.L80027394: -/* 2794 80027394 0000282D */ daddu $a1, $zero, $zero -/* 2798 80027398 27A40038 */ addiu $a0, $sp, 0x38 -/* 279C 8002739C 00851821 */ addu $v1, $a0, $a1 -.L800273A0: -/* 27A0 800273A0 90620000 */ lbu $v0, ($v1) -/* 27A4 800273A4 50400004 */ beql $v0, $zero, .L800273B8 -/* 27A8 800273A8 24A50001 */ addiu $a1, $a1, 1 -/* 27AC 800273AC 2442FFFF */ addiu $v0, $v0, -1 -/* 27B0 800273B0 08009CF1 */ j .L800273C4 -/* 27B4 800273B4 A0620000 */ sb $v0, ($v1) -.L800273B8: -/* 27B8 800273B8 28A20020 */ slti $v0, $a1, 0x20 -/* 27BC 800273BC 1440FFF8 */ bnez $v0, .L800273A0 -/* 27C0 800273C0 00851821 */ addu $v1, $a0, $a1 -.L800273C4: -/* 27C4 800273C4 28A20020 */ slti $v0, $a1, 0x20 -/* 27C8 800273C8 10400009 */ beqz $v0, .L800273F0 -/* 27CC 800273CC 27A30038 */ addiu $v1, $sp, 0x38 -/* 27D0 800273D0 00651021 */ addu $v0, $v1, $a1 -.L800273D4: -/* 27D4 800273D4 90420000 */ lbu $v0, ($v0) -/* 27D8 800273D8 14400005 */ bnez $v0, .L800273F0 -/* 27DC 800273DC 00000000 */ nop -/* 27E0 800273E0 24A50001 */ addiu $a1, $a1, 1 -/* 27E4 800273E4 28A20020 */ slti $v0, $a1, 0x20 -/* 27E8 800273E8 1440FFFA */ bnez $v0, .L800273D4 -/* 27EC 800273EC 00651021 */ addu $v0, $v1, $a1 -.L800273F0: -/* 27F0 800273F0 93A20001 */ lbu $v0, 1($sp) -/* 27F4 800273F4 00A2102A */ slt $v0, $a1, $v0 -/* 27F8 800273F8 54400001 */ bnel $v0, $zero, .L80027400 -/* 27FC 800273FC A3A50001 */ sb $a1, 1($sp) -.L80027400: -/* 2800 80027400 0000282D */ daddu $a1, $zero, $zero -/* 2804 80027404 27A40058 */ addiu $a0, $sp, 0x58 -/* 2808 80027408 00851821 */ addu $v1, $a0, $a1 -.L8002740C: -/* 280C 8002740C 90620000 */ lbu $v0, ($v1) -/* 2810 80027410 50400004 */ beql $v0, $zero, .L80027424 -/* 2814 80027414 24A50001 */ addiu $a1, $a1, 1 -/* 2818 80027418 2442FFFF */ addiu $v0, $v0, -1 -/* 281C 8002741C 08009D0C */ j .L80027430 -/* 2820 80027420 A0620000 */ sb $v0, ($v1) -.L80027424: -/* 2824 80027424 28A20020 */ slti $v0, $a1, 0x20 -/* 2828 80027428 1440FFF8 */ bnez $v0, .L8002740C -/* 282C 8002742C 00851821 */ addu $v1, $a0, $a1 -.L80027430: -/* 2830 80027430 28A20020 */ slti $v0, $a1, 0x20 -/* 2834 80027434 10400009 */ beqz $v0, .L8002745C -/* 2838 80027438 27A30058 */ addiu $v1, $sp, 0x58 -/* 283C 8002743C 00651021 */ addu $v0, $v1, $a1 -.L80027440: -/* 2840 80027440 90420000 */ lbu $v0, ($v0) -/* 2844 80027444 14400005 */ bnez $v0, .L8002745C -/* 2848 80027448 00000000 */ nop -/* 284C 8002744C 24A50001 */ addiu $a1, $a1, 1 -/* 2850 80027450 28A20020 */ slti $v0, $a1, 0x20 -/* 2854 80027454 1440FFFA */ bnez $v0, .L80027440 -/* 2858 80027458 00651021 */ addu $v0, $v1, $a1 -.L8002745C: -/* 285C 8002745C 93A20002 */ lbu $v0, 2($sp) -/* 2860 80027460 00A2102A */ slt $v0, $a1, $v0 -/* 2864 80027464 54400001 */ bnel $v0, $zero, .L8002746C -/* 2868 80027468 A3A50002 */ sb $a1, 2($sp) -.L8002746C: -/* 286C 8002746C 2405001F */ addiu $a1, $zero, 0x1f -/* 2870 80027470 27A30018 */ addiu $v1, $sp, 0x18 -/* 2874 80027474 00651021 */ addu $v0, $v1, $a1 -.L80027478: -/* 2878 80027478 90420000 */ lbu $v0, ($v0) -/* 287C 8002747C 14400004 */ bnez $v0, .L80027490 -/* 2880 80027480 00000000 */ nop -/* 2884 80027484 24A5FFFF */ addiu $a1, $a1, -1 -/* 2888 80027488 04A1FFFB */ bgez $a1, .L80027478 -/* 288C 8002748C 00651021 */ addu $v0, $v1, $a1 -.L80027490: -/* 2890 80027490 93A20008 */ lbu $v0, 8($sp) -/* 2894 80027494 0045102A */ slt $v0, $v0, $a1 -/* 2898 80027498 54400001 */ bnel $v0, $zero, .L800274A0 -/* 289C 8002749C A3A50008 */ sb $a1, 8($sp) -.L800274A0: -/* 28A0 800274A0 2405001F */ addiu $a1, $zero, 0x1f -/* 28A4 800274A4 27A30038 */ addiu $v1, $sp, 0x38 -/* 28A8 800274A8 00651021 */ addu $v0, $v1, $a1 -.L800274AC: -/* 28AC 800274AC 90420000 */ lbu $v0, ($v0) -/* 28B0 800274B0 14400004 */ bnez $v0, .L800274C4 -/* 28B4 800274B4 00000000 */ nop -/* 28B8 800274B8 24A5FFFF */ addiu $a1, $a1, -1 -/* 28BC 800274BC 04A1FFFB */ bgez $a1, .L800274AC -/* 28C0 800274C0 00651021 */ addu $v0, $v1, $a1 -.L800274C4: -/* 28C4 800274C4 93A20009 */ lbu $v0, 9($sp) -/* 28C8 800274C8 0045102A */ slt $v0, $v0, $a1 -/* 28CC 800274CC 54400001 */ bnel $v0, $zero, .L800274D4 -/* 28D0 800274D0 A3A50009 */ sb $a1, 9($sp) -.L800274D4: -/* 28D4 800274D4 2405001F */ addiu $a1, $zero, 0x1f -/* 28D8 800274D8 27A30058 */ addiu $v1, $sp, 0x58 -/* 28DC 800274DC 00651021 */ addu $v0, $v1, $a1 -.L800274E0: -/* 28E0 800274E0 90420000 */ lbu $v0, ($v0) -/* 28E4 800274E4 14400004 */ bnez $v0, .L800274F8 -/* 28E8 800274E8 00000000 */ nop -/* 28EC 800274EC 24A5FFFF */ addiu $a1, $a1, -1 -/* 28F0 800274F0 04A1FFFB */ bgez $a1, .L800274E0 -/* 28F4 800274F4 00651021 */ addu $v0, $v1, $a1 -.L800274F8: -/* 28F8 800274F8 93A2000A */ lbu $v0, 0xa($sp) -/* 28FC 800274FC 0045102A */ slt $v0, $v0, $a1 -/* 2900 80027500 54400001 */ bnel $v0, $zero, .L80027508 -/* 2904 80027504 A3A5000A */ sb $a1, 0xa($sp) -.L80027508: -/* 2908 80027508 93A20008 */ lbu $v0, 8($sp) -/* 290C 8002750C 93A30000 */ lbu $v1, ($sp) -/* 2910 80027510 93A4007C */ lbu $a0, 0x7c($sp) -/* 2914 80027514 00431021 */ addu $v0, $v0, $v1 -/* 2918 80027518 00441023 */ subu $v0, $v0, $a0 -/* 291C 8002751C A3A20010 */ sb $v0, 0x10($sp) -/* 2920 80027520 93A20009 */ lbu $v0, 9($sp) -/* 2924 80027524 93A30001 */ lbu $v1, 1($sp) -/* 2928 80027528 93A4007D */ lbu $a0, 0x7d($sp) -/* 292C 8002752C 00431021 */ addu $v0, $v0, $v1 -/* 2930 80027530 00441023 */ subu $v0, $v0, $a0 -/* 2934 80027534 A3A20011 */ sb $v0, 0x11($sp) -/* 2938 80027538 93A2000A */ lbu $v0, 0xa($sp) -/* 293C 8002753C 93A30002 */ lbu $v1, 2($sp) -/* 2940 80027540 93A4007E */ lbu $a0, 0x7e($sp) -/* 2944 80027544 00431021 */ addu $v0, $v0, $v1 -/* 2948 80027548 00441023 */ subu $v0, $v0, $a0 -/* 294C 8002754C A3A20012 */ sb $v0, 0x12($sp) -/* 2950 80027550 93A2007C */ lbu $v0, 0x7c($sp) -/* 2954 80027554 93A4007F */ lbu $a0, 0x7f($sp) -/* 2958 80027558 00440018 */ mult $v0, $a0 -/* 295C 8002755C 24030008 */ addiu $v1, $zero, 8 -/* 2960 80027560 00002812 */ mflo $a1 -/* 2964 80027564 93A20010 */ lbu $v0, 0x10($sp) -/* 2968 80027568 00641823 */ subu $v1, $v1, $a0 -/* 296C 8002756C 00430018 */ mult $v0, $v1 -/* 2970 80027570 00001012 */ mflo $v0 -/* 2974 80027574 00A21021 */ addu $v0, $a1, $v0 -/* 2978 80027578 000210C3 */ sra $v0, $v0, 3 -/* 297C 8002757C A3A20010 */ sb $v0, 0x10($sp) -/* 2980 80027580 93A2007D */ lbu $v0, 0x7d($sp) -/* 2984 80027584 00440018 */ mult $v0, $a0 -/* 2988 80027588 00002812 */ mflo $a1 -/* 298C 8002758C 93A20011 */ lbu $v0, 0x11($sp) -/* 2990 80027590 00000000 */ nop -/* 2994 80027594 00430018 */ mult $v0, $v1 -/* 2998 80027598 00001012 */ mflo $v0 -/* 299C 8002759C 00A21021 */ addu $v0, $a1, $v0 -/* 29A0 800275A0 000210C3 */ sra $v0, $v0, 3 -/* 29A4 800275A4 A3A20011 */ sb $v0, 0x11($sp) -/* 29A8 800275A8 93A2007E */ lbu $v0, 0x7e($sp) -/* 29AC 800275AC 00440018 */ mult $v0, $a0 -/* 29B0 800275B0 00002012 */ mflo $a0 -/* 29B4 800275B4 93A20012 */ lbu $v0, 0x12($sp) -/* 29B8 800275B8 00000000 */ nop -/* 29BC 800275BC 00430018 */ mult $v0, $v1 -/* 29C0 800275C0 00001012 */ mflo $v0 -/* 29C4 800275C4 00821021 */ addu $v0, $a0, $v0 -/* 29C8 800275C8 000210C3 */ sra $v0, $v0, 3 -/* 29CC 800275CC A3A20012 */ sb $v0, 0x12($sp) -/* 29D0 800275D0 93A20010 */ lbu $v0, 0x10($sp) -/* 29D4 800275D4 93A40011 */ lbu $a0, 0x11($sp) -/* 29D8 800275D8 93A30012 */ lbu $v1, 0x12($sp) -/* 29DC 800275DC 000212C0 */ sll $v0, $v0, 0xb -/* 29E0 800275E0 00042180 */ sll $a0, $a0, 6 -/* 29E4 800275E4 00441021 */ addu $v0, $v0, $a0 -/* 29E8 800275E8 00031840 */ sll $v1, $v1, 1 -/* 29EC 800275EC 00431021 */ addu $v0, $v0, $v1 -/* 29F0 800275F0 24420001 */ addiu $v0, $v0, 1 -/* 29F4 800275F4 A4C20000 */ sh $v0, ($a2) -/* 29F8 800275F8 03E00008 */ jr $ra -/* 29FC 800275FC 27BD0078 */ addiu $sp, $sp, 0x78 diff --git a/ver/us/symbol_addrs.txt b/ver/us/symbol_addrs.txt index c20023fdb1..41bea27798 100644 --- a/ver/us/symbol_addrs.txt +++ b/ver/us/symbol_addrs.txt @@ -2783,7 +2783,7 @@ D_800A0F44 = 0x800A0F44; // type:data rom:0x7C344 D_800A0F48 = 0x800A0F48; // type:data rom:0x7C348 D_800A0F50 = 0x800A0F50; // type:data rom:0x7C350 D_800A0F54 = 0x800A0F54; // type:data rom:0x7C354 -nuAuMgrThread = 0x800A0F58; // type:data rom:0x7C358 +nuAuMgrThread = 0x800A0F58; // type:data phys_init_integrator_for_current_state = 0x800E2F60; // type:func rom:0x7C410 gravity_use_fall_parms = 0x800E306C; // type:func rom:0x7C51C phys_update_falling = 0x800E3100; // type:func rom:0x7C5B0 @@ -25659,7 +25659,6 @@ EF2680_set_script_owner_npc_col_height = 0x802424B0; // type:func rom:0xEF4AC0 EF2680_TackleAI_Main = 0x80242530; // type:func rom:0xEF4B40 EF2680_SpinyAI_Main = 0x8024299C; // type:func rom:0xEF4FAC N(FlyingAI_JumpVels) = 0x802444BC; // type:data rom:0xEF6ACC -flo_14_ConsumableChoiceList = 0x802453B0; // type:data rom:0xEF79C0 D_802453B8_EF79C8 = 0x802453B8; // type:data rom:0xEF79C8 D_802453C0_EF79D0 = 0x802453C0; // type:data rom:0xEF79D0 D_80245408_EF7A18 = 0x80245408; // type:data rom:0xEF7A18 @@ -26037,7 +26036,6 @@ flo_09_pad_2004 = 0x80242004; // type:data D_80242180 = 0x80242180; // flo_24_pad_21A4 = 0x802421A4; // type:data D_80242208 = 0x80242208; // type:data -D_80242310 = 0x80242310; // type:data D_80242330 = 0x80242330; // type:data D_80242344 = 0x80242344; // type:data osr_01_LetterDelivery_SavedNpcAnim = 0x80242344; // type:data @@ -26045,7 +26043,6 @@ D_80242350 = 0x80242350; // type:data D_80242370 = 0x80242370; // type:data D_80242390 = 0x80242390; // type:data D_802423B0 = 0x802423B0; // type:data -D_802423D0 = 0x802423D0; // type:data D_802423F0 = 0x802423F0; // type:data D_80242410 = 0x80242410; // type:data D_80242430 = 0x80242430; // type:data @@ -26053,8 +26050,7 @@ D_80242450 = 0x80242450; // type:data D_802424E0 = 0x802424E0; // type:data D_80242568_filemenu = 0x80242568; // type:data flo_23_pad_2598 = 0x80242598; // type:data -flo_23_ConsumableChoiceList = 0x802426E0; // type:data -flo_23_ItemChoiceList = 0x802426E0; // type:data +flo_23_ItemChoiceList = 0x802426E0; // type:data segment:flo_23 flo_23_D_8024284C_pad = 0x8024284C; // type:data flo_23_FlowerGuard_ItemChoiceList = 0x80242850; // type:data flo_09_pad_2874 = 0x80242874; // type:data @@ -26142,7 +26138,6 @@ flo_25_pad_4734 = 0x80244734; // type:data D_802447C0 = 0x802447C0; // type:data arn_03_pad_47DC = 0x802447DC; // type:data D_80244A20 = 0x80244A20; // type:data -arn_03_ConsumableChoiceList = 0x80244A20; // type:data arn_03_KeyItemChoiceList = 0x80244A20; // type:data sbk_30_D_80244C18 = 0x80244C18; // type:data D_80244D88 = 0x80244D88; // type:data @@ -26153,7 +26148,6 @@ flo_03_pad_4ECC = 0x80244ECC; // type:data flo_14_pad_4F24 = 0x80244F24; // type:data flo_08_pad_4F3C = 0x80244F3C; // type:data flo_14_pad_4F64 = 0x80244F64; // type:data -flo_25_ConsumableChoiceList = 0x80244FA0; // type:data flo_25_ItemChoiceList = 0x80244FA0; // type:data arn_05_pad_4FF8 = 0x80244FF8; // type:data flo_25_D_8024510C_pad = 0x8024510C; // type:data diff --git a/ver/us/undefined_syms.txt b/ver/us/undefined_syms.txt index f93198457a..937f67d7e5 100644 --- a/ver/us/undefined_syms.txt +++ b/ver/us/undefined_syms.txt @@ -735,8 +735,3 @@ D_8024F580_hos_05 = 0x8024F580; osr_00_802437C0 = 0x802437C0; mim_03_802424E0 = 0x802424E0; sam_04_80245210 = 0x80245210; - -// incorrectly-identified vtx addresses for tst_13 -D_802423D0 = 0x802423D0; -D_80242310 = 0x80242310; -flo_23_ConsumableChoiceList = 0x802426E0;