diff --git a/assets/xml/objects/object_bee.xml b/assets/xml/objects/object_bee.xml index 735d191f3..8fcd930fa 100644 --- a/assets/xml/objects/object_bee.xml +++ b/assets/xml/objects/object_bee.xml @@ -1,28 +1,38 @@  + - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/assets/xml/objects/object_kamejima.xml b/assets/xml/objects/object_kamejima.xml index e8368051d..cce285475 100644 --- a/assets/xml/objects/object_kamejima.xml +++ b/assets/xml/objects/object_kamejima.xml @@ -1,81 +1,99 @@  + - + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/assets/xml/objects/object_kin2_obj.xml b/assets/xml/objects/object_kin2_obj.xml index e0ae09106..d36766ee4 100644 --- a/assets/xml/objects/object_kin2_obj.xml +++ b/assets/xml/objects/object_kin2_obj.xml @@ -1,33 +1,51 @@  + - + + - - - - + + + + + + + + - - + + + + - + + + - + + - + + + + + diff --git a/assets/xml/objects/object_umajump.xml b/assets/xml/objects/object_umajump.xml index 6d86b4298..cec43c3a6 100644 --- a/assets/xml/objects/object_umajump.xml +++ b/assets/xml/objects/object_umajump.xml @@ -2,7 +2,7 @@ - + diff --git a/assets/xml/overlays/ovl_Dm_Char08.xml b/assets/xml/overlays/ovl_Dm_Char08.xml new file mode 100644 index 000000000..4d96a8eb4 --- /dev/null +++ b/assets/xml/overlays/ovl_Dm_Char08.xml @@ -0,0 +1,17 @@ + + + + + + + + + + + + + + + + + diff --git a/include/functions.h b/include/functions.h index 395c99985..f86542b19 100644 --- a/include/functions.h +++ b/include/functions.h @@ -882,6 +882,7 @@ void func_800C636C(PlayState* play, DynaCollisionContext* dyna, s32 bgId); void func_800C63C4(PlayState* play, DynaCollisionContext* dyna, s32 bgId); void func_800C641C(PlayState* play, DynaCollisionContext* dyna, s32 bgId); void func_800C6474(PlayState* play, DynaCollisionContext* dyna, s32 bgId); +void func_800C6554(PlayState* play, DynaCollisionContext* dyna); void DynaPoly_DeleteBgActor(PlayState* play, DynaCollisionContext* dyna, s32 bgId); void BgCheck_CalcWaterboxDimensions(Vec3f* minPos, Vec3f* maxXPos, Vec3f* maxZPos, Vec3s* minPosOut, s16* xLength, s16* zLength); void DynaPoly_ExpandSRT(PlayState* play, DynaCollisionContext* dyna, s32 bgId, s32* vtxStartIndex, s32* polyStartIndex, s32* waterBoxStartIndex); diff --git a/spec b/spec index c99e6ce3f..428de2321 100644 --- a/spec +++ b/spec @@ -1286,8 +1286,7 @@ beginseg name "ovl_Bg_Umajump" compress include "build/src/overlays/actors/ovl_Bg_Umajump/z_bg_umajump.o" - include "build/data/ovl_Bg_Umajump/ovl_Bg_Umajump.data.o" - include "build/data/ovl_Bg_Umajump/ovl_Bg_Umajump.reloc.o" + include "build/src/overlays/actors/ovl_Bg_Umajump/ovl_Bg_Umajump_reloc.o" endseg beginseg @@ -3108,8 +3107,7 @@ beginseg name "ovl_Dm_Char08" compress include "build/src/overlays/actors/ovl_Dm_Char08/z_dm_char08.o" - include "build/data/ovl_Dm_Char08/ovl_Dm_Char08.data.o" - include "build/data/ovl_Dm_Char08/ovl_Dm_Char08.reloc.o" + include "build/src/overlays/actors/ovl_Dm_Char08/ovl_Dm_Char08_reloc.o" endseg beginseg @@ -3947,8 +3945,7 @@ beginseg name "ovl_Bg_Kin2_Picture" compress include "build/src/overlays/actors/ovl_Bg_Kin2_Picture/z_bg_kin2_picture.o" - include "build/data/ovl_Bg_Kin2_Picture/ovl_Bg_Kin2_Picture.data.o" - include "build/data/ovl_Bg_Kin2_Picture/ovl_Bg_Kin2_Picture.reloc.o" + include "build/src/overlays/actors/ovl_Bg_Kin2_Picture/ovl_Bg_Kin2_Picture_reloc.o" endseg beginseg @@ -4365,8 +4362,7 @@ beginseg name "ovl_En_Stone_heishi" compress include "build/src/overlays/actors/ovl_En_Stone_heishi/z_en_stone_heishi.o" - include "build/data/ovl_En_Stone_heishi/ovl_En_Stone_heishi.data.o" - include "build/data/ovl_En_Stone_heishi/ovl_En_Stone_heishi.reloc.o" + include "build/src/overlays/actors/ovl_En_Stone_heishi/ovl_En_Stone_heishi_reloc.o" endseg beginseg diff --git a/src/overlays/actors/ovl_Bg_Kin2_Fence/z_bg_kin2_fence.c b/src/overlays/actors/ovl_Bg_Kin2_Fence/z_bg_kin2_fence.c index 09f71c4ff..34aba7769 100644 --- a/src/overlays/actors/ovl_Bg_Kin2_Fence/z_bg_kin2_fence.c +++ b/src/overlays/actors/ovl_Bg_Kin2_Fence/z_bg_kin2_fence.c @@ -150,7 +150,7 @@ void BgKin2Fence_Init(Actor* thisx, PlayState* play) { Actor_ProcessInitChain(&this->dyna.actor, sInitChain); DynaPolyActor_Init(&this->dyna, 0); - DynaPolyActor_LoadMesh(play, &this->dyna, &object_kin2_obj_Colheader_000908); + DynaPolyActor_LoadMesh(play, &this->dyna, &gOceanSpiderHouseFireplaceGrateCol); Collider_InitJntSph(play, &this->collider); Collider_SetJntSph(play, &this->collider, &this->dyna.actor, &sJntSphInit, this->colliderElements); Matrix_SetTranslateRotateYXZ(this->dyna.actor.world.pos.x, this->dyna.actor.world.pos.y, diff --git a/src/overlays/actors/ovl_Bg_Kin2_Picture/z_bg_kin2_picture.c b/src/overlays/actors/ovl_Bg_Kin2_Picture/z_bg_kin2_picture.c index 2f50ca820..39c72a108 100644 --- a/src/overlays/actors/ovl_Bg_Kin2_Picture/z_bg_kin2_picture.c +++ b/src/overlays/actors/ovl_Bg_Kin2_Picture/z_bg_kin2_picture.c @@ -5,6 +5,7 @@ */ #include "z_bg_kin2_picture.h" +#include "assets/objects/object_kin2_obj/object_kin2_obj.h" #define FLAGS 0x00000000 @@ -15,13 +16,17 @@ void BgKin2Picture_Destroy(Actor* thisx, PlayState* play); void BgKin2Picture_Update(Actor* thisx, PlayState* play); void BgKin2Picture_Draw(Actor* thisx, PlayState* play); -void func_80B6F4D4(BgKin2Picture* this, PlayState* play); -void func_80B6F5B8(BgKin2Picture* this, PlayState* play); -void func_80B6F640(BgKin2Picture* this, PlayState* play); -void func_80B6F72C(BgKin2Picture* this, PlayState* play); -void func_80B6F90C(BgKin2Picture* this, PlayState* play); +void BgKin2Picture_SetupWait(BgKin2Picture* this); +void BgKin2Picture_Wait(BgKin2Picture* this, PlayState* play); +void BgKin2Picture_SetupPlayCutscene(BgKin2Picture* this); +void BgKin2Picture_PlayCutscene(BgKin2Picture* this, PlayState* play); +void BgKin2Picture_SetupShiver(BgKin2Picture* this); +void BgKin2Picture_Shiver(BgKin2Picture* this, PlayState* play); +void BgKin2Picture_SetupFall(BgKin2Picture* this); +void BgKin2Picture_Fall(BgKin2Picture* this, PlayState* play); +void BgKin2Picture_SetupDoNothing(BgKin2Picture* this); +void BgKin2Picture_DoNothing(BgKin2Picture* this, PlayState* play); -#if 0 const ActorInit Bg_Kin2_Picture_InitVars = { ACTOR_BG_KIN2_PICTURE, ACTORCAT_PROP, @@ -34,73 +39,307 @@ const ActorInit Bg_Kin2_Picture_InitVars = { (ActorFunc)BgKin2Picture_Draw, }; -// static ColliderTrisElementInit sTrisElementsInit[2] = { -static ColliderTrisElementInit D_80B6F990[2] = { +static ColliderTrisElementInit sTrisElementsInit[] = { { - { ELEMTYPE_UNK4, { 0x00000000, 0x00, 0x00 }, { 0x000138B0, 0x00, 0x00 }, TOUCH_NONE | TOUCH_SFX_NORMAL, BUMP_ON, OCELEM_NONE, }, - { { { -20.0f, 53.29999923706055f, 9.0f }, { -20.0f, 3.0f, 9.0f }, { 20.0f, 3.0f, 9.0f } } }, + { + ELEMTYPE_UNK4, + { 0x00000000, 0x00, 0x00 }, + { 0x000138B0, 0x00, 0x00 }, + TOUCH_NONE | TOUCH_SFX_NORMAL, + BUMP_ON, + OCELEM_NONE, + }, + { { { -20.0f, 53.3f, 9.0f }, { -20.0f, 3.0f, 9.0f }, { 20.0f, 3.0f, 9.0f } } }, }, { - { ELEMTYPE_UNK4, { 0x00000000, 0x00, 0x00 }, { 0x000138B0, 0x00, 0x00 }, TOUCH_NONE | TOUCH_SFX_NORMAL, BUMP_ON, OCELEM_NONE, }, - { { { -20.0f, 53.29999923706055f, 9.0f }, { 20.0f, 3.0f, 9.0f }, { 20.0f, 53.29999923706055f, 9.0f } } }, + { + ELEMTYPE_UNK4, + { 0x00000000, 0x00, 0x00 }, + { 0x000138B0, 0x00, 0x00 }, + TOUCH_NONE | TOUCH_SFX_NORMAL, + BUMP_ON, + OCELEM_NONE, + }, + { { { -20.0f, 53.3f, 9.0f }, { 20.0f, 3.0f, 9.0f }, { 20.0f, 53.3f, 9.0f } } }, }, }; -// static ColliderTrisInit sTrisInit = { -static ColliderTrisInit D_80B6FA08 = { - { COLTYPE_NONE, AT_NONE, AC_ON | AC_TYPE_PLAYER, OC1_NONE, OC2_NONE, COLSHAPE_TRIS, }, - ARRAY_COUNT(sTrisElementsInit), D_80B6F990, // sTrisElementsInit, +static ColliderTrisInit sTrisInit = { + { + COLTYPE_NONE, + AT_NONE, + AC_ON | AC_TYPE_PLAYER, + OC1_NONE, + OC2_NONE, + COLSHAPE_TRIS, + }, + ARRAY_COUNT(sTrisElementsInit), + sTrisElementsInit, }; -// static InitChainEntry sInitChain[] = { -static InitChainEntry D_80B6FA24[] = { - ICHAIN_F32_DIV1000(gravity, -2000, ICHAIN_CONTINUE), - ICHAIN_F32_DIV1000(terminalVelocity, -20000, ICHAIN_CONTINUE), - ICHAIN_F32(uncullZoneForward, 4000, ICHAIN_CONTINUE), - ICHAIN_F32(uncullZoneScale, 100, ICHAIN_CONTINUE), - ICHAIN_F32(uncullZoneDownward, 100, ICHAIN_CONTINUE), - ICHAIN_VEC3F_DIV1000(scale, 100, ICHAIN_STOP), +static Vec3f sDustBasePos = { 0.0f, 23.0f, 0.0f }; + +static InitChainEntry sInitChain[] = { + ICHAIN_F32_DIV1000(gravity, -2000, ICHAIN_CONTINUE), ICHAIN_F32_DIV1000(terminalVelocity, -20000, ICHAIN_CONTINUE), + ICHAIN_F32(uncullZoneForward, 4000, ICHAIN_CONTINUE), ICHAIN_F32(uncullZoneScale, 100, ICHAIN_CONTINUE), + ICHAIN_F32(uncullZoneDownward, 100, ICHAIN_CONTINUE), ICHAIN_VEC3F_DIV1000(scale, 100, ICHAIN_STOP), }; -#endif +s32 BgKin2Picture_IsSkulltulaCollected(PlayState* play, s32 skulltulaParams) { + s32 flag = -1; -extern ColliderTrisElementInit D_80B6F990[2]; -extern ColliderTrisInit D_80B6FA08; -extern InitChainEntry D_80B6FA24[]; + if ((u8)skulltulaParams & 3) { + flag = BG_KIN2_PICTURE_GET_3FC(skulltulaParams); + } -extern UNK_TYPE D_06000658; -extern UNK_TYPE D_06000798; + return (flag >= 0) && Flags_GetTreasure(play, flag); +} -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Bg_Kin2_Picture/func_80B6EFA0.s") +void BgKin2Picture_SpawnSkulltula(BgKin2Picture* this, PlayState* play2) { + PlayState* play = play2; + s32 skulltulaSpawnParams; -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Bg_Kin2_Picture/func_80B6EFEC.s") + if (!BG_KIN2_PICTURE_SKULLTULA_COLLECTED(&this->dyna.actor)) { // Gold Skulltula is still here. + skulltulaSpawnParams = BG_KIN2_PICTURE_SKULLTULA_SPAWN_PARAM(&this->dyna.actor); + if (!BgKin2Picture_IsSkulltulaCollected(play, skulltulaSpawnParams) && + Actor_Spawn(&play->actorCtx, play, ACTOR_EN_SW, this->dyna.actor.home.pos.x, + this->dyna.actor.home.pos.y + 23.0f, this->dyna.actor.home.pos.z, 0, + this->dyna.actor.home.rot.y, 0, skulltulaSpawnParams)) { + play_sound(NA_SE_SY_TRE_BOX_APPEAR); + } + } +} -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Bg_Kin2_Picture/func_80B6F098.s") +#define DUST_COUNT 20 -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Bg_Kin2_Picture/BgKin2Picture_Init.s") +void BgKin2Picture_SpawnDust(BgKin2Picture* this, PlayState* play) { + f32 offset; + Vec3f basePos; + Vec3f pos; + Vec3f velocity; + Vec3f accel; + s32 angle; + s32 scale; + s16 scaleStep; + s32 baseAngle; + s32 i; -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Bg_Kin2_Picture/BgKin2Picture_Destroy.s") + Matrix_SetTranslateRotateYXZ(this->dyna.actor.world.pos.x, + this->dyna.actor.world.pos.y + + (this->dyna.actor.shape.yOffset * this->dyna.actor.scale.y), + this->dyna.actor.world.pos.z, &this->dyna.actor.shape.rot); + Matrix_MultVec3f(&sDustBasePos, &basePos); + pos.y = basePos.y - 7.0f; + velocity.y = 0.0f; + accel.y = 0.2f; -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Bg_Kin2_Picture/func_80B6F4C0.s") + for (i = 0, baseAngle = 0; i < DUST_COUNT; i++, baseAngle += (0x10000 / DUST_COUNT)) { + angle = (s32)(Rand_ZeroOne() * (0x10000 / DUST_COUNT)) + baseAngle; + offset = (Rand_ZeroOne() * 14.0f) + 4.0f; + pos.x = Math_SinS(angle) * offset; + pos.z = Math_CosS(angle) * offset; + velocity.x = (Rand_ZeroOne() - 0.5f) + (pos.x * (1.0f / 6.0f)); + velocity.z = (Rand_ZeroOne() - 0.5f) + (pos.z * (1.0f / 6.0f)); + pos.x += basePos.x; + pos.z += basePos.z; + accel.x = velocity.x * -0.09f; + accel.z = velocity.z * -0.09f; + scale = (s32)(Rand_ZeroOne() * 10.0f) + 10; + scaleStep = (s32)(Rand_ZeroOne() * 10.0f) + 15; + func_800B1210(play, &pos, &velocity, &accel, scale, scaleStep); + } +} -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Bg_Kin2_Picture/func_80B6F4D4.s") +void BgKin2Picture_Init(Actor* thisx, PlayState* play) { + s32 pad; + BgKin2Picture* this = THIS; + s32 skulltulaParams; + Vec3f vertices[3]; + s32 i; + s32 j; + ColliderTrisElementInit* element; -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Bg_Kin2_Picture/func_80B6F5A4.s") + Actor_ProcessInitChain(&this->dyna.actor, sInitChain); + DynaPolyActor_Init(&this->dyna, 0); + DynaPolyActor_LoadMesh(play, &this->dyna, &gOceanSpiderHouseSkullkidPaintingCol); + func_800C62BC(play, &play->colCtx.dyna, this->dyna.bgId); + Collider_InitTris(play, &this->colliderTris); + Collider_SetTris(play, &this->colliderTris, &this->dyna.actor, &sTrisInit, this->colliderElement); + Matrix_SetTranslateRotateYXZ(this->dyna.actor.world.pos.x, this->dyna.actor.world.pos.y, + this->dyna.actor.world.pos.z, &this->dyna.actor.shape.rot); -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Bg_Kin2_Picture/func_80B6F5B8.s") + for (i = 0; i < ARRAY_COUNT(sTrisElementsInit); i++) { + for (j = 0; j < ARRAY_COUNT(vertices); j++) { + element = &sTrisInit.elements[i]; + Matrix_MultVec3f(&element->dim.vtx[j], &vertices[j]); + } + Collider_SetTrisVertices(&this->colliderTris, i, &vertices[0], &vertices[1], &vertices[2]); + } -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Bg_Kin2_Picture/func_80B6F61C.s") + Actor_SetFocus(&this->dyna.actor, 23.0f); + skulltulaParams = BG_KIN2_PICTURE_SKULLTULA_SPAWN_PARAM(&this->dyna.actor); -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Bg_Kin2_Picture/func_80B6F640.s") + if (BG_KIN2_PICTURE_SKULLTULA_COLLECTED(&this->dyna.actor) || + BgKin2Picture_IsSkulltulaCollected(play, skulltulaParams)) { + this->skulltulaNoiseTimer = -1; + } -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Bg_Kin2_Picture/func_80B6F708.s") + BgKin2Picture_SetupWait(this); +} -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Bg_Kin2_Picture/func_80B6F72C.s") +void BgKin2Picture_Destroy(Actor* thisx, PlayState* play) { + BgKin2Picture* this = THIS; -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Bg_Kin2_Picture/func_80B6F8F8.s") + DynaPoly_DeleteBgActor(play, &play->colCtx.dyna, this->dyna.bgId); + Collider_DestroyTris(play, &this->colliderTris); +} -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Bg_Kin2_Picture/func_80B6F90C.s") +void BgKin2Picture_SetupWait(BgKin2Picture* this) { + this->actionFunc = BgKin2Picture_Wait; +} -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Bg_Kin2_Picture/BgKin2Picture_Update.s") +void BgKin2Picture_Wait(BgKin2Picture* this, PlayState* play) { + // hit by projectile + if (this->colliderTris.base.acFlags & AC_HIT) { + this->colliderTris.base.acFlags &= ~AC_HIT; + ActorCutscene_SetIntentToPlay(this->dyna.actor.cutscene); + BgKin2Picture_SetupPlayCutscene(this); + } else { // Gold Skulltula can be heard behind Skullkid's painting. + if (this->skulltulaNoiseTimer >= 0) { + if (this->skulltulaNoiseTimer == 0) { + Actor_PlaySfxAtPos(&this->dyna.actor, NA_SE_EN_STALGOLD_ROLL); -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Bg_Kin2_Picture/BgKin2Picture_Draw.s") + if (Rand_ZeroOne() < 0.1f) { + this->skulltulaNoiseTimer = Rand_S16Offset(40, 80); + } else { + this->skulltulaNoiseTimer = 8; + } + } else { + this->skulltulaNoiseTimer--; + } + } + CollisionCheck_SetAC(play, &play->colChkCtx, &this->colliderTris.base); + } +} + +void BgKin2Picture_SetupPlayCutscene(BgKin2Picture* this) { + this->actionFunc = BgKin2Picture_PlayCutscene; +} + +void BgKin2Picture_PlayCutscene(BgKin2Picture* this, PlayState* play) { + if (ActorCutscene_GetCanPlayNext(this->dyna.actor.cutscene)) { + ActorCutscene_StartAndSetUnkLinkFields(this->dyna.actor.cutscene, &this->dyna.actor); + this->cutsceneStarted = true; + BgKin2Picture_SetupShiver(this); + } else { + ActorCutscene_SetIntentToPlay(this->dyna.actor.cutscene); + } +} + +void BgKin2Picture_SetupShiver(BgKin2Picture* this) { + this->paintingTimer = 13; + this->xOffsetAngle = 0; + this->yOffsetAngle = 0; + this->actionFunc = BgKin2Picture_Shiver; +} + +void BgKin2Picture_Shiver(BgKin2Picture* this, PlayState* play) { + s32 pad; + Vec3f basePosOffset; + Vec3f posOffset; + + this->paintingTimer--; + if (this->paintingTimer <= 0) { + Math_Vec3f_Copy(&this->dyna.actor.world.pos, &this->dyna.actor.home.pos); + BgKin2Picture_SetupFall(this); + } else { + this->xOffsetAngle += 0x7BAC; + this->yOffsetAngle += 0x4E20; + basePosOffset.x = Math_CosS(this->xOffsetAngle); + basePosOffset.y = Math_CosS(this->yOffsetAngle) * 0.2f; + basePosOffset.z = 0.0f; + Matrix_RotateYS(this->dyna.actor.shape.rot.y, MTXMODE_NEW); + Matrix_MultVec3f(&basePosOffset, &posOffset); + Math_Vec3f_Sum(&this->dyna.actor.home.pos, &posOffset, &this->dyna.actor.world.pos); + } +} + +void BgKin2Picture_SetupFall(BgKin2Picture* this) { + this->landTimer = 0; + this->step = 0; + this->paintingTimer = 4; + this->actionFunc = BgKin2Picture_Fall; +} + +void BgKin2Picture_Fall(BgKin2Picture* this, PlayState* play) { + if (this->paintingTimer > 0) { + this->paintingTimer--; + + if (this->paintingTimer == 0) { + BgKin2Picture_SpawnSkulltula(this, play); + } + } + + Actor_MoveWithGravity(&this->dyna.actor); + Actor_UpdateBgCheckInfo(play, &this->dyna.actor, 0.0f, 0.0f, 0.0f, 4); + + if (this->dyna.actor.bgCheckFlags & 1) { + Math_StepToS(&this->step, 0x7D0, 0x78); + + if (this->landTimer < 3) { + this->landTimer++; + + if (this->dyna.actor.velocity.y <= 0.01f) { + this->dyna.actor.velocity.y *= -0.7f; + + if (this->dyna.actor.velocity.y > 6.0f) { + this->dyna.actor.velocity.y = 6.0f; + } + + if (this->landTimer < 3) { + Actor_PlaySfxAtPos(&this->dyna.actor, NA_SE_EV_SMALL_WOODPLATE_BOUND_0); + } + } + } + } + + Actor_SetFocus(&this->dyna.actor, 23.0f); + + if (!this->hasSpawnedDust && (this->dyna.actor.shape.rot.x > 0x3300)) { + BgKin2Picture_SpawnDust(this, play); + this->hasSpawnedDust = true; + } + + if (Math_ScaledStepToS(&this->dyna.actor.shape.rot.x, 0x4000, this->step)) { // facing the floor + this->dyna.actor.shape.yOffset = 40.0f; + + if (this->cutsceneStarted) { + ActorCutscene_Stop(this->dyna.actor.cutscene); + } + + func_800C6314(play, &play->colCtx.dyna, this->dyna.bgId); + Actor_PlaySfxAtPos(&this->dyna.actor, NA_SE_EV_WOODPLATE_BROKEN); + BgKin2Picture_SetupDoNothing(this); + } else { + this->dyna.actor.shape.yOffset = Math_SinS(this->dyna.actor.shape.rot.x) * 40.0f; + } +} + +void BgKin2Picture_SetupDoNothing(BgKin2Picture* this) { + this->actionFunc = BgKin2Picture_DoNothing; +} + +void BgKin2Picture_DoNothing(BgKin2Picture* this, PlayState* play) { +} + +void BgKin2Picture_Update(Actor* thisx, PlayState* play) { + BgKin2Picture* this = THIS; + + this->actionFunc(this, play); +} + +void BgKin2Picture_Draw(Actor* thisx, PlayState* play) { + BgKin2Picture* this = THIS; + + Gfx_DrawDListOpa(play, gOceanSpiderHouseSkullkidPaintingDL); +} diff --git a/src/overlays/actors/ovl_Bg_Kin2_Picture/z_bg_kin2_picture.h b/src/overlays/actors/ovl_Bg_Kin2_Picture/z_bg_kin2_picture.h index 19651ef57..ce7cf95fb 100644 --- a/src/overlays/actors/ovl_Bg_Kin2_Picture/z_bg_kin2_picture.h +++ b/src/overlays/actors/ovl_Bg_Kin2_Picture/z_bg_kin2_picture.h @@ -3,17 +3,27 @@ #include "global.h" +#define BG_KIN2_PICTURE_SKULLTULA_COLLECTED(thisx) (((thisx)->params >> 5) & 1) +#define BG_KIN2_PICTURE_GET_3FC(thisx) ((u8)(((thisx & 0x3FC)) >> 2)) +#define BG_KIN2_PICTURE_SKULLTULA_SPAWN_PARAM(thisx) ((((thisx)->params & 0x1F) << 2) | 0xFF03) + struct BgKin2Picture; typedef void (*BgKin2PictureActionFunc)(struct BgKin2Picture*, PlayState*); typedef struct BgKin2Picture { - /* 0x000 */ Actor actor; - /* 0x144 */ char unk_144[0xF0]; + /* 0x000 */ DynaPolyActor dyna; + /* 0x15C */ ColliderTris colliderTris; + /* 0x17C */ ColliderTrisElement colliderElement[2]; /* 0x234 */ BgKin2PictureActionFunc actionFunc; - /* 0x238 */ char unk_238[0xC]; + /* 0x238 */ s16 step; + /* 0x23A */ s8 paintingTimer; // Used for when painting is shaking and for timing Gold Skulltula spawn. + /* 0x23B */ s8 landTimer; + /* 0x23C */ s16 xOffsetAngle; + /* 0x23E */ s16 yOffsetAngle; + /* 0x240 */ s8 cutsceneStarted; + /* 0x241 */ s8 hasSpawnedDust; + /* 0x242 */ s8 skulltulaNoiseTimer; } BgKin2Picture; // size = 0x244 -extern const ActorInit Bg_Kin2_Picture_InitVars; - #endif // Z_BG_KIN2_PICTURE_H diff --git a/src/overlays/actors/ovl_Bg_Umajump/z_bg_umajump.c b/src/overlays/actors/ovl_Bg_Umajump/z_bg_umajump.c index 894ced552..2a584bb31 100644 --- a/src/overlays/actors/ovl_Bg_Umajump/z_bg_umajump.c +++ b/src/overlays/actors/ovl_Bg_Umajump/z_bg_umajump.c @@ -5,6 +5,7 @@ */ #include "z_bg_umajump.h" +#include "assets/objects/object_umajump/object_umajump.h" #define FLAGS 0x00000000 @@ -13,8 +14,10 @@ void BgUmajump_Init(Actor* thisx, PlayState* play); void BgUmajump_Destroy(Actor* thisx, PlayState* play); void BgUmajump_Update(Actor* thisx, PlayState* play); +void BgUmajump_Draw(Actor* thisx, PlayState* play); + +void func_8091A5A0(Actor* thisx, PlayState* play); -#if 0 const ActorInit Bg_Umajump_InitVars = { ACTOR_BG_UMAJUMP, ACTORCAT_PROP, @@ -27,34 +30,190 @@ const ActorInit Bg_Umajump_InitVars = { (ActorFunc)NULL, }; -// static InitChainEntry sInitChain[] = { -static InitChainEntry D_8091A810[] = { +static InitChainEntry sInitChain[] = { ICHAIN_F32(uncullZoneScale, 1200, ICHAIN_CONTINUE), ICHAIN_F32(uncullZoneDownward, 300, ICHAIN_CONTINUE), ICHAIN_VEC3F_DIV1000(scale, 100, ICHAIN_STOP), }; -#endif +void func_80919F30(BgUmajump* this, PlayState* play) { + if (this->rotationTimer >= 90) { + this->rotationTimer = 0; + } -extern InitChainEntry D_8091A810[]; + this->rotationTimer++; + this->dyna.actor.shape.yOffset = + Math_SinS((this->rotationTimer / 90.0f) * 0x10000) * (20.0f / this->dyna.actor.scale.y); +} -extern UNK_TYPE D_06001220; -extern UNK_TYPE D_06001558; +void BgUmajump_StopCutscene(BgUmajump* this, PlayState* play) { + if ((play->csCtx.frames >= 6) && !this->hasSoundPlayed) { + this->hasSoundPlayed = true; + play_sound(NA_SE_EV_KID_HORSE_NEIGH); + } -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Bg_Umajump/func_80919F30.s") + if (play->csCtx.state == CS_STATE_0) { + ActorCutscene_Stop(this->dyna.actor.cutscene); + this->dyna.actor.update = Actor_Noop; + } +} -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Bg_Umajump/func_80919FC8.s") +void BgUmajump_PlayCutscene(BgUmajump* this, PlayState* play) { + if (ActorCutscene_GetCanPlayNext(this->dyna.actor.cutscene)) { + ActorCutscene_StartAndSetUnkLinkFields(this->dyna.actor.cutscene, &this->dyna.actor); + gSaveContext.save.weekEventReg[89] |= 0x20; + this->actionFunc = BgUmajump_StopCutscene; + } else { + ActorCutscene_SetIntentToPlay(this->dyna.actor.cutscene); + } +} -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Bg_Umajump/func_8091A044.s") +void BgUmajump_CheckDistance(BgUmajump* this, PlayState* play) { + Player* player = GET_PLAYER(play); -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Bg_Umajump/func_8091A0B8.s") + if ((this->horse != NULL) && (player != NULL) && + (Math3D_XZDistance(this->horse->world.pos.x, this->horse->world.pos.z, player->actor.world.pos.x, + player->actor.world.pos.z) < 1400.0f)) { + this->actionFunc = BgUmajump_PlayCutscene; + } +} -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Bg_Umajump/BgUmajump_Init.s") +void BgUmajump_Init(Actor* thisx, PlayState* play) { + BgUmajump* this = THIS; -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Bg_Umajump/BgUmajump_Destroy.s") + Actor_ProcessInitChain(thisx, sInitChain); -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Bg_Umajump/BgUmajump_Update.s") + this->actionFunc = NULL; + this->horse = NULL; + this->hasSoundPlayed = false; -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Bg_Umajump/func_8091A5A0.s") + DynaPolyActor_Init(&this->dyna, 0); -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Bg_Umajump/func_8091A7B0.s") + this->objectIndex = BG_UMAJUMP_GET_OBJECT_INDEX(thisx); + thisx->params = BG_UMAJUMP_GET_FF(thisx); + + if ((thisx->params == BG_UMAJUMP_TYPE_2)) { + if ((((play->sceneId == SCENE_F01) && !(gSaveContext.save.weekEventReg[89] & 0x20)) && + !CHECK_QUEST_ITEM(QUEST_SONG_EPONA)) && + (thisx->cutscene != -1)) { + this->actionFunc = BgUmajump_CheckDistance; + thisx->update = func_8091A5A0; + thisx->flags |= ACTOR_FLAG_10; + this->horse = SubS_FindActor(play, this->horse, ACTORCAT_BG, ACTOR_EN_HORSE); + } else { + thisx->update = Actor_Noop; + } + } else { + this->objectIndex = Object_GetIndex(&play->objectCtx, OBJECT_UMAJUMP); + + if (this->objectIndex < 0) { + Actor_MarkForDeath(thisx); + } + + if ((thisx->params == BG_UMAJUMP_TYPE_3) && CHECK_QUEST_ITEM(QUEST_SONG_EPONA)) { + Actor_Spawn(&play->actorCtx, play, ACTOR_EN_KANBAN, thisx->world.pos.x, thisx->world.pos.y, + thisx->world.pos.z, thisx->shape.rot.x, thisx->shape.rot.y, thisx->shape.rot.z, 0x3E); + Actor_MarkForDeath(thisx); + } + } +} + +void BgUmajump_Destroy(Actor* thisx, PlayState* play) { + BgUmajump* this = THIS; + + DynaPoly_DeleteBgActor(play, &play->colCtx.dyna, this->dyna.bgId); +} + +void BgUmajump_Update(Actor* thisx, PlayState* play) { + BgUmajump* this = THIS; + + if (Object_IsLoaded(&play->objectCtx, this->objectIndex)) { + this->dyna.actor.objBankIndex = this->objectIndex; + this->dyna.actor.draw = BgUmajump_Draw; + + Actor_SetObjectDependency(play, &this->dyna.actor); + + if (this->dyna.actor.params == BG_UMAJUMP_TYPE_5) { + if (gSaveContext.save.weekEventReg[22] & 1) { + DynaPolyActor_LoadMesh(play, &this->dyna, &object_umajump_Colheader_001558); + } + } else if (this->dyna.actor.params == BG_UMAJUMP_TYPE_6) { + if (!(gSaveContext.save.weekEventReg[22] & 1)) { + DynaPolyActor_LoadMesh(play, &this->dyna, &object_umajump_Colheader_001558); + } + } else if ((this->dyna.actor.params == BG_UMAJUMP_TYPE_4) || (this->dyna.actor.params == BG_UMAJUMP_TYPE_3)) { + DynaPolyActor_LoadMesh(play, &this->dyna, &object_umajump_Colheader_001558); + } else { + DynaPolyActor_LoadMesh(play, &this->dyna, &object_umajump_Colheader_001438); + } + + if (this->dyna.actor.params == BG_UMAJUMP_TYPE_1) { + this->rotationTimer = 0; + this->actionFunc = func_80919F30; + this->dyna.actor.update = func_8091A5A0; + } else if (this->dyna.actor.params == BG_UMAJUMP_TYPE_3) { + this->dyna.actor.update = func_8091A5A0; + } else if ((this->dyna.actor.params == BG_UMAJUMP_TYPE_5) || (this->dyna.actor.params == BG_UMAJUMP_TYPE_6)) { + if (this->dyna.actor.params == BG_UMAJUMP_TYPE_5) { + if ((this->dyna.bgId == BGACTOR_NEG_ONE) && (gSaveContext.save.weekEventReg[22] & 1)) { + DynaPolyActor_LoadMesh(play, &this->dyna, &object_umajump_Colheader_001558); + } + } else if ((this->dyna.actor.params == BG_UMAJUMP_TYPE_6) && (this->dyna.bgId == BGACTOR_NEG_ONE) && + (!(gSaveContext.save.weekEventReg[22] & 1) || + ((gSaveContext.save.day == 2) && (gSaveContext.save.isNight == true) && + ((gSaveContext.save.time >= CLOCK_TIME(5, 30)) && + (gSaveContext.save.time <= CLOCK_TIME(6, 0)))))) { + DynaPolyActor_LoadMesh(play, &this->dyna, &object_umajump_Colheader_001558); + } + func_800C641C(play, &play->colCtx.dyna, this->dyna.bgId); + this->dyna.actor.update = func_8091A5A0; + } else if (this->dyna.actor.params == BG_UMAJUMP_TYPE_4) { + func_800C641C(play, &play->colCtx.dyna, this->dyna.bgId); + this->dyna.actor.update = Actor_Noop; + } else { + this->dyna.actor.update = Actor_Noop; + } + } +} + +void func_8091A5A0(Actor* thisx, PlayState* play) { + BgUmajump* this = THIS; + + if (this->actionFunc != NULL) { + this->actionFunc(this, play); + } + + if ((this->dyna.actor.params == BG_UMAJUMP_TYPE_3) && CHECK_QUEST_ITEM(QUEST_SONG_EPONA)) { + Actor_Spawn(&play->actorCtx, play, ACTOR_EN_KANBAN, this->dyna.actor.world.pos.x, this->dyna.actor.world.pos.y, + this->dyna.actor.world.pos.z, this->dyna.actor.shape.rot.x, this->dyna.actor.shape.rot.y, + this->dyna.actor.shape.rot.z, 0x3E); + Actor_MarkForDeath(&this->dyna.actor); + } + + if (this->dyna.actor.params == BG_UMAJUMP_TYPE_5) { + if ((this->dyna.bgId == BGACTOR_NEG_ONE) && (gSaveContext.save.weekEventReg[22] & 1)) { + DynaPolyActor_LoadMesh(play, &this->dyna, &object_umajump_Colheader_001558); + } else if ((this->dyna.bgId != BGACTOR_NEG_ONE) && !(gSaveContext.save.weekEventReg[22] & 1)) { + DynaPoly_DeleteBgActor(play, &play->colCtx.dyna, this->dyna.bgId); + } + } else if (this->dyna.actor.params == BG_UMAJUMP_TYPE_6) { + if ((this->dyna.bgId == BGACTOR_NEG_ONE) && + (!(gSaveContext.save.weekEventReg[22] & 1) || + ((gSaveContext.save.day == 2) && (gSaveContext.save.isNight == true) && + (gSaveContext.save.time >= CLOCK_TIME(5, 30)) && (gSaveContext.save.time <= CLOCK_TIME(6, 0))))) { + DynaPolyActor_LoadMesh(play, &this->dyna, &object_umajump_Colheader_001558); + } else if ((this->dyna.bgId != BGACTOR_NEG_ONE) && (gSaveContext.save.weekEventReg[22] & 1) && + ((gSaveContext.save.day != 2) || (gSaveContext.save.isNight != true) || + (gSaveContext.save.time < CLOCK_TIME(5, 30)) || (gSaveContext.save.time > CLOCK_TIME(6, 0)))) { + DynaPoly_DeleteBgActor(play, &play->colCtx.dyna, this->dyna.bgId); + } + } +} + +void BgUmajump_Draw(Actor* thisx, PlayState* play) { + BgUmajump* this = THIS; + + if (this->dyna.bgId != BGACTOR_NEG_ONE) { + Gfx_DrawDListOpa(play, gHorseJumpFenceDL); + } +} diff --git a/src/overlays/actors/ovl_Bg_Umajump/z_bg_umajump.h b/src/overlays/actors/ovl_Bg_Umajump/z_bg_umajump.h index 22fe9ca44..733bf77da 100644 --- a/src/overlays/actors/ovl_Bg_Umajump/z_bg_umajump.h +++ b/src/overlays/actors/ovl_Bg_Umajump/z_bg_umajump.h @@ -3,11 +3,31 @@ #include "global.h" +#define BG_UMAJUMP_GET_OBJECT_INDEX(thisx) (((thisx)->params >> 8) & 0xFF) +#define BG_UMAJUMP_GET_FF(thisx) ((thisx)->params & 0xFF) + +typedef enum { + BG_UMAJUMP_TYPE_1 = 1, + BG_UMAJUMP_TYPE_2, + BG_UMAJUMP_TYPE_3, + BG_UMAJUMP_TYPE_4, + BG_UMAJUMP_TYPE_5, + BG_UMAJUMP_TYPE_6, +} BgUmaJumpType; + struct BgUmajump; +typedef void (*BgUmajumpActionFunc)(struct BgUmajump*, PlayState*); + typedef struct BgUmajump { - /* 0x000 */ Actor actor; - /* 0x144 */ char unk_144[0x28]; + /* 0x000 */ DynaPolyActor dyna; + /* 0x15C */ BgUmajumpActionFunc actionFunc; + /* 0x160 */ union { + s32 objectIndex; + s32 rotationTimer; // y rotation + }; + /* 0x164 */ s32 hasSoundPlayed; + /* 0x168 */ Actor* horse; } BgUmajump; // size = 0x16C extern const ActorInit Bg_Umajump_InitVars; diff --git a/src/overlays/actors/ovl_Dm_Char08/z_dm_char08.c b/src/overlays/actors/ovl_Dm_Char08/z_dm_char08.c index ed8625795..94d15be60 100644 --- a/src/overlays/actors/ovl_Dm_Char08/z_dm_char08.c +++ b/src/overlays/actors/ovl_Dm_Char08/z_dm_char08.c @@ -5,17 +5,52 @@ */ #include "z_dm_char08.h" +#include "objects/object_kamejima/object_kamejima.h" #define FLAGS (ACTOR_FLAG_2000000) #define THIS ((DmChar08*)thisx) -void DmChar08_Init(Actor* thisx, PlayState* play); +void DmChar08_Init(Actor* thisx, PlayState* play2); void DmChar08_Destroy(Actor* thisx, PlayState* play); void DmChar08_Update(Actor* thisx, PlayState* play); void DmChar08_Draw(Actor* thisx, PlayState* play); -#if 0 +void func_80AAFAC4(DmChar08* this, PlayState* play); +void DmChar08_WaitForSong(DmChar08* this, PlayState* play); +void func_80AAF8F4(DmChar08* this, PlayState* play); +void func_80AAFAE4(DmChar08* this, PlayState* play); +void DmChar08_DoNothing(DmChar08* this, PlayState* play); +void func_80AAFA18(DmChar08* this, PlayState* play); +void DmChar08_SetupAppearCs(DmChar08* this, PlayState* play); +void func_80AAF884(DmChar08* this, PlayState* play); +void func_80AAFB04(DmChar08* this, PlayState* play); +void func_80AAFB94(DmChar08* this, PlayState* play); +void func_80AAFE88(DmChar08* this, PlayState* play); +void func_80AB023C(DmChar08* this, PlayState* play); +void func_80AB01E8(DmChar08* this, PlayState* play); +void DmChar08_SpawnBubbles(DmChar08* this, PlayState* play); +void func_80AAFCCC(DmChar08* this, PlayState* play); + +typedef enum { + /* 0 */ TURTLE_EYEMODE_BLINK_LEFT, + /* 1 */ TURTLE_EYEMODE_BLINK_STRAIGHT, + /* 2 */ TURTLE_EYEMODE_CLOSED, + /* 3 */ TURTLE_EYEMODE_LOOK_STRAIGHT, + /* 4 */ TURTLE_EYEMODE_UNUSED, + /* 5 */ TURTLE_EYEMODE_LOOK_RIGHT, +} EyeMode; + +typedef enum { + /* 0 */ TURTLE_ANIM_IDLE, + /* 1 */ TURTLE_ANIM_SWIM, + /* 2 */ TURTLE_ANIM_FLOAT, + /* 3 */ TURTLE_ANIM_SPEAK1, + /* 4 */ TURTLE_ANIM_COUGH, + /* 5 */ TURTLE_ANIM_SPEAK2, + /* 6 */ TURTLE_ANIM_YAWN, +} TurtleAnimation; + const ActorInit Dm_Char08_InitVars = { ACTOR_DM_CHAR08, ACTORCAT_BG, @@ -28,71 +63,1061 @@ const ActorInit Dm_Char08_InitVars = { (ActorFunc)DmChar08_Draw, }; -// static InitChainEntry sInitChain[] = { -static InitChainEntry D_80AB1764[] = { +#include "overlays/ovl_Dm_Char08/ovl_Dm_Char08.c" + +static AnimationInfo sAnimationInfo[] = { + { &gTurtleIdleAnim, 1.0f, 0.0f, -1.0f, ANIMMODE_LOOP, -24.0f }, + { &gTurtleSwimAnim, 1.0f, 0.0f, -1.0f, ANIMMODE_LOOP, -24.0f }, + { &gTurtleFloatAnim, 1.0f, 0.0f, -1.0f, ANIMMODE_LOOP, -24.0f }, + { &gTurtleSpeak1Anim, 1.0f, 0.0f, -1.0f, ANIMMODE_LOOP, -24.0f }, + { &gTurtleCoughAnim, 1.0f, 0.0f, -1.0f, ANIMMODE_LOOP, -24.0f }, + { &gTurtleSpeak2Anim, 1.0f, 0.0f, -1.0f, ANIMMODE_LOOP, -24.0f }, + { &gTurtleYawnAnim, 1.0f, 0.0f, -1.0f, ANIMMODE_LOOP, -24.0f }, +}; + +static InitChainEntry sInitChain[] = { ICHAIN_F32(uncullZoneForward, 4000, ICHAIN_CONTINUE), ICHAIN_F32(uncullZoneScale, 4000, ICHAIN_CONTINUE), ICHAIN_F32(uncullZoneDownward, 4000, ICHAIN_STOP), }; -#endif +void DmChar08_UpdateEyes(DmChar08* this) { + switch (this->eyeMode) { + case TURTLE_EYEMODE_BLINK_LEFT: + this->eyeIndex = 0; + if (this->blinkTimer > 0) { + this->blinkTimer--; + } else { + this->blinkTimer = 0; + } + if (this->blinkTimer < 4) { + this->eyeIndex = this->blinkTimer; + } + if (this->blinkTimer == 0) { + this->blinkTimer = Rand_S16Offset(30, 30); + } + break; -extern InitChainEntry D_80AB1764[]; + case TURTLE_EYEMODE_BLINK_STRAIGHT: + this->eyeIndex = 4; + if (this->blinkTimer > 0) { + this->blinkTimer--; + } else { + this->blinkTimer = 0; + } + if (this->blinkTimer < 4) { + this->eyeIndex = this->blinkTimer + 4; + } + if (this->blinkTimer == 0) { + this->blinkTimer = Rand_S16Offset(30, 30); + } + break; -extern UNK_TYPE D_06002470; -extern UNK_TYPE D_06004E70; -extern UNK_TYPE D_0600E748; + case TURTLE_EYEMODE_CLOSED: + this->eyeIndex = 2; + break; -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Dm_Char08/func_80AAF050.s") + case TURTLE_EYEMODE_LOOK_STRAIGHT: + this->eyeIndex = 4; + break; -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Dm_Char08/func_80AAF15C.s") + case TURTLE_EYEMODE_LOOK_RIGHT: + this->eyeIndex = 8; + break; -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Dm_Char08/DmChar08_Init.s") + default: + break; + } +} -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Dm_Char08/DmChar08_Destroy.s") +void DmChar08_ChangeAnim(SkelAnime* skelAnime, AnimationInfo* animationInfo, u16 animIndex) { + f32 endFrame; -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Dm_Char08/func_80AAF610.s") + animationInfo += animIndex; + if (animationInfo->frameCount < 0.0f) { + endFrame = Animation_GetLastFrame(animationInfo->animation); + } else { + endFrame = animationInfo->frameCount; + } + Animation_Change(skelAnime, animationInfo->animation, animationInfo->playSpeed, animationInfo->startFrame, endFrame, + animationInfo->mode, animationInfo->morphFrames); +} -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Dm_Char08/func_80AAF79C.s") +void DmChar08_Init(Actor* thisx, PlayState* play2) { + PlayState* play = play2; + DmChar08* this = THIS; -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Dm_Char08/func_80AAF884.s") + thisx->targetMode = 5; + this->eyeMode = TURTLE_EYEMODE_CLOSED; + thisx->targetArrowOffset = 120.0f; + ActorShape_Init(&thisx->shape, 0.0f, ActorShadow_DrawCircle, 24.0f); + SkelAnime_InitFlex(play, &this->skelAnime, &gTurtleSkel, NULL, NULL, NULL, 0); + Actor_ProcessInitChain(thisx, sInitChain); + Actor_SetScale(thisx, 0.1f); + this->unk_1F4 = 0; + this->bubbleCount = 0; + this->unk_1FF = 0; + this->alpha = 0; + this->animIndex = TURTLE_ANIM_IDLE; + this->unk_1FC = 0xFFFF; + this->dynapolyInitialized = false; + this->targetYPos = thisx->world.pos.y; + this->unk_1F0 = 0.0f; + if (play->sceneId == SCENE_31MISAKI) { + if (gSaveContext.save.weekEventReg[53] & 0x20) { + DynaPolyActor_Init(&this->dyna, 3); + DynaPolyActor_LoadMesh(play, &this->dyna, &gTurtleZoraCapeAwakeCol); + } else { + DynaPolyActor_Init(&this->dyna, 3); + DynaPolyActor_LoadMesh(play, &this->dyna, &gTurtleZoraCapeAsleepCol); + } + this->dynapolyInitialized = true; + } else if (play->sceneId == SCENE_SEA) { + DynaPolyActor_Init(&this->dyna, 3); + DynaPolyActor_LoadMesh(play, &this->dyna, &sTurtleGreatBayTempleCol); + this->dynapolyInitialized = true; + } -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Dm_Char08/func_80AAF8F4.s") + this->palmTree1 = Actor_Spawn(&play->actorCtx, play, ACTOR_OBJ_YASI, thisx->world.pos.x + -80.0f, + thisx->world.pos.y + 390.0f, thisx->world.pos.z, 0, 0, 0, 1); + this->palmTree2 = Actor_Spawn(&play->actorCtx, play, ACTOR_OBJ_YASI, thisx->world.pos.x + 68.0f, + thisx->world.pos.y + 368.0f, thisx->world.pos.z - 174.0f, 0, 0x7530, 0, 1); -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Dm_Char08/func_80AAFA18.s") + switch (play->sceneId) { + case SCENE_31MISAKI: + if (gSaveContext.save.weekEventReg[53] & 0x20) { + thisx->world.pos.x = -6480.0f; + this->targetYPos = -120.0f; + thisx->world.pos.z = 1750.0f; + thisx->world.rot.x = 0; + thisx->world.rot.y = -0x7234; + thisx->world.rot.z = 0; + thisx->shape.rot.x = 0; + thisx->shape.rot.y = -0x7234; + thisx->shape.rot.z = 0; + this->unk_1F0 = 1.0f; + this->unk_1FF = 2; + this->animIndex = TURTLE_ANIM_FLOAT; + this->unk_203 = 0x63; + this->eyeMode = TURTLE_EYEMODE_BLINK_STRAIGHT; + this->unk_207 = 0; + this->unk_208 = 0; + thisx->flags |= ACTOR_FLAG_1; + if (gSaveContext.save.entrance == ENTRANCE(ZORA_CAPE, 8)) { + this->eyeMode = TURTLE_EYEMODE_BLINK_LEFT; + this->actionFunc = func_80AAFAC4; + } else { + this->actionFunc = func_80AAF8F4; + } + } else { + this->actionFunc = DmChar08_WaitForSong; + } + break; -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Dm_Char08/func_80AAFAC4.s") + case SCENE_SEA: + this->unk_1FF = 2; + this->animIndex = TURTLE_ANIM_FLOAT; + this->unk_203 = 0x63; + this->eyeMode = TURTLE_EYEMODE_BLINK_LEFT; + this->unk_207 = 0; + this->unk_208 = 0; + thisx->flags |= ACTOR_FLAG_1; + this->actionFunc = func_80AAFAE4; + this->unk_1F0 = 1.0f; + break; -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Dm_Char08/func_80AAFAE4.s") + case SCENE_KONPEKI_ENT: + this->unk_1FF = 2; + this->animIndex = TURTLE_ANIM_FLOAT; + this->unk_203 = 0x63; + this->eyeMode = TURTLE_EYEMODE_BLINK_LEFT; + this->unk_207 = 0; + this->unk_208 = 0; + this->actionFunc = DmChar08_DoNothing; + this->unk_1F0 = 1.0f; + break; + } + DmChar08_ChangeAnim(&this->skelAnime, &sAnimationInfo[this->animIndex], 0); +} -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Dm_Char08/func_80AAFB04.s") +void DmChar08_Destroy(Actor* thisx, PlayState* play) { + DmChar08* this = THIS; -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Dm_Char08/func_80AAFB94.s") + if (this->dynapolyInitialized) { + DynaPoly_DeleteBgActor(play, &play->colCtx.dyna, this->dyna.bgId); + } +} -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Dm_Char08/func_80AAFBA4.s") +static s16 sSuccessSoundAlreadyPlayed = false; -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Dm_Char08/func_80AAFCCC.s") +void DmChar08_WaitForSong(DmChar08* this, PlayState* play) { + Player* player = GET_PLAYER(play); + Player* player2 = GET_PLAYER(play); -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Dm_Char08/func_80AAFE78.s") + if ((player2->stateFlags2 & PLAYER_STATE2_8000000) && + ((player2->actor.world.pos.x > -5780.0f) && (player2->actor.world.pos.x < -5385.0f) && + (player2->actor.world.pos.z > 1120.0f) && (player2->actor.world.pos.z < 2100.0f))) { + if (!sSuccessSoundAlreadyPlayed) { + play_sound(NA_SE_SY_TRE_BOX_APPEAR); + sSuccessSoundAlreadyPlayed = true; + } + } else { + sSuccessSoundAlreadyPlayed = false; + } + if ((player->transformation == PLAYER_FORM_ZORA) && (play->msgCtx.ocarinaMode == 3) && + (play->msgCtx.lastPlayedSong == OCARINA_SONG_NEW_WAVE)) { + if ((player2->actor.world.pos.x > -5780.0f) && (player2->actor.world.pos.x < -5385.0f)) { + if ((player2->actor.world.pos.z > 1120.0f) && (player2->actor.world.pos.z < 2100.0f)) { + this->actionFunc = DmChar08_SetupAppearCs; + } + } + } +} -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Dm_Char08/func_80AAFE88.s") +void DmChar08_SetupAppearCs(DmChar08* this, PlayState* play) { + s16 cs1 = this->dyna.actor.cutscene; + s16 cs = ActorCutscene_GetAdditionalCutscene( + ActorCutscene_GetAdditionalCutscene(ActorCutscene_GetAdditionalCutscene(cs1))); -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Dm_Char08/func_80AB01E8.s") + if (gSaveContext.save.weekEventReg[93] & 8) { + cs1 = cs; + } -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Dm_Char08/func_80AB023C.s") + if (ActorCutscene_GetCanPlayNext(cs1)) { + ActorCutscene_Start(cs1, &this->dyna.actor); + gSaveContext.save.weekEventReg[53] |= 0x20; + gSaveContext.save.weekEventReg[93] |= 8; + DynaPoly_DeleteBgActor(play, &play->colCtx.dyna, this->dyna.bgId); + this->actionFunc = func_80AAF884; + } else { + ActorCutscene_SetIntentToPlay(cs1); + } +} -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Dm_Char08/func_80AB032C.s") +void func_80AAF884(DmChar08* this, PlayState* play) { + if (play->csCtx.state == CS_STATE_0) { + DynaPolyActor_Init(&this->dyna, 3); + DynaPolyActor_LoadMesh(play, &this->dyna, &gTurtleZoraCapeAwakeCol); + this->dyna.actor.flags |= ACTOR_FLAG_1; + this->actionFunc = func_80AAF8F4; + } +} -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Dm_Char08/func_80AB096C.s") +void func_80AAF8F4(DmChar08* this, PlayState* play) { + s32 pad; + f32 yOffset; -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Dm_Char08/func_80AB0A10.s") + if (fabsf(this->dyna.actor.xzDistToPlayer) < 200.0f) { + this->actionFunc = func_80AAFA18; + } + this->unk_1FA += 200; + yOffset = 50.0f; + yOffset *= Math_SinS(this->unk_1FA); + Math_SmoothStepToF(&this->dyna.actor.world.pos.x, -6400.0f, 0.2f, 2.0f, 0.1f); + Math_SmoothStepToF(&this->targetYPos, -180.0f + yOffset, 0.5f, 5.0f, 0.1f); + Math_SmoothStepToF(&this->dyna.actor.world.pos.z, 1750.0f, 0.5f, 20.0f, 0.1f); + Math_SmoothStepToS(&this->dyna.actor.world.rot.y, -0x7234, 0xA, 0xDC, 1); + Math_SmoothStepToS(&this->dyna.actor.shape.rot.y, -0x7234, 0xA, 0xDC, 1); +} -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Dm_Char08/DmChar08_Update.s") +void func_80AAFA18(DmChar08* this, PlayState* play) { + s16 nextCs; + s16 nextCs2; + s16 nextCs1; -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Dm_Char08/func_80AB0E3C.s") + nextCs1 = ActorCutscene_GetAdditionalCutscene(this->dyna.actor.cutscene); + nextCs2 = nextCs1; + nextCs1 = ActorCutscene_GetAdditionalCutscene(nextCs1); -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Dm_Char08/func_80AB0E7C.s") + nextCs = ((void)0, gSaveContext.save.weekEventReg[53] & 0x40) ? nextCs1 : nextCs2; -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Dm_Char08/func_80AB0F90.s") + if (ActorCutscene_GetCanPlayNext(nextCs) != 0) { + gSaveContext.save.weekEventReg[53] |= 0x40; + ActorCutscene_Start(nextCs, &this->dyna.actor); + this->actionFunc = DmChar08_DoNothing; + } else { + ActorCutscene_SetIntentToPlay(nextCs); + } +} -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Dm_Char08/DmChar08_Draw.s") +void func_80AAFAC4(DmChar08* this, PlayState* play) { + if (play->csCtx.state == 0) { + this->actionFunc = func_80AAF8F4; + } +} + +void func_80AAFAE4(DmChar08* this, PlayState* play) { + if (play->csCtx.state == 0) { + this->actionFunc = func_80AAFB04; + } +} + +void func_80AAFB04(DmChar08* this, PlayState* play) { + Player* player = GET_PLAYER(play); + + if ((fabsf(this->dyna.actor.xzDistToPlayer) < 200.0f) && (player->actor.world.pos.y > 0.0f)) { + play->nextEntrance = ENTRANCE(ZORA_CAPE, 7); + play->transitionTrigger = TRANS_TRIGGER_START; + Scene_SetExitFade(play); + this->actionFunc = func_80AAFB94; + } +} + +void func_80AAFB94(DmChar08* this, PlayState* play) { +} + +Color_RGBA8 sLargeTurtleBubblePrimColor = { 250, 200, 250, 100 }; +Color_RGBA8 sLargeTurtleBubbleEnvColor = { 80, 80, 80, 0 }; +Vec3f sLargeTurtleBubbleAccel = { 0.0f, -0.8f, 0.0f }; + +void DmChar08_SpawnBubbles(DmChar08* this, PlayState* play) { + s32 i; + Vec3f velocity; + + velocity.x = (Rand_ZeroOne() - 0.5f) * 24.0f; + velocity.y = -5.2f; + velocity.z = 4.0f; + sLargeTurtleBubbleAccel.x = 0.0f; + sLargeTurtleBubbleAccel.y = 1.18f; + sLargeTurtleBubbleAccel.z = 0.0f; + for (i = 0; i < this->bubbleCount; i++) { + EffectSsDtBubble_SpawnCustomColor(play, &this->bubblePos, &velocity, &sLargeTurtleBubbleAccel, + &sLargeTurtleBubblePrimColor, &sLargeTurtleBubbleEnvColor, + Rand_S16Offset(80, 130), 30, 0); + } +} + +void func_80AAFCCC(DmChar08* this, PlayState* play) { + switch (play->sceneId) { + case SCENE_31MISAKI: + if (!(gSaveContext.save.weekEventReg[55] & 0x80)) { + switch (this->unk_206) { + case 0: + break; + + case 1: + // Fire hookshot + Message_StartTextbox(play, 0x102A, &this->dyna.actor); + this->unk_206++; + break; + + case 2: + // I know your name + if (Message_GetState(&play->msgCtx) == TEXT_STATE_CLOSING) { + Message_StartTextbox(play, 0x102B, &this->dyna.actor); + this->unk_206 = 0; + } + break; + } + } else { + switch (this->unk_206) { + case 0: + break; + + case 1: + // Going to the temple again + Message_StartTextbox(play, 0x103B, &this->dyna.actor); + this->unk_206++; + break; + + case 2: + if (Message_GetState(&play->msgCtx) == TEXT_STATE_CLOSING) { + func_801477B4(play); + this->unk_206 = 0; + } + break; + } + } + return; + + case SCENE_SEA: + switch (this->unk_206) { + case 0: + break; + + case 1: + Message_StartTextbox(play, 0x102E, &this->dyna.actor); + this->unk_206++; + break; + + case 2: + if (Message_GetState(&play->msgCtx) == TEXT_STATE_CLOSING) { + Message_StartTextbox(play, 0x102F, &this->dyna.actor); + this->unk_206 = 0; + } + break; + } + break; + } +} + +void DmChar08_DoNothing(DmChar08* this, PlayState* play) { +} + +void func_80AAFE88(DmChar08* this, PlayState* play) { + s32 actorActionIndex; + CsCmdActorAction* csAction; + f32 phi_f12; + + if (Cutscene_CheckActorAction(play, 474)) { + actorActionIndex = Cutscene_GetActorActionIndex(play, 474); + if (this->unk_1F6 != play->csCtx.actorActions[actorActionIndex]->action) { + this->unk_1F6 = play->csCtx.actorActions[actorActionIndex]->action; + switch (play->csCtx.actorActions[actorActionIndex]->action) { + case 1: + this->animIndex = TURTLE_ANIM_IDLE; + break; + + case 3: + this->bubbleCount = 2; + break; + + case 4: + this->animIndex = TURTLE_ANIM_FLOAT; + break; + + case 5: + this->animIndex = TURTLE_ANIM_SWIM; + break; + + case 6: + this->eyeMode = TURTLE_EYEMODE_BLINK_LEFT; + break; + + case 7: + this->eyeMode = TURTLE_EYEMODE_CLOSED; + break; + + case 8: + this->animIndex = TURTLE_ANIM_YAWN; + break; + + case 9: + this->animIndex = TURTLE_ANIM_FLOAT; + break; + + case 10: + this->animIndex = TURTLE_ANIM_COUGH; + break; + + case 12: + this->animIndex = TURTLE_ANIM_SPEAK2; + break; + + case 13: + this->bubbleCount = 0; + break; + + case 14: + Actor_PlaySfxAtPos(&this->dyna.actor, NA_SE_EV_BIG_TORTOISE_ROLL); + this->animIndex = TURTLE_ANIM_FLOAT; + break; + } + } + switch (play->csCtx.actorActions[actorActionIndex]->action) { + case 2: + this->unk_1FF = 1; + phi_f12 = 2.0f * Environment_LerpWeight(play->csCtx.actorActions[actorActionIndex]->endFrame, + play->csCtx.actorActions[actorActionIndex]->startFrame, + play->csCtx.frames); + if (phi_f12 > 1.0f) { + phi_f12 = 1.0f; + } + + this->alpha = (1.0f - phi_f12) * 255.0f; + if (this->alpha < 6) { + this->unk_1FF = 2; + } + + Cutscene_ActorTranslateAndYaw(&this->dyna.actor, play, actorActionIndex); + break; + + case 5: + Cutscene_ActorTranslateAndYawSmooth(&this->dyna.actor, play, actorActionIndex); + break; + + case 14: + Cutscene_ActorTranslate(&this->dyna.actor, play, actorActionIndex); + Math_SmoothStepToS(&this->dyna.actor.world.rot.y, play->csCtx.actorActions[actorActionIndex]->rot.y, + 0xA, 0xDC, 1); + this->dyna.actor.shape.rot.y = this->dyna.actor.world.rot.y; + break; + + default: + Cutscene_ActorTranslateAndYaw(&this->dyna.actor, play, actorActionIndex); + break; + } + this->targetYPos = this->dyna.actor.world.pos.y; + if ((this->unk_1FF >= 2) || (play->csCtx.actorActions[actorActionIndex]->action == 2)) { + Math_SmoothStepToF(&this->unk_1F0, 1.0f, 0.02f, 0.1f, 0.00001f); + } + } else { + this->unk_1F6 = 99; + } +} + +void func_80AB01E8(DmChar08* this, PlayState* play) { + if (this->animIndex != this->unk_203) { + this->unk_203 = this->animIndex; + DmChar08_ChangeAnim(&this->skelAnime, &sAnimationInfo[this->animIndex], 0); + } +} + +void func_80AB023C(DmChar08* this, PlayState* play) { + if ((play->msgCtx.currentTextId != this->unk_1FC) && (play->msgCtx.currentTextId != 0)) { + this->unk_1FC = play->msgCtx.currentTextId; + this->unk_208 = 0; + switch (play->msgCtx.currentTextId) { + case 0x1025: // Slept well + this->unk_207 = 1; + break; + + case 0x1026: // Time Flies + this->unk_207 = 2; + break; + + case 0x1027: // See Everything + this->unk_207 = 3; + break; + + case 0x1028: // No time + this->unk_207 = 4; + break; + + case 0x1029: // Quick lets go + this->unk_207 = 10; + break; + + case 0x102C: // Having trouble + this->unk_207 = 5; + break; + + case 0x102D: // Ready, climb + this->unk_207 = 8; + break; + + case 0x102A: // Fire hookshot + this->unk_207 = 6; + break; + + case 0x102B: // I know your name + this->unk_207 = 2; + break; + + case 0x102E: // Returning to shore + this->unk_207 = 9; + break; + + case 0x102F: // It is okay to retreat + this->unk_207 = 7; + break; + + case 0x103B: // Going to the temple again + this->unk_207 = 6; + + break; + case 0x1030: // Return to sleep + this->unk_207 = 4; + break; + } + } +} + +void func_80AB032C(DmChar08* this, PlayState* play) { + switch (this->unk_207) { + case 1: + switch (this->unk_208) { + case 0: + this->animIndex = TURTLE_ANIM_YAWN; + this->eyeMode = TURTLE_EYEMODE_CLOSED; + this->unk_208++; + break; + + case 1: + if (Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) { + this->animIndex = TURTLE_ANIM_FLOAT; + this->eyeMode = TURTLE_EYEMODE_BLINK_LEFT; + this->unk_207 = 0; + this->unk_208 = 0; + } + break; + } + break; + + case 2: + switch (this->unk_208) { + case 0: + this->animIndex = TURTLE_ANIM_COUGH; + this->eyeMode = TURTLE_EYEMODE_CLOSED; + this->unk_208++; + break; + + case 1: + if (Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) { + this->animIndex = TURTLE_ANIM_SPEAK1; + this->eyeMode = TURTLE_EYEMODE_BLINK_LEFT; + this->unk_208++; + } + break; + + case 2: + if (Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) { + this->animIndex = TURTLE_ANIM_FLOAT; + this->eyeMode = TURTLE_EYEMODE_BLINK_LEFT; + this->unk_207 = 0; + this->unk_208 = 0; + } + break; + } + break; + + case 3: + case 4: + case 8: + switch (this->unk_208) { + case 0: + this->animIndex = TURTLE_ANIM_SPEAK1; + if (this->unk_207 >= 5) { + this->eyeMode = TURTLE_EYEMODE_CLOSED; + } else { + this->eyeMode = TURTLE_EYEMODE_BLINK_LEFT; + } + this->unk_208 = 2; + break; + + case 2: + if (Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) { + this->animIndex = TURTLE_ANIM_SPEAK2; + this->eyeMode = TURTLE_EYEMODE_CLOSED; + this->unk_208++; + } + break; + + case 3: + if (Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) { + if (this->unk_207 != 4) { + this->animIndex = TURTLE_ANIM_FLOAT; + this->eyeMode = TURTLE_EYEMODE_BLINK_LEFT; + this->unk_207 = 0; + this->unk_208 = 0; + } else { + this->animIndex = TURTLE_ANIM_SPEAK1; + this->eyeMode = TURTLE_EYEMODE_BLINK_LEFT; + this->unk_208++; + } + } + break; + + case 4: + case 5: + if (Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) { + this->unk_208++; + } + break; + + case 6: + if (Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) { + this->animIndex = TURTLE_ANIM_FLOAT; + this->eyeMode = TURTLE_EYEMODE_BLINK_LEFT; + this->unk_207 = 0; + this->unk_208 = 0; + } + break; + } + break; + + case 5: + switch (this->unk_208) { + case 0: + this->animIndex = TURTLE_ANIM_SPEAK1; + this->eyeMode = TURTLE_EYEMODE_BLINK_LEFT; + this->unk_208++; + break; + + case 2: + case 3: + if (Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) { + this->unk_208++; + } + break; + + case 4: + if (Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) { + this->animIndex = TURTLE_ANIM_SPEAK2; + this->eyeMode = TURTLE_EYEMODE_CLOSED; + this->unk_208++; + } + break; + + case 5: + if (Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) { + this->animIndex = TURTLE_ANIM_FLOAT; + this->eyeMode = TURTLE_EYEMODE_BLINK_LEFT; + this->unk_207 = 0; + this->unk_208 = 0; + } + break; + } + break; + + case 6: + switch (this->unk_208) { + case 0: + this->animIndex = TURTLE_ANIM_SPEAK1; + this->eyeMode = TURTLE_EYEMODE_LOOK_RIGHT; + this->unk_208++; + break; + + case 1: + if (Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) { + this->unk_208++; + } + break; + + case 2: + if (Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) { + this->animIndex = TURTLE_ANIM_FLOAT; + this->eyeMode = TURTLE_EYEMODE_BLINK_LEFT; + this->unk_207 = 0; + this->unk_208 = 0; + } + break; + } + break; + + case 7: + switch (this->unk_208) { + case 0: + this->animIndex = TURTLE_ANIM_SPEAK2; + this->eyeMode = TURTLE_EYEMODE_CLOSED; + this->unk_208++; + break; + + case 1: + if (Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) { + this->animIndex = TURTLE_ANIM_SPEAK1; + this->eyeMode = TURTLE_EYEMODE_CLOSED; + this->unk_208++; + } + break; + + case 2: + if (Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) { + this->animIndex = TURTLE_ANIM_FLOAT; + this->eyeMode = TURTLE_EYEMODE_BLINK_LEFT; + this->unk_207 = 0; + this->unk_208 = 0; + } + break; + } + break; + + case 9: + switch (this->unk_208) { + case 0: + this->animIndex = TURTLE_ANIM_SPEAK1; + this->eyeMode = TURTLE_EYEMODE_BLINK_LEFT; + this->unk_208++; + break; + + case 1: + if (Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) { + this->unk_208++; + } + if ((Message_GetState(&play->msgCtx) == TEXT_STATE_DONE) && Message_ShouldAdvance(play)) { + this->unk_208 = 3; + } + break; + + case 2: + if (Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) { + this->animIndex = TURTLE_ANIM_FLOAT; + this->eyeMode = TURTLE_EYEMODE_BLINK_LEFT; + this->unk_208++; + } + if ((Message_GetState(&play->msgCtx) == TEXT_STATE_DONE) && Message_ShouldAdvance(play)) { + this->unk_208 = 3; + } + break; + + case 3: + if (Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) { + this->animIndex = TURTLE_ANIM_COUGH; + this->eyeMode = TURTLE_EYEMODE_CLOSED; + this->unk_208++; + } + break; + + case 4: + if (Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) { + this->animIndex = TURTLE_ANIM_FLOAT; + this->eyeMode = TURTLE_EYEMODE_BLINK_LEFT; + this->unk_207 = 0; + this->unk_208 = 0; + } + break; + } + break; + case 10: + switch (this->unk_208) { + case 0: + this->animIndex = TURTLE_ANIM_SPEAK1; + this->eyeMode = TURTLE_EYEMODE_BLINK_LEFT; + this->unk_208++; + break; + case 1: + if (Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) { + this->animIndex = TURTLE_ANIM_SPEAK2; + this->eyeMode = TURTLE_EYEMODE_CLOSED; + this->unk_208++; + } + break; + case 2: + if (Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) { + this->animIndex = TURTLE_ANIM_SPEAK1; + this->eyeMode = TURTLE_EYEMODE_BLINK_LEFT; + this->unk_208++; + } + break; + case 3: + if (Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) { + this->animIndex = TURTLE_ANIM_FLOAT; + this->eyeMode = TURTLE_EYEMODE_BLINK_LEFT; + this->unk_207 = 0; + this->unk_208 = 0; + } + break; + } + break; + } +} + +void func_80AB096C(DmChar08* this, PlayState* play) { + if ((play->csCtx.state != 0) && (play->sceneId == SCENE_31MISAKI) && (gSaveContext.sceneLayer == 0) && + (play->csCtx.currentCsIndex == 0)) { + if ((play->csCtx.frames >= 890) && (play->csCtx.frames < 922)) { + Actor_PlaySfxAtPos(&this->dyna.actor, NA_SE_EV_EARTHQUAKE_LAST2 - SFX_FLAG); + } + } + if ((this->animIndex == TURTLE_ANIM_SWIM) && Animation_OnFrame(&this->skelAnime, 16.0f)) { + Actor_PlaySfxAtPos(&this->dyna.actor, NA_SE_EV_BIG_TORTOISE_SWIM); + } +} + +void DmChar08_UpdateCollision(DmChar08* this, PlayState* play) { + Player* player = GET_PLAYER(play); + f32 curFrame; + f32 phi_f2; + f32 phi_f0; + f32 phi_f12; + s32 i; + + if (player->actor.world.pos.x > 0.0f) { + curFrame = this->skelAnime.curFrame; + if (curFrame <= 19.0f) { + phi_f12 = 19.0f; + phi_f2 = curFrame / 19.0f; + } else { + phi_f2 = (29.0f - curFrame) / 9.0f; + phi_f12 = 29.0f; + } + + sTurtleGreatBayTempleCol.polyList = sTurtleGreatBayTempleColPolygons; + + for (i = 0; i < ARRAY_COUNT(sTurtleGreatBayTempleColVertices); i++) { + sTurtleGreatBayTempleColVertices[i].x = sTurtleGreatBayTempleColVertices2[i].x; + } + + sTurtleGreatBayTempleColVertices[0].y = (100.0f * phi_f2) + 900.0f; + sTurtleGreatBayTempleColVertices[1].y = (100.0f * phi_f2) + 900.0f; + sTurtleGreatBayTempleColVertices[2].y = (500.0f * phi_f2) + -200.0f; + sTurtleGreatBayTempleColVertices[3].y = (900.0f * phi_f2) + -800.0f; + sTurtleGreatBayTempleColVertices[5].y = 0x4B0; + sTurtleGreatBayTempleColVertices[9].y = 0x6A4; + } else { + phi_f0 = this->skelAnime.curFrame + 26.0f; + if (phi_f0 > 29.0f) { + phi_f12 = 29.0f; + phi_f0 -= 29.0f; + } + + if (phi_f0 <= 18.0f) { + phi_f2 = phi_f0 / 18.0f; + } else { + phi_f2 = (29.0f - phi_f0) / 10.0f; + } + + sTurtleGreatBayTempleCol.polyList = sTurtleGreatBayTempleColPolygons2; + + for (i = 0; i < ARRAY_COUNT(sTurtleGreatBayTempleColVertices); i++) { + sTurtleGreatBayTempleColVertices[i].x = -sTurtleGreatBayTempleColVertices2[i].x; + } + + sTurtleGreatBayTempleColVertices[0].y = (500.0f * phi_f2) + 720.0f; + sTurtleGreatBayTempleColVertices[1].y = (660.0f * phi_f2) + 420.0f; + sTurtleGreatBayTempleColVertices[2].y = (1130.0f * phi_f2) + -430.0f; + sTurtleGreatBayTempleColVertices[3].y = (1430.0f * phi_f2) + -1060.0f; + sTurtleGreatBayTempleColVertices[5].y = 0x4B0; + sTurtleGreatBayTempleColVertices[9].y = 0x6A4; + } + func_800C6554(play, &play->colCtx.dyna); +} + +void DmChar08_Update(Actor* thisx, PlayState* play) { + DmChar08* this = THIS; + + this->dyna.actor.focus.pos.x = this->focusPos.x; + this->dyna.actor.focus.pos.y = this->focusPos.y + this->dyna.actor.targetArrowOffset; + this->dyna.actor.focus.pos.z = this->focusPos.z; + this->dyna.actor.focus.rot.x = this->dyna.actor.world.rot.x; + this->dyna.actor.focus.rot.y = this->dyna.actor.world.rot.y; + this->dyna.actor.focus.rot.z = this->dyna.actor.world.rot.z; + + if (Actor_ProcessTalkRequest(&this->dyna.actor, &play->state)) { + this->unk_206 = 1; + } + + DmChar08_UpdateEyes(this); + this->actionFunc(this, play); + func_80AAFE88(this, play); + func_80AB023C(this, play); + func_80AB032C(this, play); + func_80AB01E8(this, play); + SkelAnime_Update(&this->skelAnime); + DmChar08_SpawnBubbles(this, play); + this->dyna.actor.world.pos.y = this->targetYPos; + if (play->sceneId == SCENE_31MISAKI) { + if (this->dyna.actor.xzDistToPlayer > 1300.0f) { + func_800C62BC(play, &play->colCtx.dyna, this->dyna.bgId); + } else { + func_800C6314(play, &play->colCtx.dyna, this->dyna.bgId); + } + } + if (this->unk_1FF != 0) { + func_80AAFCCC(this, play); + func_800B8614(&this->dyna.actor, play, 400.0f); + } + func_80AB096C(this, play); + DmChar08_UpdateCollision(this, play); +} + +s32 DmChar08_OverrideLimbDraw(PlayState* play, s32 limbIndex, Gfx** dList, Vec3f* pos, Vec3s* rot, Actor* thisx) { + if ((play->csCtx.state == 0) && (play->sceneId == SCENE_31MISAKI) && + (limbIndex == TURTLE_LIMB_FRONT_RIGHT_UPPER_FLIPPER)) { + rot->z = -0x5E24; + } + return false; +} + +void DmChar08_PostLimbDraw(PlayState* play, s32 limbIndex, Gfx** dList, Vec3s* rot, Actor* thisx) { + DmChar08* this = THIS; + Vec3f src; + + if (limbIndex == TURTLE_LIMB_SHELL) { + src.x = 800.0f; + src.y = 2600.0f; + src.z = -800.0f; + Matrix_MultVec3f(&src, &this->tree1Pos); + src.x = 2600.0f; + src.y = 2500.0f; + src.z = 700.0f; + Matrix_MultVec3f(&src, &this->tree2Pos); + } else if (limbIndex == TURTLE_LIMB_LOWER_MOUTH) { + src.x = 1600.0f; + src.y = -200.0f; + src.z = 0.0f; + Matrix_MultVec3f(&src, &this->bubblePos); + } else if (limbIndex == TURTLE_LIMB_UPPER_MOUTH) { + src.x = 600.0f; + src.y = 700.0f; + src.z = 0.0f; + Matrix_MultVec3f(&src, &this->focusPos); + } +} + +void DmChar08_TransformLimbDraw(PlayState* play, s32 limbIndex, Actor* thisx) { + DmChar08* this = THIS; + f32 one; + + switch (limbIndex) { + case TURTLE_LIMB_SHELL: + break; + + case TURTLE_LIMB_NECK: + Matrix_Pop(); + one = 1.0f; + Matrix_Scale(((one - 0.7f) * this->unk_1F0) + 0.7f, ((one - 0.7f) * this->unk_1F0) + 0.7f, 1.0f, + MTXMODE_APPLY); + Matrix_Push(); + break; + + case TURTLE_LIMB_FRONT_LEFT_UPPER_FLIPPER: + case TURTLE_LIMB_FRONT_LEFT_LOWER_FLIPPER: + case TURTLE_LIMB_FRONT_RIGHT_UPPER_FLIPPER: + case TURTLE_LIMB_FRONT_RIGHT_LOWER_FLIPPER: + Matrix_Pop(); + Matrix_Scale((this->unk_1F0 * 0.4f) + 0.6f, (this->unk_1F0 * 0.4f) + 0.6f, (this->unk_1F0 * 0.4f) + 0.6f, + MTXMODE_APPLY); + Matrix_Push(); + break; + + case TURTLE_LIMB_FRONT_LEFT_END_FLIPPER: + case TURTLE_LIMB_FRONT_RIGHT_END_FLIPPER: + Matrix_Scale((this->unk_1F0 * 0.4f) + 0.6f, (this->unk_1F0 * 0.4f) + 0.6f, (this->unk_1F0 * 0.4f) + 0.6f, + MTXMODE_APPLY); + break; + + case TURTLE_TAIL_LIMB: + Matrix_Pop(); + Matrix_Scale((this->unk_1F0 * 0.52f) + 0.48f, (this->unk_1F0 * 0.52f) + 0.48f, + (this->unk_1F0 * 0.52f) + 0.48f, MTXMODE_APPLY); + Matrix_Push(); + break; + + case TURTLE_LIMB_BACK_LEFT_FLIPPER: + case TURTLE_LIMB_BACK_RIGHT_FLIPPER: + Matrix_Scale((this->unk_1F0 * 0.55f) + 0.45f, (this->unk_1F0 * 0.2f) + 0.8f, + (this->unk_1F0 * 0.55f) + 0.45f, MTXMODE_APPLY); + break; + } +} + +TexturePtr sBigTurtleEyeTextures[] = { + gTurtleEyeOpenLeftTex, gTurtleEyeHalfLeftTex, gTurtleEyeClosedTex, + gTurtleEyeHalfLeftTex, gTurtleEyeOpenStraightTex, gTurtleEyeHalfStraightTex, + gTurtleEyeClosedTex, gTurtleEyeHalfStraightTex, gTurtleEyeOpenRightTex, +}; + +void DmChar08_Draw(Actor* thisx, PlayState* play) { + s32 pad; + DmChar08* this = THIS; + + OPEN_DISPS(play->state.gfxCtx); + func_8012C28C(play->state.gfxCtx); + + gSPSegment(POLY_OPA_DISP++, 0x08, Lib_SegmentedToVirtual(sBigTurtleEyeTextures[this->eyeIndex])); + gSPSegment(POLY_OPA_DISP++, 0x09, Lib_SegmentedToVirtual(sBigTurtleEyeTextures[this->eyeIndex])); + if ((this->unk_1FF > 0) || (play->csCtx.state != CS_STATE_0)) { + SkelAnime_DrawTransformFlexOpa(play, this->skelAnime.skeleton, this->skelAnime.jointTable, + this->skelAnime.dListCount, DmChar08_OverrideLimbDraw, DmChar08_PostLimbDraw, + DmChar08_TransformLimbDraw, &this->dyna.actor); + this->palmTree1->world.pos.x = this->tree1Pos.x; + this->palmTree1->world.pos.y = this->tree1Pos.y; + this->palmTree1->world.pos.z = this->tree1Pos.z; + this->palmTree2->world.pos.x = this->tree2Pos.x; + this->palmTree2->world.pos.y = this->tree2Pos.y; + this->palmTree2->world.pos.z = this->tree2Pos.z; + } + if (this->unk_1FF == 0) { + Scene_SetRenderModeXlu(play, 0, 1); + gSPMatrix(POLY_OPA_DISP++, Matrix_NewMtx(play->state.gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW); + gSPDisplayList(POLY_OPA_DISP++, gTurtleAsleepDL); + } else if (this->unk_1FF == 1) { + func_8012C2DC(play->state.gfxCtx); + Scene_SetRenderModeXlu(play, 2, 2); + gDPSetEnvColor(POLY_XLU_DISP++, 0, 0, 0, this->alpha); + gSPMatrix(POLY_XLU_DISP++, Matrix_NewMtx(play->state.gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW); + gSPDisplayList(POLY_XLU_DISP++, gTurtleAsleepDL); + } + CLOSE_DISPS(play->state.gfxCtx); +} diff --git a/src/overlays/actors/ovl_Dm_Char08/z_dm_char08.h b/src/overlays/actors/ovl_Dm_Char08/z_dm_char08.h index 1718a9fb0..2cdbb52c7 100644 --- a/src/overlays/actors/ovl_Dm_Char08/z_dm_char08.h +++ b/src/overlays/actors/ovl_Dm_Char08/z_dm_char08.h @@ -8,10 +8,36 @@ struct DmChar08; typedef void (*DmChar08ActionFunc)(struct DmChar08*, PlayState*); typedef struct DmChar08 { - /* 0x000 */ Actor actor; - /* 0x144 */ char unk_144[0x5C]; + /* 0x000 */ DynaPolyActor dyna; + /* 0x15C */ SkelAnime skelAnime; /* 0x1A0 */ DmChar08ActionFunc actionFunc; - /* 0x1A4 */ char unk_1A4[0x68]; + /* 0x1A4 */ Actor* palmTree1; + /* 0x1A8 */ Actor* palmTree2; + /* 0x1AC */ Vec3f tree1Pos; + /* 0x1B8 */ Vec3f tree2Pos; + /* 0x1C4 */ Vec3f bubblePos; + /* 0x1D0 */ Vec3f focusPos; + /* 0x1DC */ UNK_TYPE1 unk_1DC[8]; + /* 0x1E4 */ f32 targetYPos; + /* 0x1E8 */ UNK_TYPE1 unk_1E8[8]; + /* 0x1F0 */ f32 unk_1F0; + /* 0x1F4 */ s16 unk_1F4; + /* 0x1F6 */ s16 unk_1F6; + /* 0x1F6 */ s16 blinkTimer; + /* 0x1FA */ s16 unk_1FA; + /* 0x1FC */ u16 unk_1FC; + /* 0x1FE */ u8 bubbleCount; + /* 0x1FF */ u8 unk_1FF; + /* 0x200 */ u8 eyeMode; + /* 0x201 */ u8 eyeIndex; + /* 0x202 */ u8 animIndex; + /* 0x203 */ u8 unk_203; + /* 0x204 */ UNK_TYPE1 unk_204; + /* 0x205 */ u8 alpha; + /* 0x206 */ u8 unk_206; + /* 0x207 */ u8 unk_207; + /* 0x208 */ u8 unk_208; + /* 0x209 */ u8 dynapolyInitialized; } DmChar08; // size = 0x20C extern const ActorInit Dm_Char08_InitVars; diff --git a/src/overlays/actors/ovl_Dm_Char09/z_dm_char09.c b/src/overlays/actors/ovl_Dm_Char09/z_dm_char09.c index 8f02a8bb4..0bb112b43 100644 --- a/src/overlays/actors/ovl_Dm_Char09/z_dm_char09.c +++ b/src/overlays/actors/ovl_Dm_Char09/z_dm_char09.c @@ -31,7 +31,7 @@ const ActorInit Dm_Char09_InitVars = { }; static AnimationInfo sAnimationInfo[] = { - { &object_bee_Anim_00005C, 1.0f, 0.0f, -1.0f, ANIMMODE_LOOP, 0.0f }, + { &gBeeFlyingAnim, 1.0f, 0.0f, -1.0f, ANIMMODE_LOOP, 0.0f }, }; void DmChar09_ChangeAnim(SkelAnime* skelAnime, AnimationInfo* animationInfo, u16 animIndex) { @@ -53,8 +53,8 @@ void DmChar09_Init(Actor* thisx, PlayState* play) { DmChar09* this = THIS; ActorShape_Init(&this->actor.shape, 0.0f, ActorShadow_DrawCircle, 19.0f); - SkelAnime_Init(play, &this->skelAnime, &object_bee_Skel_001398, &object_bee_Anim_00005C, this->jointTable, - this->morphTable, OBJECT_BEE_LIMB_MAX); + SkelAnime_Init(play, &this->skelAnime, &gBeeSkel, &gBeeFlyingAnim, this->jointTable, this->morphTable, + OBJECT_BEE_LIMB_MAX); DmChar09_ChangeAnim(&this->skelAnime, sAnimationInfo, 0); Actor_SetScale(&this->actor, 0.01f); this->unk_228 = Rand_ZeroOne() * 65535.0f; diff --git a/src/overlays/actors/ovl_Eff_Kamejima_Wave/z_eff_kamejima_wave.c b/src/overlays/actors/ovl_Eff_Kamejima_Wave/z_eff_kamejima_wave.c index 83842569f..2de3d8604 100644 --- a/src/overlays/actors/ovl_Eff_Kamejima_Wave/z_eff_kamejima_wave.c +++ b/src/overlays/actors/ovl_Eff_Kamejima_Wave/z_eff_kamejima_wave.c @@ -56,7 +56,7 @@ void EffKamejimaWave_Init(Actor* thisx, PlayState* play) { this->actionFunc = func_80BCEC6C; sVtxAlpha = 255; } - D_80BCF1C4 = Lib_SegmentedToVirtual(object_kamejima_Matanimheader_001AF0); + D_80BCF1C4 = Lib_SegmentedToVirtual(gTurtleWaveTexAnim); } void EffKamejimaWave_Destroy(Actor* thisx, PlayState* play) { @@ -137,7 +137,7 @@ void EffKamejimaWave_Update(Actor* thisx, PlayState* play) { } void EffKamejimaWave_SetVtxAlpha(u8 alpha) { - Vtx* vtx = Lib_SegmentedToVirtual(&object_kamejima_Vtx_000000); + Vtx* vtx = Lib_SegmentedToVirtual(&gTurtleWaveVtx); vtx[2].v.cn[3] = alpha; vtx[6].v.cn[3] = alpha; @@ -165,7 +165,7 @@ void EffKamejimaWave_Draw(Actor* thisx, PlayState* play) { AnimatedMat_Draw(play, D_80BCF1C4); gDPSetPrimColor(POLY_XLU_DISP++, 0, 0x80, primColor.r, primColor.g, primColor.b, 255); gDPSetEnvColor(POLY_XLU_DISP++, envColor.r, envColor.g, envColor.b, 255); - gSPDisplayList(POLY_XLU_DISP++, object_kamejima_DL_000140); + gSPDisplayList(POLY_XLU_DISP++, gTurtleWaveDL); CLOSE_DISPS(play->state.gfxCtx); } diff --git a/src/overlays/actors/ovl_En_Bee/z_en_bee.c b/src/overlays/actors/ovl_En_Bee/z_en_bee.c index 0a0c6dd3f..7d40e9931 100644 --- a/src/overlays/actors/ovl_En_Bee/z_en_bee.c +++ b/src/overlays/actors/ovl_En_Bee/z_en_bee.c @@ -15,12 +15,12 @@ void EnBee_Destroy(Actor* thisx, PlayState* play); void EnBee_Update(Actor* thisx, PlayState* play); void EnBee_Draw(Actor* thisx, PlayState* play); -void func_80B5A9E8(EnBee* this, PlayState* play); -void func_80B5AC3C(EnBee* this, PlayState* play); -void func_80B5A854(EnBee* this); -void func_80B5ABC4(EnBee* this); +void EnBee_SetupFlyIdle(EnBee* this); +void EnBee_FlyIdle(EnBee* this, PlayState* play); +void EnBee_SetupAttack(EnBee* this); +void EnBee_Attack(EnBee* this, PlayState* play); -s32 D_80B5B1F0 = 0; +s32 sNumLoadedBees = 0; const ActorInit En_Bee_InitVars = { ACTOR_EN_BEE, @@ -94,14 +94,14 @@ void EnBee_Init(Actor* thisx, PlayState* play) { this->actor.colChkInfo.mass = 10; ActorShape_Init(&this->actor.shape, 0.0f, ActorShadow_DrawCircle, 19.0f); - SkelAnime_Init(play, &this->skelAnime, &object_bee_Skel_001398, &object_bee_Anim_00005C, this->morphTable, - this->jointTable, OBJECT_BEE_LIMB_MAX); + SkelAnime_Init(play, &this->skelAnime, &gBeeSkel, &gBeeFlyingAnim, this->morphTable, this->jointTable, + OBJECT_BEE_LIMB_MAX); this->actor.colChkInfo.health = 1; this->actor.colChkInfo.damageTable = &sDamageTable; this->actor.targetMode = 6; Collider_InitAndSetCylinder(play, &this->collider, &this->actor, &sCylinderInit); - this->unk_218 = D_80B5B1F0; - D_80B5B1F0++; + this->instanceId = sNumLoadedBees; + sNumLoadedBees++; this->actor.shape.shadowScale = 12.0f; if (ActorCutscene_GetCurrentIndex() != -1) { @@ -109,7 +109,7 @@ void EnBee_Init(Actor* thisx, PlayState* play) { } this->actor.hintId = TATL_HINT_ID_GIANT_BEE; - func_80B5A854(this); + EnBee_SetupFlyIdle(this); } void EnBee_Destroy(Actor* thisx, PlayState* play) { @@ -118,121 +118,122 @@ void EnBee_Destroy(Actor* thisx, PlayState* play) { Collider_DestroyCylinder(play, &this->collider); } -void func_80B5A854(EnBee* this) { +void EnBee_SetupFlyIdle(EnBee* this) { s32 pad; - Vec3f sp48; - s16 sp46; + Vec3f tempPos; + s16 yawOffset; - Animation_Change(&this->skelAnime, &object_bee_Anim_00005C, 1.0f, 0.0f, - Animation_GetLastFrame(&object_bee_Anim_00005C), 0, -10.0f); - Math_Vec3f_Copy(&sp48, &this->actor.home.pos); + Animation_Change(&this->skelAnime, &gBeeFlyingAnim, 1.0f, 0.0f, Animation_GetLastFrame(&gBeeFlyingAnim), 0, -10.0f); + Math_Vec3f_Copy(&tempPos, &this->actor.home.pos); - sp46 = (this->unk_218 * 0x700) + 0x2000; - sp48.x += Math_SinS(sp46) * 50.0f; - sp48.y = Rand_ZeroFloat(50.0f) + (this->actor.floorHeight + 30.0f); - sp48.z += Math_CosS(sp46) * 50.0f; + yawOffset = (this->instanceId * 0x700) + 0x2000; + tempPos.x += Math_SinS(yawOffset) * 50.0f; + tempPos.y = Rand_ZeroFloat(50.0f) + (this->actor.floorHeight + 30.0f); + tempPos.z += Math_CosS(yawOffset) * 50.0f; - Math_Vec3f_Copy(&this->unk_21C[0], &sp48); - Math_Vec3f_Copy(&sp48, &this->actor.home.pos); + Math_Vec3f_Copy(&this->targetPos[0], &tempPos); + Math_Vec3f_Copy(&tempPos, &this->actor.home.pos); - sp48.x += Math_SinS(sp46 - 0x4000) * 50.0f; - sp48.y = Rand_ZeroFloat(50.0f) + (this->actor.floorHeight + 30.0f); - sp48.z += Math_CosS(sp46 - 0x4000) * 50.0f; + tempPos.x += Math_SinS(yawOffset - 0x4000) * 50.0f; + tempPos.y = Rand_ZeroFloat(50.0f) + (this->actor.floorHeight + 30.0f); + tempPos.z += Math_CosS(yawOffset - 0x4000) * 50.0f; - Math_Vec3f_Copy(&this->unk_21C[1], &sp48); + Math_Vec3f_Copy(&this->targetPos[1], &tempPos); - this->unk_204 = Rand_S16Offset(0x14, 0x1E); - this->unk_208 = 0; - this->actionFunc = func_80B5A9E8; + this->attackDelayTimer = Rand_S16Offset(20, 30); + this->isHostile = false; + this->actionFunc = EnBee_FlyIdle; } -void func_80B5A9E8(EnBee* this, PlayState* play) { - Vec3f sp3C; +void EnBee_FlyIdle(EnBee* this, PlayState* play) { + Vec3f nextPos; s32 pad[2]; if ((this->actor.category != ACTORCAT_ENEMY) && (ActorCutscene_GetCurrentIndex() == -1)) { func_800BC154(play, &play->actorCtx, &this->actor, ACTORCAT_ENEMY); } - Math_Vec3f_Copy(&sp3C, &this->unk_21C[this->unk_214]); - sp3C.x += Math_SinS(this->unk_20C) * 30.0f; - sp3C.z += Math_CosS(this->unk_20C) * 30.0f; + Math_Vec3f_Copy(&nextPos, &this->targetPos[this->posIndex]); + nextPos.x += Math_SinS(this->targetYaw) * 30.0f; + nextPos.z += Math_CosS(this->targetYaw) * 30.0f; - if (!(this->unk_218 & 1)) { - this->unk_20C += (s16)((s32)randPlusMinusPoint5Scaled(1000.0f) + 4000); + if ((this->instanceId % 2) == 0) { + this->targetYaw += (s16)((s32)randPlusMinusPoint5Scaled(1000.0f) + 4000); } else { - this->unk_20C -= (s16)((s32)randPlusMinusPoint5Scaled(1000.0f) + 4000); + this->targetYaw -= (s16)((s32)randPlusMinusPoint5Scaled(1000.0f) + 4000); } - this->unk_210 += 1000; - this->actor.velocity.y = Math_SinS(this->unk_210); + this->flightHoverOffset += 1000; + this->actor.velocity.y = Math_SinS(this->flightHoverOffset); - if (this->unk_20C > 0x10000) { - this->unk_20C = 0; - this->unk_214++; - this->unk_214 &= 1; + if (this->targetYaw > 0x10000) { + this->targetYaw = 0; + this->posIndex++; + this->posIndex &= 1; } - Math_SmoothStepToS(&this->actor.world.rot.y, Math_Vec3f_Yaw(&this->actor.world.pos, &sp3C), 1, 0x7D0, 0); + Math_SmoothStepToS(&this->actor.world.rot.y, Math_Vec3f_Yaw(&this->actor.world.pos, &nextPos), 1, 0x7D0, 0); Math_ApproachF(&this->actor.speedXZ, 3.0f, 0.3f, 1.0f); - if ((this->unk_204 == 0) && (this->actor.params != 0)) { - func_80B5ABC4(this); + if ((this->attackDelayTimer == 0) && (this->actor.params != BEE_BEHAVIOR_IDLE)) { + EnBee_SetupAttack(this); } } -void func_80B5ABC4(EnBee* this) { - Animation_Change(&this->skelAnime, &object_bee_Anim_00005C, 1.0f, 0.0f, - Animation_GetLastFrame(&object_bee_Anim_00005C), 0, -10.0f); - this->unk_208 = 1; - this->actionFunc = func_80B5AC3C; +void EnBee_SetupAttack(EnBee* this) { + Animation_Change(&this->skelAnime, &gBeeFlyingAnim, 1.0f, 0.0f, Animation_GetLastFrame(&gBeeFlyingAnim), 0, -10.0f); + this->isHostile = true; + this->actionFunc = EnBee_Attack; } -void func_80B5AC3C(EnBee* this, PlayState* play) { +void EnBee_Attack(EnBee* this, PlayState* play) { Player* player = GET_PLAYER(play); - Vec3f sp88; - f32 rnd; - f32 phi_fs1; + Vec3f nextPos; + f32 rand; + f32 yawOffset; s32 i; - Math_Vec3f_Copy(&sp88, &player->actor.world.pos); - phi_fs1 = (this->unk_218 * 0x700) + 0x2000; + Math_Vec3f_Copy(&nextPos, &player->actor.world.pos); + yawOffset = (this->instanceId * 0x700) + 0x2000; for (i = 0; i < 2; i++) { - rnd = randPlusMinusPoint5Scaled(20.0f); - sp88.x += Math_SinS((this->actor.yawTowardsPlayer + ((f32)this->unk_20C)) + phi_fs1) * (rnd + 30.0f); - sp88.y = (Math_SinS(this->unk_210) * 10.0f) + (player->actor.floorHeight + 40.0f); - rnd = randPlusMinusPoint5Scaled(20.0f); - sp88.z += Math_CosS((f32)this->actor.yawTowardsPlayer + this->unk_20C + phi_fs1) * (rnd + 30.0f); - Math_Vec3f_Copy(&this->unk_21C[i], &sp88); - phi_fs1 -= 16384.0f; + rand = randPlusMinusPoint5Scaled(20.0f); + nextPos.x += Math_SinS((f32)this->actor.yawTowardsPlayer + this->targetYaw + yawOffset) * (rand + 30.0f); + nextPos.y = (Math_SinS(this->flightHoverOffset) * 10.0f) + (player->actor.floorHeight + 40.0f); + rand = randPlusMinusPoint5Scaled(20.0f); + + nextPos.z += Math_CosS((f32)this->actor.yawTowardsPlayer + this->targetYaw + yawOffset) * (rand + 30.0f); + Math_Vec3f_Copy(&this->targetPos[i], &nextPos); + yawOffset -= 0x4000; } - Math_Vec3f_Copy(&sp88, &this->unk_21C[this->unk_214]); + Math_Vec3f_Copy(&nextPos, &this->targetPos[this->posIndex]); - if (!(this->unk_218 & 1)) { - this->unk_20C += (this->unk_218 * 0x700) + (s32)randPlusMinusPoint5Scaled((this->unk_218 * 0x700) * 0.5f); + if ((this->instanceId % 2) == 0) { + this->targetYaw += + (this->instanceId * 0x700) + (s32)randPlusMinusPoint5Scaled((this->instanceId * 0x700) * 0.5f); } else { - this->unk_20C -= (this->unk_218 * 0x700) + (s32)randPlusMinusPoint5Scaled((this->unk_218 * 0x700) * 0.5f); + this->targetYaw -= + (this->instanceId * 0x700) + (s32)randPlusMinusPoint5Scaled((this->instanceId * 0x700) * 0.5f); } - this->unk_210 += (s32)randPlusMinusPoint5Scaled(500.0f) + 1000; + this->flightHoverOffset += (s32)randPlusMinusPoint5Scaled(500.0f) + 1000; - if (this->unk_20C > 0x10000) { - this->unk_20C = 0; - this->unk_214++; - this->unk_214 &= 1; + if (this->targetYaw > 0x10000) { + this->targetYaw = 0; + this->posIndex++; + this->posIndex &= 1; } - Math_SmoothStepToS(&this->actor.world.rot.y, Math_Vec3f_Yaw(&this->actor.world.pos, &sp88), 1, 0x1388, 0); - Math_ApproachF(&this->actor.world.pos.y, sp88.y, 0.3f, 3.0f); + Math_SmoothStepToS(&this->actor.world.rot.y, Math_Vec3f_Yaw(&this->actor.world.pos, &nextPos), 1, 0x1388, 0); + Math_ApproachF(&this->actor.world.pos.y, nextPos.y, 0.3f, 3.0f); Math_ApproachF(&this->actor.speedXZ, 5.0f, 0.3f, 1.0f); } -void func_80B5AF80(EnBee* this, PlayState* play) { - if ((this->unk_206 == 0) && (this->collider.base.atFlags & AC_HIT)) { +void EnBee_UpdateDamage(EnBee* this, PlayState* play) { + if ((this->sfxHitTimer == 0) && (this->collider.base.atFlags & AT_HIT)) { AudioSfx_StopByPosAndId(&this->actor.projectedPos, NA_SE_EN_BEE_FLY - SFX_FLAG); - this->unk_206 = 5; + this->sfxHitTimer = 5; } if (this->collider.base.acFlags & AC_HIT) { @@ -253,16 +254,16 @@ void EnBee_Update(Actor* thisx, PlayState* play) { SkelAnime_Update(&this->skelAnime); if (this->actor.category == ACTORCAT_ENEMY) { - if (this->unk_204 != 0) { - this->unk_204--; + if (this->attackDelayTimer != 0) { + this->attackDelayTimer--; } - if (this->unk_206 != 0) { - this->unk_206--; + if (this->sfxHitTimer != 0) { + this->sfxHitTimer--; } } Actor_PlaySfxAtPos(&this->actor, NA_SE_EN_BEE_FLY - SFX_FLAG); - func_80B5AF80(this, play); + EnBee_UpdateDamage(this, play); Math_Vec3s_Copy(&this->actor.shape.rot, &this->actor.world.rot); Actor_SetFocus(&this->actor, 0.0f); Actor_SetScale(&this->actor, 0.01f); diff --git a/src/overlays/actors/ovl_En_Bee/z_en_bee.h b/src/overlays/actors/ovl_En_Bee/z_en_bee.h index 1638407ee..851a0a216 100644 --- a/src/overlays/actors/ovl_En_Bee/z_en_bee.h +++ b/src/overlays/actors/ovl_En_Bee/z_en_bee.h @@ -8,20 +8,25 @@ struct EnBee; typedef void (*EnBeeActionFunc)(struct EnBee*, PlayState*); +typedef enum { + /* 0 */ BEE_BEHAVIOR_IDLE = 0, + /* 1 */ BEE_BEHAVIOR_ATTACK, +} BeeBehaviorType; + typedef struct EnBee { /* 0x000 */ Actor actor; /* 0x144 */ SkelAnime skelAnime; /* 0x188 */ Vec3s morphTable[OBJECT_BEE_LIMB_MAX]; /* 0x1C4 */ Vec3s jointTable[OBJECT_BEE_LIMB_MAX]; /* 0x200 */ EnBeeActionFunc actionFunc; - /* 0x204 */ s16 unk_204; - /* 0x206 */ s16 unk_206; - /* 0x208 */ s16 unk_208; - /* 0x20C */ s32 unk_20C; - /* 0x210 */ s32 unk_210; - /* 0x214 */ s32 unk_214; - /* 0x218 */ s32 unk_218; - /* 0x21C */ Vec3f unk_21C[2]; + /* 0x204 */ s16 attackDelayTimer; + /* 0x206 */ s16 sfxHitTimer; + /* 0x208 */ s16 isHostile; // set and not used + /* 0x20C */ s32 targetYaw; + /* 0x210 */ s32 flightHoverOffset; + /* 0x214 */ s32 posIndex; + /* 0x218 */ s32 instanceId; + /* 0x21C */ Vec3f targetPos[2]; /* 0x234 */ UNK_TYPE1 pad234[8]; /* 0x23C */ ColliderCylinder collider; } EnBee; // size = 0x288 diff --git a/src/overlays/actors/ovl_En_Stone_heishi/z_en_stone_heishi.c b/src/overlays/actors/ovl_En_Stone_heishi/z_en_stone_heishi.c index fe4882947..121d73c51 100644 --- a/src/overlays/actors/ovl_En_Stone_heishi/z_en_stone_heishi.c +++ b/src/overlays/actors/ovl_En_Stone_heishi/z_en_stone_heishi.c @@ -17,12 +17,16 @@ void EnStoneheishi_Draw(Actor* thisx, PlayState* play); void func_80BC9560(EnStoneheishi* this, PlayState* play); void func_80BC9680(EnStoneheishi* this, PlayState* play); -void func_80BC9908(EnStoneheishi* this, PlayState* play); -void func_80BC9A2C(EnStoneheishi* this, PlayState* play); +void EnStoneheishi_CheckGivenItem(EnStoneheishi* this, PlayState* play); +void EnStoneheishi_DrinkBottleProcess(EnStoneheishi* this, PlayState* play); void func_80BC9D28(EnStoneheishi* this, PlayState* play); void func_80BC9E50(EnStoneheishi* this, PlayState* play); +void func_80BC94B0(EnStoneheishi* this); +void func_80BC9660(EnStoneheishi* this); +void EnStoneheishi_SetupCheckGivenItem(EnStoneheishi*); +void EnStoneheishi_GiveItemReward(EnStoneheishi* this, PlayState* play); +void EnStoneheishi_SetupDrinkBottleProcess(EnStoneheishi* this); -#if 0 const ActorInit En_Stone_heishi_InitVars = { ACTOR_EN_STONE_HEISHI, ACTORCAT_NPC, @@ -35,54 +39,496 @@ const ActorInit En_Stone_heishi_InitVars = { (ActorFunc)EnStoneheishi_Draw, }; -// static ColliderCylinderInit sCylinderInit = { -static ColliderCylinderInit D_80BCA3A0 = { - { COLTYPE_NONE, AT_NONE, AC_NONE, OC1_ON | OC1_TYPE_ALL, OC2_TYPE_2, COLSHAPE_CYLINDER, }, - { ELEMTYPE_UNK0, { 0x00000000, 0x00, 0x00 }, { 0xF7CFFFFF, 0x00, 0x00 }, TOUCH_NONE | TOUCH_SFX_NORMAL, BUMP_NONE, OCELEM_ON, }, +static ColliderCylinderInit sCylinderInit = { + { + COLTYPE_NONE, + AT_NONE, + AC_NONE, + OC1_ON | OC1_TYPE_ALL, + OC2_TYPE_2, + COLSHAPE_CYLINDER, + }, + { + ELEMTYPE_UNK0, + { 0x00000000, 0x00, 0x00 }, + { 0xF7CFFFFF, 0x00, 0x00 }, + TOUCH_NONE | TOUCH_SFX_NORMAL, + BUMP_NONE, + OCELEM_ON, + }, { 15, 70, 0, { 0, 0, 0 } }, }; -#endif +static u16 sEnStoneHeishiTextIds[] = { 0x1473, 0x1474, 0x1475, 0x1476, 0x1477, 0x1478, 0x1479, 0x147A, 0x1472 }; -extern ColliderCylinderInit D_80BCA3A0; +static AnimationHeader* sAnimations[] = { + &gSoldierStandHandOnHip, &gSoldierDrink, &gSoldierCheerWithSpear, &gSoldierWave, + &gSoldierSitAndReach, &gSoldierDrink, &gSoldierStandUp, +}; -extern UNK_TYPE D_06000768; -extern UNK_TYPE D_06003BFC; +static u8 sAnimationModes[] = { + ANIMMODE_LOOP, ANIMMODE_ONCE, ANIMMODE_LOOP, ANIMMODE_LOOP, ANIMMODE_LOOP, ANIMMODE_LOOP, ANIMMODE_ONCE, +}; -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_En_Stone_heishi/EnStoneheishi_Init.s") +typedef enum { + /* 0 */ EN_STONE_ACTION_0, + /* 1 */ EN_STONE_ACTION_1, + /* 2 */ EN_STONE_ACTION_CHECK_ITEM, + /* 3 */ EN_STONE_ACTION_DRINK_BOTTLE, + /* 4 */ EN_STONE_ACTION_4 +} EnStoneHeishiAction; -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_En_Stone_heishi/EnStoneheishi_Destroy.s") +typedef enum { + /* 0 */ EN_STONE_DRINK_BOTTLE_INITIAL, + /* 1 */ EN_STONE_DRINK_BOTTLE_DRINKING, + /* 2 */ EN_STONE_DRINK_BOTTLE_EMPTY, + /* 3 */ EN_STONE_DRINK_BOTTLE_STAND_UP, + /* 4 */ EN_STONE_DRINK_BOTTLE_STANDING +} EnStoneHeishiDrinkBottle; -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_En_Stone_heishi/func_80BC935C.s") +typedef enum { + /* 0 */ EN_STONE_BOTTLE_NONE, + /* 1 */ EN_STONE_BOTTLE_RED_POTION, + /* 2 */ EN_STONE_BOTTLE_EMPTY, + /* 3 */ EN_STONE_BOTTLE_BLUE_POTION, +} EnStoneHeishiBottle; -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_En_Stone_heishi/func_80BC941C.s") +typedef enum { + /* 0 */ EN_STONE_HEISHI_ANIM_STAND_HAND_ON_HIP, + /* 1 */ EN_STONE_HEISHI_ANIM_DRINK_1, + /* 2 */ EN_STONE_HEISHI_ANIM_CHEER_WITH_SPEAR, + /* 3 */ EN_STONE_HEISHI_ANIM_WAVE, + /* 4 */ EN_STONE_HEISHI_ANIM_SIT_AND_REACH, + /* 5 */ EN_STONE_HEISHI_ANIM_DRINK_2, + /* 6 */ EN_STONE_HEISHI_ANIM_STAND_UP, +} EnStoneHeishiAnimations; -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_En_Stone_heishi/func_80BC94B0.s") +void EnStoneheishi_Init(Actor* thisx, PlayState* play) { + EnStoneheishi* this = THIS; -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_En_Stone_heishi/func_80BC9560.s") + ActorShape_Init(&this->actor.shape, 0.0f, ActorShadow_DrawCircle, 25.0f); + SkelAnime_InitFlex(play, &this->skelAnime, &gSoldierSkel, &gSoldierWave, this->jointTable, this->morphTable, + SOLDIER_LIMB_MAX); -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_En_Stone_heishi/func_80BC9660.s") + this->actor.colChkInfo.mass = MASS_IMMOVABLE; + this->actor.targetMode = 6; + this->actor.gravity = -3.0f; -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_En_Stone_heishi/func_80BC9680.s") + Collider_InitAndSetCylinder(play, &this->collider, &this->actor, &sCylinderInit); -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_En_Stone_heishi/func_80BC98EC.s") + this->collider.dim.radius = 40; + this->collider.dim.height = 40; + this->collider.dim.yShift = 0; -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_En_Stone_heishi/func_80BC9908.s") + func_80BC94B0(this); +} -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_En_Stone_heishi/func_80BC9A10.s") +void EnStoneheishi_Destroy(Actor* thisx, PlayState* play) { + EnStoneheishi* this = THIS; -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_En_Stone_heishi/func_80BC9A2C.s") + Collider_DestroyCylinder(play, &this->collider); +} -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_En_Stone_heishi/func_80BC9C88.s") +void EnStoneheishi_ChangeAnim(EnStoneheishi* this, s32 animIndex) { + f32 startFrame = 0.0f; -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_En_Stone_heishi/func_80BC9D28.s") + this->animIndex = animIndex; + this->endFrame = Animation_GetLastFrame(sAnimations[animIndex]); -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_En_Stone_heishi/func_80BC9E50.s") + // This will never pass since this animation index is never used. + if (animIndex == EN_STONE_HEISHI_ANIM_DRINK_2) { + startFrame = 55.0f; + } -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_En_Stone_heishi/EnStoneheishi_Update.s") + Animation_Change(&this->skelAnime, sAnimations[this->animIndex], 1.0f, startFrame, this->endFrame, + sAnimationModes[this->animIndex], -10.0f); +} -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_En_Stone_heishi/func_80BCA0AC.s") +void EnStoneheishi_TrackPlayer(EnStoneheishi* this) { + s32 yawDiff = ABS_ALT((s16)(this->actor.yawTowardsPlayer - this->actor.world.rot.y)); -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_En_Stone_heishi/func_80BCA104.s") + this->targetHeadRot.y = 0; -#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_En_Stone_heishi/EnStoneheishi_Draw.s") + if ((this->actor.xzDistToPlayer < 200.0f) && (yawDiff < 0x4E20)) { + this->targetHeadRot.y = this->actor.yawTowardsPlayer - this->actor.world.rot.y; + if (this->targetHeadRot.y > 0x2710) { + this->targetHeadRot.y = 0x2710; + } else if (this->targetHeadRot.y < -0x2710) { + this->targetHeadRot.y = -0x2710; + } + } +} + +void func_80BC94B0(EnStoneheishi* this) { + this->textIdIndex = 0; + if (gSaveContext.save.weekEventReg[41] & 0x40) { // After drinking bottle + EnStoneheishi_ChangeAnim(this, EN_STONE_HEISHI_ANIM_CHEER_WITH_SPEAR); + this->textIdIndex = 8; + this->actor.flags &= ~ACTOR_FLAG_80; + } else { // Initial configuration + EnStoneheishi_ChangeAnim(this, EN_STONE_HEISHI_ANIM_WAVE); + if (gSaveContext.save.weekEventReg[41] & 0x80) { + this->textIdIndex = 2; + } + } + this->actor.textId = sEnStoneHeishiTextIds[this->textIdIndex]; + this->action = EN_STONE_ACTION_0; + this->actionFunc = func_80BC9560; +} + +void func_80BC9560(EnStoneheishi* this, PlayState* play) { + Player* player = GET_PLAYER(play); + s32 yawDiff; + + if (Actor_ProcessTalkRequest(&this->actor, &play->state)) { + func_80BC9660(this); + return; + } + + if (!(gSaveContext.save.weekEventReg[41] & 0x40) && (play->actorCtx.lensMaskSize != 100)) { + this->actor.flags |= ACTOR_FLAG_8000000; + return; + } + + SkelAnime_Update(&this->skelAnime); + + this->actor.flags &= ~ACTOR_FLAG_8000000; + + yawDiff = ABS_ALT((s16)(this->actor.yawTowardsPlayer - this->actor.world.rot.y)); + + if ((yawDiff <= 0x18F0) && !(player->stateFlags1 & PLAYER_STATE1_800000)) { + func_800B8614(&this->actor, play, 70.0f); + } +} + +void func_80BC9660(EnStoneheishi* this) { + this->textIdSet = false; + this->action = EN_STONE_ACTION_1; + this->actionFunc = func_80BC9680; +} + +void func_80BC9680(EnStoneheishi* this, PlayState* play) { + f32 currentFrame = this->skelAnime.curFrame; + + if ((this->textIdIndex == 0) || (this->textIdIndex == 2)) { + if (this->animIndex != EN_STONE_HEISHI_ANIM_SIT_AND_REACH) { + if (fabsf(this->headRot.x - this->targetHeadRot.x) < 50.0f) { + EnStoneheishi_ChangeAnim(this, EN_STONE_HEISHI_ANIM_SIT_AND_REACH); + } + return; + } + } else if (this->textIdIndex == 3) { + if (this->animIndex != EN_STONE_HEISHI_ANIM_WAVE) { + if ((this->timer == 0) && (fabsf(this->headRot.x - this->targetHeadRot.x) < 50.0f)) { + EnStoneheishi_ChangeAnim(this, EN_STONE_HEISHI_ANIM_WAVE); + } + return; + } else if (!this->textIdSet && (this->endFrame <= currentFrame)) { + Player* player = GET_PLAYER(play); + + this->textIdSet = true; + player->actor.textId = sEnStoneHeishiTextIds[this->textIdIndex]; + + func_80151938(play, sEnStoneHeishiTextIds[this->textIdIndex]); + func_80151BB4(play, 0x12); + } + } + + SkelAnime_Update(&this->skelAnime); + + if ((Message_GetState(&play->msgCtx) == TEXT_STATE_5) && Message_ShouldAdvance(play)) { + func_801477B4(play); + + if (this->textIdIndex == 2) { + func_80151938(play, 0xFF); + EnStoneheishi_SetupCheckGivenItem(this); + } else if (this->textIdIndex == 3) { + func_80BC94B0(this); + } else if (this->textIdIndex == 6) { + EnStoneheishi_GiveItemReward(this, play); + } else { + if (this->textIdIndex < 7) { + this->textIdIndex++; + } else { + func_80151BB4(play, 0x12); + func_80BC94B0(this); + return; + } + func_80151938(play, sEnStoneHeishiTextIds[this->textIdIndex]); + } + } +} + +void EnStoneheishi_SetupCheckGivenItem(EnStoneheishi* this) { + this->action = EN_STONE_ACTION_CHECK_ITEM; + this->actionFunc = EnStoneheishi_CheckGivenItem; +} + +void EnStoneheishi_CheckGivenItem(EnStoneheishi* this, PlayState* play) { + s32 itemActionParam; + + SkelAnime_Update(&this->skelAnime); + + if (Message_GetState(&play->msgCtx) == TEXT_STATE_16) { + itemActionParam = func_80123810(play); + if (itemActionParam > PLAYER_AP_NONE) { + this->timer = 40; + func_801477B4(play); + + if ((itemActionParam == PLAYER_AP_BOTTLE_POTION_RED) || (itemActionParam == PLAYER_AP_BOTTLE_POTION_BLUE)) { + this->playerGivesBluePotion = false; + if (itemActionParam == PLAYER_AP_BOTTLE_POTION_BLUE) { + this->playerGivesBluePotion = true; + } + EnStoneheishi_SetupDrinkBottleProcess(this); + } else { + Player* player = GET_PLAYER(play); + + this->textIdIndex = 3; + player->actor.textId = 0; + gSaveContext.save.weekEventReg[41] |= 0x80; + this->action = EN_STONE_ACTION_1; + this->actionFunc = func_80BC9680; + } + } else if (itemActionParam < PLAYER_AP_NONE) { + func_801477B4(play); + func_80151BB4(play, 0x12); + func_80BC94B0(this); + } + } +} + +void EnStoneheishi_SetupDrinkBottleProcess(EnStoneheishi* this) { + this->action = EN_STONE_ACTION_DRINK_BOTTLE; + this->actionFunc = EnStoneheishi_DrinkBottleProcess; +} + +void EnStoneheishi_DrinkBottleProcess(EnStoneheishi* this, PlayState* play) { + f32 currentFrame = this->skelAnime.curFrame; + Player* player = GET_PLAYER(play); + + SkelAnime_Update(&this->skelAnime); + + switch (this->drinkBottleState) { + case EN_STONE_DRINK_BOTTLE_INITIAL: + if (this->timer == 0) { + this->textIdIndex = 4; + func_80151938(play, sEnStoneHeishiTextIds[this->textIdIndex]); + player->actor.textId = sEnStoneHeishiTextIds[this->textIdIndex]; + this->drinkBottleState++; + } + + default: + break; + + case EN_STONE_DRINK_BOTTLE_DRINKING: + if ((Message_GetState(&play->msgCtx) == TEXT_STATE_5) && Message_ShouldAdvance(play)) { + Player* player = GET_PLAYER(play); + + play->msgCtx.msgLength = 0; + player->actor.textId = 0; + player->exchangeItemId = PLAYER_AP_NONE; + this->bottleDisplay = EN_STONE_BOTTLE_RED_POTION; + + if (this->playerGivesBluePotion) { + this->bottleDisplay = EN_STONE_BOTTLE_BLUE_POTION; + } + + Player_SetModels(player, 3); + EnStoneheishi_ChangeAnim(this, EN_STONE_HEISHI_ANIM_DRINK_1); + this->timer = 30; + this->drinkBottleState++; + } + break; + + case EN_STONE_DRINK_BOTTLE_EMPTY: + if (this->timer != 0) { + if ((this->timer < 10) && (this->bottleDisplay != EN_STONE_BOTTLE_EMPTY)) { + this->bottleDisplay = EN_STONE_BOTTLE_EMPTY; + Actor_PlaySfxAtPos(&this->actor, NA_SE_VO_NP_DRINK); + func_80123D50(play, GET_PLAYER(play), ITEM_BOTTLE, PLAYER_AP_BOTTLE); + } + } else { + this->drinkBottleState++; + } + break; + + case EN_STONE_DRINK_BOTTLE_STAND_UP: + if (this->endFrame <= currentFrame) { + Audio_PlayFanfare(NA_BGM_GET_ITEM | 0x900); + this->bottleDisplay = EN_STONE_BOTTLE_NONE; + EnStoneheishi_ChangeAnim(this, EN_STONE_HEISHI_ANIM_STAND_UP); + this->drinkBottleState++; + } + break; + + case EN_STONE_DRINK_BOTTLE_STANDING: + if (this->endFrame <= currentFrame) { + this->textIdIndex = 5; + func_80151938(play, sEnStoneHeishiTextIds[this->textIdIndex]); + player->actor.textId = sEnStoneHeishiTextIds[this->textIdIndex]; + EnStoneheishi_ChangeAnim(this, EN_STONE_HEISHI_ANIM_STAND_HAND_ON_HIP); + this->action = EN_STONE_ACTION_1; + this->actionFunc = func_80BC9680; + } + break; + } +} + +void EnStoneheishi_GiveItemReward(EnStoneheishi* this, PlayState* play) { + func_801477B4(play); + + if (INV_CONTENT(ITEM_MASK_STONE) == ITEM_MASK_STONE) { + Actor_PickUp(&this->actor, play, GI_RUPEE_BLUE, 300.0f, 300.0f); + } else { + Actor_PickUp(&this->actor, play, GI_MASK_STONE, 300.0f, 300.0f); + } + + this->action = EN_STONE_ACTION_4; + this->actionFunc = func_80BC9D28; +} + +void func_80BC9D28(EnStoneheishi* this, PlayState* play) { + SkelAnime_Update(&this->skelAnime); + + if (Actor_HasParent(&this->actor, play)) { + this->actor.parent = NULL; + this->textIdIndex++; + this->actor.textId = sEnStoneHeishiTextIds[this->textIdIndex]; + gSaveContext.save.weekEventReg[41] |= 0x40; + Actor_ProcessTalkRequest(&this->actor, &play->state); + func_800B8500(&this->actor, play, 400.0f, 400.0f, PLAYER_AP_MINUS1); + this->actionFunc = func_80BC9E50; + } else if (INV_CONTENT(ITEM_MASK_STONE) == ITEM_MASK_STONE) { + Actor_PickUp(&this->actor, play, GI_RUPEE_BLUE, 300.0f, 300.0f); + } else { + Actor_PickUp(&this->actor, play, GI_MASK_STONE, 300.0f, 300.0f); + } +} + +void func_80BC9E50(EnStoneheishi* this, PlayState* play) { + SkelAnime_Update(&this->skelAnime); + + if (Actor_ProcessTalkRequest(&this->actor, &play->state)) { + func_80151BB4(play, 0x35); + func_80151BB4(play, 0x12); + this->action = EN_STONE_ACTION_1; + this->actionFunc = func_80BC9680; + } else { + func_800B8500(&this->actor, play, 400.0f, 400.0f, PLAYER_AP_MINUS1); + } +} + +void EnStoneheishi_Update(Actor* thisx, PlayState* play) { + s32 pad; + EnStoneheishi* this = THIS; + Player* player = GET_PLAYER(play); + + if (this->timer != 0) { + this->timer--; + } + + this->actor.shape.rot.y = this->actor.world.rot.y; + this->actionFunc(this, play); + + Actor_MoveWithGravity(&this->actor); + Actor_UpdateBgCheckInfo(play, &this->actor, 20.0f, 20.0f, 50.0f, 0x1D); + Actor_SetScale(&this->actor, 0.01f); + + if (((gSaveContext.save.weekEventReg[41] & 0x40) || (play->actorCtx.lensMaskSize == 100)) && + !(player->stateFlags1 & PLAYER_STATE1_800000)) { + if ((this->animIndex != EN_STONE_HEISHI_ANIM_WAVE) && + ((((this->action == EN_STONE_ACTION_0) || (this->action == EN_STONE_ACTION_1)) || + (this->action == EN_STONE_ACTION_CHECK_ITEM)) || + ((this->action == EN_STONE_ACTION_DRINK_BOTTLE) && + (this->drinkBottleState <= EN_STONE_DRINK_BOTTLE_DRINKING)))) { + EnStoneheishi_TrackPlayer(this); + } else { + this->targetHeadRot.y = 0; + } + + if (!(gSaveContext.save.weekEventReg[41] & 0x40)) { + Actor_SetFocus(&this->actor, 30.0f); + } else { + Actor_SetFocus(&this->actor, 60.0f); + } + + Math_SmoothStepToS(&this->headRot.y, this->targetHeadRot.y, 1, 0xBB8, 0); + Math_SmoothStepToS(&this->headRot.x, this->targetHeadRot.x, 1, 0x3E8, 0); + + Collider_UpdateCylinder(&this->actor, &this->collider); + CollisionCheck_SetOC(play, &play->colChkCtx, &this->collider.base); + } +} + +s32 EnStoneheishi_OverrideLimbDraw(PlayState* play, s32 limbIndex, Gfx** dList, Vec3f* pos, Vec3s* rot, Actor* thisx, + Gfx** gfxp) { + EnStoneheishi* this = THIS; + + if (limbIndex == SOLDIER_LIMB_HEAD) { + rot->x += this->headRot.y; + rot->y += this->headRot.x; + rot->z += this->headRot.z; + } + + return false; +} + +void EnStoneheishi_PostLimbDraw(PlayState* play, s32 limbIndex, Gfx** dList, Vec3s* rot, Actor* thisx, Gfx** gfxp) { + static Vec3f sLeftHandPos = { 0.0f, 0.0f, 0.0f }; + EnStoneheishi* this = THIS; + Gfx* gfx; + + if ((limbIndex == SOLDIER_LIMB_LEFT_HAND) && (this->bottleDisplay != EN_STONE_BOTTLE_NONE)) { + gfx = func_8012C2B4(*gfxp); + + sLeftHandPos.x = 320.0f; + sLeftHandPos.y = 210.0f; + sLeftHandPos.z = 440.0f; + + Matrix_Translate(sLeftHandPos.x, sLeftHandPos.y, sLeftHandPos.z, MTXMODE_APPLY); + + gDPPipeSync(gfx++); + + Matrix_RotateYS(-0x1770, MTXMODE_APPLY); + Matrix_RotateXS(0x7D0, MTXMODE_APPLY); + Matrix_RotateZS(-0x7530, MTXMODE_APPLY); + + if (this->bottleDisplay != EN_STONE_BOTTLE_EMPTY) { + if (this->bottleDisplay == EN_STONE_BOTTLE_BLUE_POTION) { + gDPSetEnvColor(gfx++, 0, 0, 200, 0); // Blue Potion + } else { + gDPSetEnvColor(gfx++, 200, 0, 0, 0); // Red Potion + } + gSPMatrix(gfx++, Matrix_NewMtx(play->state.gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW); + gSPDisplayList(gfx++, gSoldierBottleContentsDL); + } + + gSPMatrix(gfx++, Matrix_NewMtx(play->state.gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW); + gSPDisplayList(gfx++, gSoldierBottleDL); + + *gfxp = gfx++; + } +} + +void EnStoneheishi_Draw(Actor* thisx, PlayState* play) { + EnStoneheishi* this = THIS; + + OPEN_DISPS(play->state.gfxCtx); + + if (!(gSaveContext.save.weekEventReg[41] & 0x40)) { + func_8012C2DC(play->state.gfxCtx); + + POLY_XLU_DISP = + SkelAnime_DrawFlex(play, this->skelAnime.skeleton, this->skelAnime.jointTable, this->skelAnime.dListCount, + EnStoneheishi_OverrideLimbDraw, EnStoneheishi_PostLimbDraw, &this->actor, POLY_XLU_DISP); + } else { + func_8012C28C(play->state.gfxCtx); + + POLY_OPA_DISP = + SkelAnime_DrawFlex(play, this->skelAnime.skeleton, this->skelAnime.jointTable, this->skelAnime.dListCount, + EnStoneheishi_OverrideLimbDraw, EnStoneheishi_PostLimbDraw, &this->actor, POLY_OPA_DISP); + } + + CLOSE_DISPS(play->state.gfxCtx); +} diff --git a/src/overlays/actors/ovl_En_Stone_heishi/z_en_stone_heishi.h b/src/overlays/actors/ovl_En_Stone_heishi/z_en_stone_heishi.h index f4eb8e5f2..7b09d32bb 100644 --- a/src/overlays/actors/ovl_En_Stone_heishi/z_en_stone_heishi.h +++ b/src/overlays/actors/ovl_En_Stone_heishi/z_en_stone_heishi.h @@ -2,6 +2,7 @@ #define Z_EN_STONE_HEISHI_H #include "global.h" +#include "assets/objects/object_sdn/object_sdn.h" struct EnStoneheishi; @@ -9,9 +10,22 @@ typedef void (*EnStoneheishiActionFunc)(struct EnStoneheishi*, PlayState*); typedef struct EnStoneheishi { /* 0x000 */ Actor actor; - /* 0x144 */ char unk_144[0x110]; + /* 0x144 */ SkelAnime skelAnime; + /* 0x188 */ Vec3s jointTable[SOLDIER_LIMB_MAX]; + /* 0x1EE */ Vec3s morphTable[SOLDIER_LIMB_MAX]; /* 0x254 */ EnStoneheishiActionFunc actionFunc; - /* 0x258 */ char unk_258[0x6C]; + /* 0x258 */ Vec3s headRot; + /* 0x25E */ Vec3s targetHeadRot; + /* 0x264 */ s32 animIndex; + /* 0x268 */ s16 timer; + /* 0x26A */ s16 drinkBottleState; + /* 0x26C */ f32 endFrame; + /* 0x270 */ s16 action; + /* 0x272 */ s16 textIdIndex; + /* 0x274 */ s16 textIdSet; + /* 0x276 */ u8 bottleDisplay; + /* 0x277 */ u8 playerGivesBluePotion; + /* 0x278 */ ColliderCylinder collider; } EnStoneheishi; // size = 0x2C4 extern const ActorInit En_Stone_heishi_InitVars; diff --git a/src/overlays/actors/ovl_Obj_Hgdoor/z_obj_hgdoor.c b/src/overlays/actors/ovl_Obj_Hgdoor/z_obj_hgdoor.c index 72aaa3e12..ae528e3ea 100644 --- a/src/overlays/actors/ovl_Obj_Hgdoor/z_obj_hgdoor.c +++ b/src/overlays/actors/ovl_Obj_Hgdoor/z_obj_hgdoor.c @@ -16,15 +16,15 @@ void ObjHgdoor_Destroy(Actor* thisx, PlayState* play); void ObjHgdoor_Update(Actor* thisx, PlayState* play); void ObjHgdoor_Draw(Actor* thisx, PlayState* play); -void ObjHgdoor_SetupCheckShouldOpen(ObjHgdoor* this); -void ObjHgdoor_CheckShouldOpen(ObjHgdoor* this, PlayState* play); -void func_80BD42AC(ObjHgdoor* this); -void func_80BD42C0(ObjHgdoor* this, PlayState* play); -void func_80BD433C(ObjHgdoor* this); -void func_80BD4358(ObjHgdoor* this, PlayState* play); -void func_80BD4460(ObjHgdoor* this); -void func_80BD4478(ObjHgdoor* this, PlayState* play); -s32 func_80BD44D0(ObjHgdoor* this, PlayState* play); +void ObjHgdoor_SetupIdle(ObjHgdoor* this); +void ObjHgdoor_Idle(ObjHgdoor* this, PlayState* play); +void ObjHgdoor_SetupCutscene(ObjHgdoor* this); +void ObjHgdoor_PlayCutscene(ObjHgdoor* this, PlayState* play); +void ObjHgdoor_SetupCsAction(ObjHgdoor* this); +void ObjHgdoor_HandleCsAction(ObjHgdoor* this, PlayState* play); +void ObjHgdoor_SetupStopCs(ObjHgdoor* this); +void ObjHgdoor_StopCs(ObjHgdoor* this, PlayState* play); +s32 ObjHgdoor_Rotate(ObjHgdoor* this, PlayState* play); const ActorInit Obj_Hgdoor_InitVars = { ACTOR_OBJ_HGDOOR, @@ -38,9 +38,7 @@ const ActorInit Obj_Hgdoor_InitVars = { (ActorFunc)ObjHgdoor_Draw, }; -static s16 D_80BD4690 = 0; -static s32 unused = 0; -static s32 unused2 = 0; +static s16 sOpenFlag = 0; void ObjHgdoor_SetChild(ObjHgdoor* this, PlayState* play) { Actor* actorIterator = play->actorCtx.actorLists[ACTORCAT_PROP].first; @@ -82,7 +80,7 @@ void ObjHgdoor_Init(Actor* thisx, PlayState* play) { this->rotation = 0; this->timer = 0; this->cutscene = this->dyna.actor.cutscene; - ObjHgdoor_SetupCheckShouldOpen(this); + ObjHgdoor_SetupIdle(this); } void ObjHgdoor_Destroy(Actor* thisx, PlayState* play) { @@ -91,29 +89,29 @@ void ObjHgdoor_Destroy(Actor* thisx, PlayState* play) { DynaPoly_DeleteBgActor(play, &play->colCtx.dyna, this->dyna.bgId); } -void ObjHgdoor_SetupCheckShouldOpen(ObjHgdoor* this) { - this->actionFunc = ObjHgdoor_CheckShouldOpen; +void ObjHgdoor_SetupIdle(ObjHgdoor* this) { + this->actionFunc = ObjHgdoor_Idle; } -void ObjHgdoor_CheckShouldOpen(ObjHgdoor* this, PlayState* play) { +void ObjHgdoor_Idle(ObjHgdoor* this, PlayState* play) { if (!(gSaveContext.save.weekEventReg[75] & 0x20) && !(gSaveContext.save.weekEventReg[52] & 0x20) && (this->dyna.actor.xzDistToPlayer < 100.0f) && (this->dyna.actor.playerHeightRel < 40.0f) && OBJHGDOOR_IS_RIGHT_DOOR(&this->dyna.actor)) { ObjHgdoor_SetChild(this, play); ObjHgdoor_SetParent(this, play); - func_80BD42AC(this); + ObjHgdoor_SetupCutscene(this); } } -void func_80BD42AC(ObjHgdoor* this) { - this->actionFunc = func_80BD42C0; +void ObjHgdoor_SetupCutscene(ObjHgdoor* this) { + this->actionFunc = ObjHgdoor_PlayCutscene; } -void func_80BD42C0(ObjHgdoor* this, PlayState* play) { +void ObjHgdoor_PlayCutscene(ObjHgdoor* this, PlayState* play) { if (ActorCutscene_GetCanPlayNext(this->cutscene)) { ActorCutscene_Start(this->cutscene, &this->dyna.actor); - func_80BD433C(this); - func_80BD433C((ObjHgdoor*)this->dyna.actor.child); + ObjHgdoor_SetupCsAction(this); + ObjHgdoor_SetupCsAction((ObjHgdoor*)this->dyna.actor.child); } else { if (ActorCutscene_GetCurrentIndex() == 0x7C) { ActorCutscene_Stop(0x7C); @@ -122,50 +120,58 @@ void func_80BD42C0(ObjHgdoor* this, PlayState* play) { } } -void func_80BD433C(ObjHgdoor* this) { - this->unk166 = 0x63; - this->actionFunc = func_80BD4358; +void ObjHgdoor_SetupCsAction(ObjHgdoor* this) { + this->csAction = 0x63; + this->actionFunc = ObjHgdoor_HandleCsAction; } -void func_80BD4358(ObjHgdoor* this, PlayState* play) { +void ObjHgdoor_HandleCsAction(ObjHgdoor* this, PlayState* play) { s32 actionIndex; if (Cutscene_CheckActorAction(play, 483)) { actionIndex = Cutscene_GetActorActionIndex(play, 483); - if (this->unk166 != play->csCtx.actorActions[actionIndex]->action) { - this->unk166 = play->csCtx.actorActions[actionIndex]->action; + if (this->csAction != play->csCtx.actorActions[actionIndex]->action) { + this->csAction = play->csCtx.actorActions[actionIndex]->action; switch (play->csCtx.actorActions[actionIndex]->action) { case 1: Actor_PlaySfxAtPos(&this->dyna.actor, NA_SE_EV_WOOD_DOOR_OPEN_SPEEDY); if ((this->dyna.actor.parent != NULL) && (this->dyna.actor.parent->id == ACTOR_EN_HG)) { this->dyna.actor.parent->colChkInfo.health = 1; } - D_80BD4690 = 1; + sOpenFlag = 1; break; + case 2: break; } } - if ((D_80BD4690 == 1) && (func_80BD44D0(this, play))) { - func_80BD4460(this); + if ((sOpenFlag == 1) && ObjHgdoor_Rotate(this, play)) { + ObjHgdoor_SetupStopCs(this); } } else { - this->unk166 = 0x63; + this->csAction = 0x63; } } -void func_80BD4460(ObjHgdoor* this) { +void ObjHgdoor_SetupStopCs(ObjHgdoor* this) { this->timer = 0; - this->actionFunc = func_80BD4478; + this->actionFunc = ObjHgdoor_StopCs; } -void func_80BD4478(ObjHgdoor* this, PlayState* play) { - if (this->timer++ > 80 && !ActorCutscene_GetCanPlayNext(this->cutscene)) { - ActorCutscene_Stop(this->cutscene); +void ObjHgdoor_StopCs(ObjHgdoor* this, PlayState* play) { + if (this->timer++ > 80) { + if (!ActorCutscene_GetCanPlayNext(this->cutscene)) { + ActorCutscene_Stop(this->cutscene); + } } } -s32 func_80BD44D0(ObjHgdoor* this, PlayState* play) { +/** + * @brief Function to increment the rotation angle of the door + * + * @return true when door is fully open, false otherwise + */ +s32 ObjHgdoor_Rotate(ObjHgdoor* this, PlayState* play) { if (this->rotation < 0x5555) { this->rotation += 0x1388; } else { @@ -175,7 +181,7 @@ s32 func_80BD44D0(ObjHgdoor* this, PlayState* play) { return false; } -void func_80BD4500(ObjHgdoor* this) { +void ObjHgdoor_Open(ObjHgdoor* this) { this->dyna.actor.shape.rot.y = this->dyna.actor.home.rot.y; if (OBJHGDOOR_IS_RIGHT_DOOR(&this->dyna.actor)) { this->dyna.actor.shape.rot.y += this->rotation; @@ -188,7 +194,7 @@ void ObjHgdoor_Update(Actor* thisx, PlayState* play) { ObjHgdoor* this = THIS; this->actionFunc(this, play); - func_80BD4500(this); + ObjHgdoor_Open(this); } void ObjHgdoor_Draw(Actor* thisx, PlayState* play) { diff --git a/src/overlays/actors/ovl_Obj_Hgdoor/z_obj_hgdoor.h b/src/overlays/actors/ovl_Obj_Hgdoor/z_obj_hgdoor.h index 803236ac1..3e0af9e8c 100644 --- a/src/overlays/actors/ovl_Obj_Hgdoor/z_obj_hgdoor.h +++ b/src/overlays/actors/ovl_Obj_Hgdoor/z_obj_hgdoor.h @@ -16,7 +16,7 @@ typedef struct ObjHgdoor { /* 0x160 */ s16 cutscene; /* 0x162 */ s16 rotation; /* 0x164 */ s16 timer; - /* 0x166 */ u16 unk166; + /* 0x166 */ u16 csAction; } ObjHgdoor; // size = 0x168 extern const ActorInit Obj_Hgdoor_InitVars; diff --git a/tools/disasm/functions.txt b/tools/disasm/functions.txt index 9552c0287..7c0fc2dd4 100644 --- a/tools/disasm/functions.txt +++ b/tools/disasm/functions.txt @@ -6903,14 +6903,14 @@ 0x809199FC:("func_809199FC",), 0x80919D68:("EffDust_Draw",), 0x80919F30:("func_80919F30",), - 0x80919FC8:("func_80919FC8",), - 0x8091A044:("func_8091A044",), - 0x8091A0B8:("func_8091A0B8",), + 0x80919FC8:("BgUmajump_StopCutscene",), + 0x8091A044:("BgUmajump_PlayCutscene",), + 0x8091A0B8:("BgUmajump_CheckDistance",), 0x8091A124:("BgUmajump_Init",), 0x8091A2D8:("BgUmajump_Destroy",), 0x8091A30C:("BgUmajump_Update",), 0x8091A5A0:("func_8091A5A0",), - 0x8091A7B0:("func_8091A7B0",), + 0x8091A7B0:("BgUmajump_Draw",), 0x8091A8A0:("func_8091A8A0",), 0x8091A8C4:("EnInsect_XZDistanceSquared",), 0x8091A8F4:("EnInsect_InBottleRange",), @@ -11629,12 +11629,12 @@ 0x80AAEABC:("DmChar07_DoNothing",), 0x80AAEACC:("DmChar07_Update",), 0x80AAEAF0:("DmChar07_Draw",), - 0x80AAF050:("func_80AAF050",), - 0x80AAF15C:("func_80AAF15C",), + 0x80AAF050:("DmChar08_UpdateEyes",), + 0x80AAF15C:("DmChar08_ChangeAnimation",), 0x80AAF1F8:("DmChar08_Init",), 0x80AAF5D8:("DmChar08_Destroy",), - 0x80AAF610:("func_80AAF610",), - 0x80AAF79C:("func_80AAF79C",), + 0x80AAF610:("DmChar08_WaitForSong",), + 0x80AAF79C:("DmChar08_SetupAppearCs",), 0x80AAF884:("func_80AAF884",), 0x80AAF8F4:("func_80AAF8F4",), 0x80AAFA18:("func_80AAFA18",), @@ -11642,19 +11642,19 @@ 0x80AAFAE4:("func_80AAFAE4",), 0x80AAFB04:("func_80AAFB04",), 0x80AAFB94:("func_80AAFB94",), - 0x80AAFBA4:("func_80AAFBA4",), + 0x80AAFBA4:("DmChar08_SpawnBubbles",), 0x80AAFCCC:("func_80AAFCCC",), - 0x80AAFE78:("func_80AAFE78",), + 0x80AAFE78:("DmChar08_DoNothing",), 0x80AAFE88:("func_80AAFE88",), 0x80AB01E8:("func_80AB01E8",), 0x80AB023C:("func_80AB023C",), 0x80AB032C:("func_80AB032C",), 0x80AB096C:("func_80AB096C",), - 0x80AB0A10:("func_80AB0A10",), + 0x80AB0A10:("DmChar08_UpdateCollision",), 0x80AB0CC8:("DmChar08_Update",), - 0x80AB0E3C:("func_80AB0E3C",), - 0x80AB0E7C:("func_80AB0E7C",), - 0x80AB0F90:("func_80AB0F90",), + 0x80AB0E3C:("DmChar08_OverrideLimbDraw",), + 0x80AB0E7C:("DmChar08_PostLimbDraw",), + 0x80AB0F90:("DmChar08_TransformLimbDraw",), 0x80AB1124:("DmChar08_Draw",), 0x80AB1E10:("DmChar09_ChangeAnim",), 0x80AB1EAC:("DmChar09_Init",), @@ -14322,21 +14322,21 @@ 0x80B6ED58:("BgKin2Fence_DoNothing",), 0x80B6ED68:("BgKin2Fence_Update",), 0x80B6ED8C:("BgKin2Fence_Draw",), - 0x80B6EFA0:("func_80B6EFA0",), - 0x80B6EFEC:("func_80B6EFEC",), - 0x80B6F098:("func_80B6F098",), + 0x80B6EFA0:("BgKin2Picture_IsSkulltulaCollected",), + 0x80B6EFEC:("BgKin2Picture_SpawnSkulltula",), + 0x80B6F098:("BgKin2Picture_SpawnDust",), 0x80B6F2DC:("BgKin2Picture_Init",), 0x80B6F478:("BgKin2Picture_Destroy",), - 0x80B6F4C0:("func_80B6F4C0",), - 0x80B6F4D4:("func_80B6F4D4",), - 0x80B6F5A4:("func_80B6F5A4",), - 0x80B6F5B8:("func_80B6F5B8",), - 0x80B6F61C:("func_80B6F61C",), - 0x80B6F640:("func_80B6F640",), - 0x80B6F708:("func_80B6F708",), - 0x80B6F72C:("func_80B6F72C",), - 0x80B6F8F8:("func_80B6F8F8",), - 0x80B6F90C:("func_80B6F90C",), + 0x80B6F4C0:("BgKin2Picture_SetupWait",), + 0x80B6F4D4:("BgKin2Picture_Wait",), + 0x80B6F5A4:("BgKin2Picture_SetupPlayCutscene",), + 0x80B6F5B8:("BgKin2Picture_PlayCutscene",), + 0x80B6F61C:("BgKin2Picture_SetupShiver",), + 0x80B6F640:("BgKin2Picture_Shiver",), + 0x80B6F708:("BgKin2Picture_SetupFall",), + 0x80B6F72C:("BgKin2Picture_Fall",), + 0x80B6F8F8:("BgKin2Picture_SetupDoNothing",), + 0x80B6F90C:("BgKin2Picture_DoNothing",), 0x80B6F91C:("BgKin2Picture_Update",), 0x80B6F940:("BgKin2Picture_Draw",), 0x80B6FB30:("func_80B6FB30",), @@ -15595,22 +15595,22 @@ 0x80BC7BBC:("OceffWipe5_Draw",), 0x80BC9270:("EnStoneheishi_Init",), 0x80BC9330:("EnStoneheishi_Destroy",), - 0x80BC935C:("func_80BC935C",), - 0x80BC941C:("func_80BC941C",), + 0x80BC935C:("EnStoneheishi_ChangeAnim",), + 0x80BC941C:("EnStoneheishi_TrackPlayer",), 0x80BC94B0:("func_80BC94B0",), 0x80BC9560:("func_80BC9560",), 0x80BC9660:("func_80BC9660",), 0x80BC9680:("func_80BC9680",), - 0x80BC98EC:("func_80BC98EC",), - 0x80BC9908:("func_80BC9908",), - 0x80BC9A10:("func_80BC9A10",), - 0x80BC9A2C:("func_80BC9A2C",), - 0x80BC9C88:("func_80BC9C88",), + 0x80BC98EC:("EnStoneheishi_SetupCheckGivenItem",), + 0x80BC9908:("EnStoneheishi_CheckGivenItem",), + 0x80BC9A10:("EnStoneheishi_SetupDrinkBottleProcess",), + 0x80BC9A2C:("EnStoneheishi_DrinkBottleProcess",), + 0x80BC9C88:("EnStoneheishi_GiveItemReward",), 0x80BC9D28:("func_80BC9D28",), 0x80BC9E50:("func_80BC9E50",), 0x80BC9EE4:("EnStoneheishi_Update",), - 0x80BCA0AC:("func_80BCA0AC",), - 0x80BCA104:("func_80BCA104",), + 0x80BCA0AC:("EnStoneheishi_OverrideLimbDraw",), + 0x80BCA104:("EnStoneheishi_PostLimbDraw",), 0x80BCA2AC:("EnStoneheishi_Draw",), 0x80BCA5A0:("OceffWipe6_Init",), 0x80BCA5F8:("OceffWipe6_Destroy",), @@ -15765,16 +15765,16 @@ 0x80BD40D0:("func_80BD40D0",), 0x80BD4108:("ObjHgdoor_Init",), 0x80BD41B4:("ObjHgdoor_Destroy",), - 0x80BD41E8:("ObjHgdoor_SetupCheckShouldOpen",), - 0x80BD41FC:("ObjHgdoor_CheckShouldOpen",), - 0x80BD42AC:("func_80BD42AC",), - 0x80BD42C0:("func_80BD42C0",), - 0x80BD433C:("func_80BD433C",), - 0x80BD4358:("func_80BD4358",), - 0x80BD4460:("func_80BD4460",), - 0x80BD4478:("func_80BD4478",), - 0x80BD44D0:("func_80BD44D0",), - 0x80BD4500:("func_80BD4500",), + 0x80BD41E8:("ObjHgdoor_SetupIdle",), + 0x80BD41FC:("ObjHgdoor_Idle",), + 0x80BD42AC:("ObjHgdoor_SetupCutscene",), + 0x80BD42C0:("ObjHgdoor_PlayCutscene",), + 0x80BD433C:("ObjHgdoor_SetupCsAction",), + 0x80BD4358:("ObjHgdoor_HandleCsAction",), + 0x80BD4460:("ObjHgdoor_SetupStopCs",), + 0x80BD4478:("ObjHgdoor_StopCs",), + 0x80BD44D0:("ObjHgdoor_Rotate",), + 0x80BD4500:("ObjHgdoor_Open",), 0x80BD4540:("ObjHgdoor_Update",), 0x80BD4570:("ObjHgdoor_Draw",), 0x80BD4720:("func_80BD4720",), diff --git a/tools/disasm/variables.txt b/tools/disasm/variables.txt index dc951261b..ec157198d 100644 --- a/tools/disasm/variables.txt +++ b/tools/disasm/variables.txt @@ -12659,21 +12659,21 @@ 0x80AAE960:("Dm_Char06_InitVars","UNK_TYPE1","",0x1), 0x80AAEFF0:("Dm_Char07_InitVars","UNK_TYPE1","",0x1), 0x80AB1370:("Dm_Char08_InitVars","UNK_TYPE1","",0x1), - 0x80AB1390:("D_80AB1390","UNK_TYPE1","",0x1), - 0x80AB1398:("D_80AB1398","UNK_TYPE1","",0x1), - 0x80AB13A0:("D_80AB13A0","UNK_TYPE1","",0x1), - 0x80AB14D0:("D_80AB14D0","UNK_TYPE1","",0x1), - 0x80AB1600:("D_80AB1600","UNK_TYPE2","",0x2), - 0x80AB1648:("D_80AB1648","UNK_TYPE2","",0x2), - 0x80AB1690:("D_80AB1690","UNK_TYPE1","",0x1), + 0x80AB1390:("D_80AB1390","CamData","",0x8), + 0x80AB1398:("D_80AB1398","SurfaceType","",0x8), + 0x80AB13A0:("D_80AB13A0","CollisionPoly","19",0xCC), + 0x80AB14D0:("sTurtleGreatBayTempleColPolygons2","CollisionPoly[]","19",0xCC), + 0x80AB1600:("D_80AB1600","Vec3s[]","12",0x48), + 0x80AB1648:("D_80AB1648","Vec3s[]","12",0x48), + 0x80AB1690:("sTurtleGreatBayTempleCol","CollisionHeader","",0x2C), 0x80AB16A8:("D_80AB16A8","UNK_PTR","",0x4), - 0x80AB16BC:("D_80AB16BC","UNK_TYPE1","",0x1), - 0x80AB1764:("D_80AB1764","UNK_TYPE1","",0x1), - 0x80AB1770:("D_80AB1770","UNK_TYPE2","",0x2), - 0x80AB1774:("D_80AB1774","UNK_TYPE1","",0x1), - 0x80AB1778:("D_80AB1778","UNK_TYPE1","",0x1), - 0x80AB177C:("D_80AB177C","UNK_TYPE4","",0x4), - 0x80AB1788:("D_80AB1788","UNK_TYPE1","",0x1), + 0x80AB16BC:("sLargeTurtleAnimationInfo","AnimationInfo[]","0x7",0xE0), + 0x80AB1764:("sInitChain","InitChainEntry","",0x1), + 0x80AB1770:("D_80AB1770","s16","",0x2), + 0x80AB1774:("sLargeTurtleBubblePrimColor","Color_RGBA8","",0x4), + 0x80AB1778:("sLargeTurtleBubbleEnvColor","Color_RGBA8","",0x4), + 0x80AB177C:("sLargeTurtleBubbelAccel","Vec3f","",0xC), + 0x80AB1788:("sLargeTurtleEyeTextures","TexturePtr","9",0x1), 0x80AB17B0:("jtbl_80AB17B0","UNK_PTR","",0x4), 0x80AB17C8:("D_80AB17C8","f32","",0x4), 0x80AB17CC:("D_80AB17CC","f32","",0x4), @@ -14305,7 +14305,7 @@ 0x80B3FE50:("D_80B3FE50","f32","",0x4), 0x80B3FE54:("D_80B3FE54","f32","",0x4), 0x80B3FE58:("D_80B3FE58","UNK_TYPE1","",0x1), - 0x80B3FE70:("D_80B3FE70","UNK_TYPE1","",0x1), + 0x80B3FE70:("sEyeTextures","TexturePtr[]","0x9",0x4), 0x80B3FE90:("D_80B3FE90","f32","",0x4), 0x80B3FE94:("D_80B3FE94","f32","",0x4), 0x80B40760:("Bg_Goron_Oyu_InitVars","UNK_TYPE1","",0x1), diff --git a/tools/permuter_settings.toml b/tools/permuter_settings.toml index bf61be341..380acbfc2 100644 --- a/tools/permuter_settings.toml +++ b/tools/permuter_settings.toml @@ -1,3 +1,5 @@ +compiler_type = "ido" + [preserve_macros] "g[DS]P.*" = "void" "gs[DS]P.*" = "void"