mirror/Shipwright
1
0
Fork 0
mirror of https://github.com/HarbourMasters/Shipwright.git synced 2024-11-26 03:12:18 -05:00
Code Issues Projects Releases Wiki Activity

Save states (#300)

Browse Source
This commit is contained in:
louist103 2022-05-12 13:28:24 -04:00 committed by GitHub
parent 5746305157
commit 635fb71b76
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
64 changed files with 2084 additions and 634 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
libultraship/libultraship/ConfigFile.h
View File

@ -1,3 +1,6 @@
#ifndef CONFIG_FILE_H
#define CONFIG_FILE_H
#pragma once
#include <string>
@ -35,3 +38,5 @@ namespace Ship {
mINI::INIFile File;
};
}
#endif

5
libultraship/libultraship/GameVersions.h
View File

@ -1,3 +1,6 @@
#ifndef GAME_VERSION_H
#define GAME_VERSION_H
#pragma once
#define OOT_NTSC_10 0xEC7011B7
@ -18,3 +21,5 @@
#define OOT_IQUE_TW 0x3D81FB3E
#define OOT_IQUE_CN 0xB1E1E07B
#define OOT_UNKNOWN 0xFFFFFFFF
#endif

5
libultraship/libultraship/GlobalCtx2.h
View File

@ -1,3 +1,6 @@
#ifndef GLOBAL_CTX_2
#define GLOBAL_CTX_2
#pragma once
#ifdef __cplusplus
@ -39,3 +42,5 @@ namespace Ship {
};
}
#endif
#endif

3
libultraship/libultraship/Window.cpp
View File

@ -24,6 +24,7 @@
#include <chrono>
#include "SohHooks.h"
#include "SohConsole.h"
#include <iostream>
extern "C" {
@ -328,6 +329,8 @@ namespace Ship {
GlobalCtx2::GetInstance()->GetWindow()->ToggleFullscreen();
}
// OTRTODO: Rig with Kirito's console?
//if (dwScancode == Ship::stoi(Conf["KEYBOARD SHORTCUTS"]["KEY_CONSOLE"])) {
// ToggleConsole();

2
soh/include/functions.h
View File

@ -29,6 +29,7 @@ void gDPSetTextureImage(Gfx* pkt, u32 f, u32 s, u32 w, uintptr_t i);
void gSPDisplayList(Gfx* pkt, Gfx* dl);
void gSPDisplayListOffset(Gfx* pkt, Gfx* dl, int offset);
void gSPVertex(Gfx* pkt, uintptr_t v, int n, int v0);
void gSPInvalidateTexCache(Gfx* pkt, uintptr_t texAddr);
void cleararena(void);
void bootproc(void);
@ -2406,6 +2407,7 @@ void Heaps_Free(void);
#ifdef __cplusplus
#undef this
};
#undef this
#endif
#endif

5
soh/include/libc/stddef.h
View File

@ -1,7 +1,12 @@
#ifndef STDDEF_H
#define STDDEF_H
#ifndef __cplusplus
#define NULL ((void*)0)
#else
#define NULL nullptr
#endif
#if 0
#define size_t unsigned long
#define ssize_t long

3
soh/include/z64.h
View File

@ -30,6 +30,9 @@
#include "ichain.h"
#include "regs.h"
#define AUDIO_HEAP_SIZE 0x38000
#define SYSTEM_HEAP_SIZE (1024 * 1024 * 4)
#ifdef __cplusplus
namespace Ship
{

4
soh/soh.vcxproj
View File

@ -180,6 +180,7 @@
<ClCompile Include="soh\Enhancements\debugger\debugSaveEditor.cpp" />
<ClCompile Include="soh\Enhancements\debugger\ImGuiHelpers.cpp" />
<ClCompile Include="soh\Enhancements\gameconsole.c" />
<ClCompile Include="soh\Enhancements\savestates.cpp" />
<ClCompile Include="soh\GbiWrap.cpp" />
<ClCompile Include="soh\gu_pc.c" />
<ClCompile Include="soh\OTRGlobals.cpp" />
@ -328,7 +329,6 @@
<ClCompile Include="src\code\z_msgevent.c" />
<ClCompile Include="src\code\z_olib.c" />
<ClCompile Include="src\code\z_onepointdemo.c" />
<ClCompile Include="src\code\z_onepointdemo_data.c" />
<ClCompile Include="src\code\z_parameter.c" />
<ClCompile Include="src\code\z_path.c" />
<ClCompile Include="src\code\z_play.c" />
@ -926,10 +926,12 @@
<ClInclude Include="soh\Enhancements\cvar.h" />
<ClInclude Include="soh\Enhancements\debugconsole.h" />
<ClInclude Include="soh\Enhancements\debugger\colViewer.h" />
<ClInclude Include="soh\Enhancements\savestates.h" />
<ClInclude Include="soh\Enhancements\debugger\debugger.h" />
<ClInclude Include="soh\Enhancements\debugger\debugSaveEditor.h" />
<ClInclude Include="soh\Enhancements\debugger\ImGuiHelpers.h" />
<ClInclude Include="soh\gameconsole.h" />
<ClInclude Include="soh\OTRAudio.h" />
<ClInclude Include="soh\OTRGlobals.h" />
<ClInclude Include="soh\util.h" />
<ClInclude Include="src\overlays\actors\ovl_Arms_Hook\z_arms_hook.h" />

15
soh/soh.vcxproj.filters
View File

@ -630,9 +630,6 @@
<ClCompile Include="src\code\z_onepointdemo.c">
<Filter>Source Files\src\code</Filter>
</ClCompile>
<ClCompile Include="src\code\z_onepointdemo_data.c">
<Filter>Source Files\src\code</Filter>
</ClCompile>
<ClCompile Include="src\code\z_parameter.c">
<Filter>Source Files\src\code</Filter>
</ClCompile>
@ -2190,6 +2187,12 @@
<ClCompile Include="soh\Enhancements\debugger\ImGuiHelpers.cpp">
<Filter>Source Files\soh\Enhancements\debugger</Filter>
</ClCompile>
<ClCompile Include="src\code\z_cheap_proc.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="soh\Enhancements\savestates.cpp">
<Filter>Source Files\soh\Enhancements</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="src\overlays\actors\ovl_kaleido_scope\z_kaleido_scope.h">
@ -3746,6 +3749,12 @@
<ClInclude Include="soh\Enhancements\debugger\ImGuiHelpers.h">
<Filter>Header Files\soh\Enhancements\debugger</Filter>
</ClInclude>
<ClInclude Include="soh\Enhancements\savestates.h">
<Filter>Source Files\soh\Enhancements</Filter>
</ClInclude>
<ClInclude Include="soh\OTRAudio.h">
<Filter>Source Files\soh</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<None Include="include\macro.inc">

75
soh/soh/Enhancements/debugconsole.cpp
View File

@ -1,7 +1,15 @@
#ifdef _MSC_VER
#define NOGDI
#endif
#include "debugconsole.h"
#include "../libultraship/SohImGuiImpl.h"
#include "savestates.h"
#include <vector>
#include <string>
#include "soh/OTRGlobals.h"
#define Path _Path
#define PATH_HACK
@ -303,6 +311,66 @@ static bool EntranceHandler(const std::vector<std::string>& args) {
gSaveContext.nextTransition = 11;
}
static bool SaveStateHandler(const std::vector<std::string>& args) {
unsigned int slot = OTRGlobals::Instance->gSaveStateMgr->GetCurrentSlot();
const SaveStateReturn rtn = OTRGlobals::Instance->gSaveStateMgr->AddRequest({ slot, RequestType::SAVE });
switch (rtn) {
case SaveStateReturn::SUCCESS:
INFO("[SOH] Saved state to slot %u", slot);
return CMD_SUCCESS;
case SaveStateReturn::FAIL_WRONG_GAMESTATE:
ERROR("[SOH] Can not save a state outside of \"GamePlay\"");
return CMD_FAILED;
}
}
static bool LoadStateHandler(const std::vector<std::string>& args) {
unsigned int slot = OTRGlobals::Instance->gSaveStateMgr->GetCurrentSlot();
const SaveStateReturn rtn = OTRGlobals::Instance->gSaveStateMgr->AddRequest({ slot, RequestType::LOAD });
switch (rtn) {
case SaveStateReturn::SUCCESS:
INFO("[SOH] Loaded state from slot %u", slot);
return CMD_SUCCESS;
case SaveStateReturn::FAIL_INVALID_SLOT:
ERROR("[SOH] Invalid State Slot Number (%u)", slot);
return CMD_FAILED;
case SaveStateReturn::FAIL_STATE_EMPTY:
ERROR("[SOH] State Slot (%u) is empty", slot);
return CMD_FAILED;
case SaveStateReturn::FAIL_WRONG_GAMESTATE:
ERROR("[SOH] Can not load a state outside of \"GamePlay\"");
return CMD_FAILED;
}
}
static bool StateSlotSelectHandler(const std::vector<std::string>& args) {
if (args.size() != 2) {
ERROR("[SOH] Unexpected arguments passed");
return CMD_FAILED;
}
int slot;
try {
slot = std::stoi(args[1], nullptr, 10);
} catch (std::invalid_argument const& ex) {
ERROR("[SOH] SaveState slot value must be a number.");
return CMD_FAILED;
}
if (slot < 0) {
ERROR("[SOH] Invalid slot passed. Slot must be between 0 and 2");
return CMD_FAILED;
}
OTRGlobals::Instance->gSaveStateMgr->SetCurrentSlot(slot);
INFO("[SOH] Slot %u selected", OTRGlobals::Instance->gSaveStateMgr->GetCurrentSlot());
return CMD_SUCCESS;
}
#define VARTYPE_INTEGER 0
#define VARTYPE_FLOAT 1
#define VARTYPE_STRING 2
@ -416,6 +484,13 @@ void DebugConsole_Init(void) {
{ { "slot", ArgumentType::NUMBER }, { "item id", ArgumentType::NUMBER } } });
CMD_REGISTER("entrance",
{ EntranceHandler, "Sends player to the entered entrance (hex)", { { "entrance", ArgumentType::NUMBER } } });
CMD_REGISTER("save_state", { SaveStateHandler, "Save a state." });
CMD_REGISTER("load_state", { LoadStateHandler, "Load a state." });
CMD_REGISTER("set_slot", { StateSlotSelectHandler, "Selects a SaveState slot", {
{ "Slot number", ArgumentType::NUMBER, }
} });
DebugConsole_LoadCVars();
}
template <typename Numeric> bool is_number(const std::string& s) {

957
soh/soh/Enhancements/savestates.cpp Normal file
View File

@ -0,0 +1,957 @@
#include "savestates.h"
#include "GameVersions.h"
#include <cstdio> // std::sprintf
#include "spdlog/spdlog.h"
#include <soh/OTRGlobals.h>
#include <soh/OTRAudio.h>
#include <SohImGuiImpl.h>
#include "z64.h"
#include "z64save.h"
#include <variables.h>
#include <functions.h>
#include "z64map_mark.h"
#include "../../src/overlays/actors/ovl_Boss_Ganon/z_boss_ganon.h"
#include "../../src/overlays/actors/ovl_Boss_Ganon2/z_boss_ganon2.h"
#include "../../src/overlays/actors/ovl_Boss_Tw/z_boss_tw.h"
#include "../../src/overlays/actors/ovl_En_Clear_Tag/z_en_clear_tag.h"
#include "../../src/overlays/actors/ovl_En_Fr/z_en_fr.h"
extern "C" GlobalContext* gGlobalCtx;
// FROM z_lights.c
// I didn't feel like moving it into a header file.
#define LIGHTS_BUFFER_SIZE 32
typedef struct {
/* 0x000 */ s32 numOccupied;
/* 0x004 */ s32 searchIndex;
/* 0x008 */ LightNode buf[LIGHTS_BUFFER_SIZE];
} LightsBuffer; // size = 0x188
#include "savestates_extern.inc"
typedef struct SaveStateInfo {
unsigned char sysHeapCopy[SYSTEM_HEAP_SIZE];
unsigned char audioHeapCopy[AUDIO_HEAP_SIZE];
SaveContext saveContextCopy;
GameInfo gameInfoCopy;
LightsBuffer lightBufferCopy;
AudioContext audioContextCopy;
MtxF mtxStackCopy[20]; // always 20 matricies
MtxF currentMtxCopy;
uint32_t rngSeed;
int16_t blueWarpTimerCopy; /* From door_warp_1 */
SeqScriptState seqScriptStateCopy[4];// Unrelocated
unk_D_8016E750 unk_D_8016E750Copy[4];
ActiveSound gActiveSoundsCopy[7][MAX_CHANNELS_PER_BANK];
uint8_t gSoundBankMutedCopy[7];
u8 D_801333F0_copy;
u8 gAudioSfxSwapOff_copy;
uint16_t gAudioSfxSwapSource_copy[10];
uint16_t gAudioSfxSwapTarget_copy[10];
uint8_t gAudioSfxSwapMode_copy[10];
void (*D_801755D0_copy)(void);
MapMarkData** sLoadedMarkDataTableCopy;
//Static Data
//Camera data
int32_t sInitRegs_copy;
int32_t gDbgCamEnabled_copy;
int32_t sDbgModeIdx_copy;
int16_t sNextUID_copy;
int32_t sCameraInterfaceFlags_copy;
int32_t sCameraInterfaceAlpha_copy;
int32_t sCameraShrinkWindowVal_copy;
int32_t D_8011D3AC_copy;
int32_t sDemo5PrevAction12Frame_copy;
int32_t sDemo5PrevSfxFrame_copy;
int32_t D_8011D3F0_copy;
OnePointCsFull D_8011D6AC_copy[3];
OnePointCsFull D_8011D724_copy[3];
OnePointCsFull D_8011D79C_copy[3];
OnePointCsFull D_8011D83C_copy[2];
OnePointCsFull D_8011D88C_copy[2];
OnePointCsFull D_8011D8DC_copy[3];
OnePointCsFull D_8011D954_copy[4];
OnePointCsFull D_8011D9F4_copy[3];
int16_t D_8011DB08_copy;
int16_t D_8011DB0C_copy;
int32_t sOOBTimer_copy;
f32 D_8015CE50_copy;
f32 D_8015CE54_copy;
CamColChk D_8015CE58_copy;
//Gameover
uint16_t gGameOverTimer_copy;
//One point demo
uint32_t sPrevFrameCs1100_copy;
CutsceneCameraPoint D_8012013C_copy[14];
CutsceneCameraPoint D_8012021C_copy[14];
CutsceneCameraPoint D_801204D4_copy[14];
CutsceneCameraPoint D_801205B4_copy[14];
OnePointCsFull D_801208EC_copy[3];
OnePointCsFull D_80120964_copy[2];
OnePointCsFull D_801209B4_copy[4];
OnePointCsFull D_80120ACC_copy[5];
OnePointCsFull D_80120B94_copy[11];
OnePointCsFull D_80120D4C_copy[7];
OnePointCsFull D_80120FA4_copy[6];
OnePointCsFull D_80121184_copy[2];
OnePointCsFull D_801211D4_copy[2];
OnePointCsFull D_8012133C_copy[3];
OnePointCsFull D_801213B4_copy[5];
OnePointCsFull D_8012151C_copy[2];
OnePointCsFull D_8012156C_copy[2];
OnePointCsFull D_801215BC_copy[1];
OnePointCsFull D_80121C24_copy[7];
OnePointCsFull D_80121D3C_copy[3];
OnePointCsFull D_80121F1C_copy[4];
OnePointCsFull D_80121FBC_copy[4];
OnePointCsFull D_801220D4_copy[5];
OnePointCsFull D_80122714_copy[4];
OnePointCsFull D_80122CB4_copy[2];
OnePointCsFull D_80122D04_copy[2];
OnePointCsFull D_80122E44_copy[2][7];
OnePointCsFull D_8012313C_copy[3];
OnePointCsFull D_801231B4_copy[4];
OnePointCsFull D_80123254_copy[2];
OnePointCsFull D_801232A4_copy[1];
OnePointCsFull D_80123894_copy[3];
OnePointCsFull D_8012390C_copy[2];
OnePointCsFull D_8012395C_copy[3];
OnePointCsFull D_801239D4_copy[3];
uint16_t gTimeIncrement_copy;
//Overlay static data
// z_bg_ddan_kd
Vec3f sBgDdanKdVelocity_copy;
Vec3f sBgDdanKdAccel_copy;
// z_bg_dodoago
s16 sBgDodoagoFirstExplosiveFlag_copy;
u8 sBgDodoagoDisableBombCatcher_copy;
s32 sBgDodoagoTimer_copy;
// z_bg_haka_trap
uint32_t D_80880F30_copy;
uint32_t D_80881014_copy;
// z_bg_hidan_rock
float D_8088BFC0_copy;
// z_bg_menkuri_eye
int32_t D_8089C1A0_copy;
// z_bg_mori_hineri
int16_t sBgMoriHineriNextCamIdx_copy;
// z_bg_po_event
uint8_t sBgPoEventBlocksAtRest_copy;
uint8_t sBgPoEventPuzzleState_copy;
float sBgPoEventblockPushDist_copy;
// z_bg_relay_objects
uint32_t D_808A9508_copy;
// z_bg_spot18_basket
int16_t D_808B85D0_copy;
// z_boss_ganon
uint32_t sBossGanonSeed1_copy;
uint32_t sBossGanonSeed2_copy;
uint32_t sBossGanonSeed3_copy;
void* sBossGanonGanondorf_copy;
void* sBossGanonZelda_copy;
void* sBossGanonCape_copy;
GanondorfEffect sBossGanonEffectBuf_copy[200];
// z_boss_ganon
uint32_t sBossGanonSeed1;
uint32_t sBossGanonSeed2;
uint32_t sBossGanonSeed3;
void* sBossGanonGanondorf;
void* sBossGanonZelda;
void* sBossGanonCape;
GanondorfEffect sBossGanonEffectBuf[200];
// z_boss_ganon2
Vec3f D_8090EB20_copy;
int8_t D_80910638_copy;
void* sBossGanon2Zelda_copy;
void* D_8090EB30_copy;
int32_t sBossGanon2Seed1_copy;
int32_t sBossGanon2Seed2_copy;
int32_t sBossGanon2Seed3_copy;
Vec3f D_809105D8_copy[4];
Vec3f D_80910608_copy[4];
BossGanon2Effect sBossGanon2Particles_copy[100];
// z_boss_tw
uint8_t sTwInitalized_copy;
BossTwEffect sTwEffects_copy[150];
// z_demo_6k
Vec3f sDemo6kVelocity_copy;
// z_demo_du
int32_t D_8096CE94_copy;
// z_demo_kekkai
Vec3f demoKekkaiVel_copy;
// z_en_bw
int32_t sSlugGroup_copy;
// z_en_clear_tag
uint8_t sClearTagIsEffectInitialized_copy;
EnClearTagEffect sClearTagEffects_copy[CLEAR_TAG_EFFECT_MAX_COUNT];
// z_en_fr
EnFrPointers sEnFrPointers_copy;
// z_en_goma
uint8_t sSpawnNum_copy;
// z_en_insect
float D_80A7DEB0_copy;
int16_t D_80A7DEB4_copy;
int16_t D_80A7DEB8_copy;
// z_en_ishi
int16_t sRockRotSpeedX_copy;
int16_t sRockRotSpeedY_copy;
// z_en_niw
int16_t D_80AB85E0_copy;
uint8_t sLowerRiverSpawned_copy;
uint8_t sUpperRiverSpawned_copy;
// z_en_po_field
int32_t sEnPoFieldNumSpawned_copy;
Vec3s sEnPoFieldSpawnPositions_copy[10];
u8 sEnPoFieldSpawnSwitchFlags_copy[10];
// z_en_takara_man
uint8_t sTakaraIsInitialized_copy;
// z_en_xc
int32_t D_80B41D90_copy;
int32_t sEnXcFlameSpawned_copy;
int32_t D_80B41DA8_copy;
int32_t D_80B41DAC_copy;
// z_en_zf
int16_t D_80B4A1B0_copy;
int16_t D_80B4A1B4_copy;
int32_t D_80B5A468_copy;
int32_t D_80B5A494_copy;
int32_t D_80B5A4BC_copy;
uint8_t sKankyoIsSpawned_copy;
int16_t sTrailingFairies_copy;
//Misc static data
// z_map_exp
s16 sPlayerInitialPosX_copy;
s16 sPlayerInitialPosZ_copy;
s16 sPlayerInitialDirection_copy;
// code_800E(something. fill me in later)
u8 sOcarinaInpEnabled_copy;
s8 D_80130F10_copy;
u8 sCurOcarinaBtnVal_copy;
u8 sPrevOcarinaNoteVal_copy;
u8 sCurOcarinaBtnIdx_copy;
u8 sLearnSongLastBtn_copy;
f32 D_80130F24_copy;
f32 D_80130F28_copy;
s8 D_80130F2C_copy;
s8 D_80130F30_copy;
s8 D_80130F34_copy;
u8 sDisplayedNoteValue_copy;
u8 sPlaybackState_copy;
u32 D_80130F3C_copy;
u32 sNotePlaybackTimer_copy;
u16 sPlaybackNotePos_copy;
u16 sStaffPlaybackPos_copy;
u32 sCurOcarinaBtnPress_copy;
u32 D_8016BA10_copy;
u32 sPrevOcarinaBtnPress_copy;
s32 D_8016BA18_copy;
s32 D_8016BA1C_copy;
u8 sCurOcarinaSong_copy[8];
u8 sOcarinaSongAppendPos_copy;
u8 sOcarinaHasStartedSong_copy;
u8 sOcarinaSongNoteStartIdx_copy;
u8 sOcarinaSongCnt_copy;
u16 sOcarinaAvailSongs_copy;
u8 sStaffPlayingPos_copy;
u16 sLearnSongPos_copy[0x10];
u16 D_8016BA50_copy[0x10];
u16 D_8016BA70_copy[0x10];
u8 sLearnSongExpectedNote_copy[0x10];
OcarinaNote D_8016BAA0_copy;
u8 sAudioHasMalonBgm_copy;
f32 sAudioMalonBgmDist_copy;
// Message_PAL
s16 sOcarinaNoteBufPos_copy;
s16 sOcarinaNoteBufLen_copy;
u8 sOcarinaNoteBuf_copy[12];
u8 D_8014B2F4_copy;
u8 sTextboxSkipped_copy;
u16 sNextTextId_copy;
s16 sLastPlayedSong_copy;
s16 sHasSunsSong_copy;
s16 sMessageHasSetSfx_copy;
u16 sOcarinaSongBitFlags_copy;
} SaveStateInfo;
class SaveState {
friend class SaveStateMgr;
public:
SaveState(std::shared_ptr<SaveStateMgr> mgr, unsigned int slot);
private:
unsigned int slot;
std::shared_ptr<SaveStateMgr> saveStateMgr;
std::shared_ptr<SaveStateInfo> info;
void Save(void);
void Load(void);
void BackupSeqScriptState(void);
void LoadSeqScriptState(void);
void BackupCameraData(void);
void LoadCameraData(void);
void SaveOnePointDemoData(void);
void LoadOnePointDemoData(void);
void SaveOverlayStaticData(void);
void LoadOverlayStaticData(void);
void SaveMiscCodeData(void);
void LoadMiscCodeData(void);
SaveStateInfo* GetSaveStateInfo(void);
};
SaveStateMgr::SaveStateMgr() {
this->SetCurrentSlot(0);
}
SaveStateMgr::~SaveStateMgr() {
this->states.clear();
}
SaveState::SaveState(std::shared_ptr<SaveStateMgr> mgr, unsigned int slot) : saveStateMgr(mgr), slot(slot), info(nullptr) {
this->info = std::make_shared<SaveStateInfo>();
}
void SaveState::BackupSeqScriptState(void) {
for (unsigned int i = 0; i < 4; i++) {
info->seqScriptStateCopy[i].value = gAudioContext.seqPlayers[i].scriptState.value;
info->seqScriptStateCopy[i].remLoopIters[0] = gAudioContext.seqPlayers[i].scriptState.remLoopIters[0];
info->seqScriptStateCopy[i].remLoopIters[1] = gAudioContext.seqPlayers[i].scriptState.remLoopIters[1];
info->seqScriptStateCopy[i].remLoopIters[2] = gAudioContext.seqPlayers[i].scriptState.remLoopIters[2];
info->seqScriptStateCopy[i].remLoopIters[3] = gAudioContext.seqPlayers[i].scriptState.remLoopIters[3];
info->seqScriptStateCopy[i].depth = gAudioContext.seqPlayers[i].scriptState.depth;
info->seqScriptStateCopy[i].pc = (u8*)((uintptr_t)gAudioContext.seqPlayers[i].scriptState.pc - (uintptr_t)gAudioHeap);
info->seqScriptStateCopy[i].stack[0] =
(u8*)((uintptr_t)gAudioContext.seqPlayers[i].scriptState.stack[0] - (uintptr_t)gAudioHeap);
info->seqScriptStateCopy[i].stack[1] =
(u8*)((uintptr_t)gAudioContext.seqPlayers[i].scriptState.stack[1] - (uintptr_t)gAudioHeap);
info->seqScriptStateCopy[i].stack[2] =
(u8*)((uintptr_t)gAudioContext.seqPlayers[i].scriptState.stack[2] - (uintptr_t)gAudioHeap);
info->seqScriptStateCopy[i].stack[3] =
(u8*)((uintptr_t)gAudioContext.seqPlayers[i].scriptState.stack[3] - (uintptr_t)gAudioHeap);
}
}
void SaveState::LoadSeqScriptState(void) {
for (unsigned int i = 0; i < 4; i++) {
gAudioContext.seqPlayers[i].scriptState.value = info->seqScriptStateCopy[i].value;
gAudioContext.seqPlayers[i].scriptState.remLoopIters[0] = info->seqScriptStateCopy[i].remLoopIters[0];
gAudioContext.seqPlayers[i].scriptState.remLoopIters[1] = info->seqScriptStateCopy[i].remLoopIters[1];
gAudioContext.seqPlayers[i].scriptState.remLoopIters[2] = info->seqScriptStateCopy[i].remLoopIters[2];
gAudioContext.seqPlayers[i].scriptState.remLoopIters[3] = info->seqScriptStateCopy[i].remLoopIters[3];
gAudioContext.seqPlayers[i].scriptState.depth = info->seqScriptStateCopy[i].depth;
gAudioContext.seqPlayers[i].scriptState.pc =
(u8*)((uintptr_t)info->seqScriptStateCopy[i].pc + (uintptr_t)gAudioHeap);
gAudioContext.seqPlayers[i].scriptState.stack[0] =
(u8*)((uintptr_t)info->seqScriptStateCopy[i].stack[0] + (uintptr_t)gAudioHeap);
gAudioContext.seqPlayers[i].scriptState.stack[1] =
(u8*)((uintptr_t)info->seqScriptStateCopy[i].stack[1] + (uintptr_t)gAudioHeap);
gAudioContext.seqPlayers[i].scriptState.stack[2] =
(u8*)((uintptr_t)info->seqScriptStateCopy[i].stack[2] + (uintptr_t)gAudioHeap);
gAudioContext.seqPlayers[i].scriptState.stack[3] =
(u8*)((uintptr_t)info->seqScriptStateCopy[i].stack[3] + (uintptr_t)gAudioHeap);
}
}
void SaveState::BackupCameraData(void) {
info->sInitRegs_copy = sInitRegs;
info->gDbgCamEnabled_copy = gDbgCamEnabled;
info->sNextUID_copy = sNextUID;
info->sCameraInterfaceFlags_copy = sCameraInterfaceFlags;
info->sCameraInterfaceAlpha_copy = sCameraInterfaceAlpha;
info->sCameraShrinkWindowVal_copy = sCameraShrinkWindowVal;
info->D_8011D3AC_copy = D_8011D3AC;
info->sDemo5PrevAction12Frame_copy = sDemo5PrevAction12Frame;
info->sDemo5PrevSfxFrame_copy = sDemo5PrevSfxFrame;
info->D_8011D3F0_copy = D_8011D3F0;
memcpy(info->D_8011D6AC_copy, D_8011D6AC, sizeof(info->D_8011D6AC_copy));
memcpy(info->D_8011D724_copy, D_8011D724, sizeof(info->D_8011D724_copy));
memcpy(info->D_8011D79C_copy, D_8011D79C, sizeof(info->D_8011D79C_copy));
memcpy(info->D_8011D83C_copy, D_8011D83C, sizeof(info->D_8011D83C_copy));
memcpy(info->D_8011D88C_copy, D_8011D88C, sizeof(info->D_8011D88C_copy));
memcpy(info->D_8011D8DC_copy, D_8011D8DC, sizeof(info->D_8011D8DC_copy));
memcpy(info->D_8011D954_copy, D_8011D954, sizeof(info->D_8011D954_copy));
memcpy(info->D_8011D9F4_copy, D_8011D9F4, sizeof(info->D_8011D9F4_copy));
info->D_8011DB08_copy = D_8011DB08;
info->D_8011DB0C_copy = D_8011DB0C;
info->sOOBTimer_copy = sOOBTimer;
info->D_8015CE50_copy = D_8015CE50;
info->D_8015CE54_copy = D_8015CE54;
memcpy(&info->D_8015CE58_copy, &D_8015CE58, sizeof(info->D_8015CE58_copy));
}
void SaveState::LoadCameraData(void) {
sInitRegs = info->sInitRegs_copy;
gDbgCamEnabled = info->gDbgCamEnabled_copy;
sDbgModeIdx = info->sDbgModeIdx_copy;
sNextUID = info->sNextUID_copy;
sCameraInterfaceAlpha = info->sCameraInterfaceAlpha_copy;
sCameraInterfaceFlags = info->sCameraInterfaceFlags_copy;
sCameraShrinkWindowVal = info->sCameraShrinkWindowVal_copy;
D_8011D3AC = info->D_8011D3AC_copy;
sDemo5PrevAction12Frame = info->sDemo5PrevAction12Frame_copy;
sDemo5PrevSfxFrame = info->sDemo5PrevSfxFrame_copy;
D_8011D3F0 = info->D_8011D3F0_copy;
memcpy(D_8011D6AC, info->D_8011D6AC_copy, sizeof(info->D_8011D6AC_copy));
memcpy(D_8011D724, info->D_8011D724_copy, sizeof(info->D_8011D724_copy));
memcpy(D_8011D79C, info->D_8011D79C_copy, sizeof(info->D_8011D79C_copy));
memcpy(D_8011D83C, info->D_8011D83C_copy, sizeof(info->D_8011D83C_copy));
memcpy(D_8011D88C, info->D_8011D88C_copy, sizeof(info->D_8011D88C_copy));
memcpy(D_8011D8DC, info->D_8011D8DC_copy, sizeof(info->D_8011D8DC_copy));
memcpy(D_8011D954, info->D_8011D954_copy, sizeof(info->D_8011D954_copy));
memcpy(D_8011D9F4, info->D_8011D9F4_copy, sizeof(info->D_8011D9F4_copy));
D_8011DB08 = info->D_8011DB08_copy;
D_8011DB0C = info->D_8011DB0C_copy;
sOOBTimer = info->sOOBTimer_copy;
D_8015CE50 = info->D_8015CE50_copy;
D_8015CE54 = info->D_8015CE54_copy;
memcpy(&D_8015CE58, &info->D_8015CE58_copy, sizeof(info->D_8015CE58_copy));
}
void SaveState::SaveOnePointDemoData(void) {
info->sPrevFrameCs1100_copy = sPrevFrameCs1100;
memcpy(info->D_8012013C_copy, D_8012013C, sizeof(info->D_8012013C_copy));
memcpy(info->D_8012021C_copy, D_8012021C, sizeof(info->D_8012021C_copy));
memcpy(info->D_801204D4_copy, D_801204D4, sizeof(info->D_801204D4_copy));
memcpy(info->D_801205B4_copy, D_801205B4, sizeof(info->D_801205B4_copy));
memcpy(info->D_801208EC_copy, D_801208EC, sizeof(info->D_801208EC_copy));
memcpy(info->D_80120964_copy, D_80120964, sizeof(info->D_80120964_copy));
memcpy(info->D_801209B4_copy, D_801209B4, sizeof(info->D_801209B4_copy));
memcpy(info->D_80120ACC_copy, D_80120ACC, sizeof(info->D_80120ACC_copy));
memcpy(info->D_80120B94_copy, D_80120B94, sizeof(info->D_80120B94_copy));
memcpy(info->D_80120D4C_copy, D_80120D4C, sizeof(info->D_80120D4C_copy));
memcpy(info->D_80120FA4_copy, D_80120FA4, sizeof(info->D_80120FA4_copy));
memcpy(info->D_80121184_copy, D_80121184, sizeof(info->D_80121184_copy));
memcpy(info->D_801211D4_copy, D_801211D4, sizeof(info->D_801211D4_copy));
memcpy(info->D_8012133C_copy, D_8012133C, sizeof(info->D_8012133C_copy));
memcpy(info->D_801213B4_copy, D_801213B4, sizeof(info->D_801213B4_copy));
memcpy(info->D_8012151C_copy, D_8012151C, sizeof(info->D_8012151C_copy));
memcpy(info->D_8012156C_copy, D_8012156C, sizeof(info->D_8012156C_copy));
memcpy(info->D_801215BC_copy, D_801215BC, sizeof(info->D_801215BC_copy));
memcpy(info->D_80121C24_copy, D_80121C24, sizeof(info->D_80121C24_copy));
memcpy(info->D_80121D3C_copy, D_80121D3C, sizeof(info->D_80121D3C_copy));
memcpy(info->D_80121F1C_copy, D_80121F1C, sizeof(info->D_80121F1C_copy));
memcpy(info->D_80121FBC_copy, D_80121FBC, sizeof(info->D_80121FBC_copy));
memcpy(info->D_801220D4_copy, D_801220D4, sizeof(info->D_801220D4_copy));
memcpy(info->D_80122714_copy, D_80122714, sizeof(info->D_80122714_copy));
memcpy(info->D_80122CB4_copy, D_80122CB4, sizeof(info->D_80122CB4_copy));
memcpy(info->D_80122D04_copy, D_80122D04, sizeof(info->D_80122D04_copy));
memcpy(info->D_80122E44_copy, D_80122E44, sizeof(info->D_80122E44_copy));
memcpy(info->D_8012313C_copy, D_8012313C, sizeof(info->D_8012313C_copy));
memcpy(info->D_801231B4_copy, D_801231B4, sizeof(info->D_801231B4_copy));
memcpy(info->D_80123254_copy, D_80123254, sizeof(info->D_80123254_copy));
memcpy(info->D_801232A4_copy, D_801232A4, sizeof(info->D_801232A4_copy));
memcpy(info->D_80123894_copy, D_80123894, sizeof(info->D_80123894_copy));
memcpy(info->D_8012390C_copy, D_8012390C, sizeof(info->D_8012390C_copy));
memcpy(info->D_8012395C_copy, D_8012395C, sizeof(info->D_8012395C_copy));
memcpy(info->D_801239D4_copy, D_801239D4, sizeof(info->D_801239D4_copy));
}
void SaveState::LoadOnePointDemoData(void) {
sPrevFrameCs1100 = info->sPrevFrameCs1100_copy;
memcpy(D_8012013C, info->D_8012013C_copy, sizeof(info->D_8012013C_copy));
memcpy(D_8012021C, info->D_8012021C_copy, sizeof(info->D_8012021C_copy));
memcpy(D_801204D4, info->D_801204D4_copy, sizeof(info->D_801204D4_copy));
memcpy(D_801205B4, info->D_801205B4_copy, sizeof(info->D_801205B4_copy));
memcpy(D_801208EC, info->D_801208EC_copy, sizeof(info->D_801208EC_copy));
memcpy(D_80120964, info->D_80120964_copy, sizeof(info->D_80120964_copy));
memcpy(D_801209B4, info->D_801209B4_copy, sizeof(info->D_801209B4_copy));
memcpy(D_80120ACC, info->D_80120ACC_copy, sizeof(info->D_80120ACC_copy));
memcpy(D_80120B94, info->D_80120B94_copy, sizeof(info->D_80120B94_copy));
memcpy(D_80120D4C, info->D_80120D4C_copy, sizeof(info->D_80120D4C_copy));
memcpy(D_80120FA4, info->D_80120FA4_copy, sizeof(info->D_80120FA4_copy));
memcpy(D_80121184, info->D_80121184_copy, sizeof(info->D_80121184_copy));
memcpy(D_801211D4, info->D_801211D4_copy, sizeof(info->D_801211D4_copy));
memcpy(D_8012133C, info->D_8012133C_copy, sizeof(info->D_8012133C_copy));
memcpy(D_801213B4, info->D_801213B4_copy, sizeof(info->D_801213B4_copy));
memcpy(D_8012151C, info->D_8012151C_copy, sizeof(info->D_8012151C_copy));
memcpy(D_8012156C, info->D_8012156C_copy, sizeof(info->D_8012156C_copy));
memcpy(D_801215BC, info->D_801215BC_copy, sizeof(info->D_801215BC_copy));
memcpy(D_80121C24, info->D_80121C24_copy, sizeof(info->D_80121C24_copy));
memcpy(D_80121D3C, info->D_80121D3C_copy, sizeof(info->D_80121D3C_copy));
memcpy(D_80121F1C, info->D_80121F1C_copy, sizeof(info->D_80121F1C_copy));
memcpy(D_80121FBC, info->D_80121FBC_copy, sizeof(info->D_80121FBC_copy));
memcpy(D_801220D4, info->D_801220D4_copy, sizeof(info->D_801220D4_copy));
memcpy(D_80122714, info->D_80122714_copy, sizeof(info->D_80122714_copy));
memcpy(D_80122CB4, info->D_80122CB4_copy, sizeof(info->D_80122CB4_copy));
memcpy(D_80122D04, info->D_80122D04_copy, sizeof(info->D_80122D04_copy));
memcpy(D_80122E44, info->D_80122E44_copy, sizeof(info->D_80122E44_copy));
memcpy(D_8012313C, info->D_8012313C_copy, sizeof(info->D_8012313C_copy));
memcpy(D_801231B4, info->D_801231B4_copy, sizeof(info->D_801231B4_copy));
memcpy(D_80123254, info->D_80123254_copy, sizeof(info->D_80123254_copy));
memcpy(D_801232A4, info->D_801232A4_copy, sizeof(info->D_801232A4_copy));
memcpy(D_80123894, info->D_80123894_copy, sizeof(info->D_80123894_copy));
memcpy(D_8012390C, info->D_8012390C_copy, sizeof(info->D_8012390C_copy));
memcpy(D_8012395C, info->D_8012395C_copy, sizeof(info->D_8012395C_copy));
memcpy(D_801239D4, info->D_801239D4_copy, sizeof(info->D_801239D4_copy));
}
void SaveState::SaveOverlayStaticData(void) {
info->sBgDdanKdVelocity_copy = sBgDdanKdVelocity;
info->sBgDdanKdAccel_copy = sBgDdanKdAccel;
info->sBgDodoagoFirstExplosiveFlag_copy = sBgDodoagoFirstExplosiveFlag;
info->sBgDodoagoDisableBombCatcher_copy = sBgDodoagoDisableBombCatcher;
info->sBgDodoagoTimer_copy = sBgDodoagoTimer;
info->D_80880F30_copy = D_80880F30;
info->D_80881014_copy = D_80881014;
info->D_8088BFC0_copy = D_8088BFC0;
info->sBgMoriHineriNextCamIdx_copy = sBgMoriHineriNextCamIdx;
info->sBgPoEventBlocksAtRest_copy = sBgPoEventBlocksAtRest;
info->sBgPoEventPuzzleState_copy = sBgPoEventPuzzleState;
info->sBgPoEventblockPushDist_copy = sBgPoEventblockPushDist;
info->D_808A9508_copy = D_808A9508;
info->D_808B85D0_copy = D_808B85D0;
info->sBossGanonSeed1_copy = sBossGanonSeed1;
info->sBossGanonSeed2_copy = sBossGanonSeed2;
info->sBossGanonSeed3_copy = sBossGanonSeed3;
info->sBossGanonGanondorf_copy = sBossGanonGanondorf;
info->sBossGanonZelda_copy = sBossGanonZelda;
info->sBossGanonCape_copy = sBossGanonCape;
memcpy(info->sBossGanonEffectBuf_copy, sBossGanonEffectBuf, sizeof(info->sBossGanonEffectBuf_copy));
info->D_8090EB20_copy = D_8090EB20;
info->D_80910638_copy = D_80910638;
info->sBossGanon2Zelda_copy = sBossGanon2Zelda;
info->D_8090EB30_copy = D_8090EB30;
info->sBossGanon2Seed1_copy = sBossGanon2Seed1;
info->sBossGanon2Seed2_copy = sBossGanon2Seed2;
info->sBossGanon2Seed3_copy = sBossGanon2Seed3;
memcpy(info->D_809105D8_copy, D_809105D8, sizeof(D_809105D8));
memcpy(info->D_80910608_copy, D_80910608, sizeof(D_80910608));
memcpy(info->sBossGanon2Particles_copy, sBossGanon2Particles, sizeof(sBossGanon2Particles));
info->sTwInitalized_copy = sTwInitalized;
memcpy(info->sTwEffects_copy, sTwEffects, sizeof(sTwEffects));
info->sDemo6kVelocity_copy = sDemo6kVelocity;
info->D_8096CE94_copy = D_8096CE94;
info->demoKekkaiVel_copy = demoKekkaiVel;
info->sSlugGroup_copy = sSlugGroup;
info->sClearTagIsEffectInitialized_copy = sClearTagIsEffectsInitialized;
memcpy(info->sClearTagEffects_copy, sClearTagEffects, sizeof(sClearTagEffects));
memcpy(&info->sEnFrPointers_copy, &sEnFrPointers, sizeof(info->sEnFrPointers_copy));
info->sSpawnNum_copy = sSpawnNum;
info->D_80A7DEB0_copy = D_80A7DEB0;
info->D_80A7DEB4_copy = D_80A7DEB4;
info->D_80A7DEB8_copy = D_80A7DEB8;
info->sRockRotSpeedX_copy = sRockRotSpeedX;
info->sRockRotSpeedY_copy = sRockRotSpeedY;
info->D_80AB85E0_copy = D_80AB85E0;
info->sLowerRiverSpawned_copy = sLowerRiverSpawned;
info->sUpperRiverSpawned_copy = sUpperRiverSpawned;
info->sEnPoFieldNumSpawned_copy = sEnPoFieldNumSpawned;
memcpy(info->sEnPoFieldSpawnPositions_copy, sEnPoFieldSpawnPositions, sizeof(info->sEnPoFieldSpawnPositions_copy));
memcpy(info->sEnPoFieldSpawnSwitchFlags_copy, sEnPoFieldSpawnSwitchFlags, sizeof(info->sEnPoFieldSpawnSwitchFlags_copy));
info->sTakaraIsInitialized_copy = sTakaraIsInitialized;
info->D_80B41D90_copy = D_80B41D90;
info->sEnXcFlameSpawned_copy = sEnXcFlameSpawned;
info->D_80B41DA8_copy = D_80B41DA8;
info->D_80B41DAC_copy = D_80B41DAC;
info->D_80B4A1B0_copy = D_80B4A1B0;
info->D_80B4A1B4_copy = D_80B4A1B4;
info->D_80B5A468_copy = D_80B5A468;
info->D_80B5A494_copy = D_80B5A494;
info->D_80B5A4BC_copy = D_80B5A4BC;
info->sKankyoIsSpawned_copy = sKankyoIsSpawned;
info->sTrailingFairies_copy = sTrailingFairies;
}
void SaveState::LoadOverlayStaticData(void) {
sBgDdanKdVelocity = info->sBgDdanKdVelocity_copy;
sBgDdanKdAccel = info->sBgDdanKdAccel_copy;
sBgDodoagoFirstExplosiveFlag = info->sBgDodoagoFirstExplosiveFlag_copy;
sBgDodoagoDisableBombCatcher = info->sBgDodoagoDisableBombCatcher_copy;
sBgDodoagoTimer = info->sBgDodoagoTimer_copy;
D_80880F30 = info->D_80880F30_copy;
D_80881014 = info->D_80881014_copy;
D_8088BFC0 = info->D_8088BFC0_copy;
sBgMoriHineriNextCamIdx = info->sBgMoriHineriNextCamIdx_copy;
sBgPoEventBlocksAtRest = info->sBgPoEventBlocksAtRest_copy;
sBgPoEventPuzzleState = info->sBgPoEventPuzzleState_copy;
sBgPoEventblockPushDist = info->sBgPoEventblockPushDist_copy;
D_808A9508 = info->D_808A9508_copy;
D_808B85D0 = info->D_808B85D0_copy;
sBossGanonSeed1 = info->sBossGanonSeed1_copy;
sBossGanonSeed2 = info->sBossGanonSeed2_copy;
sBossGanonSeed3 = info->sBossGanonSeed3_copy;
sBossGanonGanondorf = info->sBossGanonGanondorf_copy;
sBossGanonZelda = info->sBossGanonZelda_copy;
sBossGanonCape = info->sBossGanonCape_copy;
memcpy(sBossGanonEffectBuf, info->sBossGanonEffectBuf_copy, sizeof(info->sBossGanonEffectBuf_copy));
D_8090EB20 = info->D_8090EB20_copy;
D_80910638 = info->D_80910638_copy;
sBossGanon2Zelda = info->sBossGanon2Zelda_copy;
D_8090EB30 = info->D_8090EB30_copy;
sBossGanon2Seed1 = info->sBossGanon2Seed1_copy;
sBossGanon2Seed2 = info->sBossGanon2Seed2_copy;
sBossGanon2Seed3 = info->sBossGanon2Seed3_copy;
memcpy(D_809105D8, info->D_809105D8_copy, sizeof(D_809105D8));
memcpy(D_80910608, info->D_80910608_copy, sizeof(D_80910608));
memcpy(sBossGanon2Particles, info->sBossGanon2Particles_copy, sizeof(sBossGanon2Particles));
sTwInitalized = info->sTwInitalized_copy;
memcpy(sTwEffects, info->sTwEffects_copy, sizeof(sTwEffects));
sDemo6kVelocity = info->sDemo6kVelocity_copy;
D_8096CE94 = info->D_8096CE94_copy;
demoKekkaiVel = info->demoKekkaiVel_copy;
sSlugGroup = info->sSlugGroup_copy;
sClearTagIsEffectsInitialized = info->sClearTagIsEffectInitialized_copy;
memcpy(sClearTagEffects, info->sClearTagEffects_copy, sizeof(sClearTagEffects));
D_80A7DEB0 = info->D_80A7DEB0_copy;
D_80A7DEB4 = info->D_80A7DEB4_copy;
D_80A7DEB8 = info->D_80A7DEB8_copy;
sRockRotSpeedX = info->sRockRotSpeedX_copy;
sRockRotSpeedY = info->sRockRotSpeedY_copy;
D_80AB85E0 = info->D_80AB85E0_copy;
sLowerRiverSpawned = info->sLowerRiverSpawned_copy;
sUpperRiverSpawned = info->sUpperRiverSpawned_copy;
sEnPoFieldNumSpawned = info->sEnPoFieldNumSpawned_copy;
memcpy(sEnPoFieldSpawnPositions, info->sEnPoFieldSpawnPositions_copy, sizeof(info->sEnPoFieldSpawnPositions_copy));
memcpy(sEnPoFieldSpawnSwitchFlags, info->sEnPoFieldSpawnSwitchFlags_copy, sizeof(info->sEnPoFieldSpawnSwitchFlags_copy));
sTakaraIsInitialized = info->sTakaraIsInitialized_copy;
D_80B41D90 = info->D_80B41D90_copy;
sEnXcFlameSpawned = info->sEnXcFlameSpawned_copy;
D_80B41DA8 = info->D_80B41DA8_copy;
D_80B41DAC = info->D_80B41DAC_copy;
D_80B4A1B0 = info->D_80B4A1B0_copy;
D_80B4A1B4 = info->D_80B4A1B4_copy;
D_80B5A468 = info->D_80B5A468_copy;
D_80B5A494 = info->D_80B5A494_copy;
D_80B5A4BC = info->D_80B5A4BC_copy;
sKankyoIsSpawned = info->sKankyoIsSpawned_copy;
sTrailingFairies = info->sTrailingFairies_copy;
}
void SaveState::SaveMiscCodeData(void) {
info->gGameOverTimer_copy = gGameOverTimer;
info->gTimeIncrement_copy = gTimeIncrement;
info->sLoadedMarkDataTableCopy = sLoadedMarkDataTable;
info->sPlayerInitialPosX_copy = sPlayerInitialPosX;
info->sPlayerInitialPosZ_copy = sPlayerInitialPosZ;
info->sPlayerInitialDirection_copy = sPlayerInitialDirection;
info->sOcarinaInpEnabled_copy = sOcarinaInpEnabled;
info->D_80130F10_copy = D_80130F10;
info->sCurOcarinaBtnVal_copy = sCurOcarinaBtnVal;
info->sPrevOcarinaNoteVal_copy = sPrevOcarinaNoteVal;
info->sCurOcarinaBtnIdx_copy = sCurOcarinaBtnIdx;
info->sLearnSongLastBtn_copy = sLearnSongLastBtn;
info->D_80130F24_copy = D_80130F24;
info->D_80130F28_copy = D_80130F28;
info->D_80130F2C_copy = D_80130F2C;
info->D_80130F30_copy = D_80130F30;
info->D_80130F34_copy = D_80130F34;
info->sPlaybackState_copy = sPlaybackState;
info->D_80130F3C_copy = D_80130F3C;
info->sNotePlaybackTimer_copy = sNotePlaybackTimer;
info->sPlaybackNotePos_copy = sPlaybackNotePos;
info->sStaffPlaybackPos_copy = sStaffPlaybackPos;
info->sCurOcarinaBtnPress_copy = sCurOcarinaBtnPress;
info->D_8016BA10_copy = D_8016BA10;
info->sPrevOcarinaBtnPress_copy = sPrevOcarinaBtnPress;
info->D_8016BA18_copy = D_8016BA18;
info->D_8016BA1C_copy = D_8016BA1C;
memcpy(info->sCurOcarinaSong_copy, sCurOcarinaSong, sizeof(sCurOcarinaSong));
info->sOcarinaSongAppendPos_copy = sOcarinaSongAppendPos;
info->sOcarinaHasStartedSong_copy = sOcarinaHasStartedSong;
info->sOcarinaSongNoteStartIdx_copy = sOcarinaSongNoteStartIdx;
info->sOcarinaSongCnt_copy = sOcarinaSongCnt;
info->sOcarinaAvailSongs_copy = sOcarinaAvailSongs;
info->sStaffPlayingPos_copy = sStaffPlayingPos;
memcpy(info->sLearnSongPos_copy, sLearnSongPos, sizeof(sLearnSongPos));
memcpy(info->D_8016BA50_copy, D_8016BA50, sizeof(D_8016BA50));
memcpy(info->D_8016BA70_copy, D_8016BA70, sizeof(D_8016BA70));
memcpy(info->sLearnSongExpectedNote_copy, sLearnSongExpectedNote, sizeof(sLearnSongExpectedNote));
memcpy(&info->D_8016BAA0_copy, &D_8016BAA0, sizeof(D_8016BAA0));
info->sAudioHasMalonBgm_copy = sAudioHasMalonBgm;
info->sAudioMalonBgmDist_copy = sAudioMalonBgmDist;
info->sDisplayedNoteValue_copy = sDisplayedNoteValue;
info->sOcarinaNoteBufPos_copy = sOcarinaNoteBufPos;
info->sOcarinaNoteBufLen_copy = sOcarinaNoteBufLen;
memcpy(info->sOcarinaNoteBuf_copy, sOcarinaNoteBuf, sizeof(sOcarinaNoteBuf));
info->D_8014B2F4_copy = D_8014B2F4;
info->sTextboxSkipped_copy = sTextboxSkipped;
info->sNextTextId_copy = sNextTextId;
info->sLastPlayedSong_copy = sLastPlayedSong;
info->sHasSunsSong_copy = sHasSunsSong;
info->sMessageHasSetSfx_copy = sMessageHasSetSfx;
info->sOcarinaSongBitFlags_copy = sOcarinaSongBitFlags;
}
void SaveState::LoadMiscCodeData(void) {
gGameOverTimer = info->gGameOverTimer_copy;
gTimeIncrement = info->gTimeIncrement_copy;
sLoadedMarkDataTable = info->sLoadedMarkDataTableCopy;
sPlayerInitialPosX = info->sPlayerInitialPosX_copy;
sPlayerInitialPosZ = info->sPlayerInitialPosZ_copy;
sPlayerInitialDirection = info->sPlayerInitialDirection_copy;
sOcarinaInpEnabled = info->sOcarinaInpEnabled_copy;
D_80130F10 = info->D_80130F10_copy;
sCurOcarinaBtnVal = info->sCurOcarinaBtnVal_copy;
sPrevOcarinaNoteVal = info->sPrevOcarinaNoteVal_copy;
sCurOcarinaBtnIdx = info->sCurOcarinaBtnIdx_copy;
sLearnSongLastBtn = info->sLearnSongLastBtn_copy;
D_80130F24 = info->D_80130F24_copy;
D_80130F28 = info->D_80130F28_copy;
D_80130F2C = info->D_80130F2C_copy;
D_80130F30 = info->D_80130F30_copy;
D_80130F34 = info->D_80130F34_copy;
sPlaybackState = info->sPlaybackState_copy;
D_80130F3C = info->D_80130F3C_copy;
sNotePlaybackTimer = info->sNotePlaybackTimer_copy;
sPlaybackNotePos = info->sPlaybackNotePos_copy;
sStaffPlaybackPos = info->sStaffPlaybackPos_copy;
sCurOcarinaBtnPress = info->sCurOcarinaBtnPress_copy;
D_8016BA10 = info->D_8016BA10_copy;
sPrevOcarinaBtnPress = info->sPrevOcarinaBtnPress_copy;
D_8016BA18 = info->D_8016BA18_copy;
D_8016BA1C = info->D_8016BA1C_copy;
memcpy(sCurOcarinaSong, info->sCurOcarinaSong_copy, sizeof(sCurOcarinaSong));
sOcarinaSongAppendPos = info->sOcarinaSongAppendPos_copy;
sOcarinaHasStartedSong = info->sOcarinaHasStartedSong_copy;
sOcarinaSongNoteStartIdx = info->sOcarinaSongNoteStartIdx_copy;
sOcarinaSongCnt = info->sOcarinaSongCnt_copy;
sOcarinaAvailSongs = info->sOcarinaAvailSongs_copy;
sStaffPlayingPos = info->sStaffPlayingPos_copy;
memcpy(info->sLearnSongPos_copy, info->sLearnSongPos_copy, sizeof(sLearnSongPos));
memcpy(info->D_8016BA50_copy, info->D_8016BA50_copy, sizeof(D_8016BA50));
memcpy(info->D_8016BA70_copy, info->D_8016BA70_copy, sizeof(D_8016BA70));
memcpy(info->sLearnSongExpectedNote_copy, info->sLearnSongExpectedNote_copy, sizeof(sLearnSongExpectedNote));
memcpy(&D_8016BAA0, &info->D_8016BAA0_copy, sizeof(D_8016BAA0));
sAudioHasMalonBgm = info->sAudioHasMalonBgm_copy;
sAudioMalonBgmDist = info->sAudioMalonBgmDist_copy;
sDisplayedNoteValue = info->sDisplayedNoteValue_copy;
sOcarinaNoteBufPos = info->sOcarinaNoteBufPos_copy;
sOcarinaNoteBufLen = info->sOcarinaNoteBufLen_copy;
memcpy(sOcarinaNoteBuf, info->sOcarinaNoteBuf_copy, sizeof(sOcarinaNoteBuf));
D_8014B2F4 = info->D_8014B2F4_copy;
sTextboxSkipped = info->sTextboxSkipped_copy;
sNextTextId = info->sNextTextId_copy;
sLastPlayedSong = info->sLastPlayedSong_copy;
sHasSunsSong = info->sHasSunsSong_copy;
sMessageHasSetSfx = info->sMessageHasSetSfx_copy;
sOcarinaSongBitFlags = info->sOcarinaSongBitFlags_copy;
}
extern "C" void ProcessSaveStateRequests(void) {
OTRGlobals::Instance->gSaveStateMgr->ProcessSaveStateRequests();
}
void SaveStateMgr::SetCurrentSlot(unsigned int slot) {
SohImGui::overlay->TextDrawNotification(1.0f, true, "slot %u set", slot);
this->currentSlot = slot;
}
unsigned int SaveStateMgr::GetCurrentSlot(void) {
return this->currentSlot;
}
void SaveStateMgr::ProcessSaveStateRequests(void) {
while (!this->requests.empty()) {
const auto& request = this->requests.front();
switch (request.type) {
case RequestType::SAVE:
if (!this->states.contains(request.slot)) {
this->states[request.slot] = std::make_shared<SaveState>(OTRGlobals::Instance->gSaveStateMgr, request.slot);
}
this->states[request.slot]->Save();
SohImGui::overlay->TextDrawNotification(1.0f, true, "saved state %u", request.slot);
break;
case RequestType::LOAD:
if (this->states.contains(request.slot)) {
this->states[request.slot]->Load();
SohImGui::overlay->TextDrawNotification(1.0f, true, "loaded state %u", request.slot);
} else {
SPDLOG_ERROR("Invalid SaveState slot: {}", request.type);
}
break;
[[unlikely]] default:
SPDLOG_ERROR("Invalid SaveState request type: {}", request.type);
break;
}
this->requests.pop();
}
}
SaveStateReturn SaveStateMgr::AddRequest(const SaveStateRequest request) {
if (gGlobalCtx == nullptr) {
SPDLOG_ERROR("[SOH] Can not save or load a state outside of \"GamePlay\"");
SohImGui::overlay->TextDrawNotification(1.0f, true, "states not available here", request.slot);
return SaveStateReturn::FAIL_WRONG_GAMESTATE;
}
switch (request.type) {
case RequestType::SAVE:
requests.push(request);
break;
case RequestType::LOAD:
if (states.contains(request.slot)) {
requests.push(request);
} else {
SPDLOG_ERROR("Invalid SaveState slot: {}", request.type);
SohImGui::overlay->TextDrawNotification(1.0f, true, "state slot %u empty", request.slot);
return SaveStateReturn::FAIL_INVALID_SLOT;
}
break;
[[unlikely]] default:
SPDLOG_ERROR("Invalid SaveState request type: {}", request.type);
return SaveStateReturn::FAIL_BAD_REQUEST;
break;
}
}
void SaveState::Save(void) {
std::unique_lock<std::mutex> Lock(audio.mutex);
memcpy(&info->sysHeapCopy, gSystemHeap, SYSTEM_HEAP_SIZE /* sizeof(gSystemHeap) */);
memcpy(&info->audioHeapCopy, gAudioHeap, AUDIO_HEAP_SIZE /* sizeof(gAudioContext) */);
memcpy(&info->audioContextCopy, &gAudioContext, sizeof(AudioContext));
memcpy(&info->unk_D_8016E750Copy, D_8016E750, sizeof(info->unk_D_8016E750Copy));
BackupSeqScriptState();
memcpy(info->gActiveSoundsCopy, gActiveSounds, sizeof(gActiveSounds));
memcpy(&info->gSoundBankMutedCopy, gSoundBankMuted, sizeof(info->gSoundBankMutedCopy));
info->D_801333F0_copy = D_801333F0;
info->gAudioSfxSwapOff_copy = gAudioSfxSwapOff;
memcpy(&info->gAudioSfxSwapSource_copy, gAudioSfxSwapSource,
sizeof(info->gAudioSfxSwapSource_copy));
memcpy(&info->gAudioSfxSwapTarget_copy, gAudioSfxSwapTarget,
sizeof(info->gAudioSfxSwapTarget_copy));
memcpy(&info->gAudioSfxSwapMode_copy, gAudioSfxSwapMode,
sizeof(info->gAudioSfxSwapMode_copy));
info->D_801755D0_copy = D_801755D0;
memcpy(&info->saveContextCopy, &gSaveContext, sizeof(gSaveContext));
memcpy(&info->gameInfoCopy, gGameInfo, sizeof(*gGameInfo));
memcpy(&info->lightBufferCopy, &sLightsBuffer, sizeof(sLightsBuffer));
memcpy(&info->mtxStackCopy, &sMatrixStack, sizeof(MtxF) * 20);
memcpy(&info->currentMtxCopy, &sCurrentMatrix, sizeof(MtxF));
//Various static data
info->blueWarpTimerCopy = sWarpTimerTarget;
BackupCameraData();
SaveOnePointDemoData();
SaveOverlayStaticData();
SaveMiscCodeData();
}
void SaveState::Load(void) {
std::unique_lock<std::mutex> Lock(audio.mutex);
memcpy(gSystemHeap, &info->sysHeapCopy, SYSTEM_HEAP_SIZE);
memcpy(gAudioHeap, &info->audioHeapCopy, AUDIO_HEAP_SIZE);
memcpy(&gAudioContext, &info->audioContextCopy, sizeof(AudioContext));
memcpy(D_8016E750, &info->unk_D_8016E750Copy, sizeof(info->unk_D_8016E750Copy));
LoadSeqScriptState();
memcpy(&gSaveContext, &info->saveContextCopy, sizeof(gSaveContext));
memcpy(gGameInfo, &info->gameInfoCopy, sizeof(*gGameInfo));
memcpy(&sLightsBuffer, &info->lightBufferCopy, sizeof(sLightsBuffer));
memcpy(&sMatrixStack, &info->mtxStackCopy, sizeof(MtxF) * 20);
memcpy(&sCurrentMatrix, &info->currentMtxCopy, sizeof(MtxF));
sWarpTimerTarget = info->blueWarpTimerCopy;
memcpy(gActiveSounds, info->gActiveSoundsCopy, sizeof(gActiveSounds));
memcpy(gSoundBankMuted, &info->gSoundBankMutedCopy, sizeof(info->gSoundBankMutedCopy));
D_801333F0 = info->D_801333F0_copy;
gAudioSfxSwapOff = info->gAudioSfxSwapOff_copy;
memcpy(gAudioSfxSwapSource, &info->gAudioSfxSwapSource_copy,
sizeof(info->gAudioSfxSwapSource_copy));
memcpy(gAudioSfxSwapTarget, &info->gAudioSfxSwapTarget_copy,
sizeof(info->gAudioSfxSwapTarget_copy));
memcpy(gAudioSfxSwapMode, &info->gAudioSfxSwapMode_copy,
sizeof(info->gAudioSfxSwapMode_copy));
//Various static data
D_801755D0 = info->D_801755D0_copy;
LoadCameraData();
LoadOnePointDemoData();
LoadOverlayStaticData();
LoadMiscCodeData();
}

62
soh/soh/Enhancements/savestates.h Normal file
View File

@ -0,0 +1,62 @@
#ifndef SAVE_STATES_H
#define SAVE_STATES_H
#include <cstdint>
#include <queue>
#include <unordered_map>
#include <memory>
#include <mutex>
enum class SaveStateReturn {
SUCCESS,
FAIL_INVALID_SLOT,
FAIL_NO_MEMORY,
FAIL_STATE_EMPTY,
FAIL_WRONG_GAMESTATE,
FAIL_BAD_REQUEST,
};
typedef struct SaveStateHeader {
uint32_t stateMagic;
uint32_t stateVersion;
//uint32_t gameVersion;
} SaveStateHeader;
enum class RequestType {
SAVE,
LOAD,
};
typedef struct SaveStateRequest {
unsigned int slot;
RequestType type;
} SaveStateRequest;
class SaveState;
class SaveStateMgr {
friend class SaveState;
private:
unsigned int currentSlot;
std::unordered_map<unsigned int, std::shared_ptr<SaveState>> states;
std::queue <SaveStateRequest> requests;
std::mutex mutex;
public:
SaveStateReturn AddRequest(const SaveStateRequest request);
SaveStateMgr();
~SaveStateMgr();
void SetCurrentSlot(unsigned int slot);
unsigned int GetCurrentSlot(void);
SaveStateMgr& operator=(const SaveStateMgr& rhs) = delete;
SaveStateMgr(const SaveStateMgr& rhs) = delete;
void ProcessSaveStateRequests(void);
};
extern std::shared_ptr<SaveStateMgr> gSaveStateMgr;
#endif

257
soh/soh/Enhancements/savestates_extern.inc Normal file
View File

@ -0,0 +1,257 @@
extern "C" MtxF* sMatrixStack;
extern "C" MtxF* sCurrentMatrix;
extern "C" LightsBuffer sLightsBuffer;
extern "C" s16 sWarpTimerTarget;
extern "C" MapMarkData** sLoadedMarkDataTable;
//Camera static data
extern "C" int32_t sInitRegs;
extern "C" int32_t gDbgCamEnabled;
extern "C" int32_t sDbgModeIdx;
extern "C" int16_t sNextUID;
extern "C" int32_t sCameraInterfaceFlags;
extern "C" int32_t sCameraInterfaceAlpha;
extern "C" int32_t sCameraShrinkWindowVal;
extern "C" int32_t D_8011D3AC;
extern "C" int32_t sDemo5PrevAction12Frame;
extern "C" int32_t sDemo5PrevSfxFrame;
extern "C" int32_t D_8011D3F0;
extern "C" OnePointCsFull D_8011D6AC[];
extern "C" OnePointCsFull D_8011D724[];
extern "C" OnePointCsFull D_8011D79C[];
extern "C" OnePointCsFull D_8011D83C[];
extern "C" OnePointCsFull D_8011D88C[];
extern "C" OnePointCsFull D_8011D8DC[];
extern "C" OnePointCsFull D_8011D954[];
extern "C" OnePointCsFull D_8011D9F4[];
extern "C" int16_t D_8011DB08;
extern "C" int16_t D_8011DB0C;
extern "C" int32_t sOOBTimer;
extern "C" f32 D_8015CE50;
extern "C" f32 D_8015CE54;
extern "C" CamColChk D_8015CE58;
//Gameover
extern "C" uint16_t gGameOverTimer;
//One Point Demo
extern "C" uint32_t sPrevFrameCs1100;
extern "C" CutsceneCameraPoint D_8012013C[14];
extern "C" CutsceneCameraPoint D_8012021C[14];
extern "C" CutsceneCameraPoint D_801204D4[14];
extern "C" CutsceneCameraPoint D_801205B4[14];
extern "C" OnePointCsFull D_801208EC[3];
extern "C" OnePointCsFull D_80120964[2];
extern "C" OnePointCsFull D_801209B4[4];
extern "C" OnePointCsFull D_80120ACC[5];
extern "C" OnePointCsFull D_80120B94[11];
extern "C" OnePointCsFull D_80120D4C[7];
extern "C" OnePointCsFull D_80120FA4[6];
extern "C" OnePointCsFull D_80121184[2];
extern "C" OnePointCsFull D_801211D4[2];
extern "C" OnePointCsFull D_8012133C[3];
extern "C" OnePointCsFull D_801213B4[5];
extern "C" OnePointCsFull D_8012151C[2];
extern "C" OnePointCsFull D_8012156C[2];
extern "C" OnePointCsFull D_801215BC[1];
extern "C" OnePointCsFull D_80121C24[7];
extern "C" OnePointCsFull D_80121D3C[3];
extern "C" OnePointCsFull D_80121F1C[4];
extern "C" OnePointCsFull D_80121FBC[4];
extern "C" OnePointCsFull D_801220D4[5];
extern "C" OnePointCsFull D_80122714[4];
extern "C" OnePointCsFull D_80122CB4[2];
extern "C" OnePointCsFull D_80122D04[2];
extern "C" OnePointCsFull D_80122E44[2][7];
extern "C" OnePointCsFull D_8012313C[3];
extern "C" OnePointCsFull D_801231B4[4];
extern "C" OnePointCsFull D_80123254[2];
extern "C" OnePointCsFull D_801232A4[1];
extern "C" OnePointCsFull D_80123894[3];
extern "C" OnePointCsFull D_8012390C[2];
extern "C" OnePointCsFull D_8012395C[3];
extern "C" OnePointCsFull D_801239D4[3];
// z_bg_ddan_kd
extern "C" Vec3f sBgDdanKdVelocity;
extern "C" Vec3f sBgDdanKdAccel;
// z_bg_dodoago
extern "C" s16 sBgDodoagoFirstExplosiveFlag;
extern "C" u8 sBgDodoagoDisableBombCatcher;
extern "C" s32 sBgDodoagoTimer;
// z_bg_haka_trap
extern "C" uint32_t D_80880F30;
extern "C" uint32_t D_80881014;
// z_bg_hidan_rock
extern "C" float D_8088BFC0;
// z_bg_menkuri_eye
extern "C" int32_t D_8089C1A0;
// z_bg_mori_hineri
extern "C" int16_t sBgMoriHineriNextCamIdx;
// z_bg_po_event
extern "C" uint8_t sBgPoEventBlocksAtRest;
extern "C" uint8_t sBgPoEventPuzzleState;
extern "C" float sBgPoEventblockPushDist;
// z_bg_relay_objects
extern "C" uint32_t D_808A9508;
// z_bg_spot18_basket
extern "C" int16_t D_808B85D0;
// z_boss_ganon
extern "C" uint32_t sBossGanonSeed1;
extern "C" uint32_t sBossGanonSeed2;
extern "C" uint32_t sBossGanonSeed3;
extern "C" void* sBossGanonGanondorf;
extern "C" void* sBossGanonZelda;
extern "C" void* sBossGanonCape;
extern "C" GanondorfEffect sBossGanonEffectBuf[200];
// z_boss_ganon2
extern "C" Vec3f D_8090EB20;
extern "C" int8_t D_80910638;
extern "C" void* sBossGanon2Zelda;
extern "C" void* D_8090EB30;
extern "C" int32_t sBossGanon2Seed1;
extern "C" int32_t sBossGanon2Seed2;
extern "C" int32_t sBossGanon2Seed3;
extern "C" Vec3f D_809105D8[4];
extern "C" Vec3f D_80910608[4];
extern "C" BossGanon2Effect sBossGanon2Particles[100];
// z_boss_tw
extern "C" uint8_t sTwInitalized;
extern "C" BossTwEffect sTwEffects[150];
// z_demo_6k
extern "C" Vec3f sDemo6kVelocity;
// z_demo_du
extern "C" int32_t D_8096CE94;
// z_demo_kekkai
extern "C" Vec3f demoKekkaiVel;
// z_en_bw
extern "C" int32_t sSlugGroup;
// z_en_clear_tag
extern "C" uint8_t sClearTagIsEffectsInitialized;
extern "C" EnClearTagEffect sClearTagEffects[CLEAR_TAG_EFFECT_MAX_COUNT];
// z_en_fr
extern "C" EnFrPointers sEnFrPointers;
// z_en_goma
extern "C" uint8_t sSpawnNum;
// z_en_in
extern "C" int32_t D_80A7B998;
// z_en_insect
extern "C" float D_80A7DEB0;
extern "C" int16_t D_80A7DEB4;
extern "C" int16_t D_80A7DEB8;
// z_en_ishi
extern "C" int16_t sRockRotSpeedX;
extern "C" int16_t sRockRotSpeedY;
// z_en_niw
extern "C" int16_t D_80AB85E0;
extern "C" uint8_t sLowerRiverSpawned;
extern "C" uint8_t sUpperRiverSpawned;
// z_en_po_field
extern "C" int32_t sEnPoFieldNumSpawned;
extern "C" Vec3s sEnPoFieldSpawnPositions[10];
extern "C" u8 sEnPoFieldSpawnSwitchFlags[10];
// z_en_takara_man
extern "C" uint8_t sTakaraIsInitialized;
// z_en_xc
extern "C" int32_t D_80B41D90;
extern "C" int32_t sEnXcFlameSpawned;
extern "C" int32_t D_80B41DA8;
extern "C" int32_t D_80B41DAC;
// z_en_zf
extern "C" int16_t D_80B4A1B0;
extern "C" int16_t D_80B4A1B4;
extern "C" int32_t D_80B5A468;
extern "C" int32_t D_80B5A494;
extern "C" int32_t D_80B5A4BC;
extern "C" uint8_t sKankyoIsSpawned;
extern "C" int16_t sTrailingFairies;
extern "C" uint16_t gTimeIncrement;
extern "C" s16 sPlayerInitialPosX;
extern "C" s16 sPlayerInitialPosZ;
extern "C" s16 sPlayerInitialDirection;
// code_800EC960
// Related to ocarina
extern "C" u8 sOcarinaInpEnabled;
extern "C" s8 D_80130F10;
extern "C" u8 sCurOcarinaBtnVal;
extern "C" u8 sPrevOcarinaNoteVal;
extern "C" u8 sCurOcarinaBtnIdx;
extern "C" u8 sLearnSongLastBtn;
extern "C" f32 D_80130F24;
extern "C" f32 D_80130F28;
extern "C" s8 D_80130F2C;
extern "C" s8 D_80130F30;
extern "C" s8 D_80130F34;
extern "C" u8 sPlaybackState;
extern "C" u32 D_80130F3C;
extern "C" u32 sNotePlaybackTimer;
extern "C" u16 sPlaybackNotePos;
extern "C" u16 sStaffPlaybackPos;
//IDK what this is but it looks important
extern "C" u32 sCurOcarinaBtnPress;
extern "C" u32 D_8016BA10;
extern "C" u32 sPrevOcarinaBtnPress;
extern "C" s32 D_8016BA18;
extern "C" s32 D_8016BA1C;
extern "C" u8 sCurOcarinaSong[8];
extern "C" u8 sOcarinaSongAppendPos;
extern "C" u8 sOcarinaHasStartedSong;
extern "C" u8 sOcarinaSongNoteStartIdx;
extern "C" u8 sOcarinaSongCnt;
extern "C" u16 sOcarinaAvailSongs;
extern "C" u8 sStaffPlayingPos;
extern "C" u16 sLearnSongPos[0x10];
extern "C" u16 D_8016BA50[0x10];
extern "C" u16 D_8016BA70[0x10];
extern "C" u8 sLearnSongExpectedNote[0x10];
extern "C" OcarinaNote D_8016BAA0;
extern "C" u8 sAudioHasMalonBgm;
extern "C" f32 sAudioMalonBgmDist;
extern "C" u8 sDisplayedNoteValue;
// z_message_PAL
extern "C" s16 sOcarinaNoteBufPos;
extern "C" s16 sOcarinaNoteBufLen;
extern "C" u8 sOcarinaNoteBuf[12];
extern "C" u8 D_8014B2F4;
extern "C" u8 sTextboxSkipped;
extern "C" u16 sNextTextId;
extern "C" s16 sLastPlayedSong;
extern "C" s16 sHasSunsSong;
extern "C" s16 sMessageHasSetSfx;
extern "C" u16 sOcarinaSongBitFlags;

8
soh/soh/OTRAudio.h Normal file
View File

@ -0,0 +1,8 @@
#pragma once
static struct {
std::condition_variable cv_to_thread, cv_from_thread;
std::mutex mutex;
bool initialized;
bool processing;
} audio;

75
soh/soh/OTRGlobals.cpp
View File

@ -1,4 +1,5 @@
#include "OTRGlobals.h"
#include "OTRAudio.h"
#include <iostream>
#include <locale>
#include <codecvt>
@ -33,17 +34,14 @@
#include "macros.h"
#include <Utils/StringHelper.h>
#include <SDL2/SDL_scancode.h>
OTRGlobals* OTRGlobals::Instance;
static struct {
std::condition_variable cv_to_thread, cv_from_thread;
std::mutex mutex;
bool initialized;
bool processing;
} audio;
OTRGlobals::OTRGlobals() {
context = Ship::GlobalCtx2::CreateInstance("Ship of Harkinian");
gSaveStateMgr = std::make_shared<SaveStateMgr>();
context->GetWindow()->Init();
}
@ -114,6 +112,63 @@ extern "C" void Graph_ProcessFrame(void (*run_one_game_iter)(void)) {
}
extern "C" void Graph_StartFrame() {
// Why -1?
int32_t dwScancode = OTRGlobals::Instance->context->GetWindow()->lastScancode;
OTRGlobals::Instance->context->GetWindow()->lastScancode = -1;
switch (dwScancode - 1) {
case SDL_SCANCODE_F5: {
const unsigned int slot = OTRGlobals::Instance->gSaveStateMgr->GetCurrentSlot();
const SaveStateReturn stateReturn =
OTRGlobals::Instance->gSaveStateMgr->AddRequest({ slot, RequestType::SAVE });
switch (stateReturn) {
case SaveStateReturn::SUCCESS:
SPDLOG_INFO("[SOH] Saved state to slot {}", slot);
break;
case SaveStateReturn::FAIL_WRONG_GAMESTATE:
SPDLOG_ERROR("[SOH] Can not save a state outside of \"GamePlay\"");
break;
[[unlikely]] default:
break;
}
break;
}
case SDL_SCANCODE_F6: {
unsigned int slot = OTRGlobals::Instance->gSaveStateMgr->GetCurrentSlot();
slot++;
if (slot > 5) {
slot = 0;
}
OTRGlobals::Instance->gSaveStateMgr->SetCurrentSlot(slot);
SPDLOG_INFO("Set SaveState slot to {}.", slot);
break;
}
case SDL_SCANCODE_F7: {
const unsigned int slot = OTRGlobals::Instance->gSaveStateMgr->GetCurrentSlot();
const SaveStateReturn stateReturn =
OTRGlobals::Instance->gSaveStateMgr->AddRequest({ slot, RequestType::LOAD });
switch (stateReturn) {
case SaveStateReturn::SUCCESS:
SPDLOG_INFO("[SOH] Loaded state from slot {}", slot);
break;
case SaveStateReturn::FAIL_INVALID_SLOT:
SPDLOG_ERROR("[SOH] Invalid State Slot Number {}", slot);
break;
case SaveStateReturn::FAIL_STATE_EMPTY:
SPDLOG_ERROR("[SOH] State Slot {} is empty", slot);
break;
case SaveStateReturn::FAIL_WRONG_GAMESTATE:
SPDLOG_ERROR("[SOH] Can not load a state outside of \"GamePlay\"");
break;
[[unlikely]] default:
break;
}
break;
}
}
OTRGlobals::Instance->context->GetWindow()->StartFrame();
}
@ -131,6 +186,7 @@ extern "C" void Graph_ProcessGfxCommands(Gfx* commands) {
audio.cv_to_thread.wait(Lock);
}
}
std::unique_lock<std::mutex> Lock(audio.mutex);
//AudioMgr_ThreadEntry(&gAudioMgr);
// 528 and 544 relate to 60 fps at 32 kHz 32000/60 = 533.333..
// in an ideal world, one third of the calls should use num_samples=544 and two thirds num_samples=528
@ -156,10 +212,7 @@ extern "C" void Graph_ProcessGfxCommands(Gfx* commands) {
// printf("Audio samples before submitting: %d\n", audio_api->buffered());
AudioPlayer_Play((u8*)audio_buffer, num_audio_samples * (sizeof(int16_t) * NUM_AUDIO_CHANNELS * AUDIO_FRAMES_PER_UPDATE));
{
std::unique_lock<std::mutex> Lock(audio.mutex);
audio.processing = false;
}
audio.processing = false;
audio.cv_from_thread.notify_one();
}
}).detach();

15
soh/soh/OTRGlobals.h
View File

@ -1,17 +1,22 @@
#ifndef OTR_GLOBALS_H
#define OTR_GLOBALS_H
#pragma once
#include "GlobalCtx2.h"
#ifdef __cplusplus
#include "Enhancements/savestates.h"
class OTRGlobals
{
public:
static OTRGlobals* Instance;
static OTRGlobals* Instance;
std::shared_ptr<Ship::GlobalCtx2> context;
std::shared_ptr<Ship::GlobalCtx2> context;
std::shared_ptr<SaveStateMgr> gSaveStateMgr;
OTRGlobals();
~OTRGlobals();
OTRGlobals();
~OTRGlobals();
private:
@ -68,3 +73,5 @@ void AudioPlayer_Play(const uint8_t* buf, uint32_t len);
void AudioMgr_CreateNextAudioBuffer(s16* samples, u32 num_samples);
int Controller_ShouldRumble(size_t i);
#endif
#endif

3
soh/src/buffers/heaps.c
View File

@ -6,9 +6,6 @@
#include <unistd.h>
#endif
#define AUDIO_HEAP_SIZE 0x38000
#define SYSTEM_HEAP_SIZE (1024 * 1024 * 128)
u8* gAudioHeap;
u8* gSystemHeap;

3
soh/src/code/graph.c
View File

@ -431,6 +431,8 @@ static struct RunFrameContext {
extern AudioMgr gAudioMgr;
extern void ProcessSaveStateRequests(void);
static void RunFrame()
{
u32 size;
@ -487,6 +489,7 @@ static void RunFrame()
//uint64_t diff = (ticksB - ticksA) / (freq / 1000);
//printf("Frame simulated in %ims\n", diff);
runFrameContext.state = 1;
ProcessSaveStateRequests();
return;
nextFrame:;
}

12
soh/src/code/z_camera.c
View File

@ -565,10 +565,10 @@ s16 Camera_XZAngle(Vec3f* to, Vec3f* from) {
return DEGF_TO_BINANG(RADF_TO_DEGF(Math_FAtan2F(from->x - to->x, from->z - to->z)));
}
f32 D_8015CE50;
f32 D_8015CE54;
CamColChk D_8015CE58;
s16 func_80044ADC(Camera* camera, s16 yaw, s16 arg2) {
static f32 D_8015CE50;
static f32 D_8015CE54;
static CamColChk D_8015CE58;
Vec3f playerPos;
Vec3f rotatedPos;
Vec3f floorNorm;
@ -7221,9 +7221,9 @@ s32 Camera_DbgChangeMode(Camera* camera) {
return true;
}
s16 D_8011DB08 = 0x3F0;
s16 D_8011DB0C = 0x156;
void func_80058E8C(Camera* camera) {
static s16 D_8011DB08 = 0x3F0;
static s16 D_8011DB0C = 0x156;
s32 pad3;
f32 sp60;
s32 pad;
@ -7299,8 +7299,8 @@ void func_80058E8C(Camera* camera) {
}
}
s32 sOOBTimer = 0;
Vec3s Camera_Update(Camera* camera) {
static s32 sOOBTimer = 0;
Vec3f viewAt;
Vec3f viewEye;
Vec3f viewUp;

2
soh/src/code/z_map_mark.c
View File

@ -52,7 +52,7 @@ static MapMarkDataOverlay sMapMarkDataOvl = {
gMapMarkDataTable,
};
static MapMarkData** sLoadedMarkDataTable;
MapMarkData** sLoadedMarkDataTable;
void MapMark_Init(GlobalContext* globalCtx) {
MapMarkDataOverlay* overlay = &sMapMarkDataOvl;

4
soh/src/code/z_onepointdemo.c
View File

@ -4,9 +4,9 @@
static s16 sDisableAttention = false;
static s16 sUnused = -1;
static s32 sPrevFrameCs1100 = -4096;
s32 sPrevFrameCs1100 = -4096;
#include "z_onepointdemo_data.c"
#include "z_onepointdemo_data.inc"
void OnePointCutscene_AddVecSphToVec3f(Vec3f* dst, Vec3f* src, VecSph* vecSph) {
Vec3f out;

70
soh/src/code/z_onepointdemo_data.c → soh/src/code/z_onepointdemo_data.inc
View File

@ -1,6 +1,6 @@
#include "global.h"
static CutsceneCameraPoint D_8012013C[14] = {
CutsceneCameraPoint D_8012013C[14] = {
{ CS_CMD_CONTINUE, 25, 40, 70.79991f, { -1814, 533, -1297 } },
{ CS_CMD_CONTINUE, 20, 40, 70.99991f, { -1805, 434, -1293 } },
{ CS_CMD_CONTINUE, 10, 30, 60.0f, { -1794, 323, -1280 } },
@ -16,7 +16,7 @@ static CutsceneCameraPoint D_8012013C[14] = {
{ CS_CMD_STOP, 0, 50, 60.0f, { -1974, 12, -1179 } },
{ CS_CMD_STOP, 0, 30, 60.0f, { -1974, 12, -1179 } },
};
static CutsceneCameraPoint D_8012021C[14] = {
CutsceneCameraPoint D_8012021C[14] = {
{ CS_CMD_CONTINUE, 0, 0, 60.0f, { -1751, 604, -1233 } }, { CS_CMD_CONTINUE, 0, 0, 60.0f, { -1752, 516, -1233 } },
{ CS_CMD_CONTINUE, 0, 0, 60.0f, { -1751, 417, -1233 } }, { CS_CMD_CONTINUE, 0, 0, 60.0f, { -1767, 306, -1219 } },
{ CS_CMD_CONTINUE, 0, 0, 60.0f, { -1776, 257, -1205 } }, { CS_CMD_CONTINUE, 0, 0, 60.0f, { -1881, 147, -1149 } },
@ -54,7 +54,7 @@ static CutsceneCameraPoint D_80120434[10] = {
{ CS_CMD_STOP, 0, 0, 60.0f, { 0, 62, -119 } }, { CS_CMD_STOP, 0, 0, 60.0f, { 0, 62, -119 } },
};
static CutsceneCameraPoint D_801204D4[14] = {
CutsceneCameraPoint D_801204D4[14] = {
{ CS_CMD_CONTINUE, -15, 40, 80.600006f, { -60, 332, 183 } },
{ CS_CMD_CONTINUE, -22, 30, 80.600006f, { -60, 332, 183 } },
{ CS_CMD_CONTINUE, -20, 38, 80.600006f, { -118, 344, 41 } },
@ -70,7 +70,7 @@ static CutsceneCameraPoint D_801204D4[14] = {
{ CS_CMD_STOP, 6, 30, 85.199936f, { 25, 127, -950 } },
{ CS_CMD_STOP, 0, 30, 85.199936f, { 25, 127, -950 } },
};
static CutsceneCameraPoint D_801205B4[14] = {
CutsceneCameraPoint D_801205B4[14] = {
{ CS_CMD_CONTINUE, 0, 0, 60.0f, { -225, 785, -242 } },
{ CS_CMD_CONTINUE, -21, 0, 80.600006f, { -245, 784, -242 } },
{ CS_CMD_CONTINUE, -21, 0, 80.600006f, { -288, 485, -379 } },
@ -118,18 +118,18 @@ static s16 D_801208E0 = 12;
static s16 D_801208E4 = 90;
static s16 D_801208E8 = 8;
static OnePointCsFull D_801208EC[3] = {
OnePointCsFull D_801208EC[3] = {
{ 0x0F, 0x08, 0x0101, 1, 0, 60.0f, 1.0f, { 0.0f, 0.0f, 0.0f }, { 0.0f, 0.0f, 0.0f } },
{ 0x81, 0xFF, 0x0101, 1, 0, 60.0f, 1.0f, { 0.0f, -10.0f, 0.0f }, { 0.0f, 0.0f, 150.0f } },
{ 0x12, 0xFF, 0x0000, 1, 0, 60.0f, 1.0f, { -1.0f, -1.0f, -1.0f }, { -1.0f, -1.0f, -1.0f } },
};
static OnePointCsFull D_80120964[2] = {
OnePointCsFull D_80120964[2] = {
{ 0x8F, 0xFF, 0x0101, 1, 0, 60.0f, 1.0f, { 0.0f, 0.0f, 0.0f }, { 0.0f, 0.0f, 0.0f } },
{ 0x81, 0xFF, 0xA121, 1, 0, 75.0f, 0.6f, { 0.0f, -10.0f, 0.0f }, { 0.0f, 0.0f, 150.0f } },
};
static OnePointCsFull D_801209B4[4] = {
OnePointCsFull D_801209B4[4] = {
{ 0x8F, 0x08, 0x0101, 1, 0, 60.0f, 0.9f, { 0.0f, 0.0f, 0.0f }, { 0.0f, 0.0f, 0.0f } },
{ 0x84, 0x01, 0x0100, 29, 0, 45.0f, 0.1f, { 0.0f, -10.0f, 0.0f }, { 0.0f, 0.0f, 150.0f } },
{ 0x83, 0xFF, 0x0000, 10, 0, 60.0f, 0.2f, { 0.0f, -10.0f, 0.0f }, { 0.0f, 0.0f, 150.0f } },
@ -142,7 +142,7 @@ static OnePointCsFull D_80120A54[3] = {
{ 0x8B, 0xFF, 0x0022, 5000, 0, 75.0f, 0.005f, { 0.0f, 0.0f, -10.0f }, { -1.0f, -1.0f, -1.0f } },
};
static OnePointCsFull D_80120ACC[5] = {
OnePointCsFull D_80120ACC[5] = {
{ 0x8F, 0xFF, 0x0442, 10, 0, 40.0f, 1.0f, { -10.0f, 45.0f, 20.0f }, { 20.0f, 30.0f, 160.0f } },
{ 0x95, 0xFF, 0x0000, 1, 0, 40.0f, 1.0f, { -1.0f, -1.0f, -1.0f }, { -1.0f, -1.0f, -1.0f } },
{ 0x8F, 0x01, 0x0442, 10, 0, 40.0f, 1.0f, { -10.0f, 45.0f, 20.0f }, { 20.0f, 30.0f, 160.0f } },
@ -150,7 +150,7 @@ static OnePointCsFull D_80120ACC[5] = {
{ 0x11, 0xFF, 0x0000, 1, 0, 60.0f, 1.0f, { -1.0f, -1.0f, -1.0f }, { -1.0f, -1.0f, -1.0f } },
};
static OnePointCsFull D_80120B94[11] = {
OnePointCsFull D_80120B94[11] = {
{ 0x8F, 0x01, 0x2142, 1, 0, 40.0f, 1.0f, { 20.0f, 40.0f, 20.0f }, { -20.0f, 0.0f, -30.0f } },
{ 0x84, 0xFF, 0x0404, 19, 5, 70.0f, 0.01f, { 0.0f, 30.0f, 20.0f }, { 120.0f, 60.0f, 120.0f } },
{ 0x84, 0xFF, 0x0404, 20, 0, 60.0f, 0.01f, { 0.0f, 20.0f, 20.0f }, { 120.0f, 60.0f, 120.0f } },
@ -164,7 +164,7 @@ static OnePointCsFull D_80120B94[11] = {
{ 0x98, 0xFF, 0x0000, 1, 0, 50.0f, 1.0f, { -1.0f, -1.0f, -1.0f }, { -1.0f, -1.0f, -1.0f } },
};
static OnePointCsFull D_80120D4C[7] = {
OnePointCsFull D_80120D4C[7] = {
{ 0x8F, 0x01, 0x2142, 1, 0, 40.0f, 1.0f, { 20.0f, 40.0f, 20.0f }, { -20.0f, 0.0f, -30.0f } },
{ 0x84, 0xFF, 0x0404, 19, 5, 70.0f, 0.01f, { 0.0f, 30.0f, 20.0f }, { 120.0f, 60.0f, 120.0f } },
{ 0x84, 0xFF, 0x0404, 20, 0, 60.0f, 0.01f, { 0.0f, 20.0f, 20.0f }, { 120.0f, 60.0f, 120.0f } },
@ -185,7 +185,7 @@ static OnePointCsFull D_80120E64[8] = {
{ 0x12, 0xFF, 0x0000, 1, 0, 60.0f, 1.0f, { -1.0f, -1.0f, -1.0f }, { -1.0f, -1.0f, -1.0f } },
};
static OnePointCsFull D_80120FA4[6] = {
OnePointCsFull D_80120FA4[6] = {
{ 0x8F, 0x01, 0x2143, 30, 0, 70.0f, 0.4f, { 0.0f, 40.0f, 50.0f }, { 30.0f, 10.0f, -50.0f } },
{ 0x95, 0xFF, 0x0000, 1, 0, 50.0f, 1.0f, { -1.0f, -1.0f, -1.0f }, { -1.0f, -1.0f, -1.0f } },
{ 0x8F, 0xFF, 0x2222, 10, 0, 42.0f, 1.0f, { 0.0f, 40.0f, 0.0f }, { 0.0f, 85.0f, 45.0f } },
@ -206,12 +206,12 @@ static OnePointCsFull D_8012110C[3] = {
{ 0x12, 0xFF, 0x0000, 1, 0, 60.0f, 1.0f, { -1.0f, -1.0f, -1.0f }, { -1.0f, -1.0f, -1.0f } },
};
static OnePointCsFull D_80121184[2] = {
OnePointCsFull D_80121184[2] = {
{ 0x83, 0x01, 0x0101, 40, 0, -1.0f, 0.1f, { 0.0f, 10.0f, 0.0f }, { 0.0f, 0.0f, 0.0f } },
{ 0x12, 0xFF, 0x0000, 1, 0, 60.0f, 1.0f, { -1.0f, -1.0f, -1.0f }, { -1.0f, -1.0f, -1.0f } },
};
static OnePointCsFull D_801211D4[2] = {
OnePointCsFull D_801211D4[2] = {
{ 0x8F, 0x08, 0x0101, 50, 0, 60.0f, 1.0f, { 0.0f, 10.0f, 0.0f }, { -10.0f, 85.0f, 0.0f } },
{ 0x11, 0xFF, 0x0000, 1, 0, 60.0f, 1.0f, { -1.0f, -1.0f, -1.0f }, { -1.0f, -1.0f, -1.0f } },
};
@ -229,13 +229,13 @@ static OnePointCsFull D_80121314[1] = {
{ 0x8F, 0x08, 0x4141, 1000, 0, 75.0f, 0.6f, { 0.0f, 0.0f, 10.0f }, { 0.0f, 0.0f, 100.0f } },
};
static OnePointCsFull D_8012133C[3] = {
OnePointCsFull D_8012133C[3] = {
{ 0x8F, 0x01, 0x0141, 40, 0, 75.0f, 1.0f, { 0.0f, 60.0f, 0.0f }, { 0.0f, 0.0f, 100.0f } },
{ 0x83, 0xFF, 0x2121, 20, 0, 60.0f, 0.2f, { 0.0f, -10.0f, -10.0f }, { 0.0f, 10.0f, -100.0f } },
{ 0x11, 0xFF, 0x0000, 1, 0, 60.0f, 1.0f, { -1.0f, -1.0f, -1.0f }, { -1.0f, -1.0f, -1.0f } },
};
static OnePointCsFull D_801213B4[5] = {
OnePointCsFull D_801213B4[5] = {
{ 0x8F, 0x08, 0xC2C2, 40, 0, 70.0f, 1.0f, { 80.0f, 0.0f, 20.0f }, { 20.0f, 0.0f, 80.0f } },
{ 0x8B, 0x01, 0xC2C2, 120, 0, 70.0f, 0.1f, { 80.0f, 0.0f, 20.0f }, { 20.0f, 0.0f, 80.0f } },
{ 0x8F, 0x53, 0xC2C2, 30, 0, 50.0f, 1.0f, { 60.0f, 0.0f, 20.0f }, { 60.0f, 0.0f, 60.0f } },
@ -250,17 +250,17 @@ static OnePointCsFull D_8012147C[4] = {
{ 0x11, 0xFF, 0x0000, 1, 0, 60.0f, 1.0f, { -1.0f, -1.0f, -1.0f }, { -1.0f, -1.0f, -1.0f } },
};
static OnePointCsFull D_8012151C[2] = {
OnePointCsFull D_8012151C[2] = {
{ 0x0F, 0x01, 0x0101, 29, 0, 60.0f, 1.0f, { -700.0f, 875.0f, -100.0f }, { -550.0f, 920.0f, -150.0f } },
{ 0x12, 0xFF, 0x0000, 1, 0, 60.0f, 1.0f, { -1.0f, -1.0f, -1.0f }, { -1.0f, -1.0f, -1.0f } },
};
static OnePointCsFull D_8012156C[2] = {
OnePointCsFull D_8012156C[2] = {
{ 0x8F, 0x4D, 0x4242, 1, 0, 65.0f, 1.0f, { 60.0f, 30.0f, 0.0f }, { 50.0f, 20.0f, 150.0f } },
{ 0x81, 0xFF, 0x4242, -1, 0, 65.0f, 1.0f, { -50.0f, 60.0f, 0.0f }, { -60.0f, 40.0f, 150.0f } },
};
static OnePointCsFull D_801215BC[1] = {
OnePointCsFull D_801215BC[1] = {
{ 0x0F, 0xFF, 0x0101, 5, 0, 65.0f, 1.0f, { -1185.0f, 655.0f, 1185.0f }, { -1255.0f, 735.0f, 1255.0f } },
};
@ -331,7 +331,7 @@ static OnePointCsFull D_80121A44[12] = {
{ 0x12, 0xFF, 0x0000, 1, 0, 60.0f, 1.0f, { -1.0f, -1.0f, -1.0f }, { -1.0f, -1.0f, -1.0f } },
};
static OnePointCsFull D_80121C24[7] = {
OnePointCsFull D_80121C24[7] = {
{ 0x0F, 0x05, 0x0101, 1, 0, 60.0f, 1.0f, { 0.0f, 0.0f, 0.0f }, { 0.0f, 0.0f, 0.0f } },
{ 0x03, 0xFF, 0x0101, 89, 0, 50.0f, 0.4f, { 125.0f, 320.0f, -1500.0f }, { 125.0f, 500.0f, -1150.0f } },
{ 0x0F, 0x08, 0x0101, 40, 4, 55.0f, 1.0f, { 0.0f, 375.0f, -1440.0f }, { 5.0f, 365.0f, -1315.0f } },
@ -341,7 +341,7 @@ static OnePointCsFull D_80121C24[7] = {
{ 0x11, 0xFF, 0x0000, 1, 0, 60.0f, 1.0f, { -1.0f, -1.0f, -1.0f }, { -1.0f, -1.0f, -1.0f } },
};
static OnePointCsFull D_80121D3C[3] = {
OnePointCsFull D_80121D3C[3] = {
{ 0x0F, 0xFF, 0x0101, 1, 0, 60.0f, 1.0f, { 1023.0f, 738.0f, -2628.0f }, { 993.0f, 770.0f, -2740.0f } },
{ 0x02, 0xFF, 0x0101, 4, 0, 50.0f, 1.0f, { 1255.0f, 350.0f, -1870.0f }, { 1240.0f, 575.0f, -2100.0f } },
{ 0x0F, 0xFF, 0x0000, -1, 0, 75.0f, 1.0f, { -1.0f, -1.0f, -1.0f }, { -1.0f, -1.0f, -1.0f } },
@ -359,14 +359,14 @@ static OnePointCsFull D_80121DB4[9] = {
{ 0x12, 0xFF, 0x0000, 1, -1, -1.0f, -1.0f, { -1.0f, -1.0f, -1.0f }, { -1.0f, -1.0f, -1.0f } },
};
static OnePointCsFull D_80121F1C[4] = {
OnePointCsFull D_80121F1C[4] = {
{ 0x0F, 0x08, 0x0101, 10, 0, 60.0f, 1.0f, { 0.0f, 0.0f, 0.0f }, { 0.0f, 0.0f, 0.0f } },
{ 0x01, 0xFF, 0x2121, 10, 0, 50.0f, 0.5f, { 0.0f, 0.0f, 0.0f }, { 0.0f, 0.0f, 150.0f } },
{ 0x01, 0x02, 0x2121, 23, 0, 50.0f, 0.5f, { 0.0f, 0.0f, 0.0f }, { 0.0f, 0.0f, 150.0f } },
{ 0x11, 0xFF, 0x0000, 1, -1, -1.0f, -1.0f, { -1.0f, -1.0f, -1.0f }, { -1.0f, -1.0f, -1.0f } },
};
static OnePointCsFull D_80121FBC[4] = {
OnePointCsFull D_80121FBC[4] = {
{ 0x0F, 0xFF, 0x0101, 5, 0, 60.0f, 1.0f, { 0.0f, 0.0f, 0.0f }, { 0.0f, 0.0f, 0.0f } },
{ 0x01, 0xFF, 0x0101, 10, 0, 30.0f, 1.0f, { -2130.0f, 2885.0f, -1055.0f }, { -2085.0f, 2875.0f, -1145.0f } },
{ 0x0F, 0xFF, 0x0000, 30, 0, 60.0f, 1.0f, { -1.0f, -1.0f, -1.0f }, { -1.0f, -1.0f, -1.0f } },
@ -379,7 +379,7 @@ static OnePointCsFull D_8012205C[3] = {
{ 0x01, 0x01, 0x21A1, 10, 0, 60.0f, 1.0f, { 0.0f, -10.0f, 0.0f }, { 0.0f, 10.0f, -200.0f } },
};
static OnePointCsFull D_801220D4[5] = {
OnePointCsFull D_801220D4[5] = {
{ 0x0F, 0x01, 0x0101, 5, 0, 60.0f, 1.0f, { 0.0f, 0.0f, 0.0f }, { 0.0f, 0.0f, 0.0f } },
{ 0x01, 0xFF, 0x4141, 10, 5, 55.0f, 0.75f, { 400.0f, -50.0f, 800.0f }, { 600.0f, -60.0f, 800.0f } },
{ 0x01, 0xFF, 0x4141, 15, 10, 40.0f, 0.75f, { 0.0f, 0.0f, 0.0f }, { 0.0f, 10.0f, 200.0f } },
@ -443,7 +443,7 @@ static OnePointCsFull D_8012269C[3] = {
{ 0x11, 0xFF, 0x0000, 1, -1, -1.0f, -1.0f, { -1.0f, -1.0f, -1.0f }, { -1.0f, -1.0f, -1.0f } },
};
static OnePointCsFull D_80122714[4] = {
OnePointCsFull D_80122714[4] = {
{ 0x0F, 0xFF, 0x0101, 20, 0, 45.0f, 1.0f, { -915.0f, -2185.0f, 6335.0f }, { -915.0f, -2290.0f, 6165.0f } },
{ 0x02, 0xFF, 0x0101, -1, 0, 80.0f, 0.8f, { -920.0f, -2270.0f, 6140.0f }, { -920.0f, -2280.0f, 6070.0f } },
{ 0x02, 0xFF, 0x0101, 20, 0, 80.0f, 0.9f, { -920.0f, -2300.0f, 6140.0f }, { -920.0f, -2300.0f, 6070.0f } },
@ -512,12 +512,12 @@ static OnePointCsFull D_80122C8C[1] = {
{ 0x0F, 0xFF, 0x0101, 999, 5, 60.0f, 1.0f, { -70.0f, 140.0f, 25.0f }, { 10.0f, 180.0f, 195.0f } },
};
static OnePointCsFull D_80122CB4[2] = {
OnePointCsFull D_80122CB4[2] = {
{ 0x0F, 0xFF, 0x4242, 5, 0, 60.0f, 1.0f, { 0.0f, 0.0f, 1000.0f }, { 0.0f, 0.0f, 1100.0f } },
{ 0x02, 0xFF, 0x4242, -1, 0, 60.0f, 1.0f, { 0.0f, 0.0f, -100.0f }, { 0.0f, 0.0f, 0.0f } },
};
static OnePointCsFull D_80122D04[2] = {
OnePointCsFull D_80122D04[2] = {
{ 0x0F, 0xFF, 0x4242, 10, 0, 60.0f, 1.0f, { 0.0f, 0.0f, -100.0f }, { 0.0f, 0.0f, 0.0f } },
{ 0x02, 0xFF, 0x4242, -1, 0, 60.0f, 1.0f, { 0.0f, 0.0f, 1000.0f }, { 0.0f, 0.0f, 1100.0f } },
};
@ -534,7 +534,7 @@ static OnePointCsFull D_80122DCC[3] = {
{ 0x11, 0xFF, 0x0000, 1, -1, -1.0f, -1.0f, { -1.0f, -1.0f, -1.0f }, { -1.0f, -1.0f, -1.0f } },
};
static OnePointCsFull D_80122E44[2][7] = {
OnePointCsFull D_80122E44[2][7] = {
{
{ 0x83, 0xFF, 0x2222, 10, 5, 90.0f, 0.2f, { 50.0f, 100.0f, 140.0f }, { -30.0f, 10.0f, -20.0f } },
{ 0x8F, 0xFF, 0x0000, 20, 0, 90.0f, 1.0f, { -1.0f, -1.0f, -1.0f }, { -1.0f, -1.0f, -1.0f } },
@ -563,25 +563,25 @@ static OnePointCsFull D_80123074[5] = {
{ 0x92, 0xFF, 0x0000, 1, 0, 60.0f, 1.0f, { -1.0f, -1.0f, -1.0f }, { -1.0f, -1.0f, -1.0f } },
};
static OnePointCsFull D_8012313C[3] = {
OnePointCsFull D_8012313C[3] = {
{ 0x8F, 0xFF, 0xA2A2, 20, 8, 70.0f, 1.0f, { 65.0f, -150.0f, 50.0f }, { 30.0f, 10.0f, 90.0f } },
{ 0x81, 0xFF, 0xA2A2, 100, 0, 60.0f, 1.0f, { 70.0f, -160.0f, 50.0f }, { 25.0f, 180.0f, 180.0f } },
{ 0x92, 0xFF, 0x0000, 1, 0, 60.0f, 1.0f, { -1.0f, -1.0f, -1.0f }, { -1.0f, -1.0f, -1.0f } },
};
static OnePointCsFull D_801231B4[4] = {
OnePointCsFull D_801231B4[4] = {
{ 0x8F, 0xC5, 0x4343, 1, 0, 50.0f, 1.0f, { 0.0f, 20.0f, 0.0f }, { 0.0f, 5.0f, -1.0f } },
{ 0x81, 0xC5, 0x4343, 48, 0, 50.0f, 0.75f, { 0.0f, 80.0f, 0.0f }, { 0.0f, 15.0f, -1.0f } },
{ 0x8F, 0xC5, 0x4343, 1, 5, 45.0f, 1.0f, { 0.0f, 0.0f, 30.0f }, { 30.0f, 120.0f, 60.0f } },
{ 0x81, 0xC5, 0x4343, -1, 0, -1.0f, 1.0f, { -1.0f, -1.0f, -1.0f }, { -1.0f, -1.0f, -1.0f } },
};
static OnePointCsFull D_80123254[2] = {
OnePointCsFull D_80123254[2] = {
{ 0x0F, 0xFF, 0x0101, 1, 0, 60.0f, 1.0f, { 0.0f, 0.0f, 0.0f }, { 0.0f, 0.0f, 0.0f } },
{ 0x03, 0xC5, 0x0101, 49, 0, 50.0f, 0.05f, { 0.0f, 0.0f, 0.0f }, { 0.0f, 0.0f, 0.0f } },
};
static OnePointCsFull D_801232A4[1] = {
OnePointCsFull D_801232A4[1] = {
{ 0x0F, 0x45, 0x0101, 9999, 0, 60.0f, 1.0f, { 0.0f, 0.0f, 0.0f }, { 0.0f, 0.0f, 0.0f } },
};
@ -646,24 +646,24 @@ static OnePointCsFull D_801237CC[5] = {
{ 0x0F, 0xFF, 0x0000, 100, -45, 75.0f, 1.0f, { -1.0f, -1.0f, -1.0f }, { -1.0f, -1.0f, -1.0f } },
};
static OnePointCsFull D_80123894[3] = {
OnePointCsFull D_80123894[3] = {
{ 0x0F, 0xFF, 0x0101, 60, 0, 60.0f, 1.0f, { 0.0f, 0.0f, 0.0f }, { 0.0f, 0.0f, 0.0f } },
{ 0x0F, 0xFF, 0x4242, 30, 0, 50.0f, 1.0f, { 0.0f, 28.0f, 0.0f }, { 0.0f, 20.0f, 40.0f } },
{ 0x0D, 0xFF, 0x0000, 120, 0, 180.0f, 0.4f, { 0.0f, -5.0f, 0.0f }, { 0.0f, 2.0f, 40.0f } },
};
static OnePointCsFull D_8012390C[2] = {
OnePointCsFull D_8012390C[2] = {
{ 0x0F, 0xFF, 0x0101, 30, 0, 60.0f, 1.0f, { 0.0f, 0.0f, 0.0f }, { 0.0f, 0.0f, 0.0f } },
{ 0x0F, 0xFF, 0x4242, 180, 0, 60.0f, 1.0f, { 0.0f, 78.0f, 0.0f }, { 0.0f, 78.0f, 200.0f } },
};
static OnePointCsFull D_8012395C[3] = {
OnePointCsFull D_8012395C[3] = {
{ 0x0F, 0xFF, 0x0101, 60, 0, 60.0f, 1.0f, { 0.0f, 0.0f, 0.0f }, { 0.0f, 0.0f, 0.0f } },
{ 0x0F, 0xFF, 0x4242, 30, 0, 50.0f, 1.0f, { 0.0f, 28.0f, 0.0f }, { 0.0f, 20.0f, -45.0f } },
{ 0x0D, 0xFF, 0x0000, 120, 0, 180.0f, 0.4f, { 0.0f, -5.0f, 0.0f }, { 0.0f, 2.0f, 45.0f } },
};
static OnePointCsFull D_801239D4[3] = {
OnePointCsFull D_801239D4[3] = {
{ 0x0F, 0xFF, 0x4242, 5, 0, 60.0f, 1.0f, { 0.0f, 20.0f, 0.0f }, { 0.0f, 40.0f, -120.0f } },
{ 0x09, 0xFF, 0x4242, 0, 0, 60.0f, 1.0f, { 0.0f, 20.0f, 0.0f }, { 0.0f, 0.0f, 0.0f } },
{ 0x12, 0xFF, 0x0000, 1, 0, 60.0f, 1.0f, { -1.0f, -1.0f, -1.0f }, { -1.0f, -1.0f, -1.0f } },

2
soh/src/code/z_play.c
View File

@ -421,7 +421,7 @@ void Gameplay_Update(GlobalContext* globalCtx) {
input = globalCtx->state.input;
if ((SREG(1) < 0) || (DREG(0) != 0)) {
if ((SREG(1) < 0) || (DREG(0) != 0)) {
SREG(1) = 0;
ZeldaArena_Display();
}

26
soh/src/overlays/actors/ovl_Bg_Ddan_Kd/z_bg_ddan_kd.c
View File

@ -121,8 +121,8 @@ void BgDdanKd_CheckForExplosions(BgDdanKd* this, GlobalContext* globalCtx) {
}
}
static Vec3f velocity = { 0.0f, 5.0f, 0.0f };
static Vec3f accel = { 0.0f, -0.45f, 0.0f };
Vec3f sBgDdanKdVelocity = { 0.0f, 5.0f, 0.0f };
Vec3f sBgDdanKdAccel = { 0.0f, -0.45f, 0.0f };
void BgDdanKd_LowerStairs(BgDdanKd* this, GlobalContext* globalCtx) {
Vec3f pos1;
@ -158,11 +158,11 @@ void BgDdanKd_LowerStairs(BgDdanKd* this, GlobalContext* globalCtx) {
func_80033480(globalCtx, &pos1, 20.0f, 1, effectStrength * 135.0f, 60, 1);
func_80033480(globalCtx, &pos2, 20.0f, 1, effectStrength * 135.0f, 60, 1);
velocity.x = Rand_CenteredFloat(3.0f);
velocity.z = Rand_CenteredFloat(3.0f);
sBgDdanKdVelocity.x = Rand_CenteredFloat(3.0f);
sBgDdanKdVelocity.z = Rand_CenteredFloat(3.0f);
func_8003555C(globalCtx, &pos1, &velocity, &accel);
func_8003555C(globalCtx, &pos2, &velocity, &accel);
func_8003555C(globalCtx, &pos1, &sBgDdanKdVelocity, &sBgDdanKdAccel);
func_8003555C(globalCtx, &pos2, &sBgDdanKdVelocity, &sBgDdanKdAccel);
pos1 = this->dyna.actor.world.pos;
pos1.z += 560.0f + Rand_ZeroOne() * 5.0f;
@ -170,7 +170,7 @@ void BgDdanKd_LowerStairs(BgDdanKd* this, GlobalContext* globalCtx) {
pos1.y = Rand_ZeroOne() * 3.0f + (this->dyna.actor.floorHeight + 20.0f);
func_80033480(globalCtx, &pos1, 20.0f, 1, effectStrength * 135.0f, 60, 1);
func_8003555C(globalCtx, &pos1, &velocity, &accel);
func_8003555C(globalCtx, &pos1, &sBgDdanKdVelocity, &sBgDdanKdAccel);
}
Camera_AddQuake(&globalCtx->mainCamera, 0, effectStrength * 0.6f, 3);
Audio_PlaySoundGeneral(NA_SE_EV_PILLAR_SINK - SFX_FLAG, &this->dyna.actor.projectedPos, 4, &D_801333E0,
@ -192,11 +192,11 @@ void BgDdanKd_Draw(Actor* thisx, GlobalContext* globalCtx) {
}
void BgDdanKd_Reset(void) {
velocity.x = 0.0f;
velocity.y = 5.0f;
velocity.z = 0.0f;
sBgDdanKdVelocity.x = 0.0f;
sBgDdanKdVelocity.y = 5.0f;
sBgDdanKdVelocity.z = 0.0f;
accel.x = 0.0f;
accel.y = -0.45f;
accel.z = 0.0f;
sBgDdanKdAccel.x = 0.0f;
sBgDdanKdAccel.y = -0.45f;
sBgDdanKdAccel.z = 0.0f;
}

36
soh/src/overlays/actors/ovl_Bg_Dodoago/z_bg_dodoago.c
View File

@ -74,13 +74,13 @@ static ColliderCylinderInit sColCylinderInitLeftRight = {
{ 50, 60, 280, { 0, 0, 0 } },
};
static s16 sFirstExplosiveFlag = false;
s16 sBgDodoagoFirstExplosiveFlag = false;
static u8 sDisableBombCatcher;
u8 sBgDodoagoDisableBombCatcher;
static u8 sUnused[90]; // unknown length
//static u8 sUnused[90]; // unknown length
static s32 sTimer;
s32 sBgDodoagoTimer;
void BgDodoago_SetupAction(BgDodoago* this, BgDodoagoActionFunc actionFunc) {
this->actionFunc = actionFunc;
@ -135,7 +135,7 @@ void BgDodoago_Init(Actor* thisx, GlobalContext* globalCtx) {
Collider_SetCylinder(globalCtx, &this->colliderRight, &this->dyna.actor, &sColCylinderInitLeftRight);
BgDodoago_SetupAction(this, BgDodoago_WaitExplosives);
sDisableBombCatcher = false;
sBgDodoagoDisableBombCatcher = false;
}
void BgDodoago_Destroy(Actor* thisx, GlobalContext* globalCtx) {
@ -170,16 +170,16 @@ void BgDodoago_WaitExplosives(BgDodoago* this, GlobalContext* globalCtx) {
} else {
OnePointCutscene_Init(globalCtx, 3065, 20, &this->dyna.actor, MAIN_CAM);
Audio_PlaySoundGeneral(NA_SE_SY_ERROR, &D_801333D4, 4, &D_801333E0, &D_801333E0, &D_801333E8);
sTimer += 30;
sBgDodoagoTimer += 30;
return;
}
// the flag is never set back to false, so this only runs once
if (!sFirstExplosiveFlag) {
if (!sBgDodoagoFirstExplosiveFlag) {
// this disables the bomb catcher (see BgDodoago_Update) for a few seconds
this->dyna.actor.parent = explosive;
sFirstExplosiveFlag = true;
sTimer = 50;
sBgDodoagoFirstExplosiveFlag = true;
sBgDodoagoTimer = 50;
}
} else if (Flags_GetEventChkInf(0xB0)) {
Collider_UpdateCylinder(&this->dyna.actor, &this->colliderMain);
@ -219,11 +219,11 @@ void BgDodoago_OpenJaw(BgDodoago* this, GlobalContext* globalCtx) {
}
if (globalCtx->roomCtx.unk_74[BGDODOAGO_EYE_LEFT] != 255 || globalCtx->roomCtx.unk_74[BGDODOAGO_EYE_RIGHT] != 255) {
sTimer--;
sBgDodoagoTimer--;
return;
}
if (sTimer == 108) {
if (sBgDodoagoTimer == 108) {
for (i = ARRAY_COUNT(dustOffsets) - 1; i >= 0; i--) {
pos.x = dustOffsets[i].x + this->dyna.actor.world.pos.x;
pos.y = dustOffsets[i].y + this->dyna.actor.world.pos.y;
@ -290,16 +290,16 @@ void BgDodoago_Update(Actor* thisx, GlobalContext* globalCtx) {
this->dyna.actor.parent = &bomb->actor;
bomb->timer = 50;
bomb->actor.speedXZ = 0.0f;
sTimer = 0;
sBgDodoagoTimer = 0;
}
}
} else {
sTimer++;
sBgDodoagoTimer++;
Flags_GetSwitch(globalCtx, this->dyna.actor.params & 0x3F);
if (!sDisableBombCatcher && sTimer > 140) {
if (!sBgDodoagoDisableBombCatcher && sBgDodoagoTimer > 140) {
if (Flags_GetSwitch(globalCtx, this->dyna.actor.params & 0x3F)) {
// this prevents clearing the actor's parent pointer, effectively disabling the bomb catcher
sDisableBombCatcher++;
sBgDodoagoDisableBombCatcher++;
} else {
this->dyna.actor.parent = NULL;
}
@ -322,7 +322,7 @@ void BgDodoago_Draw(Actor* thisx, GlobalContext* globalCtx) {
}
void BgDodoago_Reset(void) {
sFirstExplosiveFlag = false;
sDisableBombCatcher = 0;
sTimer = 0;
sBgDodoagoFirstExplosiveFlag = false;
sBgDodoagoDisableBombCatcher = 0;
sBgDodoagoTimer = 0;
}

12
soh/src/overlays/actors/ovl_Bg_Haka_Gate/z_bg_haka_gate.c
View File

@ -47,7 +47,7 @@ void BgHakaGate_SkullOfTruth(BgHakaGate* this, GlobalContext* globalCtx);
void BgHakaGate_FalseSkull(BgHakaGate* this, GlobalContext* globalCtx);
static s16 sSkullOfTruthRotY = 0x100;
static u8 sPuzzleState = 1;
static u8 sBgPoEventPuzzleState = 1;
static f32 sStatueDistToPlayer = 0;
static s16 sStatueRotY;
@ -82,7 +82,7 @@ void BgHakaGate_Init(Actor* thisx, GlobalContext* globalCtx) {
if (sSkullOfTruthRotY != 0x100) {
this->actionFunc = BgHakaGate_FalseSkull;
} else if (ABS(thisx->shape.rot.y) < 0x4000) {
if ((Rand_ZeroOne() * 3.0f) < sPuzzleState) {
if ((Rand_ZeroOne() * 3.0f) < sBgPoEventPuzzleState) {
this->vIsSkullOfTruth = true;
sSkullOfTruthRotY = thisx->shape.rot.y + 0x8000;
if (Flags_GetSwitch(globalCtx, this->switchFlag)) {
@ -91,7 +91,7 @@ void BgHakaGate_Init(Actor* thisx, GlobalContext* globalCtx) {
this->actionFunc = BgHakaGate_SkullOfTruth;
}
} else {
sPuzzleState++;
sBgPoEventPuzzleState++;
this->actionFunc = BgHakaGate_FalseSkull;
}
} else {
@ -141,7 +141,7 @@ void BgHakaGate_Destroy(Actor* thisx, GlobalContext* globalCtx) {
DynaPoly_DeleteBgActor(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
if (this->dyna.actor.params == BGHAKAGATE_STATUE) {
sSkullOfTruthRotY = 0x100;
sPuzzleState = 1;
sBgPoEventPuzzleState = 1;
}
}
@ -178,7 +178,7 @@ void BgHakaGate_StatueIdle(BgHakaGate* this, GlobalContext* globalCtx) {
}
}
} else {
if (sPuzzleState == SKULL_OF_TRUTH_FOUND) {
if (sBgPoEventPuzzleState == SKULL_OF_TRUTH_FOUND) {
this->actionFunc = BgHakaGate_StatueInactive;
} else {
this->vTimer = 0;
@ -243,7 +243,7 @@ void BgHakaGate_FloorClosed(BgHakaGate* this, GlobalContext* globalCtx) {
sStatueDistToPlayer = 0.0f;
if (ABS(yawDiff) < 0x80) {
Flags_SetSwitch(globalCtx, this->switchFlag);
sPuzzleState = SKULL_OF_TRUTH_FOUND;
sBgPoEventPuzzleState = SKULL_OF_TRUTH_FOUND;
this->actionFunc = BgHakaGate_DoNothing;
} else {
func_80078884(NA_SE_SY_ERROR);

4
soh/src/overlays/actors/ovl_Bg_Haka_Trap/z_bg_haka_trap.c
View File

@ -28,7 +28,7 @@ void func_80880AE8(BgHakaTrap* this, GlobalContext* globalCtx);
void func_80880C0C(BgHakaTrap* this, GlobalContext* globalCtx);
void func_80880D68(BgHakaTrap* this);
static UNK_TYPE D_80880F30 = 0;
UNK_TYPE D_80880F30 = 0;
const ActorInit Bg_Haka_Trap_InitVars = {
ACTOR_BG_HAKA_TRAP,
@ -107,7 +107,7 @@ static InitChainEntry sInitChain[] = {
ICHAIN_VEC3F_DIV1000(scale, 100, ICHAIN_STOP),
};
static UNK_TYPE D_80881014 = 0;
UNK_TYPE D_80881014 = 0;
void BgHakaTrap_Init(Actor* thisx, GlobalContext* globalCtx) {
BgHakaTrap* this = (BgHakaTrap*)thisx;
s32 pad;

2
soh/src/overlays/actors/ovl_Bg_Hidan_Rock/z_bg_hidan_rock.c
View File

@ -120,7 +120,7 @@ void func_8088B24C(BgHidanRock* this) {
this->actionFunc = func_8088B990;
}
static f32 D_8088BFC0 = 0.0f;
f32 D_8088BFC0 = 0.0f;
void func_8088B268(BgHidanRock* this, GlobalContext* globalCtx) {
f32 sp2C;
s32 temp_v1;

10
soh/src/overlays/actors/ovl_Bg_Jya_1flift/z_bg_jya_1flift.c
View File

@ -23,7 +23,7 @@ void BgJya1flift_SetupDoNothing(BgJya1flift* this);
void BgJya1flift_ResetMoveDelay(BgJya1flift* this);
void BgJya1flift_DelayMove(BgJya1flift* this, GlobalContext* globalCtx);
static u8 sIsSpawned = false;
static u8 sKankyoIsSpawned = false;
const ActorInit Bg_Jya_1flift_InitVars = {
ACTOR_BG_JYA_1FLIFT,
@ -94,9 +94,9 @@ void BgJya1flift_InitCollision(Actor* thisx, GlobalContext* globalCtx) {
void BgJya1flift_Init(Actor* thisx, GlobalContext* globalCtx) {
BgJya1flift* this = (BgJya1flift*)thisx;
// "1 F lift"
osSyncPrintf("(１Ｆリフト)(flag %d)(room %d)\n", sIsSpawned, globalCtx->roomCtx.curRoom.num);
osSyncPrintf("(１Ｆリフト)(flag %d)(room %d)\n", sKankyoIsSpawned, globalCtx->roomCtx.curRoom.num);
this->hasInitialized = false;
if (sIsSpawned) {
if (sKankyoIsSpawned) {
Actor_Kill(thisx);
return;
}
@ -109,7 +109,7 @@ void BgJya1flift_Init(Actor* thisx, GlobalContext* globalCtx) {
BgJya1flift_SetupWaitForSwitch(this);
}
thisx->room = -1;
sIsSpawned = true;
sKankyoIsSpawned = true;
this->hasInitialized = true;
}
@ -117,7 +117,7 @@ void BgJya1flift_Destroy(Actor* thisx, GlobalContext* globalCtx) {
BgJya1flift* this = (BgJya1flift*)thisx;
if (this->hasInitialized) {
sIsSpawned = false;
sKankyoIsSpawned = false;
Collider_DestroyCylinder(globalCtx, &this->collider);
DynaPoly_DeleteBgActor(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
}

8
soh/src/overlays/actors/ovl_Bg_Jya_Bigmirror/z_bg_jya_bigmirror.c
View File

@ -14,7 +14,7 @@ void BgJyaBigmirror_Destroy(Actor* thisx, GlobalContext* globalCtx);
void BgJyaBigmirror_Update(Actor* thisx, GlobalContext* globalCtx);
void BgJyaBigmirror_Draw(Actor* thisx, GlobalContext* globalCtx);
static u8 sIsSpawned = false;
static u8 sKankyoIsSpawned = false;
const ActorInit Bg_Jya_Bigmirror_InitVars = {
ACTOR_BG_JYA_BIGMIRROR,
@ -176,7 +176,7 @@ void BgJyaBigmirror_HandleMirRay(Actor* thisx, GlobalContext* globalCtx) {
void BgJyaBigmirror_Init(Actor* thisx, GlobalContext* globalCtx) {
BgJyaBigmirror* this = (BgJyaBigmirror*)thisx;
if (sIsSpawned) {
if (sKankyoIsSpawned) {
Actor_Kill(&this->actor);
return;
}
@ -185,7 +185,7 @@ void BgJyaBigmirror_Init(Actor* thisx, GlobalContext* globalCtx) {
this->cobraInfo[0].rotY = sCobraSpawnData[0].initRotY;
this->cobraInfo[1].rotY = sCobraSpawnData[1].initRotY;
this->actor.room = -1;
sIsSpawned = true;
sKankyoIsSpawned = true;
this->spawned = true;
this->mirRayObjIndex = -1;
@ -197,7 +197,7 @@ void BgJyaBigmirror_Destroy(Actor* thisx, GlobalContext* globalCtx) {
BgJyaBigmirror* this = (BgJyaBigmirror*)thisx;
if (this->spawned) {
sIsSpawned = false;
sKankyoIsSpawned = false;
}
}

8
soh/src/overlays/actors/ovl_Bg_Jya_Lift/z_bg_jya_lift.c
View File

@ -20,7 +20,7 @@ void BgJyaLift_DelayMove(BgJyaLift* this, GlobalContext* globalCtx);
void BgJyaLift_SetupMove(BgJyaLift* this);
void BgJyaLift_Move(BgJyaLift* this, GlobalContext* globalCtx);
static s16 sIsSpawned = false;
static s16 sKankyoIsSpawned = false;
const ActorInit Bg_Jya_Lift_InitVars = {
ACTOR_BG_JYA_LIFT,
@ -55,7 +55,7 @@ void BgJyaLift_Init(Actor* thisx, GlobalContext* globalCtx) {
BgJyaLift* this = (BgJyaLift*)thisx;
this->isSpawned = false;
if (sIsSpawned) {
if (sKankyoIsSpawned) {
Actor_Kill(thisx);
return;
}
@ -70,7 +70,7 @@ void BgJyaLift_Init(Actor* thisx, GlobalContext* globalCtx) {
BgJyaLift_SetInitPosY(this);
}
thisx->room = -1;
sIsSpawned = true;
sKankyoIsSpawned = true;
this->isSpawned = true;
}
@ -81,7 +81,7 @@ void BgJyaLift_Destroy(Actor* thisx, GlobalContext* globalCtx) {
// "Goddess Lift DT"
osSyncPrintf("女神リフト DT\n");
sIsSpawned = false;
sKankyoIsSpawned = false;
DynaPoly_DeleteBgActor(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
}
}

2
soh/src/overlays/actors/ovl_Bg_Menkuri_Eye/z_bg_menkuri_eye.c
View File

@ -28,7 +28,7 @@ const ActorInit Bg_Menkuri_Eye_InitVars = {
(ActorResetFunc)BgMenkuriEye_Reset,
};
static s32 D_8089C1A0;
s32 D_8089C1A0;
static ColliderJntSphElementInit sJntSphElementsInit[1] = {
{

10
soh/src/overlays/actors/ovl_Bg_Mori_Elevator/z_bg_mori_elevator.c
View File

@ -17,7 +17,7 @@ void func_808A2008(BgMoriElevator* this, GlobalContext* globalCtx);
void BgMoriElevator_MoveIntoGround(BgMoriElevator* this, GlobalContext* globalCtx);
void BgMoriElevator_MoveAboveGround(BgMoriElevator* this, GlobalContext* globalCtx);
static s16 sIsSpawned = false;
static s16 sKankyoIsSpawned = false;
const ActorInit Bg_Mori_Elevator_InitVars = {
ACTOR_BG_MORI_ELEVATOR,
@ -87,18 +87,18 @@ void BgMoriElevator_Init(Actor* thisx, GlobalContext* globalCtx) {
s32 pad;
CollisionHeader* colHeader = NULL;
this->unk_172 = sIsSpawned;
this->unk_172 = sKankyoIsSpawned;
this->moriTexObjIndex = Object_GetIndex(&globalCtx->objectCtx, OBJECT_MORI_TEX);
if (this->moriTexObjIndex < 0) {
Actor_Kill(thisx);
// "Forest Temple obj elevator Bank Danger!"
osSyncPrintf("Error : 森の神殿 obj elevator バンク危険！(%s %d)\n", "../z_bg_mori_elevator.c", 277);
} else {
switch (sIsSpawned) {
switch (sKankyoIsSpawned) {
case false:
// "Forest Temple elevator CT"
osSyncPrintf("森の神殿 elevator CT\n");
sIsSpawned = true;
sKankyoIsSpawned = true;
this->dyna.actor.room = -1;
Actor_ProcessInitChain(&this->dyna.actor, sInitChain);
DynaPolyActor_Init(&this->dyna, DPM_PLAYER);
@ -120,7 +120,7 @@ void BgMoriElevator_Destroy(Actor* thisx, GlobalContext* globalCtx) {
// "Forest Temple elevator DT"
osSyncPrintf("森の神殿 elevator DT\n");
DynaPoly_DeleteBgActor(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
sIsSpawned = false;
sKankyoIsSpawned = false;
}
}

16
soh/src/overlays/actors/ovl_Bg_Mori_Hineri/z_bg_mori_hineri.c
View File

@ -28,7 +28,7 @@ void BgMoriHineri_SpawnBossKeyChest(BgMoriHineri* this, GlobalContext* globalCtx
void BgMoriHineri_DoNothing(BgMoriHineri* this, GlobalContext* globalCtx);
void func_808A3D58(BgMoriHineri* this, GlobalContext* globalCtx);
static s16 sNextCamIdx = SUBCAM_NONE;
s16 sBgMoriHineriNextCamIdx = SUBCAM_NONE;
const ActorInit Bg_Mori_Hineri_InitVars = {
ACTOR_BG_MORI_HINERI,
@ -194,28 +194,28 @@ void func_808A3D58(BgMoriHineri* this, GlobalContext* globalCtx) {
OnePointCutscene_EndCutscene(globalCtx, mainCamChildIdx);
}
OnePointCutscene_Init(globalCtx, 3260, 40, &this->dyna.actor, MAIN_CAM);
sNextCamIdx = OnePointCutscene_Init(globalCtx, 3261, 40, &this->dyna.actor, MAIN_CAM);
sBgMoriHineriNextCamIdx = OnePointCutscene_Init(globalCtx, 3261, 40, &this->dyna.actor, MAIN_CAM);
}
}
void func_808A3E54(BgMoriHineri* this, GlobalContext* globalCtx) {
s8 objBankIndex;
if (globalCtx->activeCamera == sNextCamIdx) {
if (sNextCamIdx != MAIN_CAM) {
if (globalCtx->activeCamera == sBgMoriHineriNextCamIdx) {
if (sBgMoriHineriNextCamIdx != MAIN_CAM) {
objBankIndex = this->dyna.actor.objBankIndex;
this->dyna.actor.objBankIndex = this->moriHineriObjIdx;
this->moriHineriObjIdx = objBankIndex;
this->dyna.actor.params ^= 1;
sNextCamIdx = MAIN_CAM;
sBgMoriHineriNextCamIdx = MAIN_CAM;
func_80078884(NA_SE_SY_TRE_BOX_APPEAR);
} else {
this->dyna.actor.draw = NULL;
this->actionFunc = func_808A3D58;
sNextCamIdx = SUBCAM_NONE;
sBgMoriHineriNextCamIdx = SUBCAM_NONE;
}
}
if ((sNextCamIdx >= SUBCAM_FIRST) &&
if ((sBgMoriHineriNextCamIdx >= SUBCAM_FIRST) &&
((GET_ACTIVE_CAM(globalCtx)->eye.z - this->dyna.actor.world.pos.z) < 1100.0f)) {
func_8002F948(&this->dyna.actor, NA_SE_EV_FLOOR_ROLLING - SFX_FLAG);
}
@ -283,5 +283,5 @@ void BgMoriHineri_DrawHallAndRoom(Actor* thisx, GlobalContext* globalCtx) {
}
void BgMoriHineri_Reset() {
sNextCamIdx = SUBCAM_NONE;
sBgMoriHineriNextCamIdx = SUBCAM_NONE;
}

8
soh/src/overlays/actors/ovl_Bg_Mori_Idomizu/z_bg_mori_idomizu.c
View File

@ -19,7 +19,7 @@ void BgMoriIdomizu_WaitForMoriTex(BgMoriIdomizu* this, GlobalContext* globalCtx)
void BgMoriIdomizu_SetupMain(BgMoriIdomizu* this);
void BgMoriIdomizu_Main(BgMoriIdomizu* this, GlobalContext* globalCtx);
static s16 sIsSpawned = false;
static s16 sKankyoIsSpawned = false;
const ActorInit Bg_Mori_Idomizu_InitVars = {
ACTOR_BG_MORI_IDOMIZU,
@ -50,7 +50,7 @@ void BgMoriIdomizu_Init(Actor* thisx, GlobalContext* globalCtx) {
s32 pad;
BgMoriIdomizu* this = (BgMoriIdomizu*)thisx;
if (sIsSpawned) {
if (sKankyoIsSpawned) {
Actor_Kill(&this->actor);
return;
}
@ -76,7 +76,7 @@ void BgMoriIdomizu_Init(Actor* thisx, GlobalContext* globalCtx) {
return;
}
BgMoriIdomizu_SetupWaitForMoriTex(this);
sIsSpawned = true;
sKankyoIsSpawned = true;
this->isLoaded = true;
this->actor.room = -1;
// "Forest Temple well water"
@ -88,7 +88,7 @@ void BgMoriIdomizu_Destroy(Actor* thisx, GlobalContext* globalCtx) {
BgMoriIdomizu* this = (BgMoriIdomizu*)thisx;
if (this->isLoaded) {
sIsSpawned = false;
sKankyoIsSpawned = false;
}
}

78
soh/src/overlays/actors/ovl_Bg_Po_Event/z_bg_po_event.c
View File

@ -80,11 +80,11 @@ static ColliderTrisInit sTrisInit = {
sTrisElementsInit,
};
static u8 sBlocksAtRest = 0;
u8 sBgPoEventBlocksAtRest = 0;
static Vec3f sZeroVec = { 0.0f, 0.0f, 0.0f };
static u8 sPuzzleState;
u8 sBgPoEventPuzzleState;
void BgPoEvent_InitPaintings(BgPoEvent* this, GlobalContext* globalCtx) {
static s16 paintingPosX[] = { -1302, -866, 1421, 985 };
@ -142,10 +142,10 @@ void BgPoEvent_InitPaintings(BgPoEvent* this, GlobalContext* globalCtx) {
}
this->timer = 0;
if (this->type == 4) {
sPuzzleState = 0;
sBgPoEventPuzzleState = 0;
this->actionFunc = BgPoEvent_AmyWait;
} else {
sPuzzleState = (s32)(Rand_ZeroOne() * 3.0f) % 3;
sBgPoEventPuzzleState = (s32)(Rand_ZeroOne() * 3.0f) % 3;
this->actionFunc = BgPoEvent_PaintingEmpty;
}
}
@ -236,7 +236,7 @@ void BgPoEvent_Destroy(Actor* thisx, GlobalContext* globalCtx) {
void BgPoEvent_BlockWait(BgPoEvent* this, GlobalContext* globalCtx) {
this->dyna.actor.world.pos.y = 833.0f;
if (sPuzzleState == 0x3F) {
if (sBgPoEventPuzzleState == 0x3F) {
if (this->type == 1) {
OnePointCutscene_Init(globalCtx, 3150, 65, NULL, MAIN_CAM);
}
@ -244,14 +244,14 @@ void BgPoEvent_BlockWait(BgPoEvent* this, GlobalContext* globalCtx) {
this->actionFunc = BgPoEvent_BlockShake;
} else if (this->dyna.actor.xzDistToPlayer > 50.0f) {
if (this->type != 1) {
sPuzzleState |= (1 << this->index);
sBgPoEventPuzzleState |= (1 << this->index);
} else {
sPuzzleState |= 0x10;
sBgPoEventPuzzleState |= 0x10;
}
} else if (this->type != 1) {
sPuzzleState &= ~(1 << this->index);
sBgPoEventPuzzleState &= ~(1 << this->index);
} else {
sPuzzleState &= ~0x10;
sBgPoEventPuzzleState &= ~0x10;
}
}
@ -265,7 +265,7 @@ void BgPoEvent_BlockShake(BgPoEvent* this, GlobalContext* globalCtx) {
}
if (this->timer == 0) {
this->dyna.actor.world.pos.x = this->dyna.actor.home.pos.x;
sPuzzleState = 0;
sBgPoEventPuzzleState = 0;
this->timer = 60;
this->actionFunc = BgPoEvent_BlockFall;
}
@ -299,9 +299,9 @@ void BgPoEvent_CheckBlock(BgPoEvent* this) {
}
}
if ((phi_v1 == phi_a1) && ((phi_t0 - phi_a3) == 60)) {
sPuzzleState |= (1 << this->index);
sBgPoEventPuzzleState |= (1 << this->index);
} else {
sPuzzleState &= ~(1 << this->index);
sBgPoEventPuzzleState &= ~(1 << this->index);
}
}
@ -312,7 +312,7 @@ void BgPoEvent_BlockFall(BgPoEvent* this, GlobalContext* globalCtx) {
if (Math_StepToF(&this->dyna.actor.world.pos.y, 433.0f, this->dyna.actor.velocity.y)) {
this->dyna.actor.flags &= ~ACTOR_FLAG_5;
this->dyna.actor.velocity.y = 0.0f;
sBlocksAtRest++;
sBgPoEventBlocksAtRest++;
if (this->type != 1) {
BgPoEvent_CheckBlock(this);
} else {
@ -334,7 +334,7 @@ void BgPoEvent_BlockIdle(BgPoEvent* this, GlobalContext* globalCtx) {
Player* player = GET_PLAYER(globalCtx);
Actor* amy;
if (sPuzzleState == 0xF) {
if (sBgPoEventPuzzleState == 0xF) {
this->actionFunc = BgPoEvent_BlockSolved;
if ((this->type == 0) && (this->index == 0)) {
amy =
@ -348,23 +348,23 @@ void BgPoEvent_BlockIdle(BgPoEvent* this, GlobalContext* globalCtx) {
gSaveContext.timer1State = 0xA;
}
} else {
if ((gSaveContext.timer1Value == 0) && (sBlocksAtRest == 5)) {
if ((gSaveContext.timer1Value == 0) && (sBgPoEventBlocksAtRest == 5)) {
player->stateFlags2 &= ~0x10;
sPuzzleState = 0x10;
sBlocksAtRest = 0;
sBgPoEventPuzzleState = 0x10;
sBgPoEventBlocksAtRest = 0;
}
if ((sPuzzleState == 0x40) || ((sPuzzleState == 0x10) && !Player_InCsMode(globalCtx))) {
if ((sBgPoEventPuzzleState == 0x40) || ((sBgPoEventPuzzleState == 0x10) && !Player_InCsMode(globalCtx))) {
this->dyna.actor.world.rot.z = this->dyna.actor.shape.rot.z;
this->actionFunc = BgPoEvent_BlockReset;
if (sPuzzleState == 0x10) {
sPuzzleState = 0x40;
if (sBgPoEventPuzzleState == 0x10) {
sBgPoEventPuzzleState = 0x40;
Audio_PlayActorSound2(&this->dyna.actor, NA_SE_EV_BLOCK_RISING);
func_8002DF54(globalCtx, &player->actor, 8);
}
} else if (this->dyna.unk_150 != 0.0f) {
if (this->direction == 0) {
if (func_800435D8(globalCtx, &this->dyna, 0x1E, 0x32, -0x14) != 0) {
sBlocksAtRest--;
sBgPoEventBlocksAtRest--;
this->direction = (this->dyna.unk_150 >= 0.0f) ? 1.0f : -1.0f;
this->actionFunc = BgPoEvent_BlockPush;
} else {
@ -382,7 +382,7 @@ void BgPoEvent_BlockIdle(BgPoEvent* this, GlobalContext* globalCtx) {
}
}
static f32 blockPushDist = 0.0f;
f32 sBgPoEventblockPushDist = 0.0f;
void BgPoEvent_BlockPush(BgPoEvent* this, GlobalContext* globalCtx) {
f32 displacement;
s32 blockStop;
@ -390,8 +390,8 @@ void BgPoEvent_BlockPush(BgPoEvent* this, GlobalContext* globalCtx) {
this->dyna.actor.speedXZ += CVar_GetS32("gFasterBlockPush", 0) != 0 ? 0.5f : 0.1f;
this->dyna.actor.speedXZ = CLAMP_MAX(this->dyna.actor.speedXZ, 2.0f);
blockStop = Math_StepToF(&blockPushDist, 20.0f, this->dyna.actor.speedXZ);
displacement = this->direction * blockPushDist;
blockStop = Math_StepToF(&sBgPoEventblockPushDist, 20.0f, this->dyna.actor.speedXZ);
displacement = this->direction * sBgPoEventblockPushDist;
this->dyna.actor.world.pos.x = (Math_SinS(this->dyna.unk_158) * displacement) + this->dyna.actor.home.pos.x;
this->dyna.actor.world.pos.z = (Math_CosS(this->dyna.unk_158) * displacement) + this->dyna.actor.home.pos.z;
if (blockStop) {
@ -402,10 +402,10 @@ void BgPoEvent_BlockPush(BgPoEvent* this, GlobalContext* globalCtx) {
this->dyna.unk_150 = 0.0f;
this->dyna.actor.home.pos.x = this->dyna.actor.world.pos.x;
this->dyna.actor.home.pos.z = this->dyna.actor.world.pos.z;
blockPushDist = 0.0f;
sBgPoEventblockPushDist = 0.0f;
this->dyna.actor.speedXZ = 0.0f;
this->direction = CVar_GetS32("gFasterBlockPush", 0) != 0 ? 3 : 5;
sBlocksAtRest++;
sBgPoEventBlocksAtRest++;
this->actionFunc = BgPoEvent_BlockIdle;
if (this->type == 1) {
return;
@ -428,7 +428,7 @@ void BgPoEvent_BlockReset(BgPoEvent* this, GlobalContext* globalCtx) {
this->index = (this->index + 1) % 4;
this->actionFunc = BgPoEvent_BlockFall;
sPuzzleState = 0;
sBgPoEventPuzzleState = 0;
if (this->type == 1) {
this->timer += 10;
this->timer = CLAMP_MAX(this->timer, 120);
@ -443,14 +443,14 @@ void BgPoEvent_BlockSolved(BgPoEvent* this, GlobalContext* globalCtx) {
player->stateFlags2 &= ~0x10;
}
if (Math_StepToF(&this->dyna.actor.world.pos.y, 369.0f, 2.0f)) {
sPuzzleState = 0x20;
sBgPoEventPuzzleState = 0x20;
Actor_Kill(&this->dyna.actor);
}
}
void BgPoEvent_AmyWait(BgPoEvent* this, GlobalContext* globalCtx) {
if (this->collider.base.acFlags & AC_HIT) {
sPuzzleState |= 0x20;
sBgPoEventPuzzleState |= 0x20;
this->timer = 5;
Actor_SetColorFilter(&this->dyna.actor, 0x4000, 0xFF, 0, 5);
Audio_PlayActorSound2(&this->dyna.actor, NA_SE_EN_PO_LAUGH2);
@ -461,12 +461,12 @@ void BgPoEvent_AmyWait(BgPoEvent* this, GlobalContext* globalCtx) {
void BgPoEvent_AmyPuzzle(BgPoEvent* this, GlobalContext* globalCtx) {
Vec3f pos;
if (sPuzzleState == 0xF) {
if (sBgPoEventPuzzleState == 0xF) {
pos.x = this->dyna.actor.world.pos.x - 5.0f;
pos.y = Rand_CenteredFloat(120.0f) + this->dyna.actor.world.pos.y;
pos.z = Rand_CenteredFloat(120.0f) + this->dyna.actor.world.pos.z;
EffectSsDeadDb_Spawn(globalCtx, &pos, &sZeroVec, &sZeroVec, 170, 0, 200, 255, 100, 170, 0, 255, 0, 1, 9, true);
} else if (sPuzzleState == 0x20) {
} else if (sBgPoEventPuzzleState == 0x20) {
Actor_Kill(&this->dyna.actor);
} else {
DECR(this->timer);
@ -476,14 +476,14 @@ void BgPoEvent_AmyPuzzle(BgPoEvent* this, GlobalContext* globalCtx) {
s32 BgPoEvent_NextPainting(BgPoEvent* this) {
if ((this->dyna.actor.parent != NULL) && (this->dyna.actor.child != NULL)) {
if (Rand_ZeroOne() < 0.5f) {
sPuzzleState = ((BgPoEvent*)this->dyna.actor.parent)->index;
sBgPoEventPuzzleState = ((BgPoEvent*)this->dyna.actor.parent)->index;
} else {
sPuzzleState = ((BgPoEvent*)this->dyna.actor.child)->index;
sBgPoEventPuzzleState = ((BgPoEvent*)this->dyna.actor.child)->index;
}
} else if (this->dyna.actor.parent != NULL) {
sPuzzleState = ((BgPoEvent*)this->dyna.actor.parent)->index;
sBgPoEventPuzzleState = ((BgPoEvent*)this->dyna.actor.parent)->index;
} else if (this->dyna.actor.child != NULL) {
sPuzzleState = ((BgPoEvent*)this->dyna.actor.child)->index;
sBgPoEventPuzzleState = ((BgPoEvent*)this->dyna.actor.child)->index;
} else {
return false;
}
@ -491,7 +491,7 @@ s32 BgPoEvent_NextPainting(BgPoEvent* this) {
}
void BgPoEvent_PaintingEmpty(BgPoEvent* this, GlobalContext* globalCtx) {
if (sPuzzleState == this->index) {
if (sBgPoEventPuzzleState == this->index) {
this->timer = 255;
this->actionFunc = BgPoEvent_PaintingAppear;
}
@ -636,7 +636,7 @@ void BgPoEvent_Draw(Actor* thisx, GlobalContext* globalCtx) {
}
void BgPoEvent_Reset(void) {
sBlocksAtRest = 0;
sPuzzleState = 0;
blockPushDist = 0.0f;
sBgPoEventBlocksAtRest = 0;
sBgPoEventPuzzleState = 0;
sBgPoEventblockPushDist = 0.0f;
}

2
soh/src/overlays/actors/ovl_Bg_Relay_Objects/z_bg_relay_objects.c
View File

@ -45,7 +45,7 @@ static InitChainEntry sInitChain[] = {
ICHAIN_VEC3F_DIV1000(scale, 100, ICHAIN_STOP),
};
static u32 D_808A9508 = 0;
u32 D_808A9508 = 0;
void BgRelayObjects_Init(Actor* thisx, GlobalContext* globalCtx) {
BgRelayObjects* this = (BgRelayObjects*)thisx;
s32 pad;

2
soh/src/overlays/actors/ovl_Bg_Spot18_Basket/z_bg_spot18_basket.c
View File

@ -84,7 +84,7 @@ void func_808B7710(Actor* thisx, GlobalContext* globalCtx) {
this->dyna.actor.colChkInfo.mass = MASS_IMMOVABLE;
}
static s16 D_808B85D0 = 0;
s16 D_808B85D0 = 0;
void func_808B7770(BgSpot18Basket* this, GlobalContext* globalCtx, f32 arg2) {
Vec3f acceleration;
Vec3f velocity;

301
soh/src/overlays/actors/ovl_Boss_Ganon/z_boss_ganon.c
View File

@ -105,35 +105,17 @@ static ColliderCylinderInit sLightBallCylinderInit = {
static u8 D_808E4C58[] = { 0, 12, 10, 12, 14, 16, 12, 14, 16, 12, 14, 16, 12, 14, 16, 10, 16, 14 };
static Vec3f sZeroVec = { 0.0f, 0.0f, 0.0f };
static EnGanonMant* sCape;
EnGanonMant* sBossGanonCape;
static s32 sSeed1;
static s32 sSeed2;
static s32 sSeed3;
s32 sBossGanonSeed1;
s32 sBossGanonSeed3;
s32 sBossGanonSeed2;
static BossGanon* sGanondorf;
BossGanon* sBossGanonGanondorf;
static EnZl3* sZelda;
EnZl3* sBossGanonZelda;
typedef struct {
/* 0x00 */ u8 type;
/* 0x01 */ u8 timer;
/* 0x04 */ Vec3f pos;
/* 0x10 */ Vec3f velocity;
/* 0x1C */ Vec3f accel;
/* 0x28 */ Color_RGB8 color;
/* 0x2C */ s16 alpha;
/* 0x2E */ s16 unk_2E;
/* 0x30 */ s16 unk_30;
/* 0x34 */ f32 scale;
/* 0x38 */ f32 unk_38; // scale target mostly, but used for other things
/* 0x3C */ f32 unk_3C; // mostly z rot
/* 0x40 */ f32 unk_40;
/* 0x44 */ f32 unk_44; // mostly x rot
/* 0x48 */ f32 unk_48; // mostly y rot
} GanondorfEffect; // size = 0x4C
GanondorfEffect sEffectBuf[200];
GanondorfEffect sBossGanonEffectBuf[200];
void BossGanonEff_SpawnWindowShard(GlobalContext* globalCtx, Vec3f* pos, Vec3f* velocity, f32 scale) {
static Color_RGB8 shardColors[] = { { 255, 175, 85 }, { 155, 205, 155 }, { 155, 125, 55 } };
@ -348,13 +330,13 @@ void BossGanon_Init(Actor* thisx, GlobalContext* globalCtx2) {
if (thisx->params < 0x64) {
Flags_SetSwitch(globalCtx, 0x14);
globalCtx->specialEffects = sEffectBuf;
globalCtx->specialEffects = sBossGanonEffectBuf;
for (i = 0; i < ARRAY_COUNT(sEffectBuf); i++) {
sEffectBuf[i].type = GDF_EFF_NONE;
for (i = 0; i < ARRAY_COUNT(sBossGanonEffectBuf); i++) {
sBossGanonEffectBuf[i].type = GDF_EFF_NONE;
}
sGanondorf = this;
sBossGanonGanondorf = this;
thisx->colChkInfo.health = 40;
Actor_ProcessInitChain(thisx, sInitChain);
ActorShape_Init(&thisx->shape, 0, NULL, 0);
@ -381,7 +363,7 @@ void BossGanon_Init(Actor* thisx, GlobalContext* globalCtx2) {
BossGanon_SetupTowerCutscene(this, globalCtx);
}
sCape = (EnGanonMant*)Actor_SpawnAsChild(&globalCtx->actorCtx, thisx, globalCtx, ACTOR_EN_GANON_MANT, 0.0f,
sBossGanonCape = (EnGanonMant*)Actor_SpawnAsChild(&globalCtx->actorCtx, thisx, globalCtx, ACTOR_EN_GANON_MANT, 0.0f,
0.0f, 0.0f, 0, 0, 0, 1);
Actor_ChangeCategory(globalCtx, &globalCtx->actorCtx, thisx, ACTORCAT_BOSS);
} else {
@ -538,10 +520,10 @@ void BossGanon_IntroCutscene(BossGanon* this, GlobalContext* globalCtx) {
gSegments[6] = VIRTUAL_TO_PHYSICAL(globalCtx->objectCtx.status[this->animBankIndex].segment);
sCape->backPush = -2.0f;
sCape->backSwayMagnitude = 0.25f;
sCape->sideSwayMagnitude = -1.0f;
sCape->minDist = 0.0f;
sBossGanonCape->backPush = -2.0f;
sBossGanonCape->backSwayMagnitude = 0.25f;
sBossGanonCape->sideSwayMagnitude = -1.0f;
sBossGanonCape->minDist = 0.0f;
this->csTimer++;
@ -584,13 +566,13 @@ void BossGanon_IntroCutscene(BossGanon* this, GlobalContext* globalCtx) {
this->useOpenHand = true;
BossGanon_SetIntroCsCamera(this, 0);
this->csState = 1;
sZelda = (EnZl3*)Actor_SpawnAsChild(&globalCtx->actorCtx, &this->actor, globalCtx, ACTOR_EN_ZL3, 0.0f,
sBossGanonZelda = (EnZl3*)Actor_SpawnAsChild(&globalCtx->actorCtx, &this->actor, globalCtx, ACTOR_EN_ZL3, 0.0f,
220.0f, -150.0f, 0, 0, 0, 0x2000);
}
Actor_SpawnAsChild(&globalCtx->actorCtx, &this->actor, globalCtx, ACTOR_EN_GANON_ORGAN, 0.0f, 0.0f, 0.0f, 0,
0, 0, 1);
sCape->minY = 57.0f;
sBossGanonCape->minY = 57.0f;
// fallthrough
case 1:
this->envLightMode = 3;
@ -736,7 +718,7 @@ void BossGanon_IntroCutscene(BossGanon* this, GlobalContext* globalCtx) {
this->csState = 9;
this->csTimer = 0;
func_8002DF54(globalCtx, &this->actor, 8);
sZelda->unk_3C8 = 0;
sBossGanonZelda->unk_3C8 = 0;
this->triforceType = GDF_TRIFORCE_ZELDA;
this->fwork[GDF_TRIFORCE_SCALE] = 10.0f;
this->fwork[GDF_TRIFORCE_PRIM_A] = 0.0f;
@ -755,7 +737,7 @@ void BossGanon_IntroCutscene(BossGanon* this, GlobalContext* globalCtx) {
Math_ApproachF(&this->fwork[GDF_TRIFORCE_ENV_G], 200.0f, 1.0f, 3.0f);
if (this->csTimer == 30) {
sZelda->unk_3C8 = 1;
sBossGanonZelda->unk_3C8 = 1;
}
if (this->csTimer >= 32) {
@ -847,7 +829,7 @@ void BossGanon_IntroCutscene(BossGanon* this, GlobalContext* globalCtx) {
this->csTimer = 0;
BossGanon_SetIntroCsCamera(this, 11);
this->unk_198 = 2;
sZelda->unk_3C8 = 2;
sBossGanonZelda->unk_3C8 = 2;
this->timers[2] = 110;
this->envLightMode = 3;
}
@ -883,7 +865,7 @@ void BossGanon_IntroCutscene(BossGanon* this, GlobalContext* globalCtx) {
if (this->csTimer > 10) {
if (this->csTimer == 62) {
sCape->attachRightArmTimer = 20.0f;
sBossGanonCape->attachRightArmTimer = 20.0f;
}
if (this->csTimer == 57) {
@ -1076,7 +1058,7 @@ void BossGanon_IntroCutscene(BossGanon* this, GlobalContext* globalCtx) {
Animation_MorphToPlayOnce(&this->skelAnime, &gDorfGetUp3Anim, 0.0f);
SkelAnime_Update(&this->skelAnime);
this->actor.shape.yOffset = 0.0f;
sCape->attachShouldersTimer = 18.0f;
sBossGanonCape->attachShouldersTimer = 18.0f;
Audio_PlayActorSound2(&this->actor, NA_SE_EV_GANON_MANTLE);
this->unk_198 = 0;
Audio_QueueSeqCmd(SEQ_PLAYER_BGM_MAIN << 24 | NA_BGM_GANONDORF_BOSS);
@ -1101,9 +1083,9 @@ void BossGanon_IntroCutscene(BossGanon* this, GlobalContext* globalCtx) {
Math_ApproachF(&this->actor.world.pos.y, 228.0f, 0.05f, 2.0f);
Math_ApproachF(&this->actor.world.pos.z, -230.0f, 0.05f, 4.0f);
sCape->backPush = -3.0f;
sCape->backSwayMagnitude = 0.25f;
sCape->sideSwayMagnitude = -3.0f;
sBossGanonCape->backPush = -3.0f;
sBossGanonCape->backSwayMagnitude = 0.25f;
sBossGanonCape->sideSwayMagnitude = -3.0f;
sin = Math_SinS(this->csTimer * 1500);
this->actor.velocity.y = this->fwork[GDF_FWORK_0] * sin * 0.04f;
@ -1136,10 +1118,10 @@ void BossGanon_IntroCutscene(BossGanon* this, GlobalContext* globalCtx) {
BossGanon_SetupWait(this, globalCtx);
}
if (sZelda != NULL) {
sZelda->actor.world.pos.x = 0.0f;
sZelda->actor.world.pos.y = 350.0f;
sZelda->actor.world.pos.z = 0.0f;
if (sBossGanonZelda != NULL) {
sBossGanonZelda->actor.world.pos.x = 0.0f;
sBossGanonZelda->actor.world.pos.y = 350.0f;
sBossGanonZelda->actor.world.pos.z = 0.0f;
}
}
@ -1529,7 +1511,7 @@ void BossGanon_DeathAndTowerCutscene(BossGanon* this, GlobalContext* globalCtx)
this->fwork[1] = Animation_GetLastFrame(&object_ganon_anime2_Anim_00EA00);
this->csState = 101;
this->skelAnime.playSpeed = 0.0f;
sZelda = (EnZl3*)Actor_SpawnAsChild(&globalCtx->actorCtx, &this->actor, globalCtx, ACTOR_EN_ZL3, 0.0f,
sBossGanonZelda = (EnZl3*)Actor_SpawnAsChild(&globalCtx->actorCtx, &this->actor, globalCtx, ACTOR_EN_ZL3, 0.0f,
6000.0f, 0.0f, 0, 0, 0, 0x2000);
player->actor.world.pos.x = -472.0f;
@ -1551,12 +1533,12 @@ void BossGanon_DeathAndTowerCutscene(BossGanon* this, GlobalContext* globalCtx)
this->csCamAt.z = -100.0f;
sCape->backPush = -2.0f;
sCape->backSwayMagnitude = 0.25f;
sCape->sideSwayMagnitude = -1.0f;
sCape->minDist = 0.0f;
sCape->minY = 4104.0f;
sCape->tearTimer = 20;
sBossGanonCape->backPush = -2.0f;
sBossGanonCape->backSwayMagnitude = 0.25f;
sBossGanonCape->sideSwayMagnitude = -1.0f;
sBossGanonCape->minDist = 0.0f;
sBossGanonCape->minY = 4104.0f;
sBossGanonCape->tearTimer = 20;
this->whiteFillAlpha = 255.0f;
globalCtx->envCtx.unk_D8 = 1.0f;
@ -1620,27 +1602,27 @@ void BossGanon_DeathAndTowerCutscene(BossGanon* this, GlobalContext* globalCtx)
if (this->csTimer == 90) {
this->csState = 103;
this->csTimer = 0;
sZelda->actor.world.pos.x = -472.0f;
sZelda->actor.world.pos.y = 4352.0f;
sZelda->actor.world.pos.z = -200.0f;
sZelda->unk_3C8 = 3;
sBossGanonZelda->actor.world.pos.x = -472.0f;
sBossGanonZelda->actor.world.pos.y = 4352.0f;
sBossGanonZelda->actor.world.pos.z = -200.0f;
sBossGanonZelda->unk_3C8 = 3;
}
break;
case 103:
Audio_PlayActorSound2(&sZelda->actor, NA_SE_EV_DOWN_TO_GROUND - SFX_FLAG);
Math_ApproachF(&sZelda->actor.world.pos.y, 4102.0f, 0.05f, 1.5f);
Audio_PlayActorSound2(&sBossGanonZelda->actor, NA_SE_EV_DOWN_TO_GROUND - SFX_FLAG);
Math_ApproachF(&sBossGanonZelda->actor.world.pos.y, 4102.0f, 0.05f, 1.5f);
this->csCamEye.x = -242.0f;
this->csCamEye.y = 4122.0f;
this->csCamEye.z = -190.0f;
this->csCamAt.x = sZelda->actor.world.pos.x;
this->csCamAt.y = sZelda->actor.world.pos.y + 40.0f + 5.0f;
this->csCamAt.z = sZelda->actor.world.pos.z;
this->csCamAt.x = sBossGanonZelda->actor.world.pos.x;
this->csCamAt.y = sBossGanonZelda->actor.world.pos.y + 40.0f + 5.0f;
this->csCamAt.z = sBossGanonZelda->actor.world.pos.z;
if (this->csTimer == 200) {
sZelda->actor.world.pos.y = 4102.0f;
sBossGanonZelda->actor.world.pos.y = 4102.0f;
this->csState = 104;
this->csTimer = 0;
} else {
@ -1652,20 +1634,20 @@ void BossGanon_DeathAndTowerCutscene(BossGanon* this, GlobalContext* globalCtx)
this->csCamEye.y = 4147.0f;
this->csCamEye.z = -200.0f;
this->csCamAt.x = sZelda->actor.world.pos.x;
this->csCamAt.y = sZelda->actor.world.pos.y + 40.0f + 5.0f;
this->csCamAt.z = sZelda->actor.world.pos.z;
this->csCamAt.x = sBossGanonZelda->actor.world.pos.x;
this->csCamAt.y = sBossGanonZelda->actor.world.pos.y + 40.0f + 5.0f;
this->csCamAt.z = sBossGanonZelda->actor.world.pos.z;
if (this->csTimer >= 10) {
Math_ApproachZeroF(&globalCtx->envCtx.unk_D8, 1.0f, 0.05f);
}
if (this->csTimer == 10) {
sZelda->unk_3C8 = 8;
sBossGanonZelda->unk_3C8 = 8;
}
if (this->csTimer == 50) {
sZelda->unk_3C8 = 4;
sBossGanonZelda->unk_3C8 = 4;
}
if (this->csTimer == 100) {
@ -1679,9 +1661,9 @@ void BossGanon_DeathAndTowerCutscene(BossGanon* this, GlobalContext* globalCtx)
this->csCamEye.y = 4154.0f;
this->csCamEye.z = -182.0f;
this->csCamAt.x = sZelda->actor.world.pos.x - 5.0f;
this->csCamAt.y = sZelda->actor.world.pos.y + 40.0f + 5.0f;
this->csCamAt.z = sZelda->actor.world.pos.z - 25.0f;
this->csCamAt.x = sBossGanonZelda->actor.world.pos.x - 5.0f;
this->csCamAt.y = sBossGanonZelda->actor.world.pos.y + 40.0f + 5.0f;
this->csCamAt.z = sBossGanonZelda->actor.world.pos.z - 25.0f;
if (this->csTimer == 10) {
Message_StartTextbox(globalCtx, 0x70D0, NULL);
@ -1698,7 +1680,7 @@ void BossGanon_DeathAndTowerCutscene(BossGanon* this, GlobalContext* globalCtx)
func_80078884(NA_SE_EV_EARTHQUAKE - SFX_FLAG);
if (this->csTimer == 20) {
sZelda->unk_3C8 = 5;
sBossGanonZelda->unk_3C8 = 5;
func_8002DF54(globalCtx, &this->actor, 0x39);
}
@ -1747,15 +1729,15 @@ void BossGanon_DeathAndTowerCutscene(BossGanon* this, GlobalContext* globalCtx)
this->csCamEye.y = 4154.0f;
this->csCamEye.z = -182.0f;
this->csCamAt.x = sZelda->actor.world.pos.x - 5.0f;
this->csCamAt.y = sZelda->actor.world.pos.y + 40.0f + 5.0f;
this->csCamAt.z = sZelda->actor.world.pos.z - 25.0f;
this->csCamAt.x = sBossGanonZelda->actor.world.pos.x - 5.0f;
this->csCamAt.y = sBossGanonZelda->actor.world.pos.y + 40.0f + 5.0f;
this->csCamAt.z = sBossGanonZelda->actor.world.pos.z - 25.0f;
this->unk_70C = Math_SinS(this->csTimer * 0x6300) * 0.3f;
func_80078884(NA_SE_EV_EARTHQUAKE - SFX_FLAG);
if (this->csTimer == 70) {
sZelda->unk_3C8 = 6;
sBossGanonZelda->unk_3C8 = 6;
}
if (this->csTimer == 90) {
@ -1778,12 +1760,12 @@ void BossGanon_DeathAndTowerCutscene(BossGanon* this, GlobalContext* globalCtx)
this->csCamEye.y = 4154.0f;
this->csCamEye.z = -242.0f;
this->csCamAt.x = (sZelda->actor.world.pos.x - 5.0f) - 30.0f;
this->csCamAt.y = (sZelda->actor.world.pos.y + 40.0f + 5.0f) - 20.0f;
this->csCamAt.z = (sZelda->actor.world.pos.z - 25.0f) + 80.0f;
this->csCamAt.x = (sBossGanonZelda->actor.world.pos.x - 5.0f) - 30.0f;
this->csCamAt.y = (sBossGanonZelda->actor.world.pos.y + 40.0f + 5.0f) - 20.0f;
this->csCamAt.z = (sBossGanonZelda->actor.world.pos.z - 25.0f) + 80.0f;
if ((this->csTimer > 50) && (Message_GetState(&globalCtx->msgCtx) == TEXT_STATE_NONE)) {
sZelda->unk_3C8 = 7;
sBossGanonZelda->unk_3C8 = 7;
this->csState = 108;
this->csTimer = 0;
}
@ -1793,9 +1775,9 @@ void BossGanon_DeathAndTowerCutscene(BossGanon* this, GlobalContext* globalCtx)
this->unk_70C = Math_SinS(this->csTimer * 0x6300) * 0.8f;
func_80078884(NA_SE_EV_EARTHQUAKE - SFX_FLAG);
this->csCamAt.x = (sZelda->actor.world.pos.x - 5.0f) - 30.0f;
this->csCamAt.y = (sZelda->actor.world.pos.y + 40.0f + 5.0f) - 20.0f;
this->csCamAt.z = (sZelda->actor.world.pos.z - 25.0f) + 80.0f;
this->csCamAt.x = (sBossGanonZelda->actor.world.pos.x - 5.0f) - 30.0f;
this->csCamAt.y = (sBossGanonZelda->actor.world.pos.y + 40.0f + 5.0f) - 20.0f;
this->csCamAt.z = (sBossGanonZelda->actor.world.pos.z - 25.0f) + 80.0f;
if (this->csTimer > 50) {
mainCam = Gameplay_GetCamera(globalCtx, MAIN_CAM);
@ -1905,7 +1887,7 @@ void BossGanon_PoundFloor(BossGanon* this, GlobalContext* globalCtx) {
break;
case 1:
sCape->gravity = -1.0f;
sBossGanonCape->gravity = -1.0f;
this->envLightMode = 1;
Math_ApproachF(&this->actor.velocity.y, -50.0f, 1.0f, 10.0f);
this->actor.world.pos.y += this->actor.velocity.y;
@ -1952,7 +1934,7 @@ void BossGanon_PoundFloor(BossGanon* this, GlobalContext* globalCtx) {
this->fwork[GDF_FWORK_1] = Animation_GetLastFrame(&gDorfGetUp3Anim);
Animation_MorphToPlayOnce(&this->skelAnime, &gDorfGetUp3Anim, 0.0f);
SkelAnime_Update(&this->skelAnime);
sCape->attachShouldersTimer = 18.0f;
sBossGanonCape->attachShouldersTimer = 18.0f;
Audio_PlayActorSound2(&this->actor, NA_SE_EV_GANON_MANTLE);
this->unk_1C2 = 4;
}
@ -2136,7 +2118,7 @@ void BossGanon_ChargeBigMagic(BossGanon* this, GlobalContext* globalCtx) {
}
if (this->timers[0] == 1) {
sCape->attachLeftArmTimer = 15.0f;
sBossGanonCape->attachLeftArmTimer = 15.0f;
Audio_PlayActorSound2(&this->actor, NA_SE_EV_GANON_MANTLE);
}
@ -2174,7 +2156,7 @@ void BossGanon_ChargeBigMagic(BossGanon* this, GlobalContext* globalCtx) {
}
if (Animation_OnFrame(&this->skelAnime, 3.0f)) {
sCape->attachShouldersTimer = 26.0f;
sBossGanonCape->attachShouldersTimer = 26.0f;
Audio_PlayActorSound2(&this->actor, NA_SE_EV_GANON_MANTLE);
}
@ -2202,7 +2184,7 @@ void BossGanon_SetupWait(BossGanon* this, GlobalContext* globalCtx) {
this->fwork[GDF_FWORK_0] = 0.0f;
this->timers[0] = (s16)Rand_ZeroFloat(64.0f) + 30;
this->unk_1C2 = 0;
sCape->minY = 2.0f;
sBossGanonCape->minY = 2.0f;
}
void BossGanon_Wait(BossGanon* this, GlobalContext* globalCtx) {
@ -2213,10 +2195,10 @@ void BossGanon_Wait(BossGanon* this, GlobalContext* globalCtx) {
this->legSwayEnabled = true;
sCape->backPush = -3.0f;
sCape->backSwayMagnitude = 0.25f;
sCape->sideSwayMagnitude = -3.0f;
sCape->minDist = 20.0f;
sBossGanonCape->backPush = -3.0f;
sBossGanonCape->backSwayMagnitude = 0.25f;
sBossGanonCape->sideSwayMagnitude = -3.0f;
sBossGanonCape->minDist = 20.0f;
SkelAnime_Update(&this->skelAnime);
@ -2271,10 +2253,10 @@ void BossGanon_SetupChargeLightBall(BossGanon* this, GlobalContext* globalCtx) {
void BossGanon_ChargeLightBall(BossGanon* this, GlobalContext* globalCtx) {
SkelAnime_Update(&this->skelAnime);
sCape->backPush = -3.0f;
sCape->backSwayMagnitude = 1.25f;
sCape->sideSwayMagnitude = -2.0f;
sCape->minDist = 10.0f;
sBossGanonCape->backPush = -3.0f;
sBossGanonCape->backSwayMagnitude = 1.25f;
sBossGanonCape->sideSwayMagnitude = -2.0f;
sBossGanonCape->minDist = 10.0f;
if (this->timers[0] < 17) {
this->envLightMode = 1;
@ -2355,7 +2337,7 @@ void BossGanon_PlayTennis(BossGanon* this, GlobalContext* globalCtx) {
rand = Rand_ZeroOne() * 1.99f;
this->fwork[GDF_FWORK_1] = Animation_GetLastFrame(volleyAnims[rand]);
Animation_MorphToPlayOnce(&this->skelAnime, volleyAnims[rand], 0.0f);
sCape->attachRightArmTimer = capeRightArmDurations[rand];
sBossGanonCape->attachRightArmTimer = capeRightArmDurations[rand];
Audio_PlayActorSound2(&this->actor, NA_SE_EV_GANON_MANTLE);
this->startVolley = false;
}
@ -2383,7 +2365,7 @@ void BossGanon_SetupBlock(BossGanon* this, GlobalContext* globalCtx) {
}
this->unk_1C2 = 0;
sCape->attachLeftArmTimer = this->timers[0] = 10;
sBossGanonCape->attachLeftArmTimer = this->timers[0] = 10;
Audio_PlayActorSound2(&this->actor, NA_SE_EV_GANON_MANTLE);
this->handLightBallScale = 0.0f;
}
@ -2391,10 +2373,10 @@ void BossGanon_SetupBlock(BossGanon* this, GlobalContext* globalCtx) {
void BossGanon_Block(BossGanon* this, GlobalContext* globalCtx) {
this->collider.base.colType = 9;
SkelAnime_Update(&this->skelAnime);
sCape->backPush = -9.0f;
sCape->backSwayMagnitude = 0.25f;
sCape->sideSwayMagnitude = -2.0f;
sCape->minDist = 13.0f;
sBossGanonCape->backPush = -9.0f;
sBossGanonCape->backSwayMagnitude = 0.25f;
sBossGanonCape->sideSwayMagnitude = -2.0f;
sBossGanonCape->minDist = 13.0f;
if (this->unk_1C2 == 0) {
if (this->timers[0] == 0) {
@ -2402,11 +2384,11 @@ void BossGanon_Block(BossGanon* this, GlobalContext* globalCtx) {
Animation_MorphToPlayOnce(&this->skelAnime, &gDorfBlockReleaseAnim, 0.0f);
this->fwork[GDF_FWORK_1] = Animation_GetLastFrame(&gDorfBlockReleaseAnim);
SkelAnime_Update(&this->skelAnime);
sCape->attachShouldersTimer = 15.0f;
sBossGanonCape->attachShouldersTimer = 15.0f;
Audio_PlayActorSound2(&this->actor, NA_SE_EV_GANON_MANTLE);
}
} else {
sCape->sideSwayMagnitude = -13.0f;
sBossGanonCape->sideSwayMagnitude = -13.0f;
if (Animation_OnFrame(&this->skelAnime, this->fwork[GDF_FWORK_1])) {
BossGanon_SetupWait(this, globalCtx);
@ -2429,7 +2411,7 @@ void BossGanon_SetupHitByLightBall(BossGanon* this, GlobalContext* globalCtx) {
this->fwork[GDF_FWORK_1] = Animation_GetLastFrame(&gDorfBigMagicHitAnim);
Animation_MorphToPlayOnce(&this->skelAnime, &gDorfBigMagicHitAnim, 0);
this->timers[0] = 70;
sCape->attachRightArmTimer = sCape->attachLeftArmTimer = 0;
sBossGanonCape->attachRightArmTimer = sBossGanonCape->attachLeftArmTimer = 0;
for (i = 1; i < 15; i++) {
this->unk_4E4[i] = D_808E4C58[i];
@ -2466,7 +2448,7 @@ void BossGanon_HitByLightBall(BossGanon* this, GlobalContext* globalCtx) {
Animation_MorphToPlayOnce(&this->skelAnime, &gDorfGetUp3Anim, 0.0f);
this->unk_1C2 = 2;
SkelAnime_Update(&this->skelAnime);
sCape->attachShouldersTimer = 18.0f;
sBossGanonCape->attachShouldersTimer = 18.0f;
Audio_PlayActorSound2(&this->actor, NA_SE_EV_GANON_MANTLE);
Audio_PlayActorSound2(&this->actor, NA_SE_EN_GANON_RESTORE);
this->timers[2] = 130;
@ -2500,7 +2482,7 @@ void BossGanon_SetupVulnerable(BossGanon* this, GlobalContext* globalCtx) {
BossGanon_SetAnimationObject(this, globalCtx, OBJECT_GANON_ANIME1);
this->fwork[GDF_FWORK_1] = Animation_GetLastFrame(&gDorfLightArrowHitAnim);
Animation_MorphToPlayOnce(&this->skelAnime, &gDorfLightArrowHitAnim, 0.0f);
sCape->attachRightArmTimer = sCape->attachLeftArmTimer = 0;
sBossGanonCape->attachRightArmTimer = sBossGanonCape->attachLeftArmTimer = 0;
this->actionFunc = BossGanon_Vulnerable;
this->actor.velocity.x = 0.0f;
@ -2508,10 +2490,10 @@ void BossGanon_SetupVulnerable(BossGanon* this, GlobalContext* globalCtx) {
this->actor.velocity.z = 0.0f;
this->unk_1C2 = 0;
sCape->backPush = -4.0f;
sCape->backSwayMagnitude = 0.75f;
sCape->sideSwayMagnitude = -3.0f;
sCape->minDist = 20.0f;
sBossGanonCape->backPush = -4.0f;
sBossGanonCape->backSwayMagnitude = 0.75f;
sBossGanonCape->sideSwayMagnitude = -3.0f;
sBossGanonCape->minDist = 20.0f;
for (i = 0; i < 10; i++) {
Actor_SpawnAsChild(&globalCtx->actorCtx, &this->actor, globalCtx, ACTOR_BOSS_GANON, this->unk_1FC.x,
@ -2571,7 +2553,7 @@ void BossGanon_Vulnerable(BossGanon* this, GlobalContext* globalCtx) {
break;
case 2:
sCape->minDist = 0.0f;
sBossGanonCape->minDist = 0.0f;
this->actor.velocity.y = this->actor.velocity.y - 0.5f;
if (this->actor.world.pos.y < 40.0f) {
@ -2625,7 +2607,7 @@ void BossGanon_Vulnerable(BossGanon* this, GlobalContext* globalCtx) {
this->unk_1C2 = 6;
this->fwork[GDF_FWORK_1] = Animation_GetLastFrame(&gDorfGetUp2Anim);
Animation_MorphToPlayOnce(&this->skelAnime, &gDorfGetUp2Anim, 0.0f);
sCape->minDist = 20.0f;
sBossGanonCape->minDist = 20.0f;
this->unk_19F = 1;
}
break;
@ -2646,7 +2628,7 @@ void BossGanon_Vulnerable(BossGanon* this, GlobalContext* globalCtx) {
Animation_MorphToPlayOnce(&this->skelAnime, &gDorfGetUp3Anim, 0.0f);
this->unk_1C2 = 8;
SkelAnime_Update(&this->skelAnime);
sCape->attachShouldersTimer = 18.0f;
sBossGanonCape->attachShouldersTimer = 18.0f;
Audio_PlayActorSound2(&this->actor, NA_SE_EV_GANON_MANTLE);
Audio_PlayActorSound2(&this->actor, NA_SE_EN_GANON_RESTORE);
break;
@ -2743,10 +2725,10 @@ void BossGanon_UpdateDamage(BossGanon* this, GlobalContext* globalCtx) {
this->actor.colChkInfo.health -= damage;
}
for (i = 0; i < ARRAY_COUNT(sCape->strands); i++) {
for (i = 0; i < ARRAY_COUNT(sBossGanonCape->strands); i++) {
for (j = 1; j < 12; j++) {
sCape->strands[i].velocities[j].x = Rand_CenteredFloat(15.0f);
sCape->strands[i].velocities[j].z = Rand_CenteredFloat(15.0f);
sBossGanonCape->strands[i].velocities[j].x = Rand_CenteredFloat(15.0f);
sBossGanonCape->strands[i].velocities[j].z = Rand_CenteredFloat(15.0f);
}
}
@ -2762,16 +2744,16 @@ void BossGanon_UpdateDamage(BossGanon* this, GlobalContext* globalCtx) {
Audio_PlayActorSound2(&this->actor, NA_SE_EN_GANON_CUTBODY);
BossGanon_SetupDamaged(this, globalCtx);
this->unk_1A6 = 15;
sCape->tearTimer = 1;
sBossGanonCape->tearTimer = 1;
}
}
} else if (acHitInfo->toucher.dmgFlags & 0x1F8A4) {
Audio_PlayActorSound2(&this->actor, 0);
for (i = 0; i < ARRAY_COUNT(sCape->strands); i++) {
for (i = 0; i < ARRAY_COUNT(sBossGanonCape->strands); i++) {
for (j = 1; j < 12; j++) {
sCape->strands[i].velocities[j].x = Rand_CenteredFloat(15.0f);
sCape->strands[i].velocities[j].z = Rand_CenteredFloat(15.0f);
sBossGanonCape->strands[i].velocities[j].x = Rand_CenteredFloat(15.0f);
sBossGanonCape->strands[i].velocities[j].z = Rand_CenteredFloat(15.0f);
}
}
}
@ -2841,7 +2823,7 @@ void BossGanon_Update(Actor* thisx, GlobalContext* globalCtx2) {
}
this->collider.base.colType = 3;
sCape->gravity = -3.0f;
sBossGanonCape->gravity = -3.0f;
this->shockGlow = false;
this->actor.flags &= ~ACTOR_FLAG_0;
this->unk_1A2++;
@ -3334,20 +3316,20 @@ void BossGanon_PostLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList
}
void BossGanon_InitRand(s32 seedInit0, s32 seedInit1, s32 seedInit2) {
sSeed1 = seedInit0;
sSeed2 = seedInit1;
sSeed3 = seedInit2;
sBossGanonSeed1 = seedInit0;
sBossGanonSeed2 = seedInit1;
sBossGanonSeed3 = seedInit2;
}
f32 BossGanon_RandZeroOne(void) {
// Wichmann-Hill algorithm
f32 randFloat;
sSeed1 = (sSeed1 * 171) % 30269;
sSeed2 = (sSeed2 * 172) % 30307;
sSeed3 = (sSeed3 * 170) % 30323;
sBossGanonSeed1 = (sBossGanonSeed1 * 171) % 30269;
sBossGanonSeed2 = (sBossGanonSeed2 * 172) % 30307;
sBossGanonSeed3 = (sBossGanonSeed3 * 170) % 30323;
randFloat = (sSeed1 / 30269.0f) + (sSeed2 / 30307.0f) + (sSeed3 / 30323.0f);
randFloat = (sBossGanonSeed1 / 30269.0f) + (sBossGanonSeed2 / 30307.0f) + (sBossGanonSeed3 / 30323.0f);
while (randFloat >= 1.0f) {
randFloat -= 1.0f;
@ -3559,7 +3541,7 @@ void BossGanon_DrawTriforce(BossGanon* this, GlobalContext* globalCtx) {
this->triforcePos.y += 3.0f;
this->triforcePos.z += -2.0f;
} else if (this->triforceType == GDF_TRIFORCE_ZELDA) {
this->triforcePos = sZelda->unk_31C;
this->triforcePos = sBossGanonZelda->unk_31C;
this->triforcePos.y += 1.8f;
this->triforcePos.z += 4.0f;
@ -3734,9 +3716,9 @@ void BossGanon_GenShadowTexture(u8* tex, BossGanon* this, GlobalContext* globalC
for (i = 0; i < 12; i++) {
for (j = 0; j < 12; j++) {
sp7C.x = sCape->strands[i].joints[j].x - this->actor.world.pos.x;
sp7C.y = sCape->strands[i].joints[j].y - this->actor.world.pos.y + 76.0f + 100.0f + 30.0f;
sp7C.z = sCape->strands[i].joints[j].z - this->actor.world.pos.z;
sp7C.x = sBossGanonCape->strands[i].joints[j].x - this->actor.world.pos.x;
sp7C.y = sBossGanonCape->strands[i].joints[j].y - this->actor.world.pos.y + 76.0f + 100.0f + 30.0f;
sp7C.z = sBossGanonCape->strands[i].joints[j].z - this->actor.world.pos.z;
Matrix_MultVec3f(&sp7C, &sp70);
@ -3746,7 +3728,7 @@ void BossGanon_GenShadowTexture(u8* tex, BossGanon* this, GlobalContext* globalC
baseX = (s32)(sp70.x + 32.0f);
baseY = (s16)sp70.y * 0x40;
if (!sCape->strands[i].torn[j]) {
if (!sBossGanonCape->strands[i].torn[j]) {
for (y = -1, addY = -0x40; y <= 1; y++, addY += 0x40) {
for (x = -3; x <= 3; x++) {
index = baseX + x + baseY + addY;
@ -3827,13 +3809,13 @@ void BossGanon_Draw(Actor* thisx, GlobalContext* globalCtx) {
BossGanon_DrawEffects(globalCtx);
sCape->actor.world.pos = this->actor.world.pos;
sBossGanonCape->actor.world.pos = this->actor.world.pos;
sCape->rightForearmPos = this->unk_214;
sCape->leftForearmPos = this->unk_220;
sBossGanonCape->rightForearmPos = this->unk_214;
sBossGanonCape->leftForearmPos = this->unk_220;
sCape->rightShoulderPos = this->unk_22C;
sCape->leftShoulderPos = this->unk_238;
sBossGanonCape->rightShoulderPos = this->unk_22C;
sBossGanonCape->leftShoulderPos = this->unk_238;
BossGanon_DrawShock(this, globalCtx);
BossGanon_DrawHandLightBall(this, globalCtx);
@ -4628,7 +4610,7 @@ void BossGanon_UpdateEffects(GlobalContext* globalCtx) {
spA0.x = 0.0f;
spA0.y = 0.0f;
for (i = 0; i < ARRAY_COUNT(sEffectBuf); i++, eff++) {
for (i = 0; i < ARRAY_COUNT(sBossGanonEffectBuf); i++, eff++) {
if (eff->type != GDF_EFF_NONE) {
eff->pos.x += eff->velocity.x;
eff->pos.y += eff->velocity.y;
@ -4662,9 +4644,9 @@ void BossGanon_UpdateEffects(GlobalContext* globalCtx) {
eff->alpha = 255;
}
} else if (eff->type == GDF_EFF_BLACK_DOT) {
xDiff = sGanondorf->unk_278.x - eff->pos.x;
yDiff = sGanondorf->unk_278.y - eff->pos.y;
zDiff = sGanondorf->unk_278.z - eff->pos.z;
xDiff = sBossGanonGanondorf->unk_278.x - eff->pos.x;
yDiff = sBossGanonGanondorf->unk_278.y - eff->pos.y;
zDiff = sBossGanonGanondorf->unk_278.z - eff->pos.z;
yRot = Math_FAtan2F(xDiff, zDiff);
@ -4704,9 +4686,9 @@ void BossGanon_UpdateEffects(GlobalContext* globalCtx) {
if (eff->unk_2E == GDF_SHOCK_DORF_YELLOW) {
bodyPart = (s16)Rand_ZeroFloat(13.9f) + 1;
eff->pos.x = sGanondorf->unk_2EC[bodyPart].x + Rand_CenteredFloat(20.0f);
eff->pos.y = sGanondorf->unk_2EC[bodyPart].y + Rand_CenteredFloat(20.0f);
eff->pos.z = sGanondorf->unk_2EC[bodyPart].z + Rand_CenteredFloat(20.0f);
eff->pos.x = sBossGanonGanondorf->unk_2EC[bodyPart].x + Rand_CenteredFloat(20.0f);
eff->pos.y = sBossGanonGanondorf->unk_2EC[bodyPart].y + Rand_CenteredFloat(20.0f);
eff->pos.z = sBossGanonGanondorf->unk_2EC[bodyPart].z + Rand_CenteredFloat(20.0f);
} else {
bodyPart = (s16)Rand_ZeroFloat(17.9f);
@ -4799,7 +4781,7 @@ void BossGanon_UpdateEffects(GlobalContext* globalCtx) {
if (((eff->scale * 150.0f) < distToPlayer) && (distToPlayer < (eff->scale * 300.0f))) {
eff->timer = 150;
func_8002F6D4(globalCtx, &sGanondorf->actor, 7.0f, sGanondorf->actor.yawTowardsPlayer, 0.0f,
func_8002F6D4(globalCtx, &sBossGanonGanondorf->actor, 7.0f, sBossGanonGanondorf->actor.yawTowardsPlayer, 0.0f,
0x20);
}
}
@ -4940,7 +4922,7 @@ void BossGanon_DrawEffects(GlobalContext* globalCtx) {
255);
gDPSetEnvColor(POLY_XLU_DISP++, sLightningEnvColors[(eff->timer * 3) + 0],
sLightningEnvColors[(eff->timer * 3) + 1], sLightningEnvColors[(eff->timer * 3) + 2], 0);
Matrix_Translate(sGanondorf->unk_260.x, sGanondorf->unk_260.y, sGanondorf->unk_260.z, MTXMODE_NEW);
Matrix_Translate(sBossGanonGanondorf->unk_260.x, sBossGanonGanondorf->unk_260.y, sBossGanonGanondorf->unk_260.z, MTXMODE_NEW);
Matrix_RotateY(eff->unk_48, MTXMODE_APPLY);
Matrix_RotateZ(eff->unk_3C, MTXMODE_APPLY);
Matrix_Scale(eff->scale, eff->scale, eff->scale, MTXMODE_APPLY);
@ -5032,16 +5014,11 @@ void BossGanon_DrawEffects(GlobalContext* globalCtx) {
#include "overlays/ovl_Boss_Ganon/ovl_Boss_Ganon.h"
void BossGanon_Reset(void) {
static EnGanonMant* sCape;
sSeed1 = 0;
sSeed2 = 0;
sSeed3 = 0;
sGanondorf = NULL;
sZelda = NULL;
sCape = NULL;
memset(sEffectBuf, 0, sizeof(sEffectBuf));
sBossGanonSeed1 = 0;
sBossGanonSeed2 = 0;
sBossGanonSeed3 = 0;
sBossGanonGanondorf = NULL;
sBossGanonZelda = NULL;
sBossGanonCape = NULL;
memset(sBossGanonEffectBuf, 0, sizeof(sBossGanonEffectBuf));
}

18
soh/src/overlays/actors/ovl_Boss_Ganon/z_boss_ganon.h
View File

@ -53,6 +53,24 @@ typedef enum {
/* 2 */ GDF_TRIFORCE_DORF
} GanondorfTriforceType;
typedef struct {
/* 0x00 */ u8 type;
/* 0x01 */ u8 timer;
/* 0x04 */ Vec3f pos;
/* 0x10 */ Vec3f velocity;
/* 0x1C */ Vec3f accel;
/* 0x28 */ Color_RGB8 color;
/* 0x2C */ s16 alpha;
/* 0x2E */ s16 unk_2E;
/* 0x30 */ s16 unk_30;
/* 0x34 */ f32 scale;
/* 0x38 */ f32 unk_38; // scale target mostly, but used for other things
/* 0x3C */ f32 unk_3C; // mostly z rot
/* 0x40 */ f32 unk_40;
/* 0x44 */ f32 unk_44; // mostly x rot
/* 0x48 */ f32 unk_48; // mostly y rot
} GanondorfEffect; // size = 0x4C
typedef struct BossGanon {
/* 0x0000 */ Actor actor;
/* 0x014C */ s32 animBankIndex;

199
soh/src/overlays/actors/ovl_Boss_Ganon2/z_boss_ganon2.c
View File

@ -49,21 +49,40 @@ const ActorInit Boss_Ganon2_InitVars = {
#include "z_boss_ganon2_data.c"
Vec3f D_8090EB20;
EnZl3* sBossGanon2Zelda;
Actor* D_8090EB30;
BossGanon2Effect sBossGanon2Particles[100];
s32 sBossGanon2Seed1;
s32 sBossGanon2Seed2;
s32 sBossGanon2Seed3;
Vec3f D_809105D8[4];
Vec3f D_80910608[4];
s8 D_80910638;
void BossGanon2_InitRand(s32 seedInit0, s32 seedInit1, s32 seedInit2) {
sSeed1 = seedInit0;
sSeed2 = seedInit1;
sSeed3 = seedInit2;
sBossGanon2Seed1 = seedInit0;
sBossGanon2Seed2 = seedInit1;
sBossGanon2Seed3 = seedInit2;
}
f32 BossGanon2_RandZeroOne(void) {
// Wichmann-Hill algorithm
f32 randFloat;
sSeed1 = (sSeed1 * 171) % 30269;
sSeed2 = (sSeed2 * 172) % 30307;
sSeed3 = (sSeed3 * 170) % 30323;
sBossGanon2Seed1 = (sBossGanon2Seed1 * 171) % 30269;
sBossGanon2Seed2 = (sBossGanon2Seed2 * 172) % 30307;
sBossGanon2Seed3 = (sBossGanon2Seed3 * 170) % 30323;
randFloat = (sSeed1 / 30269.0f) + (sSeed2 / 30307.0f) + (sSeed3 / 30323.0f);
randFloat = (sBossGanon2Seed1 / 30269.0f) + (sBossGanon2Seed2 / 30307.0f) + (sBossGanon2Seed3 / 30323.0f);
while (randFloat >= 1.0f) {
randFloat -= 1.0f;
}
@ -114,7 +133,7 @@ void func_808FD27C(GlobalContext* globalCtx, Vec3f* position, Vec3f* velocity, f
BossGanon2Effect* effect = globalCtx->specialEffects;
s16 i;
for (i = 0; i < ARRAY_COUNT(sParticles); i++, effect++) {
for (i = 0; i < ARRAY_COUNT(sBossGanon2Particles); i++, effect++) {
if (effect->type == 0) {
effect->type = 2;
effect->position = *position;
@ -136,10 +155,10 @@ void BossGanon2_Init(Actor* thisx, GlobalContext* globalCtx) {
s32 pad;
s16 i;
globalCtx->specialEffects = sParticles;
globalCtx->specialEffects = sBossGanon2Particles;
for (i = 0; i < ARRAY_COUNT(sParticles); i++) {
sParticles[i].type = 0;
for (i = 0; i < ARRAY_COUNT(sBossGanon2Particles); i++) {
sBossGanon2Particles[i].type = 0;
}
this->actor.colChkInfo.mass = MASS_IMMOVABLE;
@ -204,13 +223,13 @@ void func_808FD5F4(BossGanon2* this, GlobalContext* globalCtx) {
Gameplay_ChangeCameraStatus(globalCtx, MAIN_CAM, CAM_STAT_WAIT);
Gameplay_ChangeCameraStatus(globalCtx, this->unk_39E, CAM_STAT_ACTIVE);
this->unk_39C = 1;
sZelda = (EnZl3*)Actor_SpawnAsChild(&globalCtx->actorCtx, &this->actor, globalCtx, ACTOR_EN_ZL3, 970.0f,
sBossGanon2Zelda = (EnZl3*)Actor_SpawnAsChild(&globalCtx->actorCtx, &this->actor, globalCtx, ACTOR_EN_ZL3, 970.0f,
1086.0f, -200.0f, 0, 0, 0, 1);
sZelda->unk_3C8 = 0;
sZelda->actor.world.pos.x = 970.0f;
sZelda->actor.world.pos.y = 1086.0f;
sZelda->actor.world.pos.z = -214.0f;
sZelda->actor.shape.rot.y = -0x7000;
sBossGanon2Zelda->unk_3C8 = 0;
sBossGanon2Zelda->actor.world.pos.x = 970.0f;
sBossGanon2Zelda->actor.world.pos.y = 1086.0f;
sBossGanon2Zelda->actor.world.pos.z = -214.0f;
sBossGanon2Zelda->actor.shape.rot.y = -0x7000;
this->unk_3BC.x = 0.0f;
this->unk_3BC.y = 1.0f;
this->unk_3BC.z = 0.0f;
@ -258,20 +277,20 @@ void func_808FD5F4(BossGanon2* this, GlobalContext* globalCtx) {
player->actor.world.pos.x = 970.0f;
player->actor.world.pos.y = 1086.0f;
player->actor.world.pos.z = -166.0f;
sZelda->actor.world.pos.x = 974.0f;
sZelda->actor.world.pos.y = 1086.0f;
sZelda->actor.world.pos.z = -186.0f;
sBossGanon2Zelda->actor.world.pos.x = 974.0f;
sBossGanon2Zelda->actor.world.pos.y = 1086.0f;
sBossGanon2Zelda->actor.world.pos.z = -186.0f;
player->actor.shape.rot.y = -0x5000;
sZelda->actor.shape.rot.y = -0x5000;
sBossGanon2Zelda->actor.shape.rot.y = -0x5000;
if (this->unk_398 == 60) {
Message_StartTextbox(globalCtx, 0x70D4, NULL);
}
if (this->unk_398 == 40) {
sZelda->unk_3C8 = 1;
sBossGanon2Zelda->unk_3C8 = 1;
func_8002DF54(globalCtx, &this->actor, 0x4E);
}
if (this->unk_398 == 85) {
sZelda->unk_3C8 = 2;
sBossGanon2Zelda->unk_3C8 = 2;
func_8002DF54(globalCtx, &this->actor, 0x4F);
}
this->unk_3A4.x = 930.0f;
@ -300,14 +319,14 @@ void func_808FD5F4(BossGanon2* this, GlobalContext* globalCtx) {
Audio_QueueSeqCmd(SEQ_PLAYER_BGM_MAIN << 24 | NA_BGM_STOP);
}
if (this->unk_398 == 20) {
sZelda->unk_3C8 = 3;
sBossGanon2Zelda->unk_3C8 = 3;
func_8002DF54(globalCtx, &this->actor, 0x50);
}
if (this->unk_398 == 55) {
this->unk_39C = 4;
this->unk_398 = 0;
this->unk_410.x = 0.0f;
sZelda->unk_3C8 = 4;
sBossGanon2Zelda->unk_3C8 = 4;
func_8002DF54(globalCtx, &this->actor, 0x50);
}
break;
@ -347,11 +366,11 @@ void func_808FD5F4(BossGanon2* this, GlobalContext* globalCtx) {
player->actor.world.pos.x = 490.0f;
player->actor.world.pos.y = 1086.0f;
player->actor.world.pos.z = -166.0f;
sZelda->actor.world.pos.x = 724.0f;
sZelda->actor.world.pos.y = 1086.0f;
sZelda->actor.world.pos.z = -186.0f;
sBossGanon2Zelda->actor.world.pos.x = 724.0f;
sBossGanon2Zelda->actor.world.pos.y = 1086.0f;
sBossGanon2Zelda->actor.world.pos.z = -186.0f;
player->actor.shape.rot.y = -0x4000;
sZelda->actor.shape.rot.y = -0x5000;
sBossGanon2Zelda->actor.shape.rot.y = -0x5000;
this->unk_3A4.x = 410.0f;
this->unk_3A4.y = 1096.0f;
this->unk_3A4.z = -110.0f;
@ -370,7 +389,7 @@ void func_808FD5F4(BossGanon2* this, GlobalContext* globalCtx) {
this->unk_339 = 4;
}
if (this->unk_398 == 30) {
sZelda->unk_3C8 = 5;
sBossGanon2Zelda->unk_3C8 = 5;
func_8002DF54(globalCtx, &this->actor, 0x51);
}
if (this->unk_398 == 50) {
@ -384,11 +403,11 @@ void func_808FD5F4(BossGanon2* this, GlobalContext* globalCtx) {
player->actor.world.pos.x = 490.0f;
player->actor.world.pos.y = 1086.0f;
player->actor.world.pos.z = -166.0f;
sZelda->actor.world.pos.x = 724.0f;
sZelda->actor.world.pos.y = 1086.0f;
sZelda->actor.world.pos.z = -186.0f;
sBossGanon2Zelda->actor.world.pos.x = 724.0f;
sBossGanon2Zelda->actor.world.pos.y = 1086.0f;
sBossGanon2Zelda->actor.world.pos.z = -186.0f;
player->actor.shape.rot.y = -0x4000;
sZelda->actor.shape.rot.y = -0x5000;
sBossGanon2Zelda->actor.shape.rot.y = -0x5000;
this->unk_3A4.x = 450.0f;
this->unk_3A4.y = 1121.0f;
this->unk_3A4.z = -158.0f;
@ -457,9 +476,9 @@ void func_808FD5F4(BossGanon2* this, GlobalContext* globalCtx) {
player->actor.world.pos.y = 1086.0f;
player->actor.world.pos.z = -266.0f;
player->actor.shape.rot.y = -0x4000;
sZelda->actor.world.pos.x = 724.0f;
sZelda->actor.world.pos.y = 1086.0f;
sZelda->actor.world.pos.z = -186.0f;
sBossGanon2Zelda->actor.world.pos.x = 724.0f;
sBossGanon2Zelda->actor.world.pos.y = 1086.0f;
sBossGanon2Zelda->actor.world.pos.z = -186.0f;
this->unk_3A4.x = this->actor.world.pos.x + -10.0f;
this->unk_3A4.y = this->actor.world.pos.y + 80.0f;
this->unk_3A4.z = this->actor.world.pos.z + 50.0f;
@ -770,9 +789,9 @@ void func_808FD5F4(BossGanon2* this, GlobalContext* globalCtx) {
BossGanon2Effect* effect = globalCtx->specialEffects;
effect->unk_2E = 1;
effect->position.x = sZelda->actor.world.pos.x + 50.0f + 10.0f;
effect->position.y = sZelda->actor.world.pos.y + 350.0f;
effect->position.z = sZelda->actor.world.pos.z - 25.0f;
effect->position.x = sBossGanon2Zelda->actor.world.pos.x + 50.0f + 10.0f;
effect->position.y = sBossGanon2Zelda->actor.world.pos.y + 350.0f;
effect->position.z = sBossGanon2Zelda->actor.world.pos.z - 25.0f;
effect->velocity.x = 0.0f;
effect->velocity.z = 0.0f;
effect->velocity.y = -30.0f;
@ -782,15 +801,15 @@ void func_808FD5F4(BossGanon2* this, GlobalContext* globalCtx) {
break;
}
case 26:
this->unk_3A4.x = sZelda->actor.world.pos.x + 100.0f + 30.0f;
this->unk_3A4.y = sZelda->actor.world.pos.y + 10.0f;
this->unk_3A4.z = sZelda->actor.world.pos.z + 5.0f;
this->unk_3B0.x = sZelda->actor.world.pos.x;
this->unk_3B0.y = sZelda->actor.world.pos.y + 30.0f;
this->unk_3B0.z = sZelda->actor.world.pos.z - 20.0f;
this->unk_3A4.x = sBossGanon2Zelda->actor.world.pos.x + 100.0f + 30.0f;
this->unk_3A4.y = sBossGanon2Zelda->actor.world.pos.y + 10.0f;
this->unk_3A4.z = sBossGanon2Zelda->actor.world.pos.z + 5.0f;
this->unk_3B0.x = sBossGanon2Zelda->actor.world.pos.x;
this->unk_3B0.y = sBossGanon2Zelda->actor.world.pos.y + 30.0f;
this->unk_3B0.z = sBossGanon2Zelda->actor.world.pos.z - 20.0f;
this->unk_3BC.z = -0.5f;
if (this->unk_398 == 13) {
sZelda->unk_3C8 = 6;
sBossGanon2Zelda->unk_3C8 = 6;
}
if (this->unk_398 == 50) {
this->unk_39C = 27;
@ -879,7 +898,7 @@ void func_808FD5F4(BossGanon2* this, GlobalContext* globalCtx) {
func_808FFDB0(this, globalCtx);
this->unk_1A2[1] = 50;
this->actor.flags |= ACTOR_FLAG_0;
sZelda->unk_3C8 = 7;
sBossGanon2Zelda->unk_3C8 = 7;
}
break;
}
@ -1323,12 +1342,12 @@ void func_80900890(BossGanon2* this, GlobalContext* globalCtx) {
break;
case 2:
this->unk_1A2[0] = 300;
this->unk_3A4.x = sZelda->actor.world.pos.x - 100.0f;
this->unk_3A4.y = sZelda->actor.world.pos.y + 30.0f;
this->unk_3A4.z = (sZelda->actor.world.pos.z + 30.0f) - 60.0f;
this->unk_3B0.x = sZelda->actor.world.pos.x;
this->unk_3B0.y = sZelda->actor.world.pos.y + 30.0f;
this->unk_3B0.z = sZelda->actor.world.pos.z - 10.0f;
this->unk_3A4.x = sBossGanon2Zelda->actor.world.pos.x - 100.0f;
this->unk_3A4.y = sBossGanon2Zelda->actor.world.pos.y + 30.0f;
this->unk_3A4.z = (sBossGanon2Zelda->actor.world.pos.z + 30.0f) - 60.0f;
this->unk_3B0.x = sBossGanon2Zelda->actor.world.pos.x;
this->unk_3B0.y = sBossGanon2Zelda->actor.world.pos.y + 30.0f;
this->unk_3B0.z = sBossGanon2Zelda->actor.world.pos.z - 10.0f;
Math_ApproachZeroF(&this->unk_324, 1.0f, 5.0f);
Math_ApproachF(&globalCtx->envCtx.unk_D8, 1.0f, 1.0f, 1.0f / 51);
if (this->unk_1A2[1] == 80) {
@ -1356,8 +1375,8 @@ void func_80900890(BossGanon2* this, GlobalContext* globalCtx) {
func_8002DF54(globalCtx, &this->actor, 0x60);
this->unk_398 = 0;
case 11:
player->actor.world.pos.x = sZelda->actor.world.pos.x + 50.0f + 10.0f;
player->actor.world.pos.z = sZelda->actor.world.pos.z - 25.0f;
player->actor.world.pos.x = sBossGanon2Zelda->actor.world.pos.x + 50.0f + 10.0f;
player->actor.world.pos.z = sBossGanon2Zelda->actor.world.pos.z - 25.0f;
player->actor.shape.rot.y = -0x8000;
this->unk_3A4.x = (player->actor.world.pos.x + 100.0f) - 80.0f;
this->unk_3A4.y = (player->actor.world.pos.y + 60.0f) - 40.0f;
@ -1482,7 +1501,7 @@ void func_8090120C(BossGanon2* this, GlobalContext* globalCtx) {
func_8002DF54(globalCtx, &this->actor, 8);
this->unk_39C = 1;
this->unk_398 = 0;
sZelda->unk_3C8 = 9;
sBossGanon2Zelda->unk_3C8 = 9;
this->unk_31C = 0;
this->unk_1A2[2] = 0;
this->unk_336 = 0;
@ -1522,9 +1541,9 @@ void func_8090120C(BossGanon2* this, GlobalContext* globalCtx) {
player->actor.shape.rot.y = -0x4000;
player->actor.world.pos.x = 200.0f;
player->actor.world.pos.z = 30.0f;
sZelda->actor.world.pos.x = 340.0f;
sZelda->actor.world.pos.z = -250.0f;
sZelda->actor.world.rot.y = sZelda->actor.shape.rot.y = -0x2000;
sBossGanon2Zelda->actor.world.pos.x = 340.0f;
sBossGanon2Zelda->actor.world.pos.z = -250.0f;
sBossGanon2Zelda->actor.world.rot.y = sBossGanon2Zelda->actor.shape.rot.y = -0x2000;
this->unk_3A4.x = 250;
this->unk_3A4.y = 1150.0f;
this->unk_3A4.z = 0.0f;
@ -1543,9 +1562,9 @@ void func_8090120C(BossGanon2* this, GlobalContext* globalCtx) {
this->unk_3A4.x = 250;
this->unk_3A4.y = 1150.0f;
this->unk_3A4.z = 0.0f;
Math_ApproachF(&this->unk_3B0.x, sZelda->actor.world.pos.x, 0.2f, 20.0f);
Math_ApproachF(&this->unk_3B0.y, sZelda->actor.world.pos.y + 50.0f, 0.2f, 10.0f);
Math_ApproachF(&this->unk_3B0.z, sZelda->actor.world.pos.z, 0.2f, 20.0f);
Math_ApproachF(&this->unk_3B0.x, sBossGanon2Zelda->actor.world.pos.x, 0.2f, 20.0f);
Math_ApproachF(&this->unk_3B0.y, sBossGanon2Zelda->actor.world.pos.y + 50.0f, 0.2f, 10.0f);
Math_ApproachF(&this->unk_3B0.z, sBossGanon2Zelda->actor.world.pos.z, 0.2f, 20.0f);
if (this->unk_398 == 50) {
this->unk_39C = 3;
this->unk_398 = 0;
@ -1557,9 +1576,9 @@ void func_8090120C(BossGanon2* this, GlobalContext* globalCtx) {
this->unk_3A4.x = 330.0f;
this->unk_3A4.y = 1120.0f;
this->unk_3A4.z = -150.0f;
this->unk_3B0.x = sZelda->actor.world.pos.x;
this->unk_3B0.y = sZelda->actor.world.pos.y + 40.0f;
this->unk_3B0.z = sZelda->actor.world.pos.z;
this->unk_3B0.x = sBossGanon2Zelda->actor.world.pos.x;
this->unk_3B0.y = sBossGanon2Zelda->actor.world.pos.y + 40.0f;
this->unk_3B0.z = sBossGanon2Zelda->actor.world.pos.z;
if (this->unk_398 == 10) {
Message_StartTextbox(globalCtx, 0x70D8, NULL);
}
@ -1572,7 +1591,7 @@ void func_8090120C(BossGanon2* this, GlobalContext* globalCtx) {
if (this->unk_398 > 10) {
Math_ApproachZeroF(&this->unk_37C, 1.0f, 10.0f);
if (this->unk_398 == 30) {
sZelda->unk_3C8 = 10;
sBossGanon2Zelda->unk_3C8 = 10;
}
this->unk_339 = 23;
Math_ApproachZeroF(&globalCtx->envCtx.unk_D8, 1.0f, 0.05f);
@ -1743,7 +1762,7 @@ void func_8090120C(BossGanon2* this, GlobalContext* globalCtx) {
if (this->unk_398 == 40) {
this->unk_39C = 9;
this->unk_398 = 0;
sZelda->unk_3C8 = 11;
sBossGanon2Zelda->unk_3C8 = 11;
Message_StartTextbox(globalCtx, 0x70D9, NULL);
this->unk_336 = 0;
globalCtx->envCtx.unk_D8 = 0.0f;
@ -1754,9 +1773,9 @@ void func_8090120C(BossGanon2* this, GlobalContext* globalCtx) {
this->unk_3A4.x = 330.0f;
this->unk_3A4.y = 1120.0f;
this->unk_3A4.z = -150.0f;
this->unk_3B0.x = sZelda->actor.world.pos.x;
this->unk_3B0.y = sZelda->actor.world.pos.y + 40.0f;
this->unk_3B0.z = sZelda->actor.world.pos.z;
this->unk_3B0.x = sBossGanon2Zelda->actor.world.pos.x;
this->unk_3B0.y = sBossGanon2Zelda->actor.world.pos.y + 40.0f;
this->unk_3B0.z = sBossGanon2Zelda->actor.world.pos.z;
if (this->unk_398 > 60) {
this->unk_39C = 10;
this->unk_398 = 0;
@ -1771,26 +1790,26 @@ void func_8090120C(BossGanon2* this, GlobalContext* globalCtx) {
if ((this->unk_398 >= 40) && (this->unk_398 <= 110)) {
Math_ApproachF(&globalCtx->envCtx.unk_D8, 1.0f, 1.0f, 0.02f);
Math_ApproachF(&this->unk_384, 10.0f, 0.1f, 0.2f);
Audio_PlayActorSound2(&sZelda->actor, NA_SE_EV_GOD_LIGHTBALL_2 - SFX_FLAG);
Audio_PlayActorSound2(&sBossGanon2Zelda->actor, NA_SE_EV_GOD_LIGHTBALL_2 - SFX_FLAG);
} else {
Math_ApproachZeroF(&this->unk_384, 1.0f, 0.2f);
}
if (this->unk_398 > 130) {
Math_ApproachF(&this->unk_3B0.y, (sZelda->actor.world.pos.y + 40.0f + 10.0f) - 20.0f, 0.1f,
Math_ApproachF(&this->unk_3B0.y, (sBossGanon2Zelda->actor.world.pos.y + 40.0f + 10.0f) - 20.0f, 0.1f,
this->unk_410.x);
} else {
Math_ApproachF(&this->unk_3B0.y, sZelda->actor.world.pos.y + 40.0f + 10.0f, 0.05f,
Math_ApproachF(&this->unk_3B0.y, sBossGanon2Zelda->actor.world.pos.y + 40.0f + 10.0f, 0.05f,
this->unk_410.x * 0.25f);
}
Math_ApproachF(&this->unk_410.x, 1.0f, 1.0f, 0.01f);
if (this->unk_398 == 10) {
sZelda->unk_3C8 = 12;
sBossGanon2Zelda->unk_3C8 = 12;
}
if (this->unk_398 == 110) {
sZelda->unk_3C8 = 13;
sBossGanon2Zelda->unk_3C8 = 13;
}
if (this->unk_398 == 140) {
Audio_PlayActorSound2(&sZelda->actor, NA_SE_EV_HUMAN_BOUND);
Audio_PlayActorSound2(&sBossGanon2Zelda->actor, NA_SE_EV_HUMAN_BOUND);
}
if (this->unk_398 < 160) {
break;
@ -1845,7 +1864,7 @@ void func_80902348(BossGanon2* this, GlobalContext* globalCtx) {
}
func_8002F6D4(globalCtx, &this->actor, 15.0f, this->actor.yawTowardsPlayer + phi_v0_2, 2.0f, 0);
sZelda->unk_3C8 = 8;
sBossGanon2Zelda->unk_3C8 = 8;
this->unk_316 = 10;
break;
}
@ -1864,7 +1883,7 @@ void func_80902348(BossGanon2* this, GlobalContext* globalCtx) {
player->isBurning = true;
func_8002F6D4(globalCtx, &this->actor, 10.0f, Math_Atan2S(temp_f12, temp_f2), 0.0f, 0x10);
sZelda->unk_3C8 = 8;
sBossGanon2Zelda->unk_3C8 = 8;
}
}
}
@ -2168,7 +2187,7 @@ void BossGanon2_Update(Actor* thisx, GlobalContext* globalCtx) {
if (D_80906D78 != 0) {
D_80906D78 = 0;
for (i2 = 0; i2 < ARRAY_COUNT(sParticles); i2++) {
for (i2 = 0; i2 < ARRAY_COUNT(sBossGanon2Particles); i2++) {
angle = Rand_ZeroFloat(2 * M_PI);
sp44 = Rand_ZeroFloat(40.0f) + 10.0f;
sp58 = this->actor.world.pos;
@ -2641,7 +2660,7 @@ void func_80904FC8(BossGanon2* this, GlobalContext* globalCtx) {
gDPSetPrimColor(POLY_XLU_DISP++, 0, 0, 255, 255, 255, 200);
gDPSetEnvColor(POLY_XLU_DISP++, 255, 200, 0, 0);
gSPDisplayList(POLY_XLU_DISP++, ovl_Boss_Ganon2_DL_00B308);
Matrix_Translate(sZelda->actor.world.pos.x, sZelda->actor.world.pos.y + 80.0f, sZelda->actor.world.pos.z,
Matrix_Translate(sBossGanon2Zelda->actor.world.pos.x, sBossGanon2Zelda->actor.world.pos.y + 80.0f, sBossGanon2Zelda->actor.world.pos.z,
MTXMODE_NEW);
Matrix_ReplaceRotation(&globalCtx->billboardMtxF);
Matrix_Scale(this->unk_384, this->unk_384, this->unk_384, MTXMODE_APPLY);
@ -2728,8 +2747,8 @@ void func_80905674(BossGanon2* this, GlobalContext* globalCtx) {
this->unk_19C * -8, 32, 32));
gDPSetPrimColor(POLY_XLU_DISP++, 0, 0, 255, 255, 170, (s16)this->unk_37C);
gDPSetEnvColor(POLY_XLU_DISP++, 255, 200, 0, 128);
Matrix_Translate(sZelda->actor.world.pos.x + 100.0f, sZelda->actor.world.pos.y + 35.0f + 7.0f,
sZelda->actor.world.pos.z - 100.0f, MTXMODE_NEW);
Matrix_Translate(sBossGanon2Zelda->actor.world.pos.x + 100.0f, sBossGanon2Zelda->actor.world.pos.y + 35.0f + 7.0f,
sBossGanon2Zelda->actor.world.pos.z - 100.0f, MTXMODE_NEW);
Matrix_RotateY(-M_PI / 4.0f, MTXMODE_APPLY);
Matrix_Scale(0.040000003f, 0.040000003f, this->unk_380, MTXMODE_APPLY);
Matrix_RotateX(M_PI / 2.0f, MTXMODE_APPLY);
@ -2826,7 +2845,7 @@ void func_80905DA8(BossGanon2* this, GlobalContext* globalCtx) {
Vec3f sp78;
s16 i;
for (i = 0; i < ARRAY_COUNT(sParticles); i++, effect++) {
for (i = 0; i < ARRAY_COUNT(sBossGanon2Particles); i++, effect++) {
if (effect->type != 0) {
effect->position.x += effect->velocity.x;
effect->position.y += effect->velocity.y;
@ -2934,7 +2953,7 @@ void func_809060E8(GlobalContext* globalCtx) {
effect = effects;
for (i = 0; i < ARRAY_COUNT(sParticles); i++, effect++) {
for (i = 0; i < ARRAY_COUNT(sBossGanon2Particles); i++, effect++) {
if (effect->type == 2) {
if (!usingObjectGEff) {
BossGanon2_SetObjectSegment(NULL, globalCtx, OBJECT_GEFF, true);
@ -3080,12 +3099,12 @@ void BossGanon2_Reset(void) {
D_8090EB20.y = 0;
D_8090EB20.z = 0;
D_80910638 = 0;
sZelda = NULL;
sBossGanon2Zelda = NULL;
D_8090EB30 = NULL;
sSeed1 = 0;
sSeed2 = 0;
sSeed3 = 0;
sBossGanon2Seed1 = 0;
sBossGanon2Seed2 = 0;
sBossGanon2Seed3 = 0;
memset(D_809105D8, 0, sizeof(D_809105D8));
memset(D_80910608, 0, sizeof(D_80910608));
memset(sParticles, 0, sizeof(sParticles));
memset(sBossGanon2Particles, 0, sizeof(sBossGanon2Particles));
}

14
soh/src/overlays/actors/ovl_Boss_Ganon2/z_boss_ganon2.h
View File

@ -4,6 +4,20 @@
#include "ultra64.h"
#include "global.h"
typedef struct {
/* 0x00 */ u8 type;
/* 0x01 */ u8 unk_01;
/* 0x04 */ Vec3f position;
/* 0x10 */ Vec3f velocity;
/* 0x1C */ Vec3f accel;
/* 0x28 */ char unk_28[0x6];
/* 0x2E */ s16 unk_2E;
/* 0x30 */ char unk_30[0x4];
/* 0x34 */ f32 scale;
/* 0x38 */ Vec3f unk_38;
} BossGanon2Effect; // size = 0x44
struct BossGanon2;
typedef void (*BossGanon2ActionFunc)(struct BossGanon2*, GlobalContext*);

41
soh/src/overlays/actors/ovl_Boss_Ganon2/z_boss_ganon2_data.c
View File

@ -2,19 +2,6 @@
#include "overlays/actors/ovl_En_Zl3/z_en_zl3.h"
#include "objects/object_ganon2/object_ganon2.h"
typedef struct {
/* 0x00 */ u8 type;
/* 0x01 */ u8 unk_01;
/* 0x04 */ Vec3f position;
/* 0x10 */ Vec3f velocity;
/* 0x1C */ Vec3f accel;
/* 0x28 */ char unk_28[0x6];
/* 0x2E */ s16 unk_2E;
/* 0x30 */ char unk_30[0x4];
/* 0x34 */ f32 scale;
/* 0x38 */ Vec3f unk_38;
} BossGanon2Effect; // size = 0x44
static Vec3f D_80906D60 = { 0.0f, 0.0f, 0.0f };
static Vec3f D_80906D6C = { 0.0f, 0.0f, 500.0f };
@ -326,31 +313,7 @@ static s16 D_809071CC[] = { 1, -1, 1, 1, 3, 4, 1, 6, 7, 2, 9, 10, 2, 12, 13 };
static u8 D_809071EC[] = { 3, 2, 2, 1, 3, 3, 1, 3, 3, 1, 0, 3, 1, 0, 3 };
// padding
static u32 D_809071FC[2] = { 0 };
#include "overlays/ovl_Boss_Ganon2/ovl_Boss_Ganon2.h"
static Vec3f D_8090EB20;
static EnZl3* sZelda;
static Actor* D_8090EB30;
// unused
static UNK_TYPE D_8090EB34;
static BossGanon2Effect sParticles[100];
static s32 sSeed1;
static s32 sSeed2;
static s32 sSeed3;
// unused
static UNK_TYPE D_809105DC;
static Vec3f D_809105D8[4];
static Vec3f D_80910608[4];
static s8 D_80910638;
// padding
//static u32 D_809071FC[2] = { 0 };

26
soh/src/overlays/actors/ovl_Boss_Mo/z_boss_mo.c
View File

@ -144,25 +144,25 @@ static f32 sFlatWidth[41] = {
#include "z_boss_mo_colchk.c"
static BossMoEffect sEffects[300];
static s32 sSeed1;
static s32 sSeed2;
static s32 sSeed3;
static s32 sBossGanonSeed1;
static s32 sBossGanonSeed2;
static s32 sBossGanonSeed3;
void BossMo_InitRand(s32 seedInit0, s32 seedInit1, s32 seedInit2) {
sSeed1 = seedInit0;
sSeed2 = seedInit1;
sSeed3 = seedInit2;
sBossGanonSeed1 = seedInit0;
sBossGanonSeed2 = seedInit1;
sBossGanonSeed3 = seedInit2;
}
f32 BossMo_RandZeroOne(void) {
// Wichmann-Hill algorithm
f32 randFloat;
sSeed1 = (sSeed1 * 171) % 30269;
sSeed2 = (sSeed2 * 172) % 30307;
sSeed3 = (sSeed3 * 170) % 30323;
sBossGanonSeed1 = (sBossGanonSeed1 * 171) % 30269;
sBossGanonSeed2 = (sBossGanonSeed2 * 172) % 30307;
sBossGanonSeed3 = (sBossGanonSeed3 * 170) % 30323;
randFloat = (sSeed1 / 30269.0f) + (sSeed2 / 30307.0f) + (sSeed3 / 30323.0f);
randFloat = (sBossGanonSeed1 / 30269.0f) + (sBossGanonSeed2 / 30307.0f) + (sBossGanonSeed3 / 30323.0f);
while (randFloat >= 1.0f) {
randFloat -= 1.0f;
}
@ -3588,7 +3588,7 @@ void BossMo_Reset(void) {
sMorphaTent1 = NULL;
sMorphaTent2 = NULL;
memset(sEffects, 0, sizeof(sEffects));
sSeed1 = 0;
sSeed2 = 0;
sSeed3 = 0;
sBossGanonSeed1 = 0;
sBossGanonSeed2 = 0;
sBossGanonSeed3 = 0;
}

45
soh/src/overlays/actors/ovl_Boss_Tw/z_boss_tw.c
View File

@ -7,34 +7,6 @@
#define FLAGS (ACTOR_FLAG_0 | ACTOR_FLAG_2 | ACTOR_FLAG_4 | ACTOR_FLAG_5)
typedef enum {
/* 0 */ TWEFF_NONE,
/* 1 */ TWEFF_DOT,
/* 2 */ TWEFF_2,
/* 3 */ TWEFF_3,
/* 4 */ TWEFF_RING,
/* 5 */ TWEFF_PLYR_FRZ,
/* 6 */ TWEFF_FLAME,
/* 7 */ TWEFF_MERGEFLAME,
/* 8 */ TWEFF_SHLD_BLST,
/* 9 */ TWEFF_SHLD_DEFL,
/* 10 */ TWEFF_SHLD_HIT
} TwEffType;
typedef enum {
/* 0 */ EFF_ARGS,
/* 1 */ EFF_UNKS1,
/* 2 */ EFF_WORK_MAX
} EffectWork;
typedef enum {
/* 0 */ EFF_SCALE,
/* 1 */ EFF_DIST,
/* 2 */ EFF_ROLL,
/* 3 */ EFF_YAW,
/* 4 */ EFF_FWORK_MAX
} EffectFWork;
typedef enum {
/* 0x00 */ TW_KOTAKE,
/* 0x01 */ TW_KOUME,
@ -47,19 +19,6 @@ typedef enum {
/* 0x69 */ TW_DEATHBALL_KOUME
} TwinrovaType;
typedef struct {
/* 0x0000 */ u8 type;
/* 0x0001 */ u8 frame;
/* 0x0004 */ Vec3f pos;
/* 0x0010 */ Vec3f curSpeed;
/* 0x001C */ Vec3f accel;
/* 0x0028 */ Color_RGB8 color;
/* 0x002C */ s16 alpha;
/* 0x002E */ s16 work[EFF_WORK_MAX];
/* 0x0034 */ f32 workf[EFF_FWORK_MAX];
/* 0x0044 */ Actor* target;
} BossTwEffect;
void BossTw_Init(Actor* thisx, GlobalContext* globalCtx);
void BossTw_Destroy(Actor* thisx, GlobalContext* globalCtx);
void BossTw_Update(Actor* thisx, GlobalContext* globalCtx);
@ -200,7 +159,7 @@ static Vec3f sTwinrovaPillarPos[] = {
{ 0.0f, 380.0f, -580.0f },
};
static u8 sTwInitalized = false;
u8 sTwInitalized = false;
static InitChainEntry sInitChain[] = {
ICHAIN_U8(targetMode, 5, ICHAIN_CONTINUE),
@ -233,7 +192,7 @@ static u8 D_8094C878;
static s16 D_8094C87A;
static s16 D_8094C87C;
static u8 D_8094C87E;
static BossTwEffect sTwEffects[150];
BossTwEffect sTwEffects[150];
void BossTw_AddDotEffect(GlobalContext* globalCtx, Vec3f* initalPos, Vec3f* initalSpeed, Vec3f* accel, f32 scale,
s16 args, s16 countLimit) {

45
soh/src/overlays/actors/ovl_Boss_Tw/z_boss_tw.h
View File

@ -4,9 +4,46 @@
#include "ultra64.h"
#include "global.h"
struct BossTw;
typedef enum {
/* 0 */ TWEFF_NONE,
/* 1 */ TWEFF_DOT,
/* 2 */ TWEFF_2,
/* 3 */ TWEFF_3,
/* 4 */ TWEFF_RING,
/* 5 */ TWEFF_PLYR_FRZ,
/* 6 */ TWEFF_FLAME,
/* 7 */ TWEFF_MERGEFLAME,
/* 8 */ TWEFF_SHLD_BLST,
/* 9 */ TWEFF_SHLD_DEFL,
/* 10 */ TWEFF_SHLD_HIT
} TwEffType;
typedef void (*BossTwActionFunc)(struct BossTw* this, GlobalContext* globalCtx);
typedef enum {
/* 0 */ EFF_ARGS,
/* 1 */ EFF_UNKS1,
/* 2 */ EFF_WORK_MAX
} EffectWork;
typedef enum {
/* 0 */ EFF_SCALE,
/* 1 */ EFF_DIST,
/* 2 */ EFF_ROLL,
/* 3 */ EFF_YAW,
/* 4 */ EFF_FWORK_MAX
} EffectFWork;
typedef struct {
/* 0x0000 */ u8 type;
/* 0x0001 */ u8 frame;
/* 0x0004 */ Vec3f pos;
/* 0x0010 */ Vec3f curSpeed;
/* 0x001C */ Vec3f accel;
/* 0x0028 */ Color_RGB8 color;
/* 0x002C */ s16 alpha;
/* 0x002E */ s16 work[EFF_WORK_MAX];
/* 0x0034 */ f32 workf[EFF_FWORK_MAX];
/* 0x0044 */ Actor* target;
} BossTwEffect;
typedef enum {
/* 0 */ CS_TIMER_1,
@ -55,6 +92,10 @@ typedef enum {
/* 26 */ FWORK_MAX
} TwFwork;
struct BossTw;
typedef void (*BossTwActionFunc)(struct BossTw*, GlobalContext* globalCtx);
typedef struct BossTw {
/* 0x0000 */ Actor actor;
/* 0x014C */ BossTwActionFunc actionFunc;

16
soh/src/overlays/actors/ovl_Demo_6K/z_demo_6k.c
View File

@ -307,7 +307,7 @@ void func_8096712C(Demo6K* this, GlobalContext* globalCtx) {
}
}
static Vec3f velocity = { 0.0f, 0.0f, 0.0f };
Vec3f sDemo6kVelocity = { 0.0f, 0.0f, 0.0f };
void func_80967244(Demo6K* this, GlobalContext* globalCtx) {
static Vec3f accel = { 0.0f, 0.0f, 0.0f };
static Color_RGBA8 primColor = { 255, 255, 255, 0 };
@ -324,9 +324,9 @@ void func_80967244(Demo6K* this, GlobalContext* globalCtx) {
rand1 = Rand_ZeroFloat(0xFFFF);
rand2 = Rand_ZeroFloat(0xFFFF);
velocity.x = Math_SinS(rand2) * Math_CosS(rand1) * 20.0f;
velocity.z = Math_CosS(rand2) * Math_CosS(rand1) * 20.0f;
velocity.y = Math_SinS(rand1) * 20.0f;
sDemo6kVelocity.x = Math_SinS(rand2) * Math_CosS(rand1) * 20.0f;
sDemo6kVelocity.z = Math_CosS(rand2) * Math_CosS(rand1) * 20.0f;
sDemo6kVelocity.y = Math_SinS(rand1) * 20.0f;
accel.y = 0.0f;
@ -342,7 +342,7 @@ void func_80967244(Demo6K* this, GlobalContext* globalCtx) {
scale = 18000;
}
EffectSsKiraKira_SpawnFocused(globalCtx, &pos, &velocity, &accel, &primColor, &envColor, scale, 20);
EffectSsKiraKira_SpawnFocused(globalCtx, &pos, &sDemo6kVelocity, &accel, &primColor, &envColor, scale, 20);
}
void func_80967410(Demo6K* this, GlobalContext* globalCtx) {
@ -820,7 +820,7 @@ void func_809691BC(Demo6K* this, GlobalContext* globalCtx, s32 params) {
}
void Demo6K_Reset(void) {
velocity.x = 0.0f;
velocity.y = 0.0f;
velocity.z = 0.0f;
sDemo6kVelocity.x = 0.0f;
sDemo6kVelocity.y = 0.0f;
sDemo6kVelocity.z = 0.0f;
}

22
soh/src/overlays/actors/ovl_Demo_Kekkai/z_demo_kekkai.c
View File

@ -132,7 +132,7 @@ void DemoKekkai_Destroy(Actor* thisx, GlobalContext* globalCtx) {
Collider_DestroyCylinder(globalCtx, &this->collider2);
}
static Vec3f vel = { 0.0f, 0.0f, 0.0f };
Vec3f demoKekkaiVel = { 0.0f, 0.0f, 0.0f };
void DemoKekkai_SpawnParticles(DemoKekkai* this, GlobalContext* globalCtx) {
static Vec3f accel = { 0.0f, 0.0f, 0.0f };
static Color_RGBA8 lightYellow = { 255, 255, 170, 0 };
@ -144,15 +144,15 @@ void DemoKekkai_SpawnParticles(DemoKekkai* this, GlobalContext* globalCtx) {
s16 roll = Rand_ZeroFloat(65535.0f);
s16 yaw = Rand_ZeroFloat(65535.0f);
vel.x = Math_SinS(yaw) * Math_CosS(roll) * Rand_ZeroFloat(8.0f);
vel.z = Math_CosS(yaw) * Math_CosS(roll) * Rand_ZeroFloat(8.0f);
vel.y = Math_SinS(roll) * Rand_ZeroFloat(3.0f);
demoKekkaiVel.x = Math_SinS(yaw) * Math_CosS(roll) * Rand_ZeroFloat(8.0f);
demoKekkaiVel.z = Math_CosS(yaw) * Math_CosS(roll) * Rand_ZeroFloat(8.0f);
demoKekkaiVel.y = Math_SinS(roll) * Rand_ZeroFloat(3.0f);
pos.x = (vel.x * 7.0f) + this->actor.world.pos.x;
pos.y = (vel.y * 20.0f) + this->actor.world.pos.y + 120.0f;
pos.z = (vel.z * 7.0f) + this->actor.world.pos.z;
pos.x = (demoKekkaiVel.x * 7.0f) + this->actor.world.pos.x;
pos.y = (demoKekkaiVel.y * 20.0f) + this->actor.world.pos.y + 120.0f;
pos.z = (demoKekkaiVel.z * 7.0f) + this->actor.world.pos.z;
EffectSsKiraKira_SpawnFocused(globalCtx, &pos, &vel, &accel, &lightYellow, &darkRed, 3000,
EffectSsKiraKira_SpawnFocused(globalCtx, &pos, &demoKekkaiVel, &accel, &lightYellow, &darkRed, 3000,
(s32)Rand_ZeroFloat(40.0f) + 45);
}
}
@ -338,7 +338,7 @@ void DemoKekkai_DrawTowerBarrier(Actor* thisx, GlobalContext* globalCtx) {
}
void DemoKekkai_Reset(void) {
vel.x = 0.0f;
vel.y = 0.0f;
vel.z = 0.0f;
demoKekkaiVel.x = 0.0f;
demoKekkaiVel.y = 0.0f;
demoKekkaiVel.z = 0.0f;
}

2
soh/src/overlays/actors/ovl_Door_Warp1/z_door_warp1.c
View File

@ -53,7 +53,7 @@ static InitChainEntry sInitChain[] = {
ICHAIN_F32(uncullZoneDownward, 4000, ICHAIN_STOP),
};
static s16 sWarpTimerTarget;
s16 sWarpTimerTarget;
void DoorWarp1_SetupAction(DoorWarp1* this, DoorWarp1ActionFunc actionFunc) {
this->actionFunc = actionFunc;

2
soh/src/overlays/actors/ovl_En_Bw/z_en_bw.c
View File

@ -122,7 +122,7 @@ static DamageTable sDamageTable = {
/* Unknown 2 */ DMG_ENTRY(0, 0x0),
};
static s32 sSlugGroup = 0;
s32 sSlugGroup = 0;
void EnBw_SetupAction(EnBw* this, EnBwActionFunc actionFunc) {
this->actionFunc = actionFunc;

14
soh/src/overlays/actors/ovl_En_Clear_Tag/z_en_clear_tag.c
View File

@ -35,7 +35,7 @@ const ActorInit En_Clear_Tag_InitVars = {
(ActorResetFunc)EnClearTag_Reset,
};
static u8 sIsEffectsInitialized = false;
u8 sClearTagIsEffectsInitialized = false;
static Vec3f sZeroVector = { 0.0f, 0.0f, 0.0f };
@ -79,10 +79,10 @@ static ColliderCylinderInit sLaserCylinderInit = {
{ 15, 30, 10, { 0, 0, 0 } },
};
static UNK_TYPE4 D_809D5C98 = 0; // unused
static UNK_TYPE4 D_809D5C9C = 0; // unused
//static UNK_TYPE4 D_809D5C98 = 0; // unused
//static UNK_TYPE4 D_809D5C9C = 0; // unused
static EnClearTagEffect sClearTagEffects[CLEAR_TAG_EFFECT_MAX_COUNT];
EnClearTagEffect sClearTagEffects[CLEAR_TAG_EFFECT_MAX_COUNT];
#include "overlays/ovl_En_Clear_Tag/ovl_En_Clear_Tag.h"
@ -273,8 +273,8 @@ void EnClearTag_Init(Actor* thisx, GlobalContext* globalCtx) {
}
// Initialize all effects to available if effects have not been initialized.
if (!sIsEffectsInitialized) {
sIsEffectsInitialized = true;
if (!sClearTagIsEffectsInitialized) {
sClearTagIsEffectsInitialized = true;
globalCtx->specialEffects = &sClearTagEffects[0];
for (i = 0; i < CLEAR_TAG_EFFECT_MAX_COUNT; i++) {
sClearTagEffects[i].type = CLEAR_TAG_EFFECT_AVAILABLE;
@ -1027,5 +1027,5 @@ void EnClearTag_DrawEffects(GlobalContext* globalCtx) {
void EnClearTag_Reset(void) {
memset(sClearTagEffects, 0, sizeof(sClearTagEffects));
sIsEffectsInitialized = false;
sClearTagIsEffectsInitialized = false;
}

14
soh/src/overlays/actors/ovl_En_Fr/z_en_fr.c
View File

@ -84,18 +84,7 @@ sEnFrPointers.flags = 12
- Deactivate frogs, frogs will jump back into the water
*/
typedef struct {
u8 flags;
EnFr* frogs[5];
} EnFrPointers;
typedef struct {
f32 xzDist;
f32 yaw;
f32 yDist;
} LogSpotToFromWater;
static EnFrPointers sEnFrPointers = {
EnFrPointers sEnFrPointers = {
0x00,
{
NULL,
@ -106,6 +95,7 @@ static EnFrPointers sEnFrPointers = {
},
};
// Flags for gSaveContext.eventChkInf[13]
static u16 sSongIndex[] = {
0x0002, 0x0004, 0x0010, 0x0008, 0x0020, 0x0040, 0x0001, 0x0000,

11
soh/src/overlays/actors/ovl_En_Fr/z_en_fr.h
View File

@ -28,6 +28,12 @@ typedef enum {
/* 07 */ FROG_NO_SONG
} FrogSongType;
typedef struct {
f32 xzDist;
f32 yaw;
f32 yDist;
} LogSpotToFromWater;
typedef struct EnFr {
/* 0x0000 */ Actor actor;
/* 0x014C */ SkelAnime skelAnime; // Frog Skeleton
@ -69,4 +75,9 @@ typedef struct EnFr {
/* 0x03B8 */ Vec3f posButterflyLight; // Used in Lights_PointNoGlowSetInfo()
} EnFr; // size = 0x03C4
typedef struct {
u8 flags;
EnFr* frogs[5];
} EnFrPointers;
#endif

2
soh/src/overlays/actors/ovl_En_Goma/z_en_goma.c
View File

@ -96,7 +96,7 @@ static ColliderCylinderInit D_80A4B7CC = {
{ 15, 30, 10, { 0, 0, 0 } },
};
static u8 sSpawnNum = 0;
u8 sSpawnNum = 0;
static Vec3f sDeadEffectVel = { 0.0f, 0.0f, 0.0f };
static InitChainEntry sInitChain[] = {

6
soh/src/overlays/actors/ovl_En_Insect/z_en_insect.c
View File

@ -32,9 +32,9 @@ void func_80A7D26C(EnInsect* this, GlobalContext* globalCtx);
void func_80A7D39C(EnInsect* this);
void func_80A7D460(EnInsect* this, GlobalContext* globalCtx);
static f32 D_80A7DEB0 = 0.0f;
static s16 D_80A7DEB4 = 0;
static s16 D_80A7DEB8 = 0;
f32 D_80A7DEB0 = 0.0f;
s16 D_80A7DEB4 = 0;
s16 D_80A7DEB8 = 0;
const ActorInit En_Insect_InitVars = {
ACTOR_EN_INSECT,

24
soh/src/overlays/actors/ovl_En_Ishi/z_en_ishi.c
View File

@ -29,8 +29,8 @@ void EnIshi_SpawnFragmentsLarge(EnIshi* this, GlobalContext* globalCtx);
void EnIshi_SpawnDustSmall(EnIshi* this, GlobalContext* globalCtx);
void EnIshi_SpawnDustLarge(EnIshi* this, GlobalContext* globalCtx);
static s16 sRotSpeedX = 0;
static s16 sRotSpeedY = 0;
s16 sRockRotSpeedX = 0;
s16 sRockRotSpeedY = 0;
const ActorInit En_Ishi_InitVars = {
ACTOR_EN_ISHI,
@ -405,11 +405,11 @@ void EnIshi_SetupFly(EnIshi* this) {
this->actor.velocity.x = Math_SinS(this->actor.world.rot.y) * this->actor.speedXZ;
this->actor.velocity.z = Math_CosS(this->actor.world.rot.y) * this->actor.speedXZ;
if ((this->actor.params & 1) == ROCK_SMALL) {
sRotSpeedX = (Rand_ZeroOne() - 0.5f) * 16000.0f;
sRotSpeedY = (Rand_ZeroOne() - 0.5f) * 2400.0f;
sRockRotSpeedX = (Rand_ZeroOne() - 0.5f) * 16000.0f;
sRockRotSpeedY = (Rand_ZeroOne() - 0.5f) * 2400.0f;
} else {
sRotSpeedX = (Rand_ZeroOne() - 0.5f) * 8000.0f;
sRotSpeedY = (Rand_ZeroOne() - 0.5f) * 1600.0f;
sRockRotSpeedX = (Rand_ZeroOne() - 0.5f) * 8000.0f;
sRockRotSpeedY = (Rand_ZeroOne() - 0.5f) * 1600.0f;
}
this->actor.colChkInfo.mass = 240;
this->actionFunc = EnIshi_Fly;
@ -455,8 +455,8 @@ void EnIshi_Fly(EnIshi* this, GlobalContext* globalCtx) {
EffectSsGRipple_Spawn(globalCtx, &contactPos, 500, 1300, 8);
}
this->actor.minVelocityY = -6.0f;
sRotSpeedX >>= 2;
sRotSpeedY >>= 2;
sRockRotSpeedX >>= 2;
sRockRotSpeedY >>= 2;
SoundSource_PlaySfxAtFixedWorldPos(globalCtx, &this->actor.world.pos, 40, NA_SE_EV_DIVE_INTO_WATER_L);
this->actor.bgCheckFlags &= ~0x40;
}
@ -464,8 +464,8 @@ void EnIshi_Fly(EnIshi* this, GlobalContext* globalCtx) {
EnIshi_Fall(this);
func_80A7ED94(&this->actor.velocity, D_80A7FA28[type]);
func_8002D7EC(&this->actor);
this->actor.shape.rot.x += sRotSpeedX;
this->actor.shape.rot.y += sRotSpeedY;
this->actor.shape.rot.x += sRockRotSpeedX;
this->actor.shape.rot.y += sRockRotSpeedY;
Actor_UpdateBgCheckInfo(globalCtx, &this->actor, 7.5f, 35.0f, 0.0f, 0xC5);
Collider_UpdateCylinder(&this->actor, &this->collider);
CollisionCheck_SetOC(globalCtx, &globalCtx->colChkCtx, &this->collider.base);
@ -502,6 +502,6 @@ void EnIshi_Draw(Actor* thisx, GlobalContext* globalCtx) {
}
void EnIshi_Reset(void) {
sRotSpeedX = 0;
sRotSpeedY = 0;
sRockRotSpeedX = 0;
sRockRotSpeedY = 0;
}

6
soh/src/overlays/actors/ovl_En_Niw/z_en_niw.c
View File

@ -35,7 +35,7 @@ void EnNiw_FeatherSpawn(EnNiw* this, Vec3f* pos, Vec3f* vel, Vec3f* accel, f32 s
void EnNiw_FeatherUpdate(EnNiw* this, GlobalContext* globalCtx);
void EnNiw_FeatherDraw(EnNiw* this, GlobalContext* globalCtx);
static s16 D_80AB85E0 = 0;
s16 D_80AB85E0 = 0;
const ActorInit En_Niw_InitVars = {
ACTOR_EN_NIW,
@ -70,9 +70,9 @@ static s16 sKakarikoFlagList[] = {
0x0200, 0x0400, 0x0800, 0x1000, 0x2000, 0x4000, 0x8000,
};
static u8 sLowerRiverSpawned = false;
u8 sLowerRiverSpawned = false;
static u8 sUpperRiverSpawned = false;
u8 sUpperRiverSpawned = false;
static ColliderCylinderInit sCylinderInit1 = {
{

36
soh/src/overlays/actors/ovl_En_Po_Field/z_en_po_field.c
View File

@ -126,7 +126,7 @@ static DamageTable sDamageTable = {
/* Unknown 2 */ DMG_ENTRY(0, 0x0),
};
static s32 sNumSpawned = 0;
s32 sEnPoFieldNumSpawned = 0;
static Vec3f sFieldMiddle = { -1000.0f, 0.0f, 6500.0f };
@ -145,22 +145,22 @@ static EnPoFieldInfo sPoFieldInfo[2] = {
static Vec3f D_80AD714C = { 0.0f, 1400.0f, 0.0f };
static Vec3s sSpawnPositions[10];
static u8 sSpawnSwitchFlags[10];
Vec3s sEnPoFieldSpawnPositions[10];
u8 sEnPoFieldSpawnSwitchFlags[10];
static MtxF sLimb7Mtx;
void EnPoField_Init(Actor* thisx, GlobalContext* globalCtx) {
EnPoField* this = (EnPoField*)thisx;
s32 pad;
if (sNumSpawned != 10) {
sSpawnPositions[sNumSpawned].x = this->actor.world.pos.x;
sSpawnPositions[sNumSpawned].y = this->actor.world.pos.y;
sSpawnPositions[sNumSpawned].z = this->actor.world.pos.z;
sSpawnSwitchFlags[sNumSpawned] = this->actor.params & 0xFF;
sNumSpawned++;
if (sEnPoFieldNumSpawned != 10) {
sEnPoFieldSpawnPositions[sEnPoFieldNumSpawned].x = this->actor.world.pos.x;
sEnPoFieldSpawnPositions[sEnPoFieldNumSpawned].y = this->actor.world.pos.y;
sEnPoFieldSpawnPositions[sEnPoFieldNumSpawned].z = this->actor.world.pos.z;
sEnPoFieldSpawnSwitchFlags[sEnPoFieldNumSpawned] = this->actor.params & 0xFF;
sEnPoFieldNumSpawned++;
}
if (sNumSpawned >= 2) {
if (sEnPoFieldNumSpawned >= 2) {
this->actor.params = 0xFF;
Actor_Kill(&this->actor);
return;
@ -407,10 +407,10 @@ void EnPoField_WaitForSpawn(EnPoField* this, GlobalContext* globalCtx) {
this->actionTimer--;
}
if (this->actionTimer == 0) {
for (i = 0; i < sNumSpawned; i++) {
if (fabsf(sSpawnPositions[i].x - player->actor.world.pos.x) < 150.0f &&
fabsf(sSpawnPositions[i].z - player->actor.world.pos.z) < 150.0f) {
if (Flags_GetSwitch(globalCtx, sSpawnSwitchFlags[i])) {
for (i = 0; i < sEnPoFieldNumSpawned; i++) {
if (fabsf(sEnPoFieldSpawnPositions[i].x - player->actor.world.pos.x) < 150.0f &&
fabsf(sEnPoFieldSpawnPositions[i].z - player->actor.world.pos.z) < 150.0f) {
if (Flags_GetSwitch(globalCtx, sEnPoFieldSpawnSwitchFlags[i])) {
if (player->stateFlags1 & 0x800000) { // Player riding Epona
return;
} else {
@ -711,7 +711,7 @@ void EnPoField_SoulInteract(EnPoField* this, GlobalContext* globalCtx) {
} else {
this->actor.textId = 0x508F;
Item_Give(globalCtx, ITEM_BIG_POE);
Flags_SetSwitch(globalCtx, sSpawnSwitchFlags[this->spawnFlagIndex]);
Flags_SetSwitch(globalCtx, sEnPoFieldSpawnSwitchFlags[this->spawnFlagIndex]);
}
} else {
Audio_PlayActorSound2(&this->actor, NA_SE_EN_PO_LAUGH);
@ -1009,8 +1009,8 @@ void EnPoField_DrawSoul(Actor* thisx, GlobalContext* globalCtx) {
}
void EnPoField_Reset(void) {
sNumSpawned = 0;
sEnPoFieldNumSpawned = 0;
memset(sSpawnPositions, 0, sizeof(sSpawnPositions));
memset(sSpawnSwitchFlags, 0, sizeof(sSpawnSwitchFlags));
memset(sEnPoFieldSpawnPositions, 0, sizeof(sEnPoFieldSpawnPositions));
memset(sEnPoFieldSpawnSwitchFlags, 0, sizeof(sEnPoFieldSpawnSwitchFlags));
}

2
soh/src/overlays/actors/ovl_En_Takara_Man/z_en_takara_man.c
View File

@ -35,7 +35,7 @@ const ActorInit En_Takara_Man_InitVars = {
(ActorResetFunc)EnTakaraMan_Reset,
};
static u8 sTakaraIsInitialized = false;
u8 sTakaraIsInitialized = false;
void EnTakaraMan_Reset(Actor* thisx, GlobalContext* globalCtx) {
sTakaraIsInitialized = false;

14
soh/src/overlays/actors/ovl_En_Xc/z_en_xc.c
View File

@ -447,7 +447,7 @@ void func_80B3D118(GlobalContext* globalCtx) {
static Vec3f D_80B42DA0;
static s32 D_80B41D90 = 0;
s32 D_80B41D90 = 0;
void EnXc_SetColossusWindSFX(GlobalContext* globalCtx) {
if (gSaveContext.sceneSetupIndex == 4) {
static Vec3f sPos = { 0.0f, 0.0f, 0.0f };
@ -484,17 +484,17 @@ void EnXc_SetColossusWindSFX(GlobalContext* globalCtx) {
}
}
static s32 sFlameSpawned = false;
s32 sEnXcFlameSpawned = false;
void EnXc_SpawnFlame(EnXc* this, GlobalContext* globalCtx) {
if (!sFlameSpawned) {
if (!sEnXcFlameSpawned) {
CsCmdActorAction* npcAction = EnXc_GetCsCmd(globalCtx, 0);
f32 xPos = npcAction->startPos.x;
f32 yPos = npcAction->startPos.y;
f32 zPos = npcAction->startPos.z;
this->flameActor = Actor_Spawn(&globalCtx->actorCtx, globalCtx, ACTOR_EN_LIGHT, xPos, yPos, zPos, 0, 0, 0, 5);
sFlameSpawned = true;
sEnXcFlameSpawned = true;
}
}
@ -519,7 +519,7 @@ void EnXc_DestroyFlame(EnXc* this) {
Actor_Kill(&this->actor);
}
static s32 D_80B41DA8 = 1;
s32 D_80B41DA8 = 1;
void EnXc_InitFlame(EnXc* this, GlobalContext* globalCtx) {
s32 pad;
s16 sceneNum = globalCtx->sceneNum;
@ -1402,7 +1402,7 @@ void func_80B3F534(GlobalContext* globalCtx) {
}
}
static s32 D_80B41DAC = 1;
s32 D_80B41DAC = 1;
void func_80B3F59C(EnXc* this, GlobalContext* globalCtx) {
CsCmdActorAction* npcAction = EnXc_GetCsCmd(globalCtx, 0);
@ -2430,7 +2430,7 @@ const ActorInit En_Xc_InitVars = {
void EnXc_Reset(void) {
D_80B41D90 = 0;
sFlameSpawned = false;
sEnXcFlameSpawned = false;
D_80B41DA8 = 1;
D_80B41DAC = 1;
}

4
soh/src/overlays/actors/ovl_En_Zf/z_en_zf.c
View File

@ -97,8 +97,8 @@ static Vec3f sPlatformPositions[] = {
};
// These seem to relate to the tagging in/out the minibosses do
static s16 D_80B4A1B0 = 0;
static s16 D_80B4A1B4 = 1;
s16 D_80B4A1B0 = 0;
s16 D_80B4A1B4 = 1;
const ActorInit En_Zf_InitVars = {
ACTOR_EN_ZF,

6
soh/src/overlays/actors/ovl_En_Zl3/z_en_zl3.c
View File

@ -45,7 +45,7 @@ static void* sEyeTextures[] = { gZelda2EyeOpenTex, gZelda2EyeHalfTex, gZelda2Eye
static void* sMouthTextures[] = { gZelda2MouthSeriousTex, gZelda2MouthHappyTex, gZelda2MouthOpenTex };
static s32 D_80B5A468 = 0;
s32 D_80B5A468 = 0;
static Vec3f D_80B5A46C = { 0.0f, 0.0f, 0.0f };
@ -55,7 +55,7 @@ static f32 D_80B5A484 = 0.0f;
static Vec3f D_80B5A488 = { 0.0f, 0.0f, 0.0f };
static s32 D_80B5A494 = -1;
s32 D_80B5A494 = -1;
static Vec3f D_80B5A498 = { 148.0f, 260.0f, -87.0f };
@ -63,7 +63,7 @@ static Vec3f D_80B5A4A4 = { -12.0f, 260.0f, -147.0f };
static Vec3f D_80B5A4B0 = { 42.0f, 260.0f, 13.0f };
static u32 D_80B5A4BC = 0;
u32 D_80B5A4BC = 0;
void func_80B533B0(Actor* thisx, GlobalContext* globalCtx) {
EnZl3* this = (EnZl3*)thisx;

14
soh/src/overlays/actors/ovl_Object_Kankyo/z_object_kankyo.c
View File

@ -57,8 +57,8 @@ const ActorInit Object_Kankyo_InitVars = {
(ActorResetFunc)ObjectKankyo_Reset,
};
static u8 sIsSpawned = false;
static s16 sTrailingFairies = 0;
u8 sKankyoIsSpawned = false;
s16 sTrailingFairies = 0;
void ObjectKankyo_SetupAction(ObjectKankyo* this, ObjectKankyoActionFunc action) {
this->actionFunc = action;
@ -76,18 +76,18 @@ void ObjectKankyo_Init(Actor* thisx, GlobalContext* globalCtx) {
this->actor.room = -1;
switch (this->actor.params) {
case 0:
if (!sIsSpawned) {
if (!sKankyoIsSpawned) {
ObjectKankyo_SetupAction(this, ObjectKankyo_Fairies);
sIsSpawned = true;
sKankyoIsSpawned = true;
} else {
Actor_Kill(&this->actor);
}
break;
case 3:
if (!sIsSpawned) {
if (!sKankyoIsSpawned) {
ObjectKankyo_SetupAction(this, ObjectKankyo_Snow);
sIsSpawned = true;
sKankyoIsSpawned = true;
} else {
Actor_Kill(&this->actor);
}
@ -939,6 +939,6 @@ void ObjectKankyo_DrawBeams(ObjectKankyo* this2, GlobalContext* globalCtx2) {
}
void ObjectKankyo_Reset(void) {
sIsSpawned = false;
sKankyoIsSpawned = false;
sTrailingFairies = 0;
}

4
soh/src/overlays/actors/ovl_player_actor/z_player.c
View File

@ -4804,7 +4804,7 @@ s32 func_8083ADD4(GlobalContext* globalCtx, Player* this) {
void func_8083AE40(Player* this, s16 objectId) {
s32 pad;
u32 size;
size_t size;
if (objectId != OBJECT_INVALID) {
this->giObjectLoading = true;
@ -4815,7 +4815,7 @@ void func_8083AE40(Player* this, s16 objectId) {
LOG_HEX("size", size, "../z_player.c", 9090);
ASSERT(size <= 1024 * 8, "size <= 1024 * 8", "../z_player.c", 9091);
DmaMgr_SendRequest2(&this->giObjectDmaRequest, (u32)this->giObjectSegment, gObjectTable[objectId].vromStart,
DmaMgr_SendRequest2(&this->giObjectDmaRequest, (uintptr_t)this->giObjectSegment, gObjectTable[objectId].vromStart,
size, 0, &this->giObjectLoadQueue, NULL, "../z_player.c", 9099);
}
}