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

Merge branch 'develop' into bradmerge

Browse Source
This commit is contained in:
briaguya 2023-01-17 16:44:46 -05:00 committed by GitHub
commit 15a6568607
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
867 changed files with 9259 additions and 4439 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
.github/workflows/generate-builds.yml vendored
View File

@ -12,7 +12,15 @@ jobs:
- uses: actions/checkout@v3
with:
submodules: true
- name: Extract assets
- name: Extract assets (Windows)
if: runner.os == 'Windows'
run: |
cp ../../../ZELOOTD.z64 OTRExporter/baserom_non_mq.z64
cmake --no-warn-unused-cli -S . -B build-cmake -G "Visual Studio 17 2022" -A x64 -DCMAKE_BUILD_TYPE:STRING=Release
cmake --build build-cmake --target ExtractAssets --config Release
7z a assets.zip soh/assets
- name: Extract assets (Unix)
if: runner.os != 'Windows'
run: |
cp ../../../ZELOOTD.z64 OTRExporter/baserom_non_mq.z64
cmake --no-warn-unused-cli -H. -Bbuild-cmake -GNinja -DCMAKE_BUILD_TYPE:STRING=Release

12
BUILDING.md
View File

@ -215,3 +215,15 @@ Use the `extract_assets.py` script file to run the exporter using any of the fol
4) In a terminal run `python3 extract_assets.py <path_to_rom>`
If the script finds multiple roms the user is prompted which to use. Selection is done using the number keys and then pressing the carriage return key.
## Getting CI to work on your fork
The CI works via [Github Actions](https://github.com/features/actions) where we mostly make use of machines hosted by Github; except for the very first step of the CI process called "Extract assets". This steps extracts assets from the game file and generates an "assets" folder in `soh/`.
To get this step working on your fork, you'll need to add a machine to your own repository as a self-hosted runner via "Settings > Actions > Runners" in your repository settings. Make sure to add the 'asset-builder' tag to your newly added runner to assign it to run this step. To setup your runner as a service read the docs [here](https://docs.github.com/en/actions/hosting-your-own-runners/configuring-the-self-hosted-runner-application-as-a-service?platform=linux).
### Runner on Windows
You'll have to enable the ability to run unsigned scripts through PowerShell. To do this, open Powershell as administrator and run `set-executionpolicy remotesigned`. Most dependencies get installed as part of the CI process. You will also need to seperately install 7z and add it to the PATH so `7z` can be run as a command. [Chocolatey](https://chocolatey.org/) or other package managers can be used to install it easily.
### Runner on UNIX systems
If you're on macOS or Linux take a look at `macports-deps.txt` or `apt-deps.txt` to see the dependencies expected to be on your machine.

4
OTRExporter/OTRExporter/AnimationExporter.cpp
View File

@ -1,11 +1,11 @@
#include "AnimationExporter.h"
#include <Animation.h>
#include <resource/type/Animation.h>
void OTRExporter_Animation::Save(ZResource* res, const fs::path& outPath, BinaryWriter* writer)
{
ZAnimation* anim = (ZAnimation*)res;
WriteHeader(res, outPath, writer, Ship::ResourceType::Animation);
WriteHeader(res, outPath, writer, Ship::ResourceType::SOH_Animation);
ZNormalAnimation* normalAnim = dynamic_cast<ZNormalAnimation*>(anim);
ZCurveAnimation* curveAnim = dynamic_cast<ZCurveAnimation*>(anim);

9
OTRExporter/OTRExporter/AudioExporter.cpp
View File

@ -1,6 +1,5 @@
#include "AudioExporter.h"
#include "Main.h"
#include <Animation.h>
#include <Utils/MemoryStream.h>
#include <Globals.h>
#include <Utils/File.h>
@ -30,7 +29,7 @@ void OTRExporter_Audio::WriteSampleEntryReference(ZAudio* audio, SampleEntry* en
void OTRExporter_Audio::WriteSampleEntry(SampleEntry* entry, BinaryWriter* writer)
{
WriteHeader(nullptr, "", writer, Ship::ResourceType::AudioSample, Ship::Version::Rachael);
WriteHeader(nullptr, "", writer, Ship::ResourceType::SOH_AudioSample, Ship::Version::Rachael);
writer->Write(entry->codec);
writer->Write(entry->medium);
@ -82,7 +81,7 @@ void OTRExporter_Audio::Save(ZResource* res, const fs::path& outPath, BinaryWrit
{
ZAudio* audio = (ZAudio*)res;
WriteHeader(res, outPath, writer, Ship::ResourceType::Audio, Ship::Version::Rachael);
WriteHeader(res, outPath, writer, Ship::ResourceType::SOH_Audio, Ship::Version::Rachael);
// Write Samples as individual files
for (auto pair : audio->samples)
@ -115,7 +114,7 @@ void OTRExporter_Audio::Save(ZResource* res, const fs::path& outPath, BinaryWrit
MemoryStream* fntStream = new MemoryStream();
BinaryWriter fntWriter = BinaryWriter(fntStream);
WriteHeader(nullptr, "", &fntWriter, Ship::ResourceType::AudioSoundFont, Ship::Version::Rachael);
WriteHeader(nullptr, "", &fntWriter, Ship::ResourceType::SOH_AudioSoundFont, Ship::Version::Rachael);
fntWriter.Write((uint32_t)i);
fntWriter.Write(audio->soundFontTable[i].medium);
@ -174,7 +173,7 @@ void OTRExporter_Audio::Save(ZResource* res, const fs::path& outPath, BinaryWrit
MemoryStream* seqStream = new MemoryStream();
BinaryWriter seqWriter = BinaryWriter(seqStream);
WriteHeader(nullptr, "", &seqWriter, Ship::ResourceType::AudioSequence, Ship::Version::Rachael);
WriteHeader(nullptr, "", &seqWriter, Ship::ResourceType::SOH_AudioSequence, Ship::Version::Rachael);
seqWriter.Write((uint32_t)seq.size());
seqWriter.Write(seq.data(), seq.size());

4
OTRExporter/OTRExporter/BackgroundExporter.cpp
View File

@ -5,6 +5,10 @@ void OTRExporter_Background::Save(ZResource* res, const fs::path& outPath, Binar
{
ZBackground* bg = (ZBackground*)res;
WriteHeader(bg, outPath, writer, Ship::ResourceType::SOH_Background);
writer->Write((uint32_t)bg->GetRawDataSize());
auto data = bg->parent->GetRawData();
writer->Write((char*)data.data() + bg->GetRawDataIndex(), bg->GetRawDataSize());
}

15
OTRExporter/OTRExporter/CMakeLists.txt
View File

@ -158,16 +158,19 @@ endif()
target_include_directories(${PROJECT_NAME} PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/../../ZAPDTR/ZAPD/
${CMAKE_CURRENT_SOURCE_DIR}/../../libultraship/extern/ZAPDUtils
${CMAKE_CURRENT_SOURCE_DIR}/../../ZAPDTR/lib/tinyxml2
${CMAKE_CURRENT_SOURCE_DIR}/../../libultraship/include
# TODO: these should no longer be necessary if we were to link against LUS
${CMAKE_CURRENT_SOURCE_DIR}/../../libultraship
${CMAKE_CURRENT_SOURCE_DIR}/../../libultraship/src
${CMAKE_CURRENT_SOURCE_DIR}/../../libultraship/src/resource
${CMAKE_CURRENT_SOURCE_DIR}/../../libultraship/src/resource/types
${CMAKE_CURRENT_SOURCE_DIR}/../../libultraship/extern
${CMAKE_CURRENT_SOURCE_DIR}/../../libultraship/extern/spdlog/include
${CMAKE_CURRENT_SOURCE_DIR}/../../libultraship/src/graphic/Fast3D/U64
${CMAKE_CURRENT_SOURCE_DIR}/../../libultraship/extern/Mercury
${CMAKE_CURRENT_SOURCE_DIR}/../../libultraship/extern/tinyxml2
${CMAKE_CURRENT_SOURCE_DIR}/../../libultraship/extern/ZAPDUtils
${CMAKE_CURRENT_SOURCE_DIR}/../../libultraship/extern/StormLib/src
${CMAKE_CURRENT_SOURCE_DIR}/../../libultraship/extern/spdlog/include
${CMAKE_CURRENT_SOURCE_DIR}/../../libultraship/extern/nlohmann-json/include
${CMAKE_CURRENT_SOURCE_DIR}/../../libultraship/src/resource
${CMAKE_CURRENT_SOURCE_DIR}/../../soh/soh
.
)

4
OTRExporter/OTRExporter/CollisionExporter.cpp
View File

@ -1,11 +1,11 @@
#include "CollisionExporter.h"
#include <Resource.h>
#include <libultraship/bridge.h>
void OTRExporter_Collision::Save(ZResource* res, const fs::path& outPath, BinaryWriter* writer)
{
ZCollisionHeader* col = (ZCollisionHeader*)res;
WriteHeader(res, outPath, writer, Ship::ResourceType::CollisionHeader);
WriteHeader(res, outPath, writer, Ship::ResourceType::SOH_CollisionHeader);
writer->Write(col->absMinX);
writer->Write(col->absMinY);

4
OTRExporter/OTRExporter/CutsceneExporter.cpp
View File

@ -1,11 +1,11 @@
#include "CutsceneExporter.h"
#include <Resource.h>
#include <libultraship/bridge.h>
void OTRExporter_Cutscene::Save(ZResource* res, const fs::path& outPath, BinaryWriter* writer)
{
ZCutscene* cs = (ZCutscene*)res;
WriteHeader(cs, outPath, writer, Ship::ResourceType::Cutscene);
WriteHeader(cs, outPath, writer, Ship::ResourceType::SOH_Cutscene);
//writer->Write((uint32_t)cs->commands.size() + 2 + 2);
writer->Write((uint32_t)0);

2
OTRExporter/OTRExporter/DisplayListExporter.cpp
View File

@ -5,7 +5,7 @@
#include <Utils/BitConverter.h>
#include "StrHash64/StrHash64.h"
#include "spdlog/spdlog.h"
#include "PR/ultra64/gbi.h"
#include <libultraship/libultra/gbi.h>
#include <Globals.h>
#include <iostream>
#include <string>

2
OTRExporter/OTRExporter/Exporter.h
View File

@ -3,7 +3,7 @@
#include "ZArray.h"
//#include "OTRExporter.h"
#include <Utils/BinaryWriter.h>
#include <Resource.h>
#include <libultraship/bridge.h>
#include "VersionInfo.h"
class OTRExporter : public ZResourceExporter

2
OTRExporter/OTRExporter/Main.cpp
View File

@ -1,4 +1,4 @@
#include <Archive.h>
#include "Main.h"
#include "BackgroundExporter.h"
#include "TextureExporter.h"
#include "RoomExporter.h"

2
OTRExporter/OTRExporter/Main.h
View File

@ -1,6 +1,6 @@
#pragma once
#include <Archive.h>
#include <libultraship/bridge.h>
extern std::shared_ptr<Ship::Archive> otrArchive;
extern std::map<std::string, std::vector<char>> files;

2
OTRExporter/OTRExporter/PathExporter.cpp
View File

@ -5,7 +5,7 @@ void OTRExporter_Path::Save(ZResource* res, const fs::path& outPath, BinaryWrite
{
ZPath* path = (ZPath*)res;
WriteHeader(res, outPath, writer, Ship::ResourceType::Path);
WriteHeader(res, outPath, writer, Ship::ResourceType::SOH_Path);
writer->Write((uint32_t)path->pathways.size());

4
OTRExporter/OTRExporter/PlayerAnimationExporter.cpp
View File

@ -1,11 +1,11 @@
#include "PlayerAnimationExporter.h"
#include <Resource.h>
#include <libultraship/bridge.h>
void OTRExporter_PlayerAnimationExporter::Save(ZResource* res, const fs::path& outPath, BinaryWriter* writer)
{
ZPlayerAnimationData* anim = (ZPlayerAnimationData*)res;
WriteHeader(res, outPath, writer, Ship::ResourceType::PlayerAnimation);
WriteHeader(res, outPath, writer, Ship::ResourceType::SOH_PlayerAnimation);
auto start = std::chrono::steady_clock::now();

4
OTRExporter/OTRExporter/RoomExporter.cpp
View File

@ -23,7 +23,7 @@
#include <ZRoom/Commands/SetAlternateHeaders.h>
#include "CollisionExporter.h"
#include "DisplayListExporter.h"
#include "Resource.h"
#include <libultraship/bridge.h>
#include <Globals.h>
#include <ZRoom/Commands/SetExitList.h>
#include <ZRoom/Commands/SetPathways.h>
@ -39,7 +39,7 @@ void OTRExporter_Room::Save(ZResource* res, const fs::path& outPath, BinaryWrite
{
ZRoom* room = (ZRoom*)res;
WriteHeader(res, outPath, writer, Ship::ResourceType::Room);
WriteHeader(res, outPath, writer, Ship::ResourceType::SOH_Room);
writer->Write((uint32_t)room->commands.size());

4
OTRExporter/OTRExporter/SkeletonExporter.cpp
View File

@ -1,5 +1,5 @@
#include "SkeletonExporter.h"
#include <Resource.h>
#include <libultraship/bridge.h>
#include <Globals.h>
#include "DisplayListExporter.h"
@ -7,7 +7,7 @@ void OTRExporter_Skeleton::Save(ZResource* res, const fs::path& outPath, BinaryW
{
ZSkeleton* skel = (ZSkeleton*)res;
WriteHeader(res, outPath, writer, Ship::ResourceType::Skeleton);
WriteHeader(res, outPath, writer, Ship::ResourceType::SOH_Skeleton);
writer->Write((uint8_t)skel->type);
writer->Write((uint8_t)skel->limbType);

4
OTRExporter/OTRExporter/SkeletonLimbExporter.cpp
View File

@ -1,13 +1,13 @@
#include "SkeletonLimbExporter.h"
#include "DisplayListExporter.h"
#include <Resource.h>
#include <libultraship/bridge.h>
#include <Globals.h>
void OTRExporter_SkeletonLimb::Save(ZResource* res, const fs::path& outPath, BinaryWriter* writer)
{
ZLimb* limb = (ZLimb*)res;
WriteHeader(res, outPath, writer, Ship::ResourceType::SkeletonLimb);
WriteHeader(res, outPath, writer, Ship::ResourceType::SOH_SkeletonLimb);
writer->Write((uint8_t)limb->type);
writer->Write((uint8_t)limb->skinSegmentType);

2
OTRExporter/OTRExporter/TextExporter.cpp
View File

@ -5,7 +5,7 @@ void OTRExporter_Text::Save(ZResource* res, const fs::path& outPath, BinaryWrite
{
ZText* txt = (ZText*)res;
WriteHeader(txt, outPath, writer, Ship::ResourceType::Text);
WriteHeader(txt, outPath, writer, Ship::ResourceType::SOH_Text);
writer->Write((uint32_t)txt->messages.size());

22
OTRExporter/OTRExporter/VersionInfo.cpp
View File

@ -1,27 +1,25 @@
#include "VersionInfo.h"
#include <Resource.h>
#include <libultraship/bridge.h>
std::map<Ship::ResourceType, uint32_t> resourceVersions;
void InitVersionInfo()
{
resourceVersions = std::map<Ship::ResourceType, uint32_t> {
{ Ship::ResourceType::Animation, 0 },
{ Ship::ResourceType::Model, 0 },
{ Ship::ResourceType::SOH_Animation, 0 },
{ Ship::ResourceType::Texture, 0 },
{ Ship::ResourceType::Material, 0 },
{ Ship::ResourceType::PlayerAnimation, 0 },
{ Ship::ResourceType::SOH_PlayerAnimation, 0 },
{ Ship::ResourceType::DisplayList, 0 },
{ Ship::ResourceType::Room, 0 },
{ Ship::ResourceType::CollisionHeader, 0 },
{ Ship::ResourceType::Skeleton, 0 },
{ Ship::ResourceType::SkeletonLimb, 0 },
{ Ship::ResourceType::SOH_Room, 0 },
{ Ship::ResourceType::SOH_CollisionHeader, 0 },
{ Ship::ResourceType::SOH_Skeleton, 0 },
{ Ship::ResourceType::SOH_SkeletonLimb, 0 },
{ Ship::ResourceType::Matrix, 0 },
{ Ship::ResourceType::Path, 0 },
{ Ship::ResourceType::SOH_Path, 0 },
{ Ship::ResourceType::Vertex, 0 },
{ Ship::ResourceType::Cutscene, 0 },
{ Ship::ResourceType::SOH_Cutscene, 0 },
{ Ship::ResourceType::Array, 0 },
{ Ship::ResourceType::Text, 0 },
{ Ship::ResourceType::SOH_Text, 0 },
{ Ship::ResourceType::Blob, 0 },
};
}

2
OTRExporter/OTRExporter/VtxExporter.cpp
View File

@ -1,5 +1,5 @@
#include "VtxExporter.h"
#include "Resource.h"
#include <libultraship/bridge.h>
#include "VersionInfo.h"

2
OTRExporter/OTRExporter/z64cutscene.h
View File

@ -2,7 +2,7 @@
#define Z64CUTSCENE_H
#if 0
#include "ultra64.h"
#include <libultraship/libultra.h>
typedef struct {
/* 0x00 */ u16 entrance; // entrance index upon which the cutscene should trigger

26
README.md
View File

@ -4,6 +4,10 @@ A PC port of OoT allowing you to enjoy the game with modern controls, widescreen
The Ship does not include assets and as such requires a prior copy of the game to play.
## Discord
Official Discord: https://discord.com/invite/BtBmd55HVH
## Quick Start (Windows)
1) Download The Ship of Harkinian from [Discord](https://discord.com/invite/BtBmd55HVH).
@ -128,32 +132,16 @@ Once you have prepared your sequences folder:
Assuming you have done everything correctly, boot up SoH and open up the SFX Editor (In the Enhancements dropdown). You should now be able to swap out any of the in game sequences/fanfares for the sequences added in your newly generated OTR file. If you have any trouble with this process please reach out in the support section of the Discord
## Take The Survey
Want to use cartridge readers in tandem with the OTRGui?
Take [this survey](https://retroarchopenhardware.com/survey.php) to increase chances of this becoming reality.
## Discord
Official Discord: https://discord.com/invite/BtBmd55HVH
## Building The Ship of Harkinian
Refer to the [building instructions](BUILDING.md) to compile SoH.
## Getting CI to work on your fork
The CI works via [Github Actions](https://github.com/features/actions) where we mostly make use of machines hosted by Github; except for the very first step of the CI process called "Extract assets". This steps extracts assets from the game file and generates an "assets" folder in `soh/`.
To get this step working on your fork, you'll need to add a machine to your own repository as a self-hosted runner via "Settings > Actions > Runners" in your repository settings. If you're on macOS or Linux take a look at `macports-deps.txt` or `apt-deps.txt` to see the dependencies expected to be on your machine. For Windows, deps get installed as part of the CI process. To setup your runner as a service read the docs [here](https://docs.github.com/en/actions/hosting-your-own-runners/configuring-the-self-hosted-runner-application-as-a-service?platform=linux).
## Troubleshooting The Exporter
- Confirm that you have an `/assets` folder filled with XMLs in the same directory as OTRGui.exe
- Confirm that `zapd.exe` exists in the `/assets/extractor` folder
## Nightly Builds
Nightly builds of Ship of Harkinian are available here: [Windows](https://nightly.link/HarbourMasters/Shipwright/workflows/generate-builds/develop/soh-windows.zip), [macOS](https://nightly.link/HarbourMasters/Shipwright/workflows/generate-builds/develop/soh-mac.zip), [Linux](https://nightly.link/HarbourMasters/Shipwright/workflows/generate-builds/develop/soh-linux.zip), [Switch](https://nightly.link/HarbourMasters/Shipwright/workflows/generate-builds/develop/soh-switch.zip), [Wii U](https://nightly.link/HarbourMasters/Shipwright/workflows/generate-builds/develop/soh-wiiu.zip)
## Take The Survey
Want to use cartridge readers in tandem with the OTRGui?
Take [this survey](https://retroarchopenhardware.com/survey.php) to increase chances of this becoming reality.
## The Harbour Masters Are...

6
ZAPDTR/.gitrepo
View File

@ -6,7 +6,7 @@
[subrepo]
remote = https://github.com/HarbourMasters/ZAPDTR.git
branch = master
commit = a53a53ea4216b926253dde2c942ae0ca6e2f2ccd
parent = f52a2a6406eb1bbd2b631c65923d879a83983ccb
commit = e23b125d89bd973998d2eb00896bcbaf1b53a329
parent = 17b1a8e7fd5517f9232e531da0fed6ef80a87f04
method = rebase
cmdver = 0.4.1
cmdver = 0.4.3

2
ZAPDTR/ZAPD/CMakeLists.txt
View File

@ -336,6 +336,8 @@ find_package(PNG REQUIRED)
target_include_directories(${PROJECT_NAME} PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/../../libultraship/extern/ZAPDUtils
${CMAKE_CURRENT_SOURCE_DIR}/../../libultraship/src/resource
${CMAKE_CURRENT_SOURCE_DIR}/../../libultraship/include
${CMAKE_CURRENT_SOURCE_DIR}/../../ZAPDTR/lib/tinyxml2
${CMAKE_CURRENT_SOURCE_DIR}/../../ZAPDTR/lib/libgfxd
${PNG_PNG_INCLUDE_DIR}/

4
ZAPDTR/ZAPD/ZResource.h
View File

@ -7,8 +7,8 @@
#include <string>
#include <vector>
#include "Declaration.h"
#include "Utils/BinaryWriter.h"
#include "Utils/Directory.h"
#include <Utils/BinaryWriter.h>
#include <Utils/Directory.h>
#include "tinyxml2.h"
#define SEGMENT_SCENE 2

2
libultraship

@ -1 +1 @@
Subproject commit b1c75c86e902e5036ee1d36afad1a35313988fe7
Subproject commit c5bab5aef8a9dd77047438718de64fb2e27eedfc

201
soh/CMakeLists.txt
View File

@ -123,7 +123,7 @@ set(Header_Files__include
#"include/stdbool_n64.h"
#"include/stddef_n64.h"
#"include/stdlib_n64.h"
"include/ultra64.h"
# "include/ultra64.h"
"include/unk.h"
"include/variables.h"
"include/vt.h"
@ -288,6 +288,194 @@ set(Source_Files__soh
)
source_group("Source Files\\soh" FILES ${Source_Files__soh})
set(Header_Files__soh__resourceTypes
"soh/resource/type/Animation.h"
"soh/resource/type/AudioSample.h"
"soh/resource/type/AudioSequence.h"
"soh/resource/type/AudioSoundFont.h"
"soh/resource/type/CollisionHeader.h"
"soh/resource/type/Cutscene.h"
"soh/resource/type/Path.h"
"soh/resource/type/PlayerAnimation.h"
"soh/resource/type/Scene.h"
"soh/resource/type/Skeleton.h"
"soh/resource/type/SkeletonLimb.h"
"soh/resource/type/Text.h"
"soh/resource/type/Background.h"
)
source_group("Header Files\\soh\\resource\\type" FILES ${Header_Files__soh__resourceTypes})
set(Source_Files__soh__resourceTypes
"soh/resource/type/Animation.cpp"
"soh/resource/type/AudioSample.cpp"
"soh/resource/type/AudioSequence.cpp"
"soh/resource/type/AudioSoundFont.cpp"
"soh/resource/type/CollisionHeader.cpp"
"soh/resource/type/Cutscene.cpp"
"soh/resource/type/Path.cpp"
"soh/resource/type/PlayerAnimation.cpp"
"soh/resource/type/Scene.cpp"
"soh/resource/type/Skeleton.cpp"
"soh/resource/type/SkeletonLimb.cpp"
"soh/resource/type/Text.cpp"
"soh/resource/type/Background.cpp"
)
source_group("Source Files\\soh\\resource\\type" FILES ${Source_Files__soh__resourceTypes})
set(Header_Files__soh__resourceFactories
"soh/resource/importer/AnimationFactory.h"
"soh/resource/importer/AudioSampleFactory.h"
"soh/resource/importer/AudioSequenceFactory.h"
"soh/resource/importer/AudioSoundFontFactory.h"
"soh/resource/importer/CollisionHeaderFactory.h"
"soh/resource/importer/CutsceneFactory.h"
"soh/resource/importer/PathFactory.h"
"soh/resource/importer/PlayerAnimationFactory.h"
"soh/resource/importer/SceneFactory.h"
"soh/resource/importer/SkeletonFactory.h"
"soh/resource/importer/SkeletonLimbFactory.h"
"soh/resource/importer/TextFactory.h"
"soh/resource/importer/BackgroundFactory.h"
)
source_group("Header Files\\soh\\resource\\importer" FILES ${Header_Files__soh__resourceFactories})
set(Source_Files__soh__resourceFactories
"soh/resource/importer/AnimationFactory.cpp"
"soh/resource/importer/AudioSampleFactory.cpp"
"soh/resource/importer/AudioSequenceFactory.cpp"
"soh/resource/importer/AudioSoundFontFactory.cpp"
"soh/resource/importer/CollisionHeaderFactory.cpp"
"soh/resource/importer/CutsceneFactory.cpp"
"soh/resource/importer/PathFactory.cpp"
"soh/resource/importer/PlayerAnimationFactory.cpp"
"soh/resource/importer/SceneFactory.cpp"
"soh/resource/importer/SkeletonFactory.cpp"
"soh/resource/importer/SkeletonLimbFactory.cpp"
"soh/resource/importer/TextFactory.cpp"
"soh/resource/importer/BackgroundFactory.cpp"
)
source_group("Source Files\\soh\\resource\\importer" FILES ${Source_Files__soh__resourceFactories})
set(Header_Files__soh__scenecommandTypes
"soh/resource/type/scenecommand/EndMarker.h"
"soh/resource/type/scenecommand/RomFile.h"
"soh/resource/type/scenecommand/SceneCommand.h"
"soh/resource/type/scenecommand/SetActorList.h"
"soh/resource/type/scenecommand/SetAlternateHeaders.h"
"soh/resource/type/scenecommand/SetCameraSettings.h"
"soh/resource/type/scenecommand/SetCollisionHeader.h"
"soh/resource/type/scenecommand/SetCsCamera.h"
"soh/resource/type/scenecommand/SetCutscenes.h"
"soh/resource/type/scenecommand/SetEchoSettings.h"
"soh/resource/type/scenecommand/SetEntranceList.h"
"soh/resource/type/scenecommand/SetExitList.h"
"soh/resource/type/scenecommand/SetLightingSettings.h"
"soh/resource/type/scenecommand/SetLightList.h"
"soh/resource/type/scenecommand/SetMesh.h"
"soh/resource/type/scenecommand/SetObjectList.h"
"soh/resource/type/scenecommand/SetPathways.h"
"soh/resource/type/scenecommand/SetRoomBehavior.h"
"soh/resource/type/scenecommand/SetRoomList.h"
"soh/resource/type/scenecommand/SetSkyboxModifier.h"
"soh/resource/type/scenecommand/SetSkyboxSettings.h"
"soh/resource/type/scenecommand/SetSoundSettings.h"
"soh/resource/type/scenecommand/SetSpecialObjects.h"
"soh/resource/type/scenecommand/SetStartPositionList.h"
"soh/resource/type/scenecommand/SetTimeSettings.h"
"soh/resource/type/scenecommand/SetTransitionActorList.h"
"soh/resource/type/scenecommand/SetWindSettings.h"
)
source_group("Header Files\\soh\\resource\\type\\scenecommand" FILES ${Header_Files__soh__scenecommandTypes})
set(Source_Files__soh__scenecommandTypes
"soh/resource/type/scenecommand/EndMarker.cpp"
"soh/resource/type/scenecommand/SetActorList.cpp"
"soh/resource/type/scenecommand/SetAlternateHeaders.cpp"
"soh/resource/type/scenecommand/SetCameraSettings.cpp"
"soh/resource/type/scenecommand/SetCollisionHeader.cpp"
"soh/resource/type/scenecommand/SetCsCamera.cpp"
"soh/resource/type/scenecommand/SetCutscenes.cpp"
"soh/resource/type/scenecommand/SetEchoSettings.cpp"
"soh/resource/type/scenecommand/SetEntranceList.cpp"
"soh/resource/type/scenecommand/SetExitList.cpp"
"soh/resource/type/scenecommand/SetLightingSettings.cpp"
"soh/resource/type/scenecommand/SetLightList.cpp"
"soh/resource/type/scenecommand/SetMesh.cpp"
"soh/resource/type/scenecommand/SetObjectList.cpp"
"soh/resource/type/scenecommand/SetPathways.cpp"
"soh/resource/type/scenecommand/SetRoomBehavior.cpp"
"soh/resource/type/scenecommand/SetRoomList.cpp"
"soh/resource/type/scenecommand/SetSkyboxModifier.cpp"
"soh/resource/type/scenecommand/SetSkyboxSettings.cpp"
"soh/resource/type/scenecommand/SetSoundSettings.cpp"
"soh/resource/type/scenecommand/SetSpecialObjects.cpp"
"soh/resource/type/scenecommand/SetStartPositionList.cpp"
"soh/resource/type/scenecommand/SetTimeSettings.cpp"
"soh/resource/type/scenecommand/SetTransitionActorList.cpp"
"soh/resource/type/scenecommand/SetWindSettings.cpp"
)
source_group("Source Files\\soh\\resource\\type\\scenecommand" FILES ${Source_Files__soh__scenecommandTypes})
set(Header_Files__soh__scenecommandFactories
"soh/resource/importer/scenecommand/EndMarkerFactory.h"
"soh/resource/importer/scenecommand/SceneCommandFactory.h"
"soh/resource/importer/scenecommand/SetActorListFactory.h"
"soh/resource/importer/scenecommand/SetAlternateHeadersFactory.h"
"soh/resource/importer/scenecommand/SetCameraSettingsFactory.h"
"soh/resource/importer/scenecommand/SetCollisionHeaderFactory.h"
"soh/resource/importer/scenecommand/SetCsCameraFactory.h"
"soh/resource/importer/scenecommand/SetCutscenesFactory.h"
"soh/resource/importer/scenecommand/SetEchoSettingsFactory.h"
"soh/resource/importer/scenecommand/SetEntranceListFactory.h"
"soh/resource/importer/scenecommand/SetExitListFactory.h"
"soh/resource/importer/scenecommand/SetLightingSettingsFactory.h"
"soh/resource/importer/scenecommand/SetLightListFactory.h"
"soh/resource/importer/scenecommand/SetMeshFactory.h"
"soh/resource/importer/scenecommand/SetObjectListFactory.h"
"soh/resource/importer/scenecommand/SetPathwaysFactory.h"
"soh/resource/importer/scenecommand/SetRoomBehaviorFactory.h"
"soh/resource/importer/scenecommand/SetRoomListFactory.h"
"soh/resource/importer/scenecommand/SetSkyboxModifierFactory.h"
"soh/resource/importer/scenecommand/SetSkyboxSettingsFactory.h"
"soh/resource/importer/scenecommand/SetSoundSettingsFactory.h"
"soh/resource/importer/scenecommand/SetSpecialObjectsFactory.h"
"soh/resource/importer/scenecommand/SetStartPositionListFactory.h"
"soh/resource/importer/scenecommand/SetTimeSettingsFactory.h"
"soh/resource/importer/scenecommand/SetTransitionActorListFactory.h"
"soh/resource/importer/scenecommand/SetWindSettingsFactory.h"
)
source_group("Header Files\\soh\\resource\\importer\\scenecommand" FILES ${Header_Files__soh__scenecommandFactories})
set(Source_Files__soh__scenecommandFactories
"soh/resource/importer/scenecommand/EndMarkerFactory.cpp"
"soh/resource/importer/scenecommand/SceneCommandFactory.cpp"
"soh/resource/importer/scenecommand/SetActorListFactory.cpp"
"soh/resource/importer/scenecommand/SetAlternateHeadersFactory.cpp"
"soh/resource/importer/scenecommand/SetCameraSettingsFactory.cpp"
"soh/resource/importer/scenecommand/SetCollisionHeaderFactory.cpp"
"soh/resource/importer/scenecommand/SetCsCameraFactory.cpp"
"soh/resource/importer/scenecommand/SetCutscenesFactory.cpp"
"soh/resource/importer/scenecommand/SetEchoSettingsFactory.cpp"
"soh/resource/importer/scenecommand/SetEntranceListFactory.cpp"
"soh/resource/importer/scenecommand/SetExitListFactory.cpp"
"soh/resource/importer/scenecommand/SetLightingSettingsFactory.cpp"
"soh/resource/importer/scenecommand/SetLightListFactory.cpp"
"soh/resource/importer/scenecommand/SetMeshFactory.cpp"
"soh/resource/importer/scenecommand/SetObjectListFactory.cpp"
"soh/resource/importer/scenecommand/SetPathwaysFactory.cpp"
"soh/resource/importer/scenecommand/SetRoomBehaviorFactory.cpp"
"soh/resource/importer/scenecommand/SetRoomListFactory.cpp"
"soh/resource/importer/scenecommand/SetSkyboxModifierFactory.cpp"
"soh/resource/importer/scenecommand/SetSkyboxSettingsFactory.cpp"
"soh/resource/importer/scenecommand/SetSoundSettingsFactory.cpp"
"soh/resource/importer/scenecommand/SetSpecialObjectsFactory.cpp"
"soh/resource/importer/scenecommand/SetStartPositionListFactory.cpp"
"soh/resource/importer/scenecommand/SetTimeSettingsFactory.cpp"
"soh/resource/importer/scenecommand/SetTransitionActorListFactory.cpp"
"soh/resource/importer/scenecommand/SetWindSettingsFactory.cpp"
)
source_group("Source Files\\soh\\resource\\importer\\scenecommand" FILES ${Source_Files__soh__scenecommandFactories})
set(Source_Files__soh__Enhancements
"soh/Enhancements/bootcommands.c"
"soh/Enhancements/debugconsole.cpp"
@ -1655,6 +1843,14 @@ set(ALL_FILES
${Source_Files__src__overlays__gamestates__ovl_title}
${Source_Files__src__overlays__misc__ovl_kaleido_scope}
${Source_Files__src__overlays__misc__ovl_map_mark_data}
${Header_Files__soh__resourceTypes}
${Source_Files__soh__resourceTypes}
${Header_Files__soh__resourceFactories}
${Source_Files__soh__resourceFactories}
${Header_Files__soh__scenecommandTypes}
${Source_Files__soh__scenecommandTypes}
${Source_Files__soh__scenecommandFactories}
${Header_Files__soh__scenecommandFactories}
)
################################################################################
@ -1741,7 +1937,7 @@ target_include_directories(${PROJECT_NAME} PRIVATE assets
${CMAKE_CURRENT_SOURCE_DIR}/../libultraship/src/misc
${CMAKE_CURRENT_SOURCE_DIR}/../libultraship/src/core
${CMAKE_CURRENT_SOURCE_DIR}/../libultraship/src/resource
${CMAKE_CURRENT_SOURCE_DIR}/../libultraship/src/resource/types
${CMAKE_CURRENT_SOURCE_DIR}/../libultraship/src/resource/type
${CMAKE_CURRENT_SOURCE_DIR}/../libultraship/src/audio
${CMAKE_CURRENT_SOURCE_DIR}/../libultraship/extern
${CMAKE_CURRENT_SOURCE_DIR}/../libultraship/extern/Mercury
@ -1752,6 +1948,7 @@ target_include_directories(${PROJECT_NAME} PRIVATE assets
${CMAKE_CURRENT_SOURCE_DIR}/../libultraship/src/graphic/Fast3D/U64/PR
${CMAKE_CURRENT_SOURCE_DIR}/../libultraship/src/graphic
${CMAKE_CURRENT_SOURCE_DIR}/../ZAPDTR/ZAPDUtils
${CMAKE_CURRENT_SOURCE_DIR}/../ZAPDTR/ZAPD/resource/type
${SDL2-INCLUDE}
${SDL2-NET-INCLUDE}
${CMAKE_CURRENT_SOURCE_DIR}/assets/

2
soh/include/fp.h
View File

@ -1,6 +1,6 @@
#ifndef FP_H
#define FP_H
#include "ultra64.h"
#include <libultraship/libultra.h>
extern f32 qNaN0x3FFFFF;
extern f32 qNaN0x10000;

3
soh/include/functions.h
View File

@ -2,6 +2,7 @@
#define FUNCTIONS_H
#include "z64.h"
#include <stdarg.h>
#ifdef __cplusplus
#define this thisx
@ -97,8 +98,6 @@ void LogUtils_CheckValidPointer(const char* exp, void* ptr, const char* file, s3
void LogUtils_LogThreadId(const char* name, s32 line);
void LogUtils_HungupThread(const char* name, s32 line);
void LogUtils_ResetHungup(void);
s32 vsprintf(char* dst, const char* fmt, va_list args);
s32 sprintf(char* dst, const char* fmt, ...);
void __osPiCreateAccessQueue(void);
void __osPiGetAccess(void);
void __osPiRelAccess(void);

6
soh/include/global.h
View File

@ -9,7 +9,7 @@
#include "soh/OTRGlobals.h"
#include "soh/Enhancements/gameconsole.h"
#include "soh/Enhancements/gameplaystats.h"
#include <Cvar.h>
#include <libultraship/bridge.h>
#define _AudioseqSegmentRomStart "Audioseq"
#define _AudiobankSegmentRomStart "Audiobank"
@ -38,4 +38,8 @@
#define _z_select_staticSegmentRomStart 0
#define _z_select_staticSegmentRomEnd 0
// TODO: POSIX/BSD Bug, this is a hack to fix the build compilation on any BSD system (Switch, Wii-U, Vita, etc)
// <sys/types.h> defines quad as a macro, which conflicts with the quad parameter on z_collision_check.c
#undef quad
#endif

2
soh/include/libc/math.h
View File

@ -1,7 +1,7 @@
#ifndef MATH_H
#define MATH_H
#include "ultra64/types.h"
#include <libultraship/libultra.h>
#define M_PI 3.14159265358979323846f
#define M_SQRT2 1.41421356237309504880f

2
soh/include/libc/stdlib.h
View File

@ -1,7 +1,7 @@
#ifndef STDLIB_H
#define STDLIB_H
#include "ultra64.h"
#include <libultraship/libultra.h>
#if 0

6
soh/include/macros.h
View File

@ -300,9 +300,9 @@ extern GraphicsContext* __gfxCtx;
// #endregion
// #region SOH [Enhancements]
#define CHECK_EQUIPMENT_AGE(i, j) (CVar_GetS32("gTimelessEquipment", 0) || (gEquipAgeReqs[i][j] == 9) || (gEquipAgeReqs[i][j] == ((void)0, gSaveContext.linkAge)))
#define CHECK_SLOT_AGE(slotIndex) (CVar_GetS32("gTimelessEquipment", 0) || (gSlotAgeReqs[slotIndex] == 9) || gSlotAgeReqs[slotIndex] == ((void)0, gSaveContext.linkAge))
#define CHECK_ITEM_AGE(itemIndex) (CVar_GetS32("gTimelessEquipment", 0) || (gItemAgeReqs[itemIndex] == 9) || (gItemAgeReqs[itemIndex] == gSaveContext.linkAge))
#define CHECK_EQUIPMENT_AGE(i, j) (CVarGetInteger("gTimelessEquipment", 0) || (gEquipAgeReqs[i][j] == 9) || (gEquipAgeReqs[i][j] == ((void)0, gSaveContext.linkAge)))
#define CHECK_SLOT_AGE(slotIndex) (CVarGetInteger("gTimelessEquipment", 0) || (gSlotAgeReqs[slotIndex] == 9) || gSlotAgeReqs[slotIndex] == ((void)0, gSaveContext.linkAge))
#define CHECK_ITEM_AGE(itemIndex) (CVarGetInteger("gTimelessEquipment", 0) || (gItemAgeReqs[itemIndex] == 9) || (gItemAgeReqs[itemIndex] == gSaveContext.linkAge))
#define DPAD_ITEM(button) ((gSaveContext.buttonStatus[(button) + 5] != BTN_DISABLED) \
? gSaveContext.equips.buttonItems[(button) + 4] \

35
soh/include/ultra64.h
View File

@ -1,35 +0,0 @@
#ifndef ULTRA64_H
#define ULTRA64_H
#include <stddef.h>
#include <stdlib.h>
#include <stdint.h>
#include "ultra64/types.h"
#include "unk.h"
#include "libc/stdarg.h"
#include "libc/stdbool.h"
#include "libc/stddef.h"
#include "libc/stdlib.h"
#include "libc/math.h"
#include "ultra64/exception.h"
#include "ultra64/rcp.h"
#include "ultra64/rdp.h"
#include "ultra64/rsp.h"
#include "ultra64/thread.h"
#include "ultra64/convert.h"
#include "ultra64/time.h"
#include "ultra64/message.h"
#include "ultra64/sptask.h"
#include "ultra64/gu.h"
#include "ultra64/vi.h"
#include "ultra64/pi.h"
#include "ultra64/controller.h"
#include "ultra64/printf.h"
#include "ultra64/mbi.h"
#include "ultra64/pfs.h"
#include "ultra64/motor.h"
#include "ultra64/r4300.h"
#endif

34
soh/include/z64.h
View File

@ -1,8 +1,8 @@
#ifndef Z64_H
#define Z64_H
#include "ultra64.h"
#include "ultra64/gs2dex.h"
#include <libultraship/libultra.h>
#include "unk.h" // this used to get pulled in via ultra64.h
#include "z64save.h"
#include "z64light.h"
#include "z64bgcheck.h"
@ -27,7 +27,7 @@
#include "alignment.h"
#include "sequence.h"
#include "sfx.h"
#include <color.h>
#include <libultraship/color.h>
#include "ichain.h"
#include "regs.h"
@ -45,6 +45,7 @@ namespace Ship
class Scene;
class DisplayList;
};
#include <memory>
#endif
#define SCREEN_WIDTH 320
@ -948,14 +949,6 @@ typedef struct {
typedef struct {
/* 0x00 */ Gfx* opa;
/* 0x04 */ Gfx* xlu;
#ifdef __cplusplus
Ship::DisplayList* opaDL;
Ship::DisplayList* xluDL;
#else
void* opaDL;
void* xluDL;
#endif
} PolygonDlist; // size = 0x8
@ -1016,14 +1009,6 @@ typedef struct {
/* 0x06 */ s16 unk_06;
/* 0x08 */ Gfx* opa;
/* 0x0C */ Gfx* xlu;
#ifdef __cplusplus
Ship::DisplayList* opaDL;
Ship::DisplayList* xluDL;
#else
void* opaDL;
void* xluDL;
#endif
} PolygonDlist2; // size = 0x8
typedef struct {
@ -1087,12 +1072,7 @@ typedef struct {
/* 0x58 */ OSMesgQueue loadQueue;
/* 0x70 */ OSMesg loadMsg;
/* 0x74 */ s16 unk_74[2]; // context-specific data used by the current scene draw config
#ifdef __cplusplus
Ship::Scene* roomToLoad;
#else
void* roomToLoad;
#endif
} RoomContext; // size = 0x78
typedef struct {
@ -1310,13 +1290,7 @@ typedef struct PlayState {
/* 0x000A4 */ s16 sceneNum;
/* 0x000A6 */ u8 sceneConfig;
/* 0x000A7 */ char unk_A7[0x9];
#ifdef __cplusplus
Ship::Scene* sceneSegment;
#else
/* 0x000B0 */ void* sceneSegment;
#endif
/* 0x000B8 */ View view;
/* 0x001E0 */ Camera mainCamera;
/* 0x0034C */ Camera subCameras[NUM_CAMS - SUBCAM_FIRST];

2
soh/include/z64animation.h
View File

@ -1,7 +1,7 @@
#ifndef Z64_ANIMATION_H
#define Z64_ANIMATION_H
#include "ultra64.h"
#include <libultraship/libultra.h>
#include "z64dma.h"
#include "z64math.h"

6
soh/include/z64audio.h
View File

@ -127,7 +127,7 @@ typedef struct {
typedef struct {
/* 0x00 */ s32 order;
/* 0x04 */ s32 npredictors;
/* 0x08 */ s16 book[]; // size 8 * order * npredictors. 8-byte aligned
/* 0x08 */ s16* book; // size 8 * order * npredictors. 8-byte aligned
} AdpcmBook; // size >= 0x8
typedef struct
@ -137,7 +137,7 @@ typedef struct
/* 0x00 */ u32 codec : 4;
/* 0x00 */ u32 medium : 2;
/* 0x00 */ u32 unk_bit26 : 1;
/* 0x00 */ u32 unk_bit25 : 1;
/* 0x00 */ u32 unk_bit25 : 1; // this has been named isRelocated in zret
/* 0x01 */ u32 size : 24;
};
u32 asU32;
@ -819,7 +819,7 @@ typedef struct {
/* 0x0E */ u8 ttl; // duration after which the DMA can be discarded
} SampleDma; // size = 0x10
#include <ultra64/abi.h>
#include <libultraship/libultra/abi.h>
typedef struct {
/* 0x0000 */ char unk_0000;

2
soh/include/z64camera.h
View File

@ -1,7 +1,7 @@
#ifndef Z64CAMERA_H
#define Z64CAMERA_H
#include "ultra64.h"
#include <libultraship/libultra.h>
#include "z64cutscene.h"
#define CAM_STAT_CUT 0

2
soh/include/z64cutscene.h
View File

@ -1,7 +1,7 @@
#ifndef Z64CUTSCENE_H
#define Z64CUTSCENE_H
#include "ultra64.h"
#include <libultraship/libultra.h>
typedef struct {
/* 0x00 */ u16 entrance; // entrance index upon which the cutscene should trigger

2
soh/include/z64dma.h
View File

@ -1,7 +1,7 @@
#ifndef Z64_DMA_H
#define Z64_DMA_H
#include "ultra64.h"
#include <libultraship/libultra.h>
typedef struct {
/* 0x00 */ uintptr_t vromAddr; // VROM address (source)

2
soh/include/z64effect.h
View File

@ -1,7 +1,7 @@
#ifndef Z64EFFECT_H
#define Z64EFFECT_H
#include <color.h>
#include <libultraship/color.h>
struct GraphicsContext;
struct PlayState;

2
soh/include/z64elf_message.h
View File

@ -1,7 +1,7 @@
#ifndef Z64ELF_MESSAGE_H
#define Z64ELF_MESSAGE_H
#include "ultra64.h"
#include <libultraship/libultra.h>
// Checks the condition and exits the script if the check passes
#define ELF_MSG_TYPE_CHECK 0

6
soh/include/z64light.h
View File

@ -1,10 +1,10 @@
#ifndef Z64LIGHT_H
#define Z64LIGHT_H
#include "ultra64.h"
#include "ultra64/gbi.h"
#include <libultraship/libultra.h>
#include <libultraship/libultra/gbi.h>
#include "z64math.h"
#include <color.h>
#include <libultraship/color.h>
typedef struct {
/* 0x0 */ s16 x;

2
soh/include/z64map_mark.h
View File

@ -1,7 +1,7 @@
#ifndef Z64MAP_MARK_H
#define Z64MAP_MARK_H
#include "ultra64.h"
#include <libultraship/libultra.h>
#define MAP_MARK_NONE -1
#define MAP_MARK_CHEST 0

3
soh/include/z64math.h
View File

@ -1,7 +1,8 @@
#ifndef Z64MATH_H
#define Z64MATH_H
#include "ultra64.h"
#include <libultraship/libultra.h>
#include <include/libc/math.h>
#define VEC_SET(V,X,Y,Z) (V).x=(X);(V).y=(Y);(V).z=(Z)

2
soh/include/z64save.h
View File

@ -1,7 +1,7 @@
#ifndef Z64SAVE_H
#define Z64SAVE_H
#include "ultra64.h"
#include <libultraship/libultra.h>
#include "z64math.h"
#include "z64audio.h"
#include "soh/Enhancements/randomizer/randomizerTypes.h"

4
soh/include/z64transition.h
View File

@ -1,8 +1,8 @@
#ifndef Z64TRANSITION_H
#define Z64TRANSITION_H
#include "ultra64.h"
#include <color.h>
#include <libultraship/libultra.h>
#include <libultraship/color.h>
typedef struct {
f32 unk_0;

2
soh/soh/CrashHandlerExp.h
View File

@ -1,4 +1,4 @@
#include <CrashHandler.h>
#include <libultraship/bridge.h>
#ifdef __cplusplus

16
soh/soh/Enhancements/bootcommands.c
View File

@ -2,15 +2,13 @@
#include "gameconsole.h"
#include <macros.h>
#include <z64.h>
#include <ultra64.h>
#include <libultraship/libultra.h>
#include <libultraship/bridge.h>
#include <functions.h>
#include <variables.h>
#include <string.h>
#include <stdarg.h>
#include <z64.h>
#include <ultra64/gbi.h>
#include <ultra64/gs2dex.h>
#include <ultra64/controller.h>
uint8_t gLoadFileSelect = 0, gSkipLogoTest = 0;
@ -22,12 +20,12 @@ static BootCommand sCommands[] = { { "--skiplogo", BootCommands_Command_SkipLogo
void BootCommands_Init()
{
CVar_RegisterS32("gDebugEnabled", 0);
CVar_RegisterS32("gLanguages", LANGUAGE_ENG);
CVar_RegisterS32("gInvertYAxis", 1);
CVar_SetS32("gRandoGenerating", 0); // Clear when a crash happened during rando seed generation
CVarRegisterInteger("gDebugEnabled", 0);
CVarRegisterInteger("gLanguages", LANGUAGE_ENG);
CVarRegisterInteger("gInvertYAxis", 1);
CVarSetInteger("gRandoGenerating", 0); // Clear when a crash happened during rando seed generation
#if defined(__SWITCH__) || defined(__WIIU__)
CVar_RegisterS32("gControlNav", 1); // always enable controller nav on switch/wii u
CVarRegisterInteger("gControlNav", 1); // always enable controller nav on switch/wii u
#endif
}

2
soh/soh/Enhancements/bootcommands.h
View File

@ -1,6 +1,6 @@
#ifndef _BOOTCOMMANDS_H_
#define _BOOTCOMMANDS_H_
#include <ultra64.h>
#include <libultraship/libultra.h>
#include <z64.h>
typedef s32 (*BootCommandFunc)(char** argv, s32 argc); // Returns the number of arguments it read

20
soh/soh/Enhancements/controls/GameControlEditor.cpp
View File

@ -8,8 +8,8 @@
#include <ImGui/imgui.h>
#include <ImGui/imgui_internal.h>
#include <Cvar.h>
#include <UltraController.h>
#include <libultraship/bridge.h>
#include <libultraship/libultra/controller.h>
#include <Utils/StringHelper.h>
#include <ImGuiImpl.h>
@ -109,7 +109,7 @@ namespace GameControlEditor {
// Draw a button mapping setting consisting of a padded label and button dropdown.
// excludedButtons indicates which buttons are unavailable to choose from.
void DrawMapping(CustomButtonMap& mapping, float labelWidth, N64ButtonMask excludedButtons) {
N64ButtonMask currentButton = CVar_GetS32(mapping.cVarName, mapping.defaultBtn);
N64ButtonMask currentButton = CVarGetInteger(mapping.cVarName, mapping.defaultBtn);
const char* preview;
if (buttonNames.contains(currentButton)) {
@ -134,7 +134,7 @@ namespace GameControlEditor {
continue;
}
if (ImGui::Selectable(i->second, i->first == currentButton)) {
CVar_SetS32(mapping.cVarName, i->first);
CVarSetInteger(mapping.cVarName, i->first);
}
}
ImGui::EndCombo();
@ -158,11 +158,11 @@ namespace GameControlEditor {
ImGui::SetCursorPos(ImVec2(cursor.x + 5, cursor.y + 5));
UIWidgets::EnhancementCheckbox("Customize Ocarina Controls", "gCustomOcarinaControls");
if (CVar_GetS32("gCustomOcarinaControls", 0) == 1) {
if (CVarGetInteger("gCustomOcarinaControls", 0) == 1) {
if (ImGui::BeginTable("tableCustomMainOcarinaControls", 2, ImGuiTableFlags_SizingStretchProp)) {
float labelWidth;
N64ButtonMask disableMask = BTN_B;
if (CVar_GetS32("gDpadOcarina", 0)) {
if (CVarGetInteger("gDpadOcarina", 0)) {
disableMask |= BTN_DUP | BTN_DDOWN | BTN_DLEFT | BTN_DRIGHT;
}
@ -242,11 +242,11 @@ namespace GameControlEditor {
UIWidgets::PaddedEnhancementCheckbox("Disable Auto-Centering in First-Person View", "gDisableAutoCenterViewFirstPerson");
DrawHelpIcon("Prevents the C-Up view from auto-centering, allowing for Gyro Aiming");
UIWidgets::PaddedEnhancementCheckbox("Enable Custom Aiming/First-Person sensitivity", "gEnableFirstPersonSensitivity", true, false);
if (CVar_GetS32("gEnableFirstPersonSensitivity", 0)) {
if (CVarGetInteger("gEnableFirstPersonSensitivity", 0)) {
UIWidgets::EnhancementSliderFloat("Aiming/First-Person Sensitivity: %d %%", "##FirstPersonSensitivity",
"gFirstPersonCameraSensitivity", 0.01f, 5.0f, "", 1.0f, true, true);
} else {
CVar_SetFloat("gFirstPersonCameraSensitivity", 1.0f);
CVarSetFloat("gFirstPersonCameraSensitivity", 1.0f);
}
SohImGui::EndGroupPanel();
@ -298,7 +298,7 @@ namespace GameControlEditor {
SohImGui::BeginGroupPanel("Misc Controls", ImGui::GetContentRegionAvail());
UIWidgets::PaddedEnhancementCheckbox("Enable walk speed modifiers", "gEnableWalkModify", true, false);
DrawHelpIcon("Hold the assigned button to change the maximum walking speed\nTo change the assigned button, go into the Ports tabs above");
if (CVar_GetS32("gEnableWalkModify", 0)) {
if (CVarGetInteger("gEnableWalkModify", 0)) {
UIWidgets::Spacer(5);
SohImGui::BeginGroupPanel("Walk Modifier", ImGui::GetContentRegionAvail());
UIWidgets::PaddedEnhancementCheckbox("Toggle modifier instead of holding", "gWalkSpeedToggle", true, false);
@ -317,7 +317,7 @@ namespace GameControlEditor {
void DrawUI(bool& open) {
if (!open) {
CVar_SetS32("gGameControlEditorEnabled", false);
CVarSetInteger("gGameControlEditorEnabled", false);
return;
}

840
soh/soh/Enhancements/cosmetics/CosmeticsEditor.cpp
View File

File diff suppressed because it is too large Load Diff

2
soh/soh/Enhancements/cosmetics/CosmeticsEditor.h
View File

@ -2,7 +2,7 @@
#include <ImGuiImpl.h>
#define PATCH_GFX(path, name, cvar, index, instruction) \
if (CVar_GetS32(cvar, 0)) { \
if (CVarGetInteger(cvar, 0)) { \
ResourceMgr_PatchGfxByName(path, name, index, instruction); \
} else { \
ResourceMgr_UnpatchGfxByName(path, name); \

2
soh/soh/Enhancements/crowd-control/CrowdControl.cpp
View File

@ -1,7 +1,7 @@
#ifdef ENABLE_CROWD_CONTROL
#include "CrowdControl.h"
#include <Cvar.h>
#include <libultraship/bridge.h>
#include <Console.h>
#include <ImGuiImpl.h>
#include <nlohmann/json.hpp>

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

@ -27,7 +27,7 @@ extern "C" {
extern PlayState* gPlayState;
}
#include <Cvar.h>
#include <libultraship/bridge.h>
#include "overlays/actors/ovl_En_Niw/z_en_niw.h"
#define CMD_REGISTER SohImGui::GetConsole()->AddCommand
@ -944,9 +944,9 @@ static bool SetCVarHandler(std::shared_ptr<Ship::Console> Console, const std::ve
int vType = CheckVarType(args[2]);
if (vType == VARTYPE_STRING)
CVar_SetString(args[1].c_str(), args[2].c_str());
CVarSetString(args[1].c_str(), args[2].c_str());
else if (vType == VARTYPE_FLOAT)
CVar_SetFloat((char*)args[1].c_str(), std::stof(args[2]));
CVarSetFloat((char*)args[1].c_str(), std::stof(args[2]));
else if (vType == VARTYPE_RGBA)
{
uint32_t val = std::stoul(&args[2].c_str()[1], nullptr, 16);
@ -955,12 +955,12 @@ static bool SetCVarHandler(std::shared_ptr<Ship::Console> Console, const std::ve
clr.g = val >> 16;
clr.b = val >> 8;
clr.a = val & 0xFF;
CVar_SetRGBA((char*)args[1].c_str(), clr);
CVarSetColor((char*)args[1].c_str(), clr);
}
else
CVar_SetS32(args[1].c_str(), std::stoi(args[2]));
CVarSetInteger(args[1].c_str(), std::stoi(args[2]));
CVar_Save();
CVarSave();
//SohImGui::GetConsole()->SendInfoMessage("[SOH] Updated player position to [ %.2f, %.2f, %.2f ]", pos.x, pos.y, pos.z);
return CMD_SUCCESS;
@ -970,18 +970,18 @@ static bool GetCVarHandler(std::shared_ptr<Ship::Console> Console, const std::ve
if (args.size() < 2)
return CMD_FAILED;
CVar* cvar = CVar_Get(args[1].c_str());
auto cvar = CVarGet(args[1].c_str());
if (cvar != nullptr)
{
if (cvar->Type == CVarType::S32)
SohImGui::GetConsole()->SendInfoMessage("[SOH] Variable %s is %i", args[1].c_str(), cvar->value.ValueS32);
else if (cvar->Type == CVarType::Float)
SohImGui::GetConsole()->SendInfoMessage("[SOH] Variable %s is %f", args[1].c_str(), cvar->value.ValueFloat);
else if (cvar->Type == CVarType::String)
SohImGui::GetConsole()->SendInfoMessage("[SOH] Variable %s is %s", args[1].c_str(), cvar->value.ValueStr);
else if (cvar->Type == CVarType::RGBA)
SohImGui::GetConsole()->SendInfoMessage("[SOH] Variable %s is %08X", args[1].c_str(), cvar->value.ValueRGBA);
if (cvar->Type == Ship::ConsoleVariableType::Integer)
SohImGui::GetConsole()->SendInfoMessage("[SOH] Variable %s is %i", args[1].c_str(), cvar->Integer);
else if (cvar->Type == Ship::ConsoleVariableType::Float)
SohImGui::GetConsole()->SendInfoMessage("[SOH] Variable %s is %f", args[1].c_str(), cvar->Float);
else if (cvar->Type == Ship::ConsoleVariableType::String)
SohImGui::GetConsole()->SendInfoMessage("[SOH] Variable %s is %s", args[1].c_str(), cvar->String.c_str());
else if (cvar->Type == Ship::ConsoleVariableType::Color)
SohImGui::GetConsole()->SendInfoMessage("[SOH] Variable %s is %08X", args[1].c_str(), cvar->Color);
}
else
{
@ -1159,5 +1159,5 @@ void DebugConsole_Init(void) {
CMD_REGISTER("cucco_storm", { CuccoStormHandler, "Cucco Storm" });
CVar_Load();
CVarLoad();
}

4
soh/soh/Enhancements/debugger/actorViewer.cpp
View File

@ -7,7 +7,7 @@
#include <bit>
#include <map>
#include <string>
#include <Cvar.h>
#include <libultraship/bridge.h>
extern "C" {
#include <z64.h>
@ -531,7 +531,7 @@ void PopulateActorDropdown(int i, std::vector<Actor*>& data) {
void DrawActorViewer(bool& open) {
if (!open) {
CVar_SetS32("gActorViewerEnabled", 0);
CVarSetInteger("gActorViewerEnabled", 0);
return;
}

90
soh/soh/Enhancements/debugger/colViewer.cpp
View File

@ -6,7 +6,7 @@
#include <vector>
#include <string>
#include <cmath>
#include <Cvar.h>
#include <libultraship/bridge.h>
extern "C" {
#include <z64.h>
@ -53,7 +53,7 @@ static std::vector<Vtx> sphereVtx;
// Draws the ImGui window for the collision viewer
void DrawColViewerWindow(bool& open) {
if (!open) {
CVar_SetS32("gCollisionViewerEnabled", 0);
CVarSetInteger("gCollisionViewerEnabled", 0);
return;
}
@ -315,7 +315,7 @@ void InitGfx(std::vector<Gfx>& gfx, ColRenderSetting setting) {
alpha = 0xFF;
}
if (CVar_GetS32("gColViewerDecal", 0) != 0) {
if (CVarGetInteger("gColViewerDecal", 0) != 0) {
rm |= ZMODE_DEC;
} else if (setting == ColRenderSetting::Transparent) {
rm |= ZMODE_XLU;
@ -327,7 +327,7 @@ void InitGfx(std::vector<Gfx>& gfx, ColRenderSetting setting) {
gfx.push_back(gsDPSetCycleType(G_CYC_1CYCLE));
gfx.push_back(gsDPSetRenderMode(rm | blc1, rm | blc2));
if (CVar_GetS32("gColViewerShaded", 0) != 0) {
if (CVarGetInteger("gColViewerShaded", 0) != 0) {
gfx.push_back(gsDPSetCombineMode(G_CC_MODULATERGB_PRIM_ENVA, G_CC_MODULATERGB_PRIM_ENVA));
gfx.push_back(gsSPLoadGeometryMode(G_CULL_BACK | G_ZBUFFER | G_LIGHTING));
} else {
@ -340,9 +340,9 @@ void InitGfx(std::vector<Gfx>& gfx, ColRenderSetting setting) {
// Draws a dynapoly structure (scenes or Bg Actors)
void DrawDynapoly(std::vector<Gfx>& dl, CollisionHeader* col, int32_t bgId) {
uint32_t colorR = CVar_GetS32("gColViewerColorNormalR", 255);
uint32_t colorG = CVar_GetS32("gColViewerColorNormalG", 255);
uint32_t colorB = CVar_GetS32("gColViewerColorNormalB", 255);
uint32_t colorR = CVarGetInteger("gColViewerColorNormalR", 255);
uint32_t colorG = CVarGetInteger("gColViewerColorNormalG", 255);
uint32_t colorB = CVarGetInteger("gColViewerColorNormalB", 255);
uint32_t colorA = 255;
uint32_t lastColorR = colorR;
@ -359,35 +359,35 @@ void DrawDynapoly(std::vector<Gfx>& dl, CollisionHeader* col, int32_t bgId) {
CollisionPoly* poly = &col->polyList[i];
if (SurfaceType_IsHookshotSurface(&gPlayState->colCtx, poly, bgId)) {
colorR = CVar_GetS32("gColViewerColorHookshotR", 128);
colorG = CVar_GetS32("gColViewerColorHookshotG", 128);
colorB = CVar_GetS32("gColViewerColorHookshotB", 255);
colorR = CVarGetInteger("gColViewerColorHookshotR", 128);
colorG = CVarGetInteger("gColViewerColorHookshotG", 128);
colorB = CVarGetInteger("gColViewerColorHookshotB", 255);
} else if (func_80041D94(&gPlayState->colCtx, poly, bgId) > 0x01) {
colorR = CVar_GetS32("gColViewerColorInteractableR", 192);
colorG = CVar_GetS32("gColViewerColorInteractableG", 0);
colorB = CVar_GetS32("gColViewerColorInteractableB", 192);
colorR = CVarGetInteger("gColViewerColorInteractableR", 192);
colorG = CVarGetInteger("gColViewerColorInteractableG", 0);
colorB = CVarGetInteger("gColViewerColorInteractableB", 192);
} else if (func_80041E80(&gPlayState->colCtx, poly, bgId) == 0x0C) {
colorR = CVar_GetS32("gColViewerColorVoidR", 255);
colorG = CVar_GetS32("gColViewerColorVoidG", 0);
colorB = CVar_GetS32("gColViewerColorVoidB", 0);
colorR = CVarGetInteger("gColViewerColorVoidR", 255);
colorG = CVarGetInteger("gColViewerColorVoidG", 0);
colorB = CVarGetInteger("gColViewerColorVoidB", 0);
} else if (SurfaceType_GetSceneExitIndex(&gPlayState->colCtx, poly, bgId) ||
func_80041E80(&gPlayState->colCtx, poly, bgId) == 0x05) {
colorR = CVar_GetS32("gColViewerColorEntranceR", 0);
colorG = CVar_GetS32("gColViewerColorEntranceG", 255);
colorB = CVar_GetS32("gColViewerColorEntranceB", 0);
colorR = CVarGetInteger("gColViewerColorEntranceR", 0);
colorG = CVarGetInteger("gColViewerColorEntranceG", 255);
colorB = CVarGetInteger("gColViewerColorEntranceB", 0);
} else if (func_80041D4C(&gPlayState->colCtx, poly, bgId) != 0 ||
SurfaceType_IsWallDamage(&gPlayState->colCtx, poly, bgId)) {
colorR = CVar_GetS32("gColViewerColorSpecialSurfaceR", 192);
colorG = CVar_GetS32("gColViewerColorSpecialSurfaceG", 255);
colorB = CVar_GetS32("gColViewerColorSpecialSurfaceB", 192);
colorR = CVarGetInteger("gColViewerColorSpecialSurfaceR", 192);
colorG = CVarGetInteger("gColViewerColorSpecialSurfaceG", 255);
colorB = CVarGetInteger("gColViewerColorSpecialSurfaceB", 192);
} else if (SurfaceType_GetSlope(&gPlayState->colCtx, poly, bgId) == 0x01) {
colorR = CVar_GetS32("gColViewerColorSlopeR", 255);
colorG = CVar_GetS32("gColViewerColorSlopeG", 255);
colorB = CVar_GetS32("gColViewerColorSlopeB", 128);
colorR = CVarGetInteger("gColViewerColorSlopeR", 255);
colorG = CVarGetInteger("gColViewerColorSlopeG", 255);
colorB = CVarGetInteger("gColViewerColorSlopeB", 128);
} else {
colorR = CVar_GetS32("gColViewerColorNormalR", 255);
colorG = CVar_GetS32("gColViewerColorNormalG", 255);
colorB = CVar_GetS32("gColViewerColorNormalB", 255);
colorR = CVarGetInteger("gColViewerColorNormalR", 255);
colorG = CVarGetInteger("gColViewerColorNormalG", 255);
colorB = CVarGetInteger("gColViewerColorNormalB", 255);
}
if (colorR != lastColorR || colorG != lastColorG || colorB != lastColorB) {
@ -435,9 +435,9 @@ void DrawDynapoly(std::vector<Gfx>& dl, CollisionHeader* col, int32_t bgId) {
// Draws the scene
void DrawSceneCollision() {
ColRenderSetting showSceneColSetting = (ColRenderSetting)CVar_GetS32("gColViewerScene", 0);
ColRenderSetting showSceneColSetting = (ColRenderSetting)CVarGetInteger("gColViewerScene", 0);
if (showSceneColSetting == ColRenderSetting::Disabled || CVar_GetS32("gColViewerEnabled", 0) == 0) {
if (showSceneColSetting == ColRenderSetting::Disabled || CVarGetInteger("gColViewerEnabled", 0) == 0) {
return;
}
@ -450,8 +450,8 @@ void DrawSceneCollision() {
// Draws all Bg Actors
void DrawBgActorCollision() {
ColRenderSetting showBgActorSetting = (ColRenderSetting)CVar_GetS32("gColViewerBgActors", 0);
if (showBgActorSetting == ColRenderSetting::Disabled || CVar_GetS32("gColViewerEnabled", 0) == 0) {
ColRenderSetting showBgActorSetting = (ColRenderSetting)CVarGetInteger("gColViewerBgActors", 0);
if (showBgActorSetting == ColRenderSetting::Disabled || CVarGetInteger("gColViewerEnabled", 0) == 0) {
return;
}
@ -575,8 +575,8 @@ void DrawColCheckList(std::vector<Gfx>& dl, Collider** objects, int32_t count) {
// Draws all Col Check objects
void DrawColCheckCollision() {
ColRenderSetting showColCheckSetting = (ColRenderSetting)CVar_GetS32("gColViewerColCheck", 0);
if (showColCheckSetting == ColRenderSetting::Disabled || CVar_GetS32("gColViewerEnabled", 0) == 0) {
ColRenderSetting showColCheckSetting = (ColRenderSetting)CVarGetInteger("gColViewerColCheck", 0);
if (showColCheckSetting == ColRenderSetting::Disabled || CVarGetInteger("gColViewerEnabled", 0) == 0) {
return;
}
@ -586,14 +586,14 @@ void DrawColCheckCollision() {
CollisionCheckContext& col = gPlayState->colChkCtx;
dl.push_back(gsDPSetPrimColor(0, 0, CVar_GetS32("gColViewerColorOCR", 255), CVar_GetS32("gColViewerColorOCG", 255),
CVar_GetS32("gColViewerColorOCB", 255), 255));
dl.push_back(gsDPSetPrimColor(0, 0, CVarGetInteger("gColViewerColorOCR", 255), CVarGetInteger("gColViewerColorOCG", 255),
CVarGetInteger("gColViewerColorOCB", 255), 255));
DrawColCheckList(dl, col.colOC, col.colOCCount);
dl.push_back(gsDPSetPrimColor(0, 0, CVar_GetS32("gColViewerColorACR", 0), CVar_GetS32("gColViewerColorACG", 0),
CVar_GetS32("gColViewerColorACB", 255), 255));
dl.push_back(gsDPSetPrimColor(0, 0, CVarGetInteger("gColViewerColorACR", 0), CVarGetInteger("gColViewerColorACG", 0),
CVarGetInteger("gColViewerColorACB", 255), 255));
DrawColCheckList(dl, col.colAC, col.colACCount);
dl.push_back(gsDPSetPrimColor(0, 0, CVar_GetS32("gColViewerColorATR", 255), CVar_GetS32("gColViewerColorATG", 0),
CVar_GetS32("gColViewerColorATB", 0), 255));
dl.push_back(gsDPSetPrimColor(0, 0, CVarGetInteger("gColViewerColorATR", 255), CVarGetInteger("gColViewerColorATG", 0),
CVarGetInteger("gColViewerColorATB", 0), 255));
DrawColCheckList(dl, col.colAT, col.colATCount);
}
@ -628,8 +628,8 @@ extern "C" f32 zdWaterBoxMinY;
// Draws all waterboxes
void DrawWaterboxList() {
ColRenderSetting showWaterboxSetting = (ColRenderSetting)CVar_GetS32("gColViewerWaterbox", 0);
if (showWaterboxSetting == ColRenderSetting::Disabled || CVar_GetS32("gColViewerEnabled", 0) == 0) {
ColRenderSetting showWaterboxSetting = (ColRenderSetting)CVarGetInteger("gColViewerWaterbox", 0);
if (showWaterboxSetting == ColRenderSetting::Disabled || CVarGetInteger("gColViewerEnabled", 0) == 0) {
return;
}
@ -637,9 +637,9 @@ void DrawWaterboxList() {
InitGfx(dl, showWaterboxSetting);
dl.push_back(gsSPMatrix(&gMtxClear, G_MTX_MODELVIEW | G_MTX_LOAD | G_MTX_NOPUSH));
dl.push_back(gsDPSetPrimColor(0, 0, CVar_GetS32("gColViewerColorWaterboxR", 0),
CVar_GetS32("gColViewerColorWaterboxG", 0),
CVar_GetS32("gColViewerColorWaterboxB", 255), 255));
dl.push_back(gsDPSetPrimColor(0, 0, CVarGetInteger("gColViewerColorWaterboxR", 0),
CVarGetInteger("gColViewerColorWaterboxG", 0),
CVarGetInteger("gColViewerColorWaterboxB", 255), 255));
CollisionHeader* col = gPlayState->colCtx.colHeader;
for (int32_t waterboxIndex = 0; waterboxIndex < col->numWaterBoxes; waterboxIndex++) {

6
soh/soh/Enhancements/debugger/debugSaveEditor.cpp
View File

@ -9,7 +9,7 @@
#include <bit>
#include <map>
#include <string>
#include <Cvar.h>
#include <libultraship/bridge.h>
extern "C" {
#include <z64.h>
@ -1622,7 +1622,7 @@ void DrawPlayerTab() {
ImGui::SameLine();
ImGui::InputScalar("C Right", ImGuiDataType_U8, &gSaveContext.equips.buttonItems[3], &one, NULL);
if (CVar_GetS32("gDpadEquips", 0)) {
if (CVarGetInteger("gDpadEquips", 0)) {
ImGui::NewLine();
ImGui::Text("Current D-pad Equips");
ImGui::InputScalar("D-pad Up ", ImGuiDataType_U8, &gSaveContext.equips.buttonItems[4], &one, NULL); // Two spaces at the end for aligning, not elegant but it's working
@ -1663,7 +1663,7 @@ void DrawPlayerTab() {
void DrawSaveEditor(bool& open) {
if (!open) {
CVar_SetS32("gSaveEditorEnabled", 0);
CVarSetInteger("gSaveEditorEnabled", 0);
return;
}

2
soh/soh/Enhancements/enemyrandomizer.cpp
View File

@ -232,7 +232,7 @@ extern "C" uint8_t GetRandomizedEnemy(PlayState* play, int16_t *actorId, f32 *po
}
EnemyEntry GetRandomizedEnemyEntry(uint32_t seed) {
if (CVar_GetS32("gSeededRandomizedEnemies", 0) && gSaveContext.n64ddFlag) {
if (CVarGetInteger("gSeededRandomizedEnemies", 0) && gSaveContext.n64ddFlag) {
uint32_t finalSeed = seed + gSaveContext.seedIcons[0] + gSaveContext.seedIcons[1] + gSaveContext.seedIcons[2] +
gSaveContext.seedIcons[3] + gSaveContext.seedIcons[4];
Random_Init(finalSeed);

2
soh/soh/Enhancements/enemyrandomizer.h
View File

@ -1,6 +1,6 @@
#pragma once
#include <Cvar.h>
#include <libultraship/bridge.h>
typedef struct EnemyEntry {
int16_t id;

8
soh/soh/Enhancements/gameconsole.c
View File

@ -2,15 +2,15 @@
#include "../OTRGlobals.h"
#include <macros.h>
#include <z64.h>
#include <ultra64.h>
#include <libultraship/libultra.h>
#include <functions.h>
#include <variables.h>
#include <stdarg.h>
#include <string.h>
#include <z64.h>
#include <ultra64/gbi.h>
#include <ultra64/gs2dex.h>
#include <ultra64/controller.h>
#include <libultraship/libultra/gbi.h>
#include <libultraship/libultra/gs2dex.h>
#include <libultraship/libultra/controller.h>
#include <string.h> /* memcpy */
#include <stdio.h>
#include <stdlib.h>

4
soh/soh/Enhancements/gameconsole.h
View File

@ -1,9 +1,9 @@
#ifndef _GAMECONSOLE_H_
#define _GAMECONSOLE_H_
#include <ultra64.h>
#include <libultraship/libultra.h>
#include <z64.h>
#include <Cvar.h>
#include <libultraship/bridge.h>
#define MAX_CVARS 2048

6
soh/soh/Enhancements/gameplaystats.cpp
View File

@ -5,7 +5,7 @@
#include <map>
#include <string>
#include <Cvar.h>
#include <libultraship/bridge.h>
#include <Hooks.h>
extern "C" {
@ -110,7 +110,7 @@ void DisplayStatIfNonZero(const char* text, uint32_t value) {
void DrawStatsTracker(bool& open) {
if (!open) {
CVar_SetS32("gGameplayStatsEnabled", 0);
CVarSetInteger("gGameplayStatsEnabled", 0);
return;
}
@ -294,7 +294,7 @@ void DrawStatsTracker(bool& open) {
DisplayStat("Sword Swings: ", gSaveContext.sohStats.count[COUNT_SWORD_SWINGS]);
DisplayStat("Steps Taken: ", gSaveContext.sohStats.count[COUNT_STEPS]);
// If using MM Bunny Hood enhancement, show how long it's been equipped (not counting pause time)
if (CVar_GetS32("gMMBunnyHood", 0) || gSaveContext.sohStats.count[COUNT_TIME_BUNNY_HOOD] > 0) {
if (CVarGetInteger("gMMBunnyHood", 0) || gSaveContext.sohStats.count[COUNT_TIME_BUNNY_HOOD] > 0) {
DisplayTimeHHMMSS(gSaveContext.sohStats.count[COUNT_TIME_BUNNY_HOOD] / 2, "Bunny Hood Time: ", COLOR_WHITE);
}
DisplayStat("Rolls: ", gSaveContext.sohStats.count[COUNT_ROLLS]);

14
soh/soh/Enhancements/presets.cpp
View File

@ -3,12 +3,12 @@
#include <string>
#include <cstdint>
#include <ImGuiImpl.h>
#include <Cvar.h>
#include <libultraship/bridge.h>
#include "soh/UIWidgets.hpp"
void clearCvars(std::vector<const char*> cvarsToClear) {
for(const char* cvar : cvarsToClear) {
CVar_Clear(cvar);
CVarClear(cvar);
}
}
@ -16,13 +16,13 @@ void applyPreset(std::vector<PresetEntry> entries) {
for(auto& [cvar, type, value] : entries) {
switch (type) {
case PRESET_ENTRY_TYPE_S32:
CVar_SetS32(cvar, std::get<int32_t>(value));
CVarSetInteger(cvar, std::get<int32_t>(value));
break;
case PRESET_ENTRY_TYPE_FLOAT:
CVar_SetFloat(cvar, std::get<float>(value));
CVarSetFloat(cvar, std::get<float>(value));
break;
case PRESET_ENTRY_TYPE_STRING:
CVar_SetString(cvar, std::get<const char*>(value));
CVarSetString(cvar, std::get<const char*>(value));
break;
}
}
@ -31,7 +31,7 @@ void applyPreset(std::vector<PresetEntry> entries) {
void DrawPresetSelector(PresetType presetTypeId) {
const std::string presetTypeCvar = "gPreset" + std::to_string(presetTypeId);
const PresetTypeDefinition presetTypeDef = presetTypes.at(presetTypeId);
const uint16_t selectedPresetId = CVar_GetS32(presetTypeCvar.c_str(), 0);
const uint16_t selectedPresetId = CVarGetInteger(presetTypeCvar.c_str(), 0);
const PresetDefinition selectedPresetDef = presetTypeDef.presets.at(selectedPresetId);
std::string comboboxTooltip = "";
for ( auto iter = presetTypeDef.presets.begin(); iter != presetTypeDef.presets.end(); ++iter ) {
@ -43,7 +43,7 @@ void DrawPresetSelector(PresetType presetTypeId) {
if (ImGui::BeginCombo("##PresetsComboBox", selectedPresetDef.label)) {
for ( auto iter = presetTypeDef.presets.begin(); iter != presetTypeDef.presets.end(); ++iter ) {
if (ImGui::Selectable(iter->second.label, iter->first == selectedPresetId)) {
CVar_SetS32(presetTypeCvar.c_str(), iter->first);
CVarSetInteger(presetTypeCvar.c_str(), iter->first);
}
}

14
soh/soh/Enhancements/randomizer/3drando/rando_main.cpp
View File

@ -5,9 +5,9 @@
#include "location_access.hpp"
#include "rando_main.hpp"
// #include <soh/Enhancements/randomizer.h>
#include <Cvar.h>
#include <libultraship/bridge.h>
#include <Window.h>
#include <ultra64/types.h>
#include <libultraship/libultra/types.h>
#define TICKS_PER_SEC 268123480.0
@ -17,14 +17,14 @@ void RandoMain::GenerateRando(std::unordered_map<RandomizerSettingKey, u8> cvarS
LocationTable_Init();
// std::string settingsFileName = "./randomizer/latest_settings.json";
// CVar_SetString("gLoadedPreset", settingsFileName.c_str());
// CVarSetString("gLoadedPreset", settingsFileName.c_str());
std::string fileName = Ship::Window::GetPathRelativeToAppDirectory(GenerateRandomizer(cvarSettings, excludedLocations).c_str());
CVar_SetString("gSpoilerLog", fileName.c_str());
CVarSetString("gSpoilerLog", fileName.c_str());
CVar_Save();
CVar_Load();
CVar_SetS32("gNewSeedGenerated", 1);
CVarSave();
CVarLoad();
CVarSetInteger("gNewSeedGenerated", 1);
}
std::array<Item, KEY_ENUM_MAX>* RandoMain::GetFullItemTable() {

6
soh/soh/Enhancements/randomizer/draw.cpp
View File

@ -1,4 +1,4 @@
#include <Cvar.h>
#include <libultraship/bridge.h>
#include "draw.h"
#include "z64.h"
#include "macros.h"
@ -12,7 +12,7 @@
extern "C" void Randomizer_DrawSmallKey(PlayState* play, GetItemEntry* getItemEntry) {
s32 pad;
s8 isColoredKeysEnabled = CVar_GetS32("gRandoMatchKeyColors", 0);
s8 isColoredKeysEnabled = CVarGetInteger("gRandoMatchKeyColors", 0);
s16 color_slot = getItemEntry->getItemId - RG_FOREST_TEMPLE_SMALL_KEY;
s16 colors[9][3] = {
{ 4, 195, 46 }, // Forest Temple
@ -49,7 +49,7 @@ extern "C" void Randomizer_DrawSmallKey(PlayState* play, GetItemEntry* getItemEn
extern "C" void Randomizer_DrawBossKey(PlayState* play, GetItemEntry* getItemEntry) {
s32 pad;
s8 isColoredKeysEnabled = CVar_GetS32("gRandoMatchKeyColors", 0);
s8 isColoredKeysEnabled = CVarGetInteger("gRandoMatchKeyColors", 0);
s16 color_slot;
color_slot = getItemEntry->getItemId - RG_FOREST_TEMPLE_BOSS_KEY;
s16 colors[6][3] = {

282
soh/soh/Enhancements/randomizer/randomizer.cpp
View File

@ -6,7 +6,7 @@
#include <macros.h>
#include <objects/gameplay_keep/gameplay_keep.h>
#include <functions.h>
#include <Cvar.h>
#include <libultraship/bridge.h>
#include <textures/icon_item_static/icon_item_static.h>
#include <textures/icon_item_24_static/icon_item_24_static.h>
#include <ImGuiImpl.h>
@ -2643,112 +2643,112 @@ RandomizerCheck Randomizer::GetCheckFromRandomizerInf(RandomizerInf randomizerIn
std::thread randoThread;
void GenerateRandomizerImgui() {
CVar_SetS32("gRandoGenerating", 1);
CVar_Save();
CVarSetInteger("gRandoGenerating", 1);
CVarSave();
std::unordered_map<RandomizerSettingKey, u8> cvarSettings;
cvarSettings[RSK_LOGIC_RULES] = CVar_GetS32("gRandomizeLogicRules", RO_LOGIC_GLITCHLESS);
cvarSettings[RSK_ALL_LOCATIONS_REACHABLE] = CVar_GetS32("gRandomizeAllLocationsReachable", RO_GENERIC_ON);
cvarSettings[RSK_FOREST] = CVar_GetS32("gRandomizeForest", RO_FOREST_CLOSED);
cvarSettings[RSK_KAK_GATE] = CVar_GetS32("gRandomizeKakarikoGate", RO_KAK_GATE_CLOSED);
cvarSettings[RSK_DOOR_OF_TIME] = CVar_GetS32("gRandomizeDoorOfTime", RO_DOOROFTIME_CLOSED);
cvarSettings[RSK_ZORAS_FOUNTAIN] = CVar_GetS32("gRandomizeZorasFountain", 0);
cvarSettings[RSK_STARTING_AGE] = CVar_GetS32("gRandomizeStartingAge", RO_AGE_CHILD);
cvarSettings[RSK_GERUDO_FORTRESS] = CVar_GetS32("gRandomizeGerudoFortress", RO_GF_NORMAL);
cvarSettings[RSK_RAINBOW_BRIDGE] = CVar_GetS32("gRandomizeRainbowBridge", RO_BRIDGE_VANILLA);
cvarSettings[RSK_RAINBOW_BRIDGE_STONE_COUNT] = CVar_GetS32("gRandomizeStoneCount", 3);
cvarSettings[RSK_RAINBOW_BRIDGE_MEDALLION_COUNT] = CVar_GetS32("gRandomizeMedallionCount", 6);
cvarSettings[RSK_RAINBOW_BRIDGE_REWARD_COUNT] = CVar_GetS32("gRandomizeRewardCount", 9);
cvarSettings[RSK_RAINBOW_BRIDGE_DUNGEON_COUNT] = CVar_GetS32("gRandomizeDungeonCount", 8);
cvarSettings[RSK_RAINBOW_BRIDGE_TOKEN_COUNT] = CVar_GetS32("gRandomizeTokenCount", 100);
cvarSettings[RSK_GANONS_TRIALS] = CVar_GetS32("gRandomizeGanonTrial", RO_GANONS_TRIALS_SET_NUMBER);
cvarSettings[RSK_TRIAL_COUNT] = CVar_GetS32("gRandomizeGanonTrialCount", 6);
cvarSettings[RSK_STARTING_OCARINA] = CVar_GetS32("gRandomizeStartingOcarina", 0);
cvarSettings[RSK_SHUFFLE_OCARINA] = CVar_GetS32("gRandomizeShuffleOcarinas", 0) ||
CVar_GetS32("gRandomizeStartingOcarina", 0);
cvarSettings[RSK_STARTING_KOKIRI_SWORD] = CVar_GetS32("gRandomizeStartingKokiriSword", 0);
cvarSettings[RSK_SHUFFLE_KOKIRI_SWORD] = CVar_GetS32("gRandomizeShuffleKokiriSword", 0) ||
CVar_GetS32("gRandomizeStartingKokiriSword", 0);
cvarSettings[RSK_STARTING_DEKU_SHIELD] = CVar_GetS32("gRandomizeStartingDekuShield", 0);
cvarSettings[RSK_STARTING_SKULLTULA_TOKEN] = CVar_GetS32("gRandomizeStartingSkulltulaToken", 0);
cvarSettings[RSK_STARTING_MAPS_COMPASSES] = CVar_GetS32("gRandomizeStartingMapsCompasses", RO_DUNGEON_ITEM_LOC_OWN_DUNGEON);
cvarSettings[RSK_SHUFFLE_DUNGEON_REWARDS] = CVar_GetS32("gRandomizeShuffleDungeonReward", RO_DUNGEON_REWARDS_END_OF_DUNGEON);
cvarSettings[RSK_SHUFFLE_SONGS] = CVar_GetS32("gRandomizeShuffleSongs", RO_SONG_SHUFFLE_SONG_LOCATIONS);
cvarSettings[RSK_SHUFFLE_TOKENS] = CVar_GetS32("gRandomizeShuffleTokens", RO_TOKENSANITY_OFF);
cvarSettings[RSK_SHOPSANITY] = CVar_GetS32("gRandomizeShopsanity", RO_SHOPSANITY_OFF);
cvarSettings[RSK_SHUFFLE_SCRUBS] = CVar_GetS32("gRandomizeShuffleScrubs", RO_SCRUBS_OFF);
cvarSettings[RSK_SHUFFLE_COWS] = CVar_GetS32("gRandomizeShuffleCows", 0);
cvarSettings[RSK_SHUFFLE_ADULT_TRADE] = CVar_GetS32("gRandomizeShuffleAdultTrade", 0);
cvarSettings[RSK_SHUFFLE_MAGIC_BEANS] = CVar_GetS32("gRandomizeShuffleBeans", 0);
cvarSettings[RSK_SHUFFLE_MERCHANTS] = CVar_GetS32("gRandomizeShuffleMerchants", RO_SHUFFLE_MERCHANTS_OFF);
cvarSettings[RSK_ENABLE_BOMBCHU_DROPS] = CVar_GetS32("gRandomizeEnableBombchuDrops", 0);
cvarSettings[RSK_BOMBCHUS_IN_LOGIC] = CVar_GetS32("gRandomizeBombchusInLogic", 0);
cvarSettings[RSK_SKIP_CHILD_ZELDA] = CVar_GetS32("gRandomizeSkipChildZelda", 0);
cvarSettings[RSK_LOGIC_RULES] = CVarGetInteger("gRandomizeLogicRules", RO_LOGIC_GLITCHLESS);
cvarSettings[RSK_ALL_LOCATIONS_REACHABLE] = CVarGetInteger("gRandomizeAllLocationsReachable", RO_GENERIC_ON);
cvarSettings[RSK_FOREST] = CVarGetInteger("gRandomizeForest", RO_FOREST_CLOSED);
cvarSettings[RSK_KAK_GATE] = CVarGetInteger("gRandomizeKakarikoGate", RO_KAK_GATE_CLOSED);
cvarSettings[RSK_DOOR_OF_TIME] = CVarGetInteger("gRandomizeDoorOfTime", RO_DOOROFTIME_CLOSED);
cvarSettings[RSK_ZORAS_FOUNTAIN] = CVarGetInteger("gRandomizeZorasFountain", 0);
cvarSettings[RSK_STARTING_AGE] = CVarGetInteger("gRandomizeStartingAge", RO_AGE_CHILD);
cvarSettings[RSK_GERUDO_FORTRESS] = CVarGetInteger("gRandomizeGerudoFortress", RO_GF_NORMAL);
cvarSettings[RSK_RAINBOW_BRIDGE] = CVarGetInteger("gRandomizeRainbowBridge", RO_BRIDGE_VANILLA);
cvarSettings[RSK_RAINBOW_BRIDGE_STONE_COUNT] = CVarGetInteger("gRandomizeStoneCount", 3);
cvarSettings[RSK_RAINBOW_BRIDGE_MEDALLION_COUNT] = CVarGetInteger("gRandomizeMedallionCount", 6);
cvarSettings[RSK_RAINBOW_BRIDGE_REWARD_COUNT] = CVarGetInteger("gRandomizeRewardCount", 9);
cvarSettings[RSK_RAINBOW_BRIDGE_DUNGEON_COUNT] = CVarGetInteger("gRandomizeDungeonCount", 8);
cvarSettings[RSK_RAINBOW_BRIDGE_TOKEN_COUNT] = CVarGetInteger("gRandomizeTokenCount", 100);
cvarSettings[RSK_GANONS_TRIALS] = CVarGetInteger("gRandomizeGanonTrial", RO_GANONS_TRIALS_SET_NUMBER);
cvarSettings[RSK_TRIAL_COUNT] = CVarGetInteger("gRandomizeGanonTrialCount", 6);
cvarSettings[RSK_STARTING_OCARINA] = CVarGetInteger("gRandomizeStartingOcarina", 0);
cvarSettings[RSK_SHUFFLE_OCARINA] = CVarGetInteger("gRandomizeShuffleOcarinas", 0) ||
CVarGetInteger("gRandomizeStartingOcarina", 0);
cvarSettings[RSK_STARTING_KOKIRI_SWORD] = CVarGetInteger("gRandomizeStartingKokiriSword", 0);
cvarSettings[RSK_SHUFFLE_KOKIRI_SWORD] = CVarGetInteger("gRandomizeShuffleKokiriSword", 0) ||
CVarGetInteger("gRandomizeStartingKokiriSword", 0);
cvarSettings[RSK_STARTING_DEKU_SHIELD] = CVarGetInteger("gRandomizeStartingDekuShield", 0);
cvarSettings[RSK_STARTING_SKULLTULA_TOKEN] = CVarGetInteger("gRandomizeStartingSkulltulaToken", 0);
cvarSettings[RSK_STARTING_MAPS_COMPASSES] = CVarGetInteger("gRandomizeStartingMapsCompasses", RO_DUNGEON_ITEM_LOC_OWN_DUNGEON);
cvarSettings[RSK_SHUFFLE_DUNGEON_REWARDS] = CVarGetInteger("gRandomizeShuffleDungeonReward", RO_DUNGEON_REWARDS_END_OF_DUNGEON);
cvarSettings[RSK_SHUFFLE_SONGS] = CVarGetInteger("gRandomizeShuffleSongs", RO_SONG_SHUFFLE_SONG_LOCATIONS);
cvarSettings[RSK_SHUFFLE_TOKENS] = CVarGetInteger("gRandomizeShuffleTokens", RO_TOKENSANITY_OFF);
cvarSettings[RSK_SHOPSANITY] = CVarGetInteger("gRandomizeShopsanity", RO_SHOPSANITY_OFF);
cvarSettings[RSK_SHUFFLE_SCRUBS] = CVarGetInteger("gRandomizeShuffleScrubs", RO_SCRUBS_OFF);
cvarSettings[RSK_SHUFFLE_COWS] = CVarGetInteger("gRandomizeShuffleCows", 0);
cvarSettings[RSK_SHUFFLE_ADULT_TRADE] = CVarGetInteger("gRandomizeShuffleAdultTrade", 0);
cvarSettings[RSK_SHUFFLE_MAGIC_BEANS] = CVarGetInteger("gRandomizeShuffleBeans", 0);
cvarSettings[RSK_SHUFFLE_MERCHANTS] = CVarGetInteger("gRandomizeShuffleMerchants", RO_SHUFFLE_MERCHANTS_OFF);
cvarSettings[RSK_ENABLE_BOMBCHU_DROPS] = CVarGetInteger("gRandomizeEnableBombchuDrops", 0);
cvarSettings[RSK_BOMBCHUS_IN_LOGIC] = CVarGetInteger("gRandomizeBombchusInLogic", 0);
cvarSettings[RSK_SKIP_CHILD_ZELDA] = CVarGetInteger("gRandomizeSkipChildZelda", 0);
// if we skip child zelda, we start with zelda's letter, and malon starts
// at the ranch, so we should *not* shuffle the weird egg
cvarSettings[RSK_SHUFFLE_WEIRD_EGG] = ((CVar_GetS32("gRandomizeSkipChildZelda", 0) == 0) &&
CVar_GetS32("gRandomizeShuffleWeirdEgg", 0));
cvarSettings[RSK_SHUFFLE_WEIRD_EGG] = ((CVarGetInteger("gRandomizeSkipChildZelda", 0) == 0) &&
CVarGetInteger("gRandomizeShuffleWeirdEgg", 0));
cvarSettings[RSK_SHUFFLE_GERUDO_MEMBERSHIP_CARD] = CVar_GetS32("gRandomizeShuffleGerudoToken", 0);
cvarSettings[RSK_SHUFFLE_FROG_SONG_RUPEES] = CVar_GetS32("gRandomizeShuffleFrogSongRupees", 0);
cvarSettings[RSK_ITEM_POOL] = CVar_GetS32("gRandomizeItemPool", RO_ITEM_POOL_BALANCED);
cvarSettings[RSK_ICE_TRAPS] = CVar_GetS32("gRandomizeIceTraps", RO_ICE_TRAPS_NORMAL);
cvarSettings[RSK_GOSSIP_STONE_HINTS] = CVar_GetS32("gRandomizeGossipStoneHints", RO_GOSSIP_STONES_NEED_NOTHING);
cvarSettings[RSK_HINT_CLARITY] = CVar_GetS32("gRandomizeHintClarity", RO_HINT_CLARITY_CLEAR);
cvarSettings[RSK_HINT_DISTRIBUTION] = CVar_GetS32("gRandomizeHintDistribution", RO_HINT_DIST_BALANCED);
cvarSettings[RSK_BLUE_FIRE_ARROWS] = CVar_GetS32("gRandomizeBlueFireArrows", 0);
cvarSettings[RSK_SUNLIGHT_ARROWS] = CVar_GetS32("gRandomizeSunlightArrows", 0);
cvarSettings[RSK_KEYSANITY] = CVar_GetS32("gRandomizeKeysanity", RO_DUNGEON_ITEM_LOC_OWN_DUNGEON);
cvarSettings[RSK_GERUDO_KEYS] = CVar_GetS32("gRandomizeGerudoKeys", RO_GERUDO_KEYS_VANILLA);
cvarSettings[RSK_KEYRINGS] = CVar_GetS32("gRandomizeShuffleKeyRings", RO_KEYRINGS_OFF);
cvarSettings[RSK_KEYRINGS_RANDOM_COUNT] = CVar_GetS32("gRandomizeShuffleKeyRingsRandomCount", 8);
cvarSettings[RSK_KEYRINGS_FOREST_TEMPLE] = CVar_GetS32("gRandomizeShuffleKeyRingsForestTemple", 0);
cvarSettings[RSK_KEYRINGS_FIRE_TEMPLE] = CVar_GetS32("gRandomizeShuffleKeyRingsFireTemple", 0);
cvarSettings[RSK_KEYRINGS_WATER_TEMPLE] = CVar_GetS32("gRandomizeShuffleKeyRingsWaterTemple", 0);
cvarSettings[RSK_KEYRINGS_SPIRIT_TEMPLE] = CVar_GetS32("gRandomizeShuffleKeyRingsSpiritTemple", 0);
cvarSettings[RSK_KEYRINGS_SHADOW_TEMPLE] = CVar_GetS32("gRandomizeShuffleKeyRingsShadowTemple", 0);
cvarSettings[RSK_KEYRINGS_BOTTOM_OF_THE_WELL] = CVar_GetS32("gRandomizeShuffleKeyRingsBottomOfTheWell", 0);
cvarSettings[RSK_KEYRINGS_GTG] = CVar_GetS32("gRandomizeShuffleKeyRingsGTG", 0);
cvarSettings[RSK_KEYRINGS_GANONS_CASTLE] = CVar_GetS32("gRandomizeShuffleKeyRingsGanonsCastle", 0);
cvarSettings[RSK_BOSS_KEYSANITY] = CVar_GetS32("gRandomizeBossKeysanity", RO_DUNGEON_ITEM_LOC_OWN_DUNGEON);
cvarSettings[RSK_GANONS_BOSS_KEY] = CVar_GetS32("gRandomizeShuffleGanonBossKey", RO_GANON_BOSS_KEY_VANILLA);
cvarSettings[RSK_LACS_STONE_COUNT] = CVar_GetS32("gRandomizeLacsStoneCount", 3);
cvarSettings[RSK_LACS_MEDALLION_COUNT] = CVar_GetS32("gRandomizeLacsMedallionCount", 6);
cvarSettings[RSK_LACS_REWARD_COUNT] = CVar_GetS32("gRandomizeLacsRewardCount", 9);
cvarSettings[RSK_LACS_DUNGEON_COUNT] = CVar_GetS32("gRandomizeLacsDungeonCount", 8);
cvarSettings[RSK_LACS_TOKEN_COUNT] = CVar_GetS32("gRandomizeLacsTokenCount", 100);
cvarSettings[RSK_STARTING_CONSUMABLES] = CVar_GetS32("gRandomizeStartingConsumables", 0);
cvarSettings[RSK_FULL_WALLETS] = CVar_GetS32("gRandomizeFullWallets", 0);
cvarSettings[RSK_SHUFFLE_GERUDO_MEMBERSHIP_CARD] = CVarGetInteger("gRandomizeShuffleGerudoToken", 0);
cvarSettings[RSK_SHUFFLE_FROG_SONG_RUPEES] = CVarGetInteger("gRandomizeShuffleFrogSongRupees", 0);
cvarSettings[RSK_ITEM_POOL] = CVarGetInteger("gRandomizeItemPool", RO_ITEM_POOL_BALANCED);
cvarSettings[RSK_ICE_TRAPS] = CVarGetInteger("gRandomizeIceTraps", RO_ICE_TRAPS_NORMAL);
cvarSettings[RSK_GOSSIP_STONE_HINTS] = CVarGetInteger("gRandomizeGossipStoneHints", RO_GOSSIP_STONES_NEED_NOTHING);
cvarSettings[RSK_HINT_CLARITY] = CVarGetInteger("gRandomizeHintClarity", RO_HINT_CLARITY_CLEAR);
cvarSettings[RSK_HINT_DISTRIBUTION] = CVarGetInteger("gRandomizeHintDistribution", RO_HINT_DIST_BALANCED);
cvarSettings[RSK_BLUE_FIRE_ARROWS] = CVarGetInteger("gRandomizeBlueFireArrows", 0);
cvarSettings[RSK_SUNLIGHT_ARROWS] = CVarGetInteger("gRandomizeSunlightArrows", 0);
cvarSettings[RSK_KEYSANITY] = CVarGetInteger("gRandomizeKeysanity", RO_DUNGEON_ITEM_LOC_OWN_DUNGEON);
cvarSettings[RSK_GERUDO_KEYS] = CVarGetInteger("gRandomizeGerudoKeys", RO_GERUDO_KEYS_VANILLA);
cvarSettings[RSK_KEYRINGS] = CVarGetInteger("gRandomizeShuffleKeyRings", RO_KEYRINGS_OFF);
cvarSettings[RSK_KEYRINGS_RANDOM_COUNT] = CVarGetInteger("gRandomizeShuffleKeyRingsRandomCount", 8);
cvarSettings[RSK_KEYRINGS_FOREST_TEMPLE] = CVarGetInteger("gRandomizeShuffleKeyRingsForestTemple", 0);
cvarSettings[RSK_KEYRINGS_FIRE_TEMPLE] = CVarGetInteger("gRandomizeShuffleKeyRingsFireTemple", 0);
cvarSettings[RSK_KEYRINGS_WATER_TEMPLE] = CVarGetInteger("gRandomizeShuffleKeyRingsWaterTemple", 0);
cvarSettings[RSK_KEYRINGS_SPIRIT_TEMPLE] = CVarGetInteger("gRandomizeShuffleKeyRingsSpiritTemple", 0);
cvarSettings[RSK_KEYRINGS_SHADOW_TEMPLE] = CVarGetInteger("gRandomizeShuffleKeyRingsShadowTemple", 0);
cvarSettings[RSK_KEYRINGS_BOTTOM_OF_THE_WELL] = CVarGetInteger("gRandomizeShuffleKeyRingsBottomOfTheWell", 0);
cvarSettings[RSK_KEYRINGS_GTG] = CVarGetInteger("gRandomizeShuffleKeyRingsGTG", 0);
cvarSettings[RSK_KEYRINGS_GANONS_CASTLE] = CVarGetInteger("gRandomizeShuffleKeyRingsGanonsCastle", 0);
cvarSettings[RSK_BOSS_KEYSANITY] = CVarGetInteger("gRandomizeBossKeysanity", RO_DUNGEON_ITEM_LOC_OWN_DUNGEON);
cvarSettings[RSK_GANONS_BOSS_KEY] = CVarGetInteger("gRandomizeShuffleGanonBossKey", RO_GANON_BOSS_KEY_VANILLA);
cvarSettings[RSK_LACS_STONE_COUNT] = CVarGetInteger("gRandomizeLacsStoneCount", 3);
cvarSettings[RSK_LACS_MEDALLION_COUNT] = CVarGetInteger("gRandomizeLacsMedallionCount", 6);
cvarSettings[RSK_LACS_REWARD_COUNT] = CVarGetInteger("gRandomizeLacsRewardCount", 9);
cvarSettings[RSK_LACS_DUNGEON_COUNT] = CVarGetInteger("gRandomizeLacsDungeonCount", 8);
cvarSettings[RSK_LACS_TOKEN_COUNT] = CVarGetInteger("gRandomizeLacsTokenCount", 100);
cvarSettings[RSK_STARTING_CONSUMABLES] = CVarGetInteger("gRandomizeStartingConsumables", 0);
cvarSettings[RSK_FULL_WALLETS] = CVarGetInteger("gRandomizeFullWallets", 0);
// RANDOTODO implement chest minigame shuffle with keysanity
cvarSettings[RSK_SHUFFLE_CHEST_MINIGAME] = false;
cvarSettings[RSK_LANGUAGE] = CVar_GetS32("gLanguages", 0);
cvarSettings[RSK_LANGUAGE] = CVarGetInteger("gLanguages", 0);
cvarSettings[RSK_CUCCO_COUNT] = CVar_GetS32("gRandomizeCuccosToReturn", 7);
cvarSettings[RSK_BIG_POE_COUNT] = CVar_GetS32("gRandomizeBigPoeTargetCount", 10);
cvarSettings[RSK_CUCCO_COUNT] = CVarGetInteger("gRandomizeCuccosToReturn", 7);
cvarSettings[RSK_BIG_POE_COUNT] = CVarGetInteger("gRandomizeBigPoeTargetCount", 10);
// If we skip child zelda, skip child stealth is pointless, so this needs to be reflected in the spoiler log
cvarSettings[RSK_SKIP_CHILD_STEALTH] =
!CVar_GetS32("gRandomizeSkipChildZelda", 0) && CVar_GetS32("gRandomizeSkipChildStealth", 0);
!CVarGetInteger("gRandomizeSkipChildZelda", 0) && CVarGetInteger("gRandomizeSkipChildStealth", 0);
cvarSettings[RSK_SKIP_EPONA_RACE] = CVar_GetS32("gRandomizeSkipEponaRace", 0);
cvarSettings[RSK_SKIP_TOWER_ESCAPE] = CVar_GetS32("gRandomizeSkipTowerEscape", 0);
cvarSettings[RSK_COMPLETE_MASK_QUEST] = CVar_GetS32("gRandomizeCompleteMaskQuest", 0);
cvarSettings[RSK_SKIP_SCARECROWS_SONG] = CVar_GetS32("gRandomizeSkipScarecrowsSong", 0);
cvarSettings[RSK_ENABLE_GLITCH_CUTSCENES] = CVar_GetS32("gRandomizeEnableGlitchCutscenes", 0);
cvarSettings[RSK_SKIP_EPONA_RACE] = CVarGetInteger("gRandomizeSkipEponaRace", 0);
cvarSettings[RSK_SKIP_TOWER_ESCAPE] = CVarGetInteger("gRandomizeSkipTowerEscape", 0);
cvarSettings[RSK_COMPLETE_MASK_QUEST] = CVarGetInteger("gRandomizeCompleteMaskQuest", 0);
cvarSettings[RSK_SKIP_SCARECROWS_SONG] = CVarGetInteger("gRandomizeSkipScarecrowsSong", 0);
cvarSettings[RSK_ENABLE_GLITCH_CUTSCENES] = CVarGetInteger("gRandomizeEnableGlitchCutscenes", 0);
cvarSettings[RSK_SKULLS_SUNS_SONG] = CVar_GetS32("gRandomizeGsExpectSunsSong", 0);
cvarSettings[RSK_SKULLS_SUNS_SONG] = CVarGetInteger("gRandomizeGsExpectSunsSong", 0);
// Link's Pocket has to have a dungeon reward if the other rewards are shuffled to end of dungeon.
cvarSettings[RSK_LINKS_POCKET] = CVar_GetS32("gRandomizeShuffleDungeonReward", RO_DUNGEON_REWARDS_END_OF_DUNGEON) != RO_DUNGEON_REWARDS_END_OF_DUNGEON ?
CVar_GetS32("gRandomizeLinksPocket", RO_LINKS_POCKET_DUNGEON_REWARD) :
cvarSettings[RSK_LINKS_POCKET] = CVarGetInteger("gRandomizeShuffleDungeonReward", RO_DUNGEON_REWARDS_END_OF_DUNGEON) != RO_DUNGEON_REWARDS_END_OF_DUNGEON ?
CVarGetInteger("gRandomizeLinksPocket", RO_LINKS_POCKET_DUNGEON_REWARD) :
RO_LINKS_POCKET_DUNGEON_REWARD;
if (OTRGlobals::Instance->HasMasterQuest() && OTRGlobals::Instance->HasOriginal()) {
// If both OTRs are loaded.
cvarSettings[RSK_RANDOM_MQ_DUNGEONS] = CVar_GetS32("gRandomizeMqDungeons", RO_MQ_DUNGEONS_NONE);
cvarSettings[RSK_MQ_DUNGEON_COUNT] = CVar_GetS32("gRandomizeMqDungeonCount", 12);
cvarSettings[RSK_RANDOM_MQ_DUNGEONS] = CVarGetInteger("gRandomizeMqDungeons", RO_MQ_DUNGEONS_NONE);
cvarSettings[RSK_MQ_DUNGEON_COUNT] = CVarGetInteger("gRandomizeMqDungeonCount", 12);
} else if (OTRGlobals::Instance->HasMasterQuest()) {
// If only Master Quest is loaded.
cvarSettings[RSK_RANDOM_MQ_DUNGEONS] = RO_MQ_DUNGEONS_SET_NUMBER;
@ -2760,31 +2760,31 @@ void GenerateRandomizerImgui() {
}
// Enable if any of the entrance rando options are enabled.
cvarSettings[RSK_SHUFFLE_ENTRANCES] = CVar_GetS32("gRandomizeShuffleDungeonsEntrances", RO_DUNGEON_ENTRANCE_SHUFFLE_OFF) ||
CVar_GetS32("gRandomizeShuffleOverworldEntrances", RO_GENERIC_OFF) ||
CVar_GetS32("gRandomizeShuffleInteriorsEntrances", RO_INTERIOR_ENTRANCE_SHUFFLE_OFF) ||
CVar_GetS32("gRandomizeShuffleGrottosEntrances", RO_GENERIC_OFF) ||
CVar_GetS32("gRandomizeShuffleOwlDrops", RO_GENERIC_OFF) ||
CVar_GetS32("gRandomizeShuffleWarpSongs", RO_GENERIC_OFF) ||
CVar_GetS32("gRandomizeShuffleOverworldSpawns", RO_GENERIC_OFF);
cvarSettings[RSK_SHUFFLE_ENTRANCES] = CVarGetInteger("gRandomizeShuffleDungeonsEntrances", RO_DUNGEON_ENTRANCE_SHUFFLE_OFF) ||
CVarGetInteger("gRandomizeShuffleOverworldEntrances", RO_GENERIC_OFF) ||
CVarGetInteger("gRandomizeShuffleInteriorsEntrances", RO_INTERIOR_ENTRANCE_SHUFFLE_OFF) ||
CVarGetInteger("gRandomizeShuffleGrottosEntrances", RO_GENERIC_OFF) ||
CVarGetInteger("gRandomizeShuffleOwlDrops", RO_GENERIC_OFF) ||
CVarGetInteger("gRandomizeShuffleWarpSongs", RO_GENERIC_OFF) ||
CVarGetInteger("gRandomizeShuffleOverworldSpawns", RO_GENERIC_OFF);
cvarSettings[RSK_SHUFFLE_DUNGEON_ENTRANCES] = CVar_GetS32("gRandomizeShuffleDungeonsEntrances", RO_DUNGEON_ENTRANCE_SHUFFLE_OFF);
cvarSettings[RSK_SHUFFLE_OVERWORLD_ENTRANCES] = CVar_GetS32("gRandomizeShuffleOverworldEntrances", RO_GENERIC_OFF);
cvarSettings[RSK_SHUFFLE_INTERIOR_ENTRANCES] = CVar_GetS32("gRandomizeShuffleInteriorsEntrances", RO_INTERIOR_ENTRANCE_SHUFFLE_OFF);
cvarSettings[RSK_SHUFFLE_GROTTO_ENTRANCES] = CVar_GetS32("gRandomizeShuffleGrottosEntrances", RO_GENERIC_OFF);
cvarSettings[RSK_SHUFFLE_OWL_DROPS] = CVar_GetS32("gRandomizeShuffleOwlDrops", RO_GENERIC_OFF);
cvarSettings[RSK_SHUFFLE_WARP_SONGS] = CVar_GetS32("gRandomizeShuffleWarpSongs", RO_GENERIC_OFF);
cvarSettings[RSK_SHUFFLE_OVERWORLD_SPAWNS] = CVar_GetS32("gRandomizeShuffleOverworldSpawns", RO_GENERIC_OFF);
cvarSettings[RSK_MIXED_ENTRANCE_POOLS] = CVar_GetS32("gRandomizeMixedEntrances", RO_GENERIC_OFF);
cvarSettings[RSK_MIX_DUNGEON_ENTRANCES] = CVar_GetS32("gRandomizeMixDungeons", RO_GENERIC_OFF);
cvarSettings[RSK_MIX_OVERWORLD_ENTRANCES] = CVar_GetS32("gRandomizeMixOverworld", RO_GENERIC_OFF);
cvarSettings[RSK_MIX_INTERIOR_ENTRANCES] = CVar_GetS32("gRandomizeMixInteriors", RO_GENERIC_OFF);
cvarSettings[RSK_MIX_GROTTO_ENTRANCES] = CVar_GetS32("gRandomizeMixGrottos", RO_GENERIC_OFF);
cvarSettings[RSK_DECOUPLED_ENTRANCES] = CVar_GetS32("gRandomizeDecoupleEntrances", RO_GENERIC_OFF);
cvarSettings[RSK_SHUFFLE_DUNGEON_ENTRANCES] = CVarGetInteger("gRandomizeShuffleDungeonsEntrances", RO_DUNGEON_ENTRANCE_SHUFFLE_OFF);
cvarSettings[RSK_SHUFFLE_OVERWORLD_ENTRANCES] = CVarGetInteger("gRandomizeShuffleOverworldEntrances", RO_GENERIC_OFF);
cvarSettings[RSK_SHUFFLE_INTERIOR_ENTRANCES] = CVarGetInteger("gRandomizeShuffleInteriorsEntrances", RO_INTERIOR_ENTRANCE_SHUFFLE_OFF);
cvarSettings[RSK_SHUFFLE_GROTTO_ENTRANCES] = CVarGetInteger("gRandomizeShuffleGrottosEntrances", RO_GENERIC_OFF);
cvarSettings[RSK_SHUFFLE_OWL_DROPS] = CVarGetInteger("gRandomizeShuffleOwlDrops", RO_GENERIC_OFF);
cvarSettings[RSK_SHUFFLE_WARP_SONGS] = CVarGetInteger("gRandomizeShuffleWarpSongs", RO_GENERIC_OFF);
cvarSettings[RSK_SHUFFLE_OVERWORLD_SPAWNS] = CVarGetInteger("gRandomizeShuffleOverworldSpawns", RO_GENERIC_OFF);
cvarSettings[RSK_MIXED_ENTRANCE_POOLS] = CVarGetInteger("gRandomizeMixedEntrances", RO_GENERIC_OFF);
cvarSettings[RSK_MIX_DUNGEON_ENTRANCES] = CVarGetInteger("gRandomizeMixDungeons", RO_GENERIC_OFF);
cvarSettings[RSK_MIX_OVERWORLD_ENTRANCES] = CVarGetInteger("gRandomizeMixOverworld", RO_GENERIC_OFF);
cvarSettings[RSK_MIX_INTERIOR_ENTRANCES] = CVarGetInteger("gRandomizeMixInteriors", RO_GENERIC_OFF);
cvarSettings[RSK_MIX_GROTTO_ENTRANCES] = CVarGetInteger("gRandomizeMixGrottos", RO_GENERIC_OFF);
cvarSettings[RSK_DECOUPLED_ENTRANCES] = CVarGetInteger("gRandomizeDecoupleEntrances", RO_GENERIC_OFF);
// todo: this efficently when we build out cvar array support
std::set<RandomizerCheck> excludedLocations;
std::stringstream excludedLocationStringStream(CVar_GetString("gRandomizeExcludedLocations", ""));
std::stringstream excludedLocationStringStream(CVarGetString("gRandomizeExcludedLocations", ""));
std::string excludedLocationString;
while (getline(excludedLocationStringStream, excludedLocationString, ',')) {
excludedLocations.insert((RandomizerCheck)std::stoi(excludedLocationString));
@ -2792,9 +2792,9 @@ void GenerateRandomizerImgui() {
RandoMain::GenerateRando(cvarSettings, excludedLocations);
CVar_SetS32("gRandoGenerating", 0);
CVar_Save();
CVar_Load();
CVarSetInteger("gRandoGenerating", 0);
CVarSave();
CVarLoad();
generated = 1;
}
@ -2806,7 +2806,7 @@ void DrawRandoEditor(bool& open) {
}
if (!open) {
CVar_SetS32("gRandomizerSettingsEnabled", 0);
CVarSetInteger("gRandomizerSettingsEnabled", 0);
return;
}
@ -2875,22 +2875,22 @@ void DrawRandoEditor(bool& open) {
DrawPresetSelector(PRESET_TYPE_RANDOMIZER);
bool disableEditingRandoSettings = CVar_GetS32("gRandoGenerating", 0) || CVar_GetS32("gOnFileSelectNameEntry", 0);
bool disableEditingRandoSettings = CVarGetInteger("gRandoGenerating", 0) || CVarGetInteger("gOnFileSelectNameEntry", 0);
ImGui::PushItemFlag(ImGuiItemFlags_Disabled, disableEditingRandoSettings);
ImGui::PushStyleVar(ImGuiStyleVar_Alpha, ImGui::GetStyle().Alpha * (disableEditingRandoSettings ? 0.5f : 1.0f));
ImGui::Dummy(ImVec2(0.0f, 0.0f));
if (ImGui::Button("Generate Seed")) {
if (CVar_GetS32("gRandoGenerating", 0) == 0) {
if (CVarGetInteger("gRandoGenerating", 0) == 0) {
randoThread = std::thread(&GenerateRandomizerImgui);
}
}
ImGui::Dummy(ImVec2(0.0f, 0.0f));
std::string spoilerfilepath = CVar_GetString("gSpoilerLog", "");
std::string spoilerfilepath = CVarGetString("gSpoilerLog", "");
ImGui::Text("Spoiler File: %s", spoilerfilepath.c_str());
// RANDOTODO settings presets
// std::string presetfilepath = CVar_GetString("gLoadedPreset", "");
// std::string presetfilepath = CVarGetString("gLoadedPreset", "");
// ImGui::Text("Settings File: %s", presetfilepath.c_str());
UIWidgets::PaddedSeparator();
@ -2990,10 +2990,10 @@ void DrawRandoEditor(bool& open) {
//Starting Age
//Disabled when Forest is set to Closed or under very specific conditions
//RANDOTODO: Replace magic number checks with enums
bool disableRandoStartingAge = (CVar_GetS32("gRandomizeLogicRules", RO_LOGIC_GLITCHLESS) == RO_LOGIC_GLITCHLESS) &&
((CVar_GetS32("gRandomizeForest", RO_FOREST_CLOSED) == RO_FOREST_CLOSED) ||
((CVar_GetS32("gRandomizeDoorOfTime", RO_DOOROFTIME_CLOSED) == RO_DOOROFTIME_CLOSED) &&
(CVar_GetS32("gRandomizeShuffleOcarinas", 0) == 0))); // ocarinas not shuffled
bool disableRandoStartingAge = (CVarGetInteger("gRandomizeLogicRules", RO_LOGIC_GLITCHLESS) == RO_LOGIC_GLITCHLESS) &&
((CVarGetInteger("gRandomizeForest", RO_FOREST_CLOSED) == RO_FOREST_CLOSED) ||
((CVarGetInteger("gRandomizeDoorOfTime", RO_DOOROFTIME_CLOSED) == RO_DOOROFTIME_CLOSED) &&
(CVarGetInteger("gRandomizeShuffleOcarinas", 0) == 0))); // ocarinas not shuffled
static const char* disableRandoStartingAgeText = "This option is disabled due to other options making the game unbeatable.";
ImGui::Text(Settings::StartingAge.GetName().c_str());
@ -3011,7 +3011,7 @@ void DrawRandoEditor(bool& open) {
if (ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenDisabled)) {
ImGui::SetTooltip("%s", disableRandoStartingAgeText);
}
CVar_SetS32("gRandomizeStartingAge", RO_AGE_CHILD);
CVarSetInteger("gRandomizeStartingAge", RO_AGE_CHILD);
ImGui::PopStyleVar(1);
ImGui::PopItemFlag();
}
@ -3059,7 +3059,7 @@ void DrawRandoEditor(bool& open) {
UIWidgets::EnhancementCombobox("gRandomizeRainbowBridge", randoRainbowBridge, RO_BRIDGE_MAX, RO_BRIDGE_VANILLA);
ImGui::PopItemWidth();
switch (CVar_GetS32("gRandomizeRainbowBridge", RO_BRIDGE_VANILLA)) {
switch (CVarGetInteger("gRandomizeRainbowBridge", RO_BRIDGE_VANILLA)) {
case RO_BRIDGE_ALWAYS_OPEN:
break;
case RO_BRIDGE_VANILLA:
@ -3108,7 +3108,7 @@ void DrawRandoEditor(bool& open) {
);
UIWidgets::EnhancementCombobox("gRandomizeGanonTrial", randoGanonsTrial, RO_GANONS_TRIALS_MAX, RO_GANONS_TRIALS_SET_NUMBER);
ImGui::PopItemWidth();
if (CVar_GetS32("gRandomizeGanonTrial", RO_GANONS_TRIALS_SET_NUMBER) == RO_GANONS_TRIALS_SET_NUMBER) {
if (CVarGetInteger("gRandomizeGanonTrial", RO_GANONS_TRIALS_SET_NUMBER) == RO_GANONS_TRIALS_SET_NUMBER) {
ImGui::Dummy(ImVec2(0.0f, 0.0f));
UIWidgets::EnhancementSliderInt("Ganon's Trial Count: %d", "##RandoTrialCount",
"gRandomizeGanonTrialCount", 1, 6, "", 6, true);
@ -3132,10 +3132,10 @@ void DrawRandoEditor(bool& open) {
);
UIWidgets::EnhancementCombobox("gRandomizeMqDungeons", randoMqDungeons, RO_MQ_DUNGEONS_MAX, RO_MQ_DUNGEONS_NONE);
ImGui::PopItemWidth();
if (CVar_GetS32("gRandomizeMqDungeons", RO_MQ_DUNGEONS_NONE) == RO_MQ_DUNGEONS_SET_NUMBER) {
if (CVarGetInteger("gRandomizeMqDungeons", RO_MQ_DUNGEONS_NONE) == RO_MQ_DUNGEONS_SET_NUMBER) {
ImGui::Dummy(ImVec2(0.0f, 0.0f));
UIWidgets::EnhancementSliderInt("Master Quest Dungeon Count: %d", "##RandoMqDungeonCount",
"gRandomizeMqDungeonCount", 1, 12, "", CVar_GetS32("gRandomizeMqDungeonCount", 12), true);
"gRandomizeMqDungeonCount", 1, 12, "", CVarGetInteger("gRandomizeMqDungeonCount", 12), true);
}
}
@ -3253,26 +3253,26 @@ void DrawRandoEditor(bool& open) {
"vice versa, while overworld entrances are shuffled in their own separate pool and indoors stay vanilla."
);
if (CVar_GetS32("gRandomizeMixedEntrances", RO_GENERIC_OFF)) {
if (CVar_GetS32("gRandomizeShuffleDungeonsEntrances", RO_GENERIC_OFF)) {
if (CVarGetInteger("gRandomizeMixedEntrances", RO_GENERIC_OFF)) {
if (CVarGetInteger("gRandomizeShuffleDungeonsEntrances", RO_GENERIC_OFF)) {
UIWidgets::Spacer(0);
ImGui::SetCursorPosX(20);
UIWidgets::EnhancementCheckbox("Mix Dungeons", "gRandomizeMixDungeons");
UIWidgets::InsertHelpHoverText("Dungeon entrances will be part of the mixed pool");
}
if (CVar_GetS32("gRandomizeShuffleOverworldEntrances", RO_GENERIC_OFF)) {
if (CVarGetInteger("gRandomizeShuffleOverworldEntrances", RO_GENERIC_OFF)) {
UIWidgets::Spacer(0);
ImGui::SetCursorPosX(20);
UIWidgets::EnhancementCheckbox("Mix Overworld", "gRandomizeMixOverworld");
UIWidgets::InsertHelpHoverText("Overworld entrances will be part of the mixed pool");
}
if (CVar_GetS32("gRandomizeShuffleInteriorsEntrances", RO_GENERIC_OFF)) {
if (CVarGetInteger("gRandomizeShuffleInteriorsEntrances", RO_GENERIC_OFF)) {
UIWidgets::Spacer(0);
ImGui::SetCursorPosX(20);
UIWidgets::EnhancementCheckbox("Mix Interiors", "gRandomizeMixInteriors");
UIWidgets::InsertHelpHoverText("Interior entrances will be part of the mixed pool");
}
if (CVar_GetS32("gRandomizeShuffleGrottosEntrances", RO_GENERIC_OFF)) {
if (CVarGetInteger("gRandomizeShuffleGrottosEntrances", RO_GENERIC_OFF)) {
UIWidgets::Spacer(0);
ImGui::SetCursorPosX(20);
UIWidgets::EnhancementCheckbox("Mix Grottos", "gRandomizeMixGrottos");
@ -3352,7 +3352,7 @@ void DrawRandoEditor(bool& open) {
// Shuffle Kokiri Sword
// Disabled when Start with Kokiri Sword is active
bool disableShuffleKokiriSword = CVar_GetS32("gRandomizeStartingKokiriSword", 0);
bool disableShuffleKokiriSword = CVarGetInteger("gRandomizeStartingKokiriSword", 0);
static const char* disableShuffleKokiriSwordText = "This option is disabled because \"Start with Kokiri Sword\" is enabled.";
UIWidgets::EnhancementCheckbox(Settings::ShuffleKokiriSword.GetName().c_str(), "gRandomizeShuffleKokiriSword",
disableShuffleKokiriSword, disableShuffleKokiriSwordText);
@ -3366,7 +3366,7 @@ void DrawRandoEditor(bool& open) {
// Shuffle Ocarinas
// Disabled when Start with Ocarina is active
bool disableShuffleOcarinas = CVar_GetS32("gRandomizeStartingOcarina", 0);
bool disableShuffleOcarinas = CVarGetInteger("gRandomizeStartingOcarina", 0);
static const char* disableShuffleOcarinasText = "This option is disabled because \"Start with Fairy Ocarina\" is enabled.";
UIWidgets::EnhancementCheckbox(Settings::ShuffleOcarinas.GetName().c_str(), "gRandomizeShuffleOcarinas",
disableShuffleOcarinas, disableShuffleOcarinasText);
@ -3380,7 +3380,7 @@ void DrawRandoEditor(bool& open) {
// Shuffle Weird Egg
// Disabled when Skip Child Zelda is active
bool disableShuffleWeirdEgg = CVar_GetS32("gRandomizeSkipChildZelda", 0);
bool disableShuffleWeirdEgg = CVarGetInteger("gRandomizeSkipChildZelda", 0);
static const char* disableShuffleWeirdEggText = "This option is disabled because \"Skip Child Zelda\" is enabled.";
UIWidgets::EnhancementCheckbox(Settings::ShuffleWeirdEgg.GetName().c_str(), "gRandomizeShuffleWeirdEgg",
disableShuffleWeirdEgg, disableShuffleWeirdEggText);
@ -3586,7 +3586,7 @@ void DrawRandoEditor(bool& open) {
);
UIWidgets::EnhancementCombobox("gRandomizeShuffleKeyRings", randoShuffleKeyRings, RO_KEYRINGS_MAX, RO_KEYRINGS_OFF);
ImGui::PopItemWidth();
switch (CVar_GetS32("gRandomizeShuffleKeyRings", RO_KEYRINGS_OFF)) {
switch (CVarGetInteger("gRandomizeShuffleKeyRings", RO_KEYRINGS_OFF)) {
case RO_KEYRINGS_COUNT:
ImGui::Dummy(ImVec2(0.0f, 0.0f));
UIWidgets::EnhancementSliderInt("Key Ring Count: %d", "##RandomizeShuffleKeyRingsRandomCount",
@ -3668,7 +3668,7 @@ void DrawRandoEditor(bool& open) {
);
UIWidgets::EnhancementCombobox("gRandomizeShuffleGanonBossKey", randoShuffleGanonsBossKey, RO_GANON_BOSS_KEY_MAX, RO_GANON_BOSS_KEY_VANILLA);
ImGui::PopItemWidth();
switch (CVar_GetS32("gRandomizeShuffleGanonBossKey", RO_GANON_BOSS_KEY_VANILLA)) {
switch (CVarGetInteger("gRandomizeShuffleGanonBossKey", RO_GANON_BOSS_KEY_VANILLA)) {
case RO_GANON_BOSS_KEY_LACS_MEDALLIONS:
ImGui::Dummy(ImVec2(0.0f, 0.0f));
UIWidgets::EnhancementSliderInt("Medallion Count: %d", "##RandoLacsMedallionCount",
@ -3741,7 +3741,7 @@ void DrawRandoEditor(bool& open) {
// Skip child stealth
// Disabled when Skip Child Zelda is active
bool disableChildStealth = CVar_GetS32("gRandomizeSkipChildZelda", 0);
bool disableChildStealth = CVarGetInteger("gRandomizeSkipChildZelda", 0);
static const char* disableChildStealthText = "This option is disabled because \"Skip Child Zelda\" is enabled";
UIWidgets::EnhancementCheckbox(Settings::SkipChildStealth.GetName().c_str(), "gRandomizeSkipChildStealth", disableChildStealth, disableChildStealthText);
UIWidgets::InsertHelpHoverText("The crawlspace into Hyrule Castle goes straight to Zelda, skipping the guards.");
@ -3842,7 +3842,7 @@ void DrawRandoEditor(bool& open) {
"\n"
"Need Mask of Truth - Hints are only available whilst wearing the Mask of Truth.\n");
UIWidgets::EnhancementCombobox("gRandomizeGossipStoneHints", randoGossipStoneHints, RO_GOSSIP_STONES_MAX, RO_GOSSIP_STONES_NEED_NOTHING);
if (CVar_GetS32("gRandomizeGossipStoneHints", RO_GOSSIP_STONES_NEED_NOTHING) != RO_GOSSIP_STONES_NONE) {
if (CVarGetInteger("gRandomizeGossipStoneHints", RO_GOSSIP_STONES_NEED_NOTHING) != RO_GOSSIP_STONES_NONE) {
// Hint Clarity
ImGui::Dummy(ImVec2(0.0f, 0.0f));
ImGui::Indent();
@ -3948,7 +3948,7 @@ void DrawRandoEditor(bool& open) {
locationsTabOpen = true;
RandomizerCheckObjects::UpdateImGuiVisibility();
// todo: this efficently when we build out cvar array support
std::stringstream excludedLocationStringStream(CVar_GetString("gRandomizeExcludedLocations", ""));
std::stringstream excludedLocationStringStream(CVarGetString("gRandomizeExcludedLocations", ""));
std::string excludedLocationString;
excludedLocations.clear();
while (getline(excludedLocationStringStream, excludedLocationString, ',')) {
@ -3998,7 +3998,7 @@ void DrawRandoEditor(bool& open) {
excludedLocationString += std::to_string(excludedLocationIt);
excludedLocationString += ",";
}
CVar_SetString("gRandomizeExcludedLocations", excludedLocationString.c_str());
CVarSetString("gRandomizeExcludedLocations", excludedLocationString.c_str());
SohImGui::RequestCvarSaveOnNextTick();
}
ImGui::SameLine();
@ -4039,7 +4039,7 @@ void DrawRandoEditor(bool& open) {
excludedLocationString += std::to_string(excludedLocationIt);
excludedLocationString += ",";
}
CVar_SetString("gRandomizeExcludedLocations", excludedLocationString.c_str());
CVarSetString("gRandomizeExcludedLocations", excludedLocationString.c_str());
SohImGui::RequestCvarSaveOnNextTick();
}
ImGui::SameLine();
@ -4074,7 +4074,7 @@ void DrawRandoEditor(bool& open) {
"No logic - Item placement is completely random. MAY BE IMPOSSIBLE TO BEAT."
);
UIWidgets::EnhancementCombobox("gRandomizeLogicRules", randoLogicRules, RO_LOGIC_MAX, RO_LOGIC_GLITCHLESS);
if (CVar_GetS32("gRandomizeLogicRules", RO_LOGIC_GLITCHLESS) == RO_LOGIC_GLITCHLESS) {
if (CVarGetInteger("gRandomizeLogicRules", RO_LOGIC_GLITCHLESS) == RO_LOGIC_GLITCHLESS) {
ImGui::SameLine();
UIWidgets::EnhancementCheckbox(Settings::LocationsReachable.GetName().c_str(), "gRandomizeAllLocationsReachable", false, "", UIWidgets::CheckboxGraphics::Cross, RO_GENERIC_ON);
UIWidgets::InsertHelpHoverText(
@ -4147,7 +4147,7 @@ void DrawRandoEditor(bool& open) {
ImGui::BeginChild("ChildStartingEquipment", ImVec2(0, -8));
// Don't display this option if Dungeon Rewards are Shuffled to End of Dungeon.
// TODO: Show this but disabled when we have options for disabled Comboboxes.
if (CVar_GetS32("gRandomizeShuffleDungeonReward", RO_DUNGEON_REWARDS_END_OF_DUNGEON) != RO_DUNGEON_REWARDS_END_OF_DUNGEON) {
if (CVarGetInteger("gRandomizeShuffleDungeonReward", RO_DUNGEON_REWARDS_END_OF_DUNGEON) != RO_DUNGEON_REWARDS_END_OF_DUNGEON) {
ImGui::Text(Settings::LinksPocketItem.GetName().c_str());
UIWidgets::EnhancementCombobox("gRandomizeLinksPocket", randoLinksPocket, RO_LINKS_POCKET_MAX, RO_LINKS_POCKET_DUNGEON_REWARD);
UIWidgets::PaddedSeparator();

4
soh/soh/Enhancements/randomizer/randomizer.h
View File

@ -4,8 +4,8 @@
#include <unordered_set>
#include <string>
#include <vector>
#include "../../../include/ultra64.h"
#include "../../../include/z64item.h"
#include <libultraship/libultra.h>
#include "z64item.h"
#include <memory>
#include <soh/Enhancements/randomizer/randomizerTypes.h>
#include "soh/Enhancements/randomizer/randomizer_check_objects.h"

52
soh/soh/Enhancements/randomizer/randomizer_check_objects.cpp
View File

@ -1,7 +1,7 @@
#include "randomizer_check_objects.h"
#include <map>
#include <string>
#include <Cvar.h>
#include <libultraship/bridge.h>
#include "z64.h"
/*
@ -924,40 +924,40 @@ void RandomizerCheckObjects::UpdateImGuiVisibility() {
(locationIt.rc != RC_UNKNOWN_CHECK) &&
(!RandomizerCheckObjects::AreaIsDungeon(locationIt.rcArea) ||
locationIt.vOrMQ == RCVORMQ_BOTH ||
locationIt.vOrMQ == RCVORMQ_MQ && CVar_GetS32("gRandomizeMqDungeons", RO_MQ_DUNGEONS_NONE) != RO_MQ_DUNGEONS_NONE && CVar_GetS32("gRandomizeMqDungeonCount", 0) > 0 || //at least one MQ dungeon
locationIt.vOrMQ == RCVORMQ_VANILLA && (CVar_GetS32("gRandomizeMqDungeons", RO_MQ_DUNGEONS_NONE) == RO_MQ_DUNGEONS_NONE || CVar_GetS32("gRandomizeMqDungeonCount", 0) < 12) //at least one vanilla dungeon
locationIt.vOrMQ == RCVORMQ_MQ && CVarGetInteger("gRandomizeMqDungeons", RO_MQ_DUNGEONS_NONE) != RO_MQ_DUNGEONS_NONE && CVarGetInteger("gRandomizeMqDungeonCount", 0) > 0 || //at least one MQ dungeon
locationIt.vOrMQ == RCVORMQ_VANILLA && (CVarGetInteger("gRandomizeMqDungeons", RO_MQ_DUNGEONS_NONE) == RO_MQ_DUNGEONS_NONE || CVarGetInteger("gRandomizeMqDungeonCount", 0) < 12) //at least one vanilla dungeon
) &&
(locationIt.rcType != RCTYPE_SHOP || CVar_GetS32("gRandomizeShopsanity", RO_SHOPSANITY_OFF) > RO_SHOPSANITY_ZERO_ITEMS) &&
(locationIt.rcType != RCTYPE_SCRUB || CVar_GetS32("gRandomizeShuffleScrubs", RO_SCRUBS_OFF) != RO_SCRUBS_OFF ||
(locationIt.rcType != RCTYPE_SHOP || CVarGetInteger("gRandomizeShopsanity", RO_SHOPSANITY_OFF) > RO_SHOPSANITY_ZERO_ITEMS) &&
(locationIt.rcType != RCTYPE_SCRUB || CVarGetInteger("gRandomizeShuffleScrubs", RO_SCRUBS_OFF) != RO_SCRUBS_OFF ||
locationIt.rc == RC_HF_DEKU_SCRUB_GROTTO || locationIt.rc == RC_LW_DEKU_SCRUB_GROTTO_FRONT || locationIt.rc == RC_LW_DEKU_SCRUB_NEAR_BRIDGE) && //The 3 scrubs that are always randomized
(locationIt.rcType != RCTYPE_MERCHANT || CVar_GetS32("gRandomizeShuffleMerchants", RO_SHUFFLE_MERCHANTS_OFF) != RO_SHUFFLE_MERCHANTS_OFF) &&
(locationIt.rcType != RCTYPE_MERCHANT || CVarGetInteger("gRandomizeShuffleMerchants", RO_SHUFFLE_MERCHANTS_OFF) != RO_SHUFFLE_MERCHANTS_OFF) &&
(locationIt.rcType != RCTYPE_GOSSIP_STONE) && // don't show gossip stones (maybe gossipsanity will be a thing eventually?)
(locationIt.rcType != RCTYPE_LINKS_POCKET) &&
(locationIt.rcType != RCTYPE_CHEST_GAME) && // don't show non final reward chest game checks until we support shuffling them
((locationIt.rcType != RCTYPE_SKULL_TOKEN) ||
(CVar_GetS32("gRandomizeShuffleTokens", RO_TOKENSANITY_OFF) == RO_TOKENSANITY_ALL) ||
((CVar_GetS32("gRandomizeShuffleTokens", RO_TOKENSANITY_OFF) == RO_TOKENSANITY_OVERWORLD) && RandomizerCheckObjects::AreaIsOverworld(locationIt.rcArea)) ||
((CVar_GetS32("gRandomizeShuffleTokens", RO_TOKENSANITY_OFF) == RO_TOKENSANITY_DUNGEONS) && RandomizerCheckObjects::AreaIsDungeon(locationIt.rcArea))
(CVarGetInteger("gRandomizeShuffleTokens", RO_TOKENSANITY_OFF) == RO_TOKENSANITY_ALL) ||
((CVarGetInteger("gRandomizeShuffleTokens", RO_TOKENSANITY_OFF) == RO_TOKENSANITY_OVERWORLD) && RandomizerCheckObjects::AreaIsOverworld(locationIt.rcArea)) ||
((CVarGetInteger("gRandomizeShuffleTokens", RO_TOKENSANITY_OFF) == RO_TOKENSANITY_DUNGEONS) && RandomizerCheckObjects::AreaIsDungeon(locationIt.rcArea))
) &&
((locationIt.rcType != RCTYPE_COW) || CVar_GetS32("gRandomizeShuffleCows", RO_GENERIC_NO)) &&
((locationIt.rcType != RCTYPE_ADULT_TRADE) || CVar_GetS32("gRandomizeShuffleAdultTrade", RO_GENERIC_NO)) &&
((locationIt.rc != RC_KF_KOKIRI_SWORD_CHEST) || CVar_GetS32("gRandomizeShuffleKokiriSword", RO_GENERIC_NO)) &&
((locationIt.rc != RC_ZR_MAGIC_BEAN_SALESMAN) || CVar_GetS32("gRandomizeShuffleBeans", RO_GENERIC_NO) == RO_GENERIC_YES) &&
((locationIt.rc != RC_HC_MALON_EGG) || CVar_GetS32("gRandomizeShuffleWeirdEgg", RO_GENERIC_NO)) &&
((locationIt.rcType != RCTYPE_FROG_SONG) || CVar_GetS32("gRandomizeShuffleFrogSongRupees", RO_GENERIC_NO)) &&
((locationIt.rcType != RCTYPE_MAP_COMPASS) || CVar_GetS32("gRandomizeStartingMapsCompasses", RO_DUNGEON_ITEM_LOC_OWN_DUNGEON) != RO_DUNGEON_ITEM_LOC_VANILLA) &&
((locationIt.rcType != RCTYPE_SMALL_KEY) || CVar_GetS32("gRandomizeKeysanity", RO_DUNGEON_ITEM_LOC_OWN_DUNGEON) != RO_DUNGEON_ITEM_LOC_VANILLA) &&
((locationIt.rcType != RCTYPE_BOSS_KEY) || CVar_GetS32("gRandomizeBossKeysanity", RO_DUNGEON_ITEM_LOC_OWN_DUNGEON) != RO_DUNGEON_ITEM_LOC_VANILLA) &&
((locationIt.rcType != RCTYPE_GANON_BOSS_KEY) || CVar_GetS32("gRandomizeShuffleGanonBossKey", RO_GANON_BOSS_KEY_VANILLA) != RO_GANON_BOSS_KEY_VANILLA) &&
((locationIt.rcType != RCTYPE_COW) || CVarGetInteger("gRandomizeShuffleCows", RO_GENERIC_NO)) &&
((locationIt.rcType != RCTYPE_ADULT_TRADE) || CVarGetInteger("gRandomizeShuffleAdultTrade", RO_GENERIC_NO)) &&
((locationIt.rc != RC_KF_KOKIRI_SWORD_CHEST) || CVarGetInteger("gRandomizeShuffleKokiriSword", RO_GENERIC_NO)) &&
((locationIt.rc != RC_ZR_MAGIC_BEAN_SALESMAN) || CVarGetInteger("gRandomizeShuffleBeans", RO_GENERIC_NO) == RO_GENERIC_YES) &&
((locationIt.rc != RC_HC_MALON_EGG) || CVarGetInteger("gRandomizeShuffleWeirdEgg", RO_GENERIC_NO)) &&
((locationIt.rcType != RCTYPE_FROG_SONG) || CVarGetInteger("gRandomizeShuffleFrogSongRupees", RO_GENERIC_NO)) &&
((locationIt.rcType != RCTYPE_MAP_COMPASS) || CVarGetInteger("gRandomizeStartingMapsCompasses", RO_DUNGEON_ITEM_LOC_OWN_DUNGEON) != RO_DUNGEON_ITEM_LOC_VANILLA) &&
((locationIt.rcType != RCTYPE_SMALL_KEY) || CVarGetInteger("gRandomizeKeysanity", RO_DUNGEON_ITEM_LOC_OWN_DUNGEON) != RO_DUNGEON_ITEM_LOC_VANILLA) &&
((locationIt.rcType != RCTYPE_BOSS_KEY) || CVarGetInteger("gRandomizeBossKeysanity", RO_DUNGEON_ITEM_LOC_OWN_DUNGEON) != RO_DUNGEON_ITEM_LOC_VANILLA) &&
((locationIt.rcType != RCTYPE_GANON_BOSS_KEY) || CVarGetInteger("gRandomizeShuffleGanonBossKey", RO_GANON_BOSS_KEY_VANILLA) != RO_GANON_BOSS_KEY_VANILLA) &&
(locationIt.rcType != RCTYPE_GF_KEY && locationIt.rc != RC_GF_GERUDO_MEMBERSHIP_CARD ||
(CVar_GetS32("gRandomizeGerudoFortress", RO_GF_NORMAL) == RO_GF_OPEN && locationIt.rcType != RCTYPE_GF_KEY && locationIt.rc != RC_GF_GERUDO_MEMBERSHIP_CARD) ||
(CVar_GetS32("gRandomizeGerudoFortress", RO_GF_NORMAL) == RO_GF_FAST &&
((locationIt.rc == RC_GF_GERUDO_MEMBERSHIP_CARD && CVar_GetS32("gRandomizeShuffleGerudoToken", RO_GENERIC_NO) == RO_GENERIC_YES) ||
(locationIt.rc == RC_GF_NORTH_F1_CARPENTER && CVar_GetS32("gRandomizeGerudoKeys", RO_GERUDO_KEYS_VANILLA) != RO_GERUDO_KEYS_VANILLA))
(CVarGetInteger("gRandomizeGerudoFortress", RO_GF_NORMAL) == RO_GF_OPEN && locationIt.rcType != RCTYPE_GF_KEY && locationIt.rc != RC_GF_GERUDO_MEMBERSHIP_CARD) ||
(CVarGetInteger("gRandomizeGerudoFortress", RO_GF_NORMAL) == RO_GF_FAST &&
((locationIt.rc == RC_GF_GERUDO_MEMBERSHIP_CARD && CVarGetInteger("gRandomizeShuffleGerudoToken", RO_GENERIC_NO) == RO_GENERIC_YES) ||
(locationIt.rc == RC_GF_NORTH_F1_CARPENTER && CVarGetInteger("gRandomizeGerudoKeys", RO_GERUDO_KEYS_VANILLA) != RO_GERUDO_KEYS_VANILLA))
) ||
(CVar_GetS32("gRandomizeGerudoFortress", RO_GF_NORMAL) == RO_GF_NORMAL &&
((locationIt.rc == RC_GF_GERUDO_MEMBERSHIP_CARD && CVar_GetS32("gRandomizeShuffleGerudoToken", RO_GENERIC_NO) == RO_GENERIC_YES) ||
(locationIt.rcType == RCTYPE_GF_KEY && CVar_GetS32("gRandomizeGerudoKeys", RO_GERUDO_KEYS_VANILLA) != RO_GERUDO_KEYS_VANILLA))
(CVarGetInteger("gRandomizeGerudoFortress", RO_GF_NORMAL) == RO_GF_NORMAL &&
((locationIt.rc == RC_GF_GERUDO_MEMBERSHIP_CARD && CVarGetInteger("gRandomizeShuffleGerudoToken", RO_GENERIC_NO) == RO_GENERIC_YES) ||
(locationIt.rcType == RCTYPE_GF_KEY && CVarGetInteger("gRandomizeGerudoKeys", RO_GERUDO_KEYS_VANILLA) != RO_GERUDO_KEYS_VANILLA))
)
)
);

144
soh/soh/Enhancements/randomizer/randomizer_check_tracker.cpp
View File

@ -6,7 +6,7 @@
#include <string>
#include <vector>
#include <set>
#include <Cvar.h>
#include <libultraship/bridge.h>
#include <Hooks.h>
#include "3drando/item_location.hpp"
@ -109,7 +109,7 @@ std::vector<uint32_t> buttons = { BTN_A, BTN_B, BTN_CUP, BTN_CDOWN, BTN_CLEFT,
void DrawCheckTracker(bool& open) {
if (!open) {
CVar_SetS32("gCheckTrackerEnabled", 0);
CVarSetInteger("gCheckTrackerEnabled", 0);
return;
}
@ -120,14 +120,14 @@ void DrawCheckTracker(bool& open) {
return;
}
if (CVar_GetS32("gCheckTrackerWindowType", 1) == 0) {
if (CVar_GetS32("gCheckTrackerShowOnlyPaused", 0) == 1)
if (CVarGetInteger("gCheckTrackerWindowType", 1) == 0) {
if (CVarGetInteger("gCheckTrackerShowOnlyPaused", 0) == 1)
if (gPlayState == nullptr || gPlayState->pauseCtx.state == 0)
return;
if (CVar_GetS32("gCheckTrackerDisplayType", 0) == 1) {
int comboButton1Mask = buttons[CVar_GetS32("gCheckTrackerComboButton1", 6)];
int comboButton2Mask = buttons[CVar_GetS32("gCheckTrackerComboButton2", 8)];
if (CVarGetInteger("gCheckTrackerDisplayType", 0) == 1) {
int comboButton1Mask = buttons[CVarGetInteger("gCheckTrackerComboButton1", 6)];
int comboButton2Mask = buttons[CVarGetInteger("gCheckTrackerComboButton2", 8)];
bool comboButtonsHeld = trackerButtonsPressed != nullptr &&
trackerButtonsPressed[0].button & comboButton1Mask &&
trackerButtonsPressed[0].button & comboButton2Mask;
@ -213,17 +213,17 @@ void DrawCheckTracker(bool& open) {
RainbowTick();
bool doDraw = false;
bool thisAreaFullyChecked = false;
bool showHidden = CVar_GetS32("gCheckTrackerOptionShowHidden", 0);
bool hideIncomplete = CVar_GetS32("gCheckTrackerAreaIncompleteHide", 0);
bool hideComplete = CVar_GetS32("gCheckTrackerAreaCompleteHide", 0);
bool showHidden = CVarGetInteger("gCheckTrackerOptionShowHidden", 0);
bool hideIncomplete = CVarGetInteger("gCheckTrackerAreaIncompleteHide", 0);
bool hideComplete = CVarGetInteger("gCheckTrackerAreaCompleteHide", 0);
bool collapseLogic;
bool doingCollapseOrExpand = optExpandAll || optCollapseAll;
bool isThisAreaSpoiled;
RandomizerCheckArea lastArea = RCAREA_INVALID;
Color_RGBA8 areaCompleteColor = CVar_GetRGBA("gCheckTrackerAreaMainCompleteColor", Color_Main_Default);
Color_RGBA8 areaIncompleteColor = CVar_GetRGBA("gCheckTrackerAreaMainIncompleteColor", Color_Main_Default);
Color_RGBA8 extraCompleteColor = CVar_GetRGBA("gCheckTrackerAreaExtraCompleteColor", Color_Area_Complete_Extra_Default);
Color_RGBA8 extraIncompleteColor = CVar_GetRGBA("gCheckTrackerAreaExtraIncompleteColor", Color_Area_Incomplete_Extra_Default);
Color_RGBA8 areaCompleteColor = CVarGetColor("gCheckTrackerAreaMainCompleteColor", Color_Main_Default);
Color_RGBA8 areaIncompleteColor = CVarGetColor("gCheckTrackerAreaMainIncompleteColor", Color_Main_Default);
Color_RGBA8 extraCompleteColor = CVarGetColor("gCheckTrackerAreaExtraCompleteColor", Color_Area_Complete_Extra_Default);
Color_RGBA8 extraIncompleteColor = CVarGetColor("gCheckTrackerAreaExtraIncompleteColor", Color_Area_Incomplete_Extra_Default);
Color_RGBA8 mainColor;
Color_RGBA8 extraColor;
std::string stemp;
@ -283,7 +283,7 @@ void DrawCheckTracker(bool& open) {
ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(extraColor.r / 255.0f, extraColor.g / 255.0f,
extraColor.b / 255.0f, extraColor.a / 255.0f));
isThisAreaSpoiled = areasSpoiled & areaMask || CVar_GetS32("gCheckTrackerOptionMQSpoilers", 0);
isThisAreaSpoiled = areasSpoiled & areaMask || CVarGetInteger("gCheckTrackerOptionMQSpoilers", 0);
if (isThisAreaSpoiled) {
if (showVOrMQ && RandomizerCheckObjects::AreaIsDungeon(obj.rcArea)) {
@ -334,12 +334,12 @@ void BeginFloatWindows(std::string UniqueName, ImGuiWindowFlags flags) {
ImGuiWindowFlags_AlwaysVerticalScrollbar | ImGuiWindowFlags_NoFocusOnAppearing;
}
if (!CVar_GetS32("gCheckTrackerWindowType", 1)) {
if (!CVarGetInteger("gCheckTrackerWindowType", 1)) {
ImGui::SetNextWindowViewport(ImGui::GetMainViewport()->ID);
windowFlags |= ImGuiWindowFlags_NoDocking | ImGuiWindowFlags_NoNav | ImGuiWindowFlags_NoTitleBar |
ImGuiWindowFlags_NoScrollWithMouse | ImGuiWindowFlags_NoScrollbar;
if (!CVar_GetS32("gCheckTrackerHudEditMode", 0)) {
if (!CVarGetInteger("gCheckTrackerHudEditMode", 0)) {
windowFlags |= ImGuiWindowFlags_NoInputs | ImGuiWindowFlags_NoMove;
}
}
@ -602,7 +602,7 @@ bool SlowUpdateCheck() {
bool ShouldUpdateChecks() {
// TODO eventually will need to be hooked into game elements rather than just save file
if (CVar_GetS32("gCheckTrackerOptionPerformanceMode", 0))
if (CVarGetInteger("gCheckTrackerOptionPerformanceMode", 0))
return SlowUpdateCheck();
else
return true;
@ -742,7 +742,7 @@ bool HasItemBeenCollected(RandomizerCheckObject obj) {
case SpoilerCollectionCheckType::SPOILER_CHK_GRAVEDIGGER:
// Gravedigger has a fix in place that means one of two save locations. Check both.
return (gSaveContext.itemGetInf[1] & 0x1000) || // vanilla flag
((gSaveContext.n64ddFlag || CVar_GetS32("gGravediggingTourFix", 0)) &&
((gSaveContext.n64ddFlag || CVarGetInteger("gGravediggingTourFix", 0)) &&
gSaveContext.sceneFlags[scene].collect & (1 << flag)); // rando/fix flag
default:
return false;
@ -754,43 +754,43 @@ void DrawLocation(RandomizerCheckObject rcObj, RandomizerCheckShow* thisCheckSta
Color_RGBA8 mainColor;
Color_RGBA8 extraColor;
std::string txt;
bool showHidden = CVar_GetS32("gCheckTrackerOptionShowHidden", 0);
bool showHidden = CVarGetInteger("gCheckTrackerOptionShowHidden", 0);
if (*thisCheckStatus == RCSHOW_UNCHECKED) {
if (!showHidden && CVar_GetS32("gCheckTrackerUncheckedHide", 0))
if (!showHidden && CVarGetInteger("gCheckTrackerUncheckedHide", 0))
return;
mainColor = CVar_GetRGBA("gCheckTrackerUncheckedMainColor", Color_Main_Default);
extraColor = CVar_GetRGBA("gCheckTrackerUncheckedExtraColor", Color_Unchecked_Extra_Default);
mainColor = CVarGetColor("gCheckTrackerUncheckedMainColor", Color_Main_Default);
extraColor = CVarGetColor("gCheckTrackerUncheckedExtraColor", Color_Unchecked_Extra_Default);
} else if (*thisCheckStatus == RCSHOW_SKIPPED) {
if (!showHidden && CVar_GetS32("gCheckTrackerSkippedHide", 0))
if (!showHidden && CVarGetInteger("gCheckTrackerSkippedHide", 0))
return;
mainColor = CVar_GetRGBA("gCheckTrackerSkippedMainColor", Color_Main_Default);
extraColor = CVar_GetRGBA("gCheckTrackerSkippedExtraColor", Color_Skipped_Extra_Default);
mainColor = CVarGetColor("gCheckTrackerSkippedMainColor", Color_Main_Default);
extraColor = CVarGetColor("gCheckTrackerSkippedExtraColor", Color_Skipped_Extra_Default);
} else if (*thisCheckStatus == RCSHOW_SEEN) {
if (!showHidden && CVar_GetS32("gCheckTrackerSeenHide", 0))
if (!showHidden && CVarGetInteger("gCheckTrackerSeenHide", 0))
return;
mainColor = CVar_GetRGBA("gCheckTrackerSeenMainColor", Color_Main_Default);
extraColor = CVar_GetRGBA("gCheckTrackerSeenExtraColor", Color_Seen_Extra_Default);
mainColor = CVarGetColor("gCheckTrackerSeenMainColor", Color_Main_Default);
extraColor = CVarGetColor("gCheckTrackerSeenExtraColor", Color_Seen_Extra_Default);
} else if (*thisCheckStatus == RCSHOW_HINTED) {
if (!showHidden && CVar_GetS32("gCheckTrackerHintedHide", 0))
if (!showHidden && CVarGetInteger("gCheckTrackerHintedHide", 0))
return;
mainColor = CVar_GetRGBA("gCheckTrackerHintedMainColor", Color_Main_Default);
extraColor = CVar_GetRGBA("gCheckTrackerHintedExtraColor", Color_Hinted_Extra_Default);
mainColor = CVarGetColor("gCheckTrackerHintedMainColor", Color_Main_Default);
extraColor = CVarGetColor("gCheckTrackerHintedExtraColor", Color_Hinted_Extra_Default);
} else if (*thisCheckStatus == RCSHOW_CHECKED) {
if (!showHidden && CVar_GetS32("gCheckTrackerCheckedHide", 0))
if (!showHidden && CVarGetInteger("gCheckTrackerCheckedHide", 0))
return;
mainColor = CVar_GetRGBA("gCheckTrackerCheckedMainColor", Color_Main_Default);
extraColor = CVar_GetRGBA("gCheckTrackerCheckedExtraColor", Color_Checked_Extra_Default);
mainColor = CVarGetColor("gCheckTrackerCheckedMainColor", Color_Main_Default);
extraColor = CVarGetColor("gCheckTrackerCheckedExtraColor", Color_Checked_Extra_Default);
} else if (*thisCheckStatus == RCSHOW_SCUMMED) {
if (!showHidden && CVar_GetS32("gCheckTrackerScummedHide", 0))
if (!showHidden && CVarGetInteger("gCheckTrackerScummedHide", 0))
return;
mainColor = CVar_GetRGBA("gCheckTrackerScummedMainColor", Color_Main_Default);
extraColor = CVar_GetRGBA("gCheckTrackerScummedExtraColor", Color_Scummed_Extra_Default);
mainColor = CVarGetColor("gCheckTrackerScummedMainColor", Color_Main_Default);
extraColor = CVarGetColor("gCheckTrackerScummedExtraColor", Color_Scummed_Extra_Default);
} else if (*thisCheckStatus == RCSHOW_SAVED) {
if (!showHidden && CVar_GetS32("gCheckTrackerSavedHide", 0))
if (!showHidden && CVarGetInteger("gCheckTrackerSavedHide", 0))
return;
mainColor = CVar_GetRGBA("gCheckTrackerSavedMainColor", Color_Main_Default);
extraColor = CVar_GetRGBA("gCheckTrackerSavedExtraColor", Color_Saved_Extra_Default);
mainColor = CVarGetColor("gCheckTrackerSavedMainColor", Color_Main_Default);
extraColor = CVarGetColor("gCheckTrackerSavedExtraColor", Color_Saved_Extra_Default);
}
//Main Text
@ -870,9 +870,9 @@ static std::set<std::string> rainbowCVars = {
int hue = 0;
void RainbowTick() {
float freqHue = hue * 2 * M_PI / (360 * CVar_GetFloat("gCosmetics.RainbowSpeed", 0.6f));
float freqHue = hue * 2 * M_PI / (360 * CVarGetFloat("gCosmetics.RainbowSpeed", 0.6f));
for (auto cvar : rainbowCVars) {
if (CVar_GetS32((cvar + "RBM").c_str(), 0) == 0)
if (CVarGetInteger((cvar + "RBM").c_str(), 0) == 0)
continue;
Color_RGBA8 newColor;
@ -881,7 +881,7 @@ void RainbowTick() {
newColor.b = sin(freqHue + (4 * M_PI / 3)) * 127 + 128;
newColor.a = 255;
CVar_SetRGBA(cvar.c_str(), newColor);
CVarSetColor(cvar.c_str(), newColor);
}
hue++;
@ -891,8 +891,8 @@ void RainbowTick() {
void ImGuiDrawTwoColorPickerSection(const char* text, const char* cvarMainName, const char* cvarExtraName,
Color_RGBA8& main_color, Color_RGBA8& extra_color, Color_RGBA8& main_default_color,
Color_RGBA8& extra_default_color, const char* cvarHideName) {
Color_RGBA8 cvarMainColor = CVar_GetRGBA(cvarMainName, main_default_color);
Color_RGBA8 cvarExtraColor = CVar_GetRGBA(cvarExtraName, extra_default_color);
Color_RGBA8 cvarMainColor = CVarGetColor(cvarMainName, main_default_color);
Color_RGBA8 cvarExtraColor = CVarGetColor(cvarExtraName, extra_default_color);
main_color = cvarMainColor;
extra_color = cvarExtraColor;
@ -914,7 +914,7 @@ void ImGuiDrawTwoColorPickerSection(const char* text, const char* cvarMainName,
ImVec4(main_color.r, main_color.g, main_color.b, main_color.a),
ImVec4(main_default_color.r, main_default_color.g, main_default_color.b, main_default_color.a)))
{
main_color = CVar_GetRGBA(cvarMainName, main_default_color);
main_color = CVarGetColor(cvarMainName, main_default_color);
};
ImGui::PopItemWidth();
@ -925,7 +925,7 @@ void ImGuiDrawTwoColorPickerSection(const char* text, const char* cvarMainName,
ImVec4(extra_color.r, extra_color.g, extra_color.b, extra_color.a),
ImVec4(extra_default_color.r, extra_default_color.g, extra_default_color.b, extra_default_color.a)))
{
extra_color = CVar_GetRGBA(cvarExtraName, extra_default_color);
extra_color = CVarGetColor(cvarExtraName, extra_default_color);
}
ImGui::PopItemWidth();
@ -942,7 +942,7 @@ const char* buttonStrings[] = { "A Button", "B Button", "C-Up", "C-Down", "C-Le
"Z Button", "R Button", "Start", "D-Up", "D-Down", "D-Left", "D-Right" };
void DrawCheckTrackerOptions(bool& open) {
if (!open) {
CVar_SetS32("gCheckTrackerSettingsEnabled", 0);
CVarSetInteger("gCheckTrackerSettingsEnabled", 0);
return;
}
@ -966,7 +966,7 @@ void DrawCheckTrackerOptions(bool& open) {
ImVec4(Color_Bg_Default.r, Color_Bg_Default.g, Color_Bg_Default.b, Color_Bg_Default.a),
false, true))
{
Color_Background = CVar_GetRGBA("gCheckTrackerBgColor", Color_Bg_Default);
Color_Background = CVarGetColor("gCheckTrackerBgColor", Color_Bg_Default);
}
ImGui::PopItemWidth();
@ -974,13 +974,13 @@ void DrawCheckTrackerOptions(bool& open) {
ImGui::SameLine();
UIWidgets::EnhancementCombobox("gCheckTrackerWindowType", windowType, 2, 1);
if (CVar_GetS32("gCheckTrackerWindowType", 1) == 0) {
if (CVarGetInteger("gCheckTrackerWindowType", 1) == 0) {
UIWidgets::EnhancementCheckbox("Enable Dragging", "gCheckTrackerHudEditMode");
UIWidgets::EnhancementCheckbox("Only enable while paused", "gCheckTrackerShowOnlyPaused");
ImGui::Text("Display Mode");
ImGui::SameLine();
UIWidgets::EnhancementCombobox("gCheckTrackerDisplayType", displayType, 2, 0);
if (CVar_GetS32("gCheckTrackerDisplayType", 0) > 0) {
if (CVarGetInteger("gCheckTrackerDisplayType", 0) > 0) {
ImGui::Text("Combo Button 1");
ImGui::SameLine();
UIWidgets::EnhancementCombobox("gCheckTrackerComboButton1", buttonStrings, 14, 6);
@ -1012,27 +1012,27 @@ void DrawCheckTrackerOptions(bool& open) {
}
void InitCheckTracker() {
SohImGui::AddWindow("Randomizer", "Check Tracker", DrawCheckTracker, CVar_GetS32("gCheckTrackerEnabled", 0) == 1);
SohImGui::AddWindow("Randomizer", "Check Tracker", DrawCheckTracker, CVarGetInteger("gCheckTrackerEnabled", 0) == 1);
SohImGui::AddWindow("Randomizer", "Check Tracker Settings", DrawCheckTrackerOptions);
Color_Background = CVar_GetRGBA("gCheckTrackerBgColor", Color_Bg_Default);
Color_Area_Incomplete_Main = CVar_GetRGBA("gCheckTrackerAreaMainIncompleteColor", Color_Main_Default);
Color_Area_Incomplete_Extra = CVar_GetRGBA("gCheckTrackerAreaExtraIncompleteColor", Color_Area_Incomplete_Extra_Default);
Color_Area_Complete_Main = CVar_GetRGBA("gCheckTrackerAreaMainCompleteColor", Color_Main_Default);
Color_Area_Complete_Extra = CVar_GetRGBA("gCheckTrackerAreaExtraCompleteColor", Color_Area_Complete_Extra_Default);
Color_Unchecked_Main = CVar_GetRGBA("gCheckTrackerUncheckedMainColor", Color_Main_Default);
Color_Unchecked_Extra = CVar_GetRGBA("gCheckTrackerUncheckedExtraColor", Color_Unchecked_Extra_Default);
Color_Skipped_Main = CVar_GetRGBA("gCheckTrackerSkippedMainColor", Color_Main_Default);
Color_Skipped_Extra = CVar_GetRGBA("gCheckTrackerSkippedExtraColor", Color_Skipped_Extra_Default);
Color_Seen_Main = CVar_GetRGBA("gCheckTrackerSeenMainColor", Color_Main_Default);
Color_Seen_Extra = CVar_GetRGBA("gCheckTrackerSeenExtraColor", Color_Seen_Extra_Default);
Color_Hinted_Main = CVar_GetRGBA("gCheckTrackerHintedMainColor", Color_Main_Default);
Color_Hinted_Extra = CVar_GetRGBA("gCheckTrackerHintedExtraColor", Color_Hinted_Extra_Default);
Color_Checked_Main = CVar_GetRGBA("gCheckTrackerCheckedMainColor", Color_Main_Default);
Color_Checked_Extra = CVar_GetRGBA("gCheckTrackerCheckedExtraColor", Color_Checked_Extra_Default);
Color_Scummed_Main = CVar_GetRGBA("gCheckTrackerScummedMainColor", Color_Main_Default);
Color_Scummed_Extra = CVar_GetRGBA("gCheckTrackerScummedExtraColor", Color_Scummed_Extra_Default);
Color_Saved_Main = CVar_GetRGBA("gCheckTrackerSavedMainColor", Color_Main_Default);
Color_Saved_Extra = CVar_GetRGBA("gCheckTrackerSavedExtraColor", Color_Saved_Extra_Default);
Color_Background = CVarGetColor("gCheckTrackerBgColor", Color_Bg_Default);
Color_Area_Incomplete_Main = CVarGetColor("gCheckTrackerAreaMainIncompleteColor", Color_Main_Default);
Color_Area_Incomplete_Extra = CVarGetColor("gCheckTrackerAreaExtraIncompleteColor", Color_Area_Incomplete_Extra_Default);
Color_Area_Complete_Main = CVarGetColor("gCheckTrackerAreaMainCompleteColor", Color_Main_Default);
Color_Area_Complete_Extra = CVarGetColor("gCheckTrackerAreaExtraCompleteColor", Color_Area_Complete_Extra_Default);
Color_Unchecked_Main = CVarGetColor("gCheckTrackerUncheckedMainColor", Color_Main_Default);
Color_Unchecked_Extra = CVarGetColor("gCheckTrackerUncheckedExtraColor", Color_Unchecked_Extra_Default);
Color_Skipped_Main = CVarGetColor("gCheckTrackerSkippedMainColor", Color_Main_Default);
Color_Skipped_Extra = CVarGetColor("gCheckTrackerSkippedExtraColor", Color_Skipped_Extra_Default);
Color_Seen_Main = CVarGetColor("gCheckTrackerSeenMainColor", Color_Main_Default);
Color_Seen_Extra = CVarGetColor("gCheckTrackerSeenExtraColor", Color_Seen_Extra_Default);
Color_Hinted_Main = CVarGetColor("gCheckTrackerHintedMainColor", Color_Main_Default);
Color_Hinted_Extra = CVarGetColor("gCheckTrackerHintedExtraColor", Color_Hinted_Extra_Default);
Color_Checked_Main = CVarGetColor("gCheckTrackerCheckedMainColor", Color_Main_Default);
Color_Checked_Extra = CVarGetColor("gCheckTrackerCheckedExtraColor", Color_Checked_Extra_Default);
Color_Scummed_Main = CVarGetColor("gCheckTrackerScummedMainColor", Color_Main_Default);
Color_Scummed_Extra = CVarGetColor("gCheckTrackerScummedExtraColor", Color_Scummed_Extra_Default);
Color_Saved_Main = CVarGetColor("gCheckTrackerSavedMainColor", Color_Main_Default);
Color_Saved_Extra = CVarGetColor("gCheckTrackerSavedExtraColor", Color_Saved_Extra_Default);
Ship::RegisterHook<Ship::ControllerRead>([](OSContPad* cont_pad) {
trackerButtonsPressed = cont_pad;

26
soh/soh/Enhancements/randomizer/randomizer_entrance_tracker.cpp
View File

@ -8,7 +8,7 @@
#include <map>
#include <string>
#include <vector>
#include <Cvar.h>
#include <libultraship/bridge.h>
#include <Hooks.h>
extern "C" {
@ -607,7 +607,7 @@ void InitEntranceTrackingData() {
void DrawEntranceTracker(bool& open) {
if (!open) {
CVar_SetS32("gEntranceTrackerEnabled", 0);
CVarSetInteger("gEntranceTrackerEnabled", 0);
return;
}
@ -717,8 +717,8 @@ void DrawEntranceTracker(bool& open) {
nextTreeState = 2;
}
uint8_t destToggle = CVar_GetS32("gEntranceTrackerSortBy", 0);
uint8_t groupToggle = CVar_GetS32("gEntranceTrackerGroupBy", 0);
uint8_t destToggle = CVarGetInteger("gEntranceTrackerSortBy", 0);
uint8_t groupToggle = CVarGetInteger("gEntranceTrackerGroupBy", 0);
// Combine destToggle and groupToggle to get a range of 0-3
uint8_t groupType = destToggle + (groupToggle * 2);
@ -765,8 +765,8 @@ void DrawEntranceTracker(bool& open) {
bool isDiscovered = IsEntranceDiscovered(entrance.index);
bool showOriginal = (!destToggle ? CVar_GetS32("gEntranceTrackerShowTo", 0) : CVar_GetS32("gEntranceTrackerShowFrom", 0)) || isDiscovered;
bool showOverride = (!destToggle ? CVar_GetS32("gEntranceTrackerShowFrom", 0) : CVar_GetS32("gEntranceTrackerShowTo", 0)) || isDiscovered;
bool showOriginal = (!destToggle ? CVarGetInteger("gEntranceTrackerShowTo", 0) : CVarGetInteger("gEntranceTrackerShowFrom", 0)) || isDiscovered;
bool showOverride = (!destToggle ? CVarGetInteger("gEntranceTrackerShowFrom", 0) : CVarGetInteger("gEntranceTrackerShowTo", 0)) || isDiscovered;
const char* origSrcAreaName = spoilerEntranceGroupNames[original->srcGroup].c_str();
const char* origTypeName = groupTypeNames[original->type].c_str();
@ -779,7 +779,7 @@ void DrawEntranceTracker(bool& open) {
const char* rplcDstName = showOverride ? override->destination.c_str() : "";
// Filter for entrances by group name, type, source/destination names, and meta tags
if ((!locationSearch.IsActive() && (showOriginal || showOverride || !CVar_GetS32("gEntranceTrackerCollapseUndiscovered", 0))) ||
if ((!locationSearch.IsActive() && (showOriginal || showOverride || !CVarGetInteger("gEntranceTrackerCollapseUndiscovered", 0))) ||
((showOriginal && (locationSearch.PassFilter(origSrcName) ||
locationSearch.PassFilter(origDstName) || locationSearch.PassFilter(origSrcAreaName) ||
locationSearch.PassFilter(origTypeName) || locationSearch.PassFilter(original->metaTag.c_str()))) ||
@ -817,8 +817,8 @@ void DrawEntranceTracker(bool& open) {
bool isDiscovered = IsEntranceDiscovered(entrance.index);
bool showOriginal = (!destToggle ? CVar_GetS32("gEntranceTrackerShowTo", 0) : CVar_GetS32("gEntranceTrackerShowFrom", 0)) || isDiscovered;
bool showOverride = (!destToggle ? CVar_GetS32("gEntranceTrackerShowFrom", 0) : CVar_GetS32("gEntranceTrackerShowTo", 0)) || isDiscovered;
bool showOriginal = (!destToggle ? CVarGetInteger("gEntranceTrackerShowTo", 0) : CVarGetInteger("gEntranceTrackerShowFrom", 0)) || isDiscovered;
bool showOverride = (!destToggle ? CVarGetInteger("gEntranceTrackerShowFrom", 0) : CVarGetInteger("gEntranceTrackerShowTo", 0)) || isDiscovered;
const char* unknown = "???";
@ -831,18 +831,18 @@ void DrawEntranceTracker(bool& open) {
// Handle highlighting and auto scroll
if (LinkIsInArea(original) != -1) {
if (CVar_GetS32("gEntranceTrackerHighlightAvailable", 0)) {
if (CVarGetInteger("gEntranceTrackerHighlightAvailable", 0)) {
color = COLOR_GREEN;
}
if (doAreaScroll) {
doAreaScroll = false;
if (CVar_GetS32("gEntranceTrackerAutoScroll", 0)) {
if (CVarGetInteger("gEntranceTrackerAutoScroll", 0)) {
ImGui::SetScrollHereY(0.0f);
}
}
} else if (original->index == lastEntranceIndex) {
if (CVar_GetS32("gEntranceTrackerHighlightPrevious", 0)) {
if (CVarGetInteger("gEntranceTrackerHighlightPrevious", 0)) {
color = COLOR_ORANGE;
}
}
@ -887,5 +887,5 @@ void DrawEntranceTracker(bool& open) {
}
void InitEntranceTracker() {
SohImGui::AddWindow("Randomizer", "Entrance Tracker", DrawEntranceTracker, CVar_GetS32("gEntranceTrackerEnabled", 0) == 1);
SohImGui::AddWindow("Randomizer", "Entrance Tracker", DrawEntranceTracker, CVarGetInteger("gEntranceTrackerEnabled", 0) == 1);
}

162
soh/soh/Enhancements/randomizer/randomizer_item_tracker.cpp
View File

@ -7,7 +7,7 @@
#include <map>
#include <string>
#include <vector>
#include <Cvar.h>
#include <libultraship/bridge.h>
#include <Hooks.h>
extern "C" {
@ -352,11 +352,11 @@ ItemTrackerNumbers GetItemCurrentAndMax(ItemTrackerItem item) {
#define IM_COL_PURPLE IM_COL32(180, 90, 200, 255)
void DrawItemCount(ItemTrackerItem item) {
int iconSize = CVar_GetS32("gItemTrackerIconSize", 36);
int iconSize = CVarGetInteger("gItemTrackerIconSize", 36);
ItemTrackerNumbers currentAndMax = GetItemCurrentAndMax(item);
ImVec2 p = ImGui::GetCursorScreenPos();
int32_t trackerNumberDisplayMode = CVar_GetS32("gItemTrackerCapacityTrack", 1);
int32_t trackerKeyNumberDisplayMode = CVar_GetS32("gItemTrackerKeyTrack", 0);
int32_t trackerNumberDisplayMode = CVarGetInteger("gItemTrackerCapacityTrack", 1);
int32_t trackerKeyNumberDisplayMode = CVarGetInteger("gItemTrackerKeyTrack", 0);
if (item.id == ITEM_KEY_SMALL && IsValidSaveFile()) {
std::string currentString = "";
@ -387,7 +387,7 @@ void DrawItemCount(ItemTrackerItem item) {
ImU32 currentColor = IM_COL_WHITE;
ImU32 maxColor = item.id == QUEST_SKULL_TOKEN ? IM_COL_RED : IM_COL_GREEN;
bool shouldAlignToLeft = CVar_GetS32("gItemTrackerCurrentOnLeft", 0) &&
bool shouldAlignToLeft = CVarGetInteger("gItemTrackerCurrentOnLeft", 0) &&
trackerNumberDisplayMode != ITEM_TRACKER_NUMBER_CAPACITY &&
trackerNumberDisplayMode != ITEM_TRACKER_NUMBER_AMMO;
@ -446,7 +446,7 @@ void DrawItemCount(ItemTrackerItem item) {
void DrawEquip(ItemTrackerItem item) {
bool hasEquip = (item.data & gSaveContext.inventory.equipment) != 0;
int iconSize = CVar_GetS32("gItemTrackerIconSize", 36);
int iconSize = CVarGetInteger("gItemTrackerIconSize", 36);
ImGui::Image(SohImGui::GetTextureByName(hasEquip && IsValidSaveFile() ? item.name : item.nameFaded),
ImVec2(iconSize, iconSize), ImVec2(0, 0), ImVec2(1, 1));
@ -455,7 +455,7 @@ void DrawEquip(ItemTrackerItem item) {
void DrawQuest(ItemTrackerItem item) {
bool hasQuestItem = (item.data & gSaveContext.inventory.questItems) != 0;
int iconSize = CVar_GetS32("gItemTrackerIconSize", 36);
int iconSize = CVarGetInteger("gItemTrackerIconSize", 36);
ImGui::BeginGroup();
ImGui::Image(SohImGui::GetTextureByName(hasQuestItem && IsValidSaveFile() ? item.name : item.nameFaded),
ImVec2(iconSize, iconSize), ImVec2(0, 0), ImVec2(1, 1));
@ -471,7 +471,7 @@ void DrawQuest(ItemTrackerItem item) {
void DrawItem(ItemTrackerItem item) {
uint32_t actualItemId = INV_CONTENT(item.id);
int iconSize = CVar_GetS32("gItemTrackerIconSize", 36);
int iconSize = CVarGetInteger("gItemTrackerIconSize", 36);
bool hasItem = actualItemId != ITEM_NONE;
if (item.id == ITEM_NONE) {
@ -532,7 +532,7 @@ void DrawBottle(ItemTrackerItem item) {
item = actualItemTrackerItemMap[actualItemId];
}
int iconSize = CVar_GetS32("gItemTrackerIconSize", 36);
int iconSize = CVarGetInteger("gItemTrackerIconSize", 36);
ImGui::Image(SohImGui::GetTextureByName(hasItem && IsValidSaveFile() ? item.name : item.nameFaded),
ImVec2(iconSize, iconSize), ImVec2(0, 0), ImVec2(1, 1));
@ -543,7 +543,7 @@ void DrawDungeonItem(ItemTrackerItem item) {
uint32_t itemId = item.id;
ImU32 dungeonColor = IM_COL_WHITE;
uint32_t bitMask = 1 << (item.id - ITEM_KEY_BOSS); // Bitset starts at ITEM_KEY_BOSS == 0. the rest are sequential
int iconSize = CVar_GetS32("gItemTrackerIconSize", 36);
int iconSize = CVarGetInteger("gItemTrackerIconSize", 36);
bool hasItem = (bitMask & gSaveContext.inventory.dungeonItems[item.data]) != 0;
bool hasSmallKey = (gSaveContext.inventory.dungeonKeys[item.data]) >= 0;
ImGui::BeginGroup();
@ -587,7 +587,7 @@ void DrawDungeonItem(ItemTrackerItem item) {
}
void DrawSong(ItemTrackerItem item) {
int iconSize = CVar_GetS32("gItemTrackerIconSize", 36);
int iconSize = CVarGetInteger("gItemTrackerIconSize", 36);
uint32_t bitMask = 1 << item.id;
bool hasSong = (bitMask & gSaveContext.inventory.questItems) != 0;
ImVec2 p = ImGui::GetCursorScreenPos();
@ -601,8 +601,8 @@ static ImVector<char> itemTrackerNotes;
void DrawNotes(bool resizeable = false) {
ImGui::BeginGroup();
int iconSize = CVar_GetS32("gItemTrackerIconSize", 36);
int iconSpacing = CVar_GetS32("gItemTrackerIconSpacing", 12);
int iconSize = CVarGetInteger("gItemTrackerIconSize", 36);
int iconSpacing = CVarGetInteger("gItemTrackerIconSpacing", 12);
struct ItemTrackerNotes {
static int TrackerNotesResizeCallback(ImGuiInputTextCallbackData* data) {
@ -627,7 +627,7 @@ void DrawNotes(bool resizeable = false) {
ImVec2 size = resizeable ? ImVec2(-FLT_MIN, ImGui::GetContentRegionAvail().y) : ImVec2(((iconSize + iconSpacing) * 6) - 8, 200);
ItemTrackerNotes::TrackerNotesInputTextMultiline("##ItemTrackerNotes", &itemTrackerNotes, size, ImGuiInputTextFlags_AllowTabInput);
if (ImGui::IsItemDeactivatedAfterEdit() && IsValidSaveFile()) {
CVar_SetString(("gItemTrackerNotes" + std::to_string(gSaveContext.fileNum)).c_str(), std::string(std::begin(itemTrackerNotes), std::end(itemTrackerNotes)).c_str());
CVarSetString(("gItemTrackerNotes" + std::to_string(gSaveContext.fileNum)).c_str(), std::string(std::begin(itemTrackerNotes), std::end(itemTrackerNotes)).c_str());
SohImGui::RequestCvarSaveOnNextTick();
}
ImGui::EndGroup();
@ -642,11 +642,11 @@ void BeginFloatingWindows(std::string UniqueName, ImGuiWindowFlags flags = 0) {
windowFlags |= ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoFocusOnAppearing | ImGuiWindowFlags_NoResize;
}
if (!CVar_GetS32("gItemTrackerWindowType", 0)) {
if (!CVarGetInteger("gItemTrackerWindowType", 0)) {
ImGui::SetNextWindowViewport(ImGui::GetMainViewport()->ID);
windowFlags |= ImGuiWindowFlags_NoDocking | ImGuiWindowFlags_NoNav | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoScrollWithMouse | ImGuiWindowFlags_NoScrollbar;
if (!CVar_GetS32("gItemTrackerHudEditMode", 0)) {
if (!CVarGetInteger("gItemTrackerHudEditMode", 0)) {
windowFlags |= ImGuiWindowFlags_NoInputs | ImGuiWindowFlags_NoMove;
}
}
@ -667,9 +667,9 @@ void EndFloatingWindows() {
* Takes in a vector of ItemTrackerItem and draws them in rows of N items
*/
void DrawItemsInRows(std::vector<ItemTrackerItem> items, int columns = 6) {
int iconSize = CVar_GetS32("gItemTrackerIconSize", 36);
int iconSpacing = CVar_GetS32("gItemTrackerIconSpacing", 12);
int topPadding = CVar_GetS32("gItemTrackerWindowType", 0) ? 20 : 0;
int iconSize = CVarGetInteger("gItemTrackerIconSize", 36);
int iconSpacing = CVarGetInteger("gItemTrackerIconSpacing", 12);
int topPadding = CVarGetInteger("gItemTrackerWindowType", 0) ? 20 : 0;
for (int i = 0; i < items.size(); i++) {
int row = i / columns;
@ -684,8 +684,8 @@ void DrawItemsInRows(std::vector<ItemTrackerItem> items, int columns = 6) {
* Takes in a vector of ItemTrackerItem and draws them evenly spread across a circle
*/
void DrawItemsInACircle(std::vector<ItemTrackerItem> items) {
int iconSize = CVar_GetS32("gItemTrackerIconSize", 36);
int iconSpacing = CVar_GetS32("gItemTrackerIconSpacing", 12);
int iconSize = CVarGetInteger("gItemTrackerIconSize", 36);
int iconSpacing = CVarGetInteger("gItemTrackerIconSpacing", 12);
ImVec2 max = ImGui::GetWindowContentRegionMax();
float radius = (iconSize + iconSpacing) * 2;
@ -705,8 +705,8 @@ void DrawItemsInACircle(std::vector<ItemTrackerItem> items) {
* to then call DrawItemsInRows
*/
std::vector<ItemTrackerItem> GetDungeonItemsVector(std::vector<ItemTrackerDungeon> dungeons, int columns = 6) {
int iconSize = CVar_GetS32("gItemTrackerIconSize", 36);
int iconSpacing = CVar_GetS32("gItemTrackerIconSpacing", 12);
int iconSize = CVarGetInteger("gItemTrackerIconSize", 36);
int iconSpacing = CVarGetInteger("gItemTrackerIconSpacing", 12);
std::vector<ItemTrackerItem> dungeonItems = {};
int rowCount = 0;
@ -752,7 +752,7 @@ std::vector<ItemTrackerItem> GetDungeonItemsVector(std::vector<ItemTrackerDungeo
/* TODO: These need to be moved to a common imgui file */
void LabeledComboBoxRightAligned(const char* label, const char* cvar, std::vector<std::string> options, s32 defaultValue) {
s32 currentValue = CVar_GetS32(cvar, defaultValue);
s32 currentValue = CVarGetInteger(cvar, defaultValue);
std::string hiddenLabel = "##" + std::string(cvar);
ImGui::Text(label);
#ifdef __WIIU__
@ -765,7 +765,7 @@ void LabeledComboBoxRightAligned(const char* label, const char* cvar, std::vecto
if (ImGui::BeginCombo(hiddenLabel.c_str(), options[currentValue].c_str())) {
for (int i = 0; i < options.size(); i++) {
if (ImGui::Selectable(options[i].c_str())) {
CVar_SetS32(cvar, i);
CVarSetInteger(cvar, i);
SohImGui::RequestCvarSaveOnNextTick();
shouldUpdateVectors = true;
}
@ -780,9 +780,9 @@ void PaddedEnhancementCheckbox(const char* text, const char* cvarName, s32 defau
if (padTop) {
ImGui::Dummy(ImVec2(0.0f, 0.0f));
}
bool val = (bool)CVar_GetS32(cvarName, defaultValue);
bool val = (bool)CVarGetInteger(cvarName, defaultValue);
if (ImGui::Checkbox(text, &val)) {
CVar_SetS32(cvarName, val);
CVarSetInteger(cvarName, val);
SohImGui::RequestCvarSaveOnNextTick();
shouldUpdateVectors = true;
}
@ -802,8 +802,8 @@ void UpdateVectors() {
dungeonRewards.insert(dungeonRewards.end(), dungeonRewardMedallions.begin(), dungeonRewardMedallions.end());
dungeonItems.clear();
if (CVar_GetS32("gItemTrackerDisplayDungeonItemsHorizontal", 1) && CVar_GetS32("gItemTrackerDungeonItemsDisplayType", 0) == 2) {
if (CVar_GetS32("gItemTrackerDisplayDungeonItemsMaps", 1)) {
if (CVarGetInteger("gItemTrackerDisplayDungeonItemsHorizontal", 1) && CVarGetInteger("gItemTrackerDungeonItemsDisplayType", 0) == 2) {
if (CVarGetInteger("gItemTrackerDisplayDungeonItemsMaps", 1)) {
dungeonItems = GetDungeonItemsVector(itemTrackerDungeonsWithMapsHorizontal, 12);
// Manually adding Thieves Hideout to an open spot so we don't get an additional row for one item
dungeonItems[23] = ITEM_TRACKER_ITEM(ITEM_KEY_SMALL, SCENE_GERUDOWAY, DrawDungeonItem);
@ -813,7 +813,7 @@ void UpdateVectors() {
dungeonItems[15] = ITEM_TRACKER_ITEM(ITEM_KEY_SMALL, SCENE_GERUDOWAY, DrawDungeonItem);
}
} else {
if (CVar_GetS32("gItemTrackerDisplayDungeonItemsMaps", 1)) {
if (CVarGetInteger("gItemTrackerDisplayDungeonItemsMaps", 1)) {
dungeonItems = GetDungeonItemsVector(itemTrackerDungeonsWithMapsCompact);
// Manually adding Thieves Hideout to an open spot so we don't get an additional row for one item
dungeonItems[35] = ITEM_TRACKER_ITEM(ITEM_KEY_SMALL, SCENE_GERUDOWAY, DrawDungeonItem);
@ -823,28 +823,28 @@ void UpdateVectors() {
}
mainWindowItems.clear();
if (CVar_GetS32("gItemTrackerInventoryItemsDisplayType", 1) == 1) {
if (CVarGetInteger("gItemTrackerInventoryItemsDisplayType", 1) == 1) {
mainWindowItems.insert(mainWindowItems.end(), inventoryItems.begin(), inventoryItems.end());
}
if (CVar_GetS32("gItemTrackerEquipmentItemsDisplayType", 1) == 1) {
if (CVarGetInteger("gItemTrackerEquipmentItemsDisplayType", 1) == 1) {
mainWindowItems.insert(mainWindowItems.end(), equipmentItems.begin(), equipmentItems.end());
}
if (CVar_GetS32("gItemTrackerMiscItemsDisplayType", 1) == 1) {
if (CVarGetInteger("gItemTrackerMiscItemsDisplayType", 1) == 1) {
mainWindowItems.insert(mainWindowItems.end(), miscItems.begin(), miscItems.end());
}
if (CVar_GetS32("gItemTrackerDungeonRewardsDisplayType", 1) == 1) {
if (CVarGetInteger("gItemTrackerDungeonRewardsDisplayType", 1) == 1) {
mainWindowItems.insert(mainWindowItems.end(), dungeonRewardStones.begin(), dungeonRewardStones.end());
mainWindowItems.insert(mainWindowItems.end(), dungeonRewardMedallions.begin(), dungeonRewardMedallions.end());
}
if (CVar_GetS32("gItemTrackerSongsDisplayType", 1) == 1) {
if (CVar_GetS32("gItemTrackerMiscItemsDisplayType", 1) == 1 && CVar_GetS32("gItemTrackerDungeonRewardsDisplayType", 1) != 1) {
if (CVarGetInteger("gItemTrackerSongsDisplayType", 1) == 1) {
if (CVarGetInteger("gItemTrackerMiscItemsDisplayType", 1) == 1 && CVarGetInteger("gItemTrackerDungeonRewardsDisplayType", 1) != 1) {
mainWindowItems.push_back(ITEM_TRACKER_ITEM(ITEM_NONE, 0, DrawItem));
mainWindowItems.push_back(ITEM_TRACKER_ITEM(ITEM_NONE, 0, DrawItem));
mainWindowItems.push_back(ITEM_TRACKER_ITEM(ITEM_NONE, 0, DrawItem));
}
mainWindowItems.insert(mainWindowItems.end(), songItems.begin(), songItems.end());
}
if (CVar_GetS32("gItemTrackerDungeonItemsDisplayType", 0) == 1) {
if (CVarGetInteger("gItemTrackerDungeonItemsDisplayType", 0) == 1) {
mainWindowItems.insert(mainWindowItems.end(), dungeonItems.begin(), dungeonItems.end());
}
@ -854,56 +854,56 @@ void UpdateVectors() {
void DrawItemTracker(bool& open) {
UpdateVectors();
if (!open) {
CVar_SetS32("gItemTrackerEnabled", 0);
CVarSetInteger("gItemTrackerEnabled", 0);
return;
}
int iconSize = CVar_GetS32("gItemTrackerIconSize", 36);
int iconSpacing = CVar_GetS32("gItemTrackerIconSpacing", 12);
int comboButton1Mask = buttonMap[CVar_GetS32("gItemTrackerComboButton1", 6)];
int comboButton2Mask = buttonMap[CVar_GetS32("gItemTrackerComboButton2", 8)];
int iconSize = CVarGetInteger("gItemTrackerIconSize", 36);
int iconSpacing = CVarGetInteger("gItemTrackerIconSpacing", 12);
int comboButton1Mask = buttonMap[CVarGetInteger("gItemTrackerComboButton1", 6)];
int comboButton2Mask = buttonMap[CVarGetInteger("gItemTrackerComboButton2", 8)];
bool comboButtonsHeld = buttonsPressed != nullptr && buttonsPressed[0].button & comboButton1Mask && buttonsPressed[0].button & comboButton2Mask;
bool isPaused = CVar_GetS32("gItemTrackerShowOnlyPaused", 0) == 0 || gPlayState != nullptr && gPlayState->pauseCtx.state > 0;
bool isPaused = CVarGetInteger("gItemTrackerShowOnlyPaused", 0) == 0 || gPlayState != nullptr && gPlayState->pauseCtx.state > 0;
if (CVar_GetS32("gItemTrackerWindowType", 0) == 1 || isPaused && (CVar_GetS32("gItemTrackerDisplayType", 0) == 0 ? CVar_GetS32("gItemTrackerEnabled", 0) : comboButtonsHeld)) {
if (CVarGetInteger("gItemTrackerWindowType", 0) == 1 || isPaused && (CVarGetInteger("gItemTrackerDisplayType", 0) == 0 ? CVarGetInteger("gItemTrackerEnabled", 0) : comboButtonsHeld)) {
if (
(CVar_GetS32("gItemTrackerInventoryItemsDisplayType", 1) == 1) ||
(CVar_GetS32("gItemTrackerEquipmentItemsDisplayType", 1) == 1) ||
(CVar_GetS32("gItemTrackerMiscItemsDisplayType", 1) == 1) ||
(CVar_GetS32("gItemTrackerDungeonRewardsDisplayType", 1) == 1) ||
(CVar_GetS32("gItemTrackerSongsDisplayType", 1) == 1) ||
(CVar_GetS32("gItemTrackerDungeonItemsDisplayType", 0) == 1) ||
(CVar_GetS32("gItemTrackerNotesDisplayType", 0) == 1)
(CVarGetInteger("gItemTrackerInventoryItemsDisplayType", 1) == 1) ||
(CVarGetInteger("gItemTrackerEquipmentItemsDisplayType", 1) == 1) ||
(CVarGetInteger("gItemTrackerMiscItemsDisplayType", 1) == 1) ||
(CVarGetInteger("gItemTrackerDungeonRewardsDisplayType", 1) == 1) ||
(CVarGetInteger("gItemTrackerSongsDisplayType", 1) == 1) ||
(CVarGetInteger("gItemTrackerDungeonItemsDisplayType", 0) == 1) ||
(CVarGetInteger("gItemTrackerNotesDisplayType", 0) == 1)
) {
BeginFloatingWindows("Item Tracker##main window");
DrawItemsInRows(mainWindowItems, 6);
if (CVar_GetS32("gItemTrackerNotesDisplayType", 0) == 1 && CVar_GetS32("gItemTrackerDisplayType", 0) == 0) {
if (CVarGetInteger("gItemTrackerNotesDisplayType", 0) == 1 && CVarGetInteger("gItemTrackerDisplayType", 0) == 0) {
DrawNotes();
}
EndFloatingWindows();
}
if (CVar_GetS32("gItemTrackerInventoryItemsDisplayType", 1) == 2) {
if (CVarGetInteger("gItemTrackerInventoryItemsDisplayType", 1) == 2) {
BeginFloatingWindows("Inventory Items Tracker");
DrawItemsInRows(inventoryItems);
EndFloatingWindows();
}
if (CVar_GetS32("gItemTrackerEquipmentItemsDisplayType", 1) == 2) {
if (CVarGetInteger("gItemTrackerEquipmentItemsDisplayType", 1) == 2) {
BeginFloatingWindows("Equipment Items Tracker");
DrawItemsInRows(equipmentItems, 3);
EndFloatingWindows();
}
if (CVar_GetS32("gItemTrackerMiscItemsDisplayType", 1) == 2) {
if (CVarGetInteger("gItemTrackerMiscItemsDisplayType", 1) == 2) {
BeginFloatingWindows("Misc Items Tracker");
DrawItemsInRows(miscItems, 4);
EndFloatingWindows();
}
if (CVar_GetS32("gItemTrackerDungeonRewardsDisplayType", 1) == 2) {
if (CVarGetInteger("gItemTrackerDungeonRewardsDisplayType", 1) == 2) {
BeginFloatingWindows("Dungeon Rewards Tracker");
if (CVar_GetS32("gItemTrackerDungeonRewardsCircle", 0) == 1) {
if (CVarGetInteger("gItemTrackerDungeonRewardsCircle", 0) == 1) {
ImGui::BeginGroup();
DrawItemsInACircle(dungeonRewardMedallions);
ImGui::EndGroup();
@ -916,16 +916,16 @@ void DrawItemTracker(bool& open) {
EndFloatingWindows();
}
if (CVar_GetS32("gItemTrackerSongsDisplayType", 1) == 2) {
if (CVarGetInteger("gItemTrackerSongsDisplayType", 1) == 2) {
BeginFloatingWindows("Songs Tracker");
DrawItemsInRows(songItems);
EndFloatingWindows();
}
if (CVar_GetS32("gItemTrackerDungeonItemsDisplayType", 0) == 2) {
if (CVarGetInteger("gItemTrackerDungeonItemsDisplayType", 0) == 2) {
BeginFloatingWindows("Dungeon Items Tracker");
if (CVar_GetS32("gItemTrackerDisplayDungeonItemsHorizontal", 1)) {
if (CVar_GetS32("gItemTrackerDisplayDungeonItemsMaps", 1)) {
if (CVarGetInteger("gItemTrackerDisplayDungeonItemsHorizontal", 1)) {
if (CVarGetInteger("gItemTrackerDisplayDungeonItemsMaps", 1)) {
DrawItemsInRows(dungeonItems, 12);
} else {
DrawItemsInRows(dungeonItems, 8);
@ -936,7 +936,7 @@ void DrawItemTracker(bool& open) {
EndFloatingWindows();
}
if (CVar_GetS32("gItemTrackerNotesDisplayType", 0) == 2 && CVar_GetS32("gItemTrackerDisplayType", 0) == 0) {
if (CVarGetInteger("gItemTrackerNotesDisplayType", 0) == 2 && CVarGetInteger("gItemTrackerDisplayType", 0) == 0) {
ImGui::SetNextWindowSize(ImVec2(400,300), ImGuiCond_FirstUseEver);
BeginFloatingWindows("Personal Notes", ImGuiWindowFlags_NoFocusOnAppearing);
DrawNotes(true);
@ -950,7 +950,7 @@ const char* itemTrackerKeyTrackOptions[3] = { "Collected / Max", "Current / Coll
void DrawItemTrackerOptions(bool& open) {
if (!open) {
CVar_SetS32("gItemTrackerSettingsEnabled", 0);
CVarSetInteger("gItemTrackerSettingsEnabled", 0);
return;
}
@ -972,21 +972,21 @@ void DrawItemTrackerOptions(bool& open) {
ImGui::SameLine();
ImGui::PushItemWidth(ImGui::GetContentRegionAvail().x);
if (ImGui::ColorEdit4("BG Color##gItemTrackerBgColor", (float*)&ChromaKeyBackground, ImGuiColorEditFlags_AlphaPreview | ImGuiColorEditFlags_AlphaBar | ImGuiColorEditFlags_NoLabel)) {
CVar_SetFloat("gItemTrackerBgColorR", ChromaKeyBackground.x);
CVar_SetFloat("gItemTrackerBgColorG", ChromaKeyBackground.y);
CVar_SetFloat("gItemTrackerBgColorB", ChromaKeyBackground.z);
CVar_SetFloat("gItemTrackerBgColorA", ChromaKeyBackground.w);
CVarSetFloat("gItemTrackerBgColorR", ChromaKeyBackground.x);
CVarSetFloat("gItemTrackerBgColorG", ChromaKeyBackground.y);
CVarSetFloat("gItemTrackerBgColorB", ChromaKeyBackground.z);
CVarSetFloat("gItemTrackerBgColorA", ChromaKeyBackground.w);
SohImGui::RequestCvarSaveOnNextTick();
}
ImGui::PopItemWidth();
LabeledComboBoxRightAligned("Window Type", "gItemTrackerWindowType", { "Floating", "Window" }, 0);
if (CVar_GetS32("gItemTrackerWindowType", 0) == 0) {
if (CVarGetInteger("gItemTrackerWindowType", 0) == 0) {
PaddedEnhancementCheckbox("Enable Dragging", "gItemTrackerHudEditMode", 0);
PaddedEnhancementCheckbox("Only enable while paused", "gItemTrackerShowOnlyPaused", 0);
LabeledComboBoxRightAligned("Display Mode", "gItemTrackerDisplayType", { "Always", "Combo Button Hold" }, 0);
if (CVar_GetS32("gItemTrackerDisplayType", 0) > 0) {
if (CVarGetInteger("gItemTrackerDisplayType", 0) > 0) {
LabeledComboBoxRightAligned("Combo Button 1", "gItemTrackerComboButton1", { "A", "B", "C-Up", "C-Down", "C-Left", "C-Right", "L", "Z", "R", "Start", "D-Up", "D-Down", "D-Left", "D-Right" }, 6);
LabeledComboBoxRightAligned("Combo Button 2", "gItemTrackerComboButton2", { "A", "B", "C-Up", "C-Down", "C-Left", "C-Right", "L", "Z", "R", "Start", "D-Up", "D-Down", "D-Left", "D-Right" }, 8);
}
@ -999,7 +999,7 @@ void DrawItemTrackerOptions(bool& open) {
UIWidgets::EnhancementCombobox("gItemTrackerCapacityTrack", itemTrackerCapacityTrackOptions, 5, 1);
UIWidgets::InsertHelpHoverText("Customize what the numbers under each item are tracking."
"\n\nNote: items without capacity upgrades will track ammo even in capacity mode");
if (CVar_GetS32("gItemTrackerCapacityTrack", 1) == ITEM_TRACKER_NUMBER_CURRENT_CAPACITY_ONLY || CVar_GetS32("gItemTrackerCapacityTrack", 1) == ITEM_TRACKER_NUMBER_CURRENT_AMMO_ONLY) {
if (CVarGetInteger("gItemTrackerCapacityTrack", 1) == ITEM_TRACKER_NUMBER_CURRENT_CAPACITY_ONLY || CVarGetInteger("gItemTrackerCapacityTrack", 1) == ITEM_TRACKER_NUMBER_CURRENT_AMMO_ONLY) {
PaddedEnhancementCheckbox("Align count to left side", "gItemTrackerCurrentOnLeft", 0);
}
ImGui::Text("Key Count Tracking");
@ -1012,19 +1012,19 @@ void DrawItemTrackerOptions(bool& open) {
LabeledComboBoxRightAligned("Equipment", "gItemTrackerEquipmentItemsDisplayType", { "Hidden", "Main Window", "Seperate" }, 1);
LabeledComboBoxRightAligned("Misc", "gItemTrackerMiscItemsDisplayType", { "Hidden", "Main Window", "Seperate" }, 1);
LabeledComboBoxRightAligned("Dungeon Rewards", "gItemTrackerDungeonRewardsDisplayType", { "Hidden", "Main Window", "Seperate" }, 1);
if (CVar_GetS32("gItemTrackerDungeonRewardsDisplayType", 1) == 2) {
if (CVarGetInteger("gItemTrackerDungeonRewardsDisplayType", 1) == 2) {
PaddedEnhancementCheckbox("Circle display", "gItemTrackerDungeonRewardsCircle", 1);
}
LabeledComboBoxRightAligned("Songs", "gItemTrackerSongsDisplayType", { "Hidden", "Main Window", "Seperate" }, 1);
LabeledComboBoxRightAligned("Dungeon Items", "gItemTrackerDungeonItemsDisplayType", { "Hidden", "Main Window", "Seperate" }, 0);
if (CVar_GetS32("gItemTrackerDungeonItemsDisplayType", 0) != 0) {
if (CVar_GetS32("gItemTrackerDungeonItemsDisplayType", 0) == 2) {
if (CVarGetInteger("gItemTrackerDungeonItemsDisplayType", 0) != 0) {
if (CVarGetInteger("gItemTrackerDungeonItemsDisplayType", 0) == 2) {
PaddedEnhancementCheckbox("Horizontal display", "gItemTrackerDisplayDungeonItemsHorizontal", 1);
}
PaddedEnhancementCheckbox("Maps and compasses", "gItemTrackerDisplayDungeonItemsMaps", 1);
}
if (CVar_GetS32("gItemTrackerDisplayType", 0) != 1) {
if (CVarGetInteger("gItemTrackerDisplayType", 0) != 1) {
LabeledComboBoxRightAligned("Personal notes", "gItemTrackerNotesDisplayType", { "Hidden", "Main Window", "Seperate" }, 0);
}
@ -1035,12 +1035,12 @@ void DrawItemTrackerOptions(bool& open) {
}
void InitItemTracker() {
SohImGui::AddWindow("Randomizer", "Item Tracker", DrawItemTracker, CVar_GetS32("gItemTrackerEnabled", 0) == 1);
SohImGui::AddWindow("Randomizer", "Item Tracker", DrawItemTracker, CVarGetInteger("gItemTrackerEnabled", 0) == 1);
SohImGui::AddWindow("Randomizer", "Item Tracker Settings", DrawItemTrackerOptions);
float trackerBgR = CVar_GetFloat("gItemTrackerBgColorR", 0);
float trackerBgG = CVar_GetFloat("gItemTrackerBgColorG", 0);
float trackerBgB = CVar_GetFloat("gItemTrackerBgColorB", 0);
float trackerBgA = CVar_GetFloat("gItemTrackerBgColorA", 1);
float trackerBgR = CVarGetFloat("gItemTrackerBgColorR", 0);
float trackerBgG = CVarGetFloat("gItemTrackerBgColorG", 0);
float trackerBgB = CVarGetFloat("gItemTrackerBgColorB", 0);
float trackerBgA = CVarGetFloat("gItemTrackerBgColorA", 1);
ChromaKeyBackground = {
trackerBgR,
trackerBgG,
@ -1055,11 +1055,11 @@ void InitItemTracker() {
buttonsPressed = cont_pad;
});
Ship::RegisterHook<Ship::LoadFile>([](uint32_t fileNum) {
const char* initialTrackerNotes = CVar_GetString(("gItemTrackerNotes" + std::to_string(fileNum)).c_str(), "");
const char* initialTrackerNotes = CVarGetString(("gItemTrackerNotes" + std::to_string(fileNum)).c_str(), "");
strcpy(itemTrackerNotes.Data, initialTrackerNotes);
});
Ship::RegisterHook<Ship::DeleteFile>([](uint32_t fileNum) {
CVar_SetString(("gItemTrackerNotes" + std::to_string(fileNum)).c_str(), "");
CVarSetString(("gItemTrackerNotes" + std::to_string(fileNum)).c_str(), "");
SohImGui::RequestCvarSaveOnNextTick();
});
}

32
soh/soh/Enhancements/sfx-editor/SfxEditor.cpp
View File

@ -2,7 +2,7 @@
#include "sequence.h"
#include <string>
#include <map>
#include <Cvar.h>
#include <libultraship/bridge.h>
#include <ImGuiImpl.h>
#include <functions.h>
#include "../randomizer/3drando/random.hpp"
@ -216,7 +216,7 @@ void Draw_SfxTab(const std::string& tabId, const std::map<u16, std::tuple<std::s
continue;
}
const std::string cvarKey = "gSfxEditor_" + sfxKey;
CVar_SetS32(cvarKey.c_str(), defaultValue);
CVarSetInteger(cvarKey.c_str(), defaultValue);
}
}
SohImGui::RequestCvarSaveOnNextTick();
@ -242,7 +242,7 @@ void Draw_SfxTab(const std::string& tabId, const std::map<u16, std::tuple<std::s
continue;
}
const int randomValue = values.back();
CVar_SetS32(cvarKey.c_str(), randomValue);
CVarSetInteger(cvarKey.c_str(), randomValue);
values.pop_back();
}
}
@ -273,7 +273,7 @@ void Draw_SfxTab(const std::string& tabId, const std::map<u16, std::tuple<std::s
const std::string previewButton = "Preview" + hiddenKey;
const std::string resetButton = "Reset" + hiddenKey;
const std::string randomizeButton = "Randomize" + hiddenKey;
const int currentValue = CVar_GetS32(cvarKey.c_str(), defaultValue);
const int currentValue = CVarGetInteger(cvarKey.c_str(), defaultValue);
ImGui::TableNextRow();
ImGui::TableNextColumn();
@ -289,7 +289,7 @@ void Draw_SfxTab(const std::string& tabId, const std::map<u16, std::tuple<std::s
}
if (ImGui::Selectable(std::get<0>(seqData).c_str())) {
CVar_SetS32(cvarKey.c_str(), value);
CVarSetInteger(cvarKey.c_str(), value);
SohImGui::RequestCvarSaveOnNextTick();
UpdateCurrentBGM(defaultValue, type);
}
@ -299,16 +299,16 @@ void Draw_SfxTab(const std::string& tabId, const std::map<u16, std::tuple<std::s
}
ImGui::TableNextColumn();
ImGui::PushItemWidth(-FLT_MIN);
if (CVar_GetS32("gSfxEditor_playing", 0) == currentValue) {
if (CVarGetInteger("gSfxEditor_playing", 0) == currentValue) {
if (ImGui::Button(stopButton.c_str())) {
func_800F5C2C();
CVar_SetS32("gSfxEditor_playing", 0);
CVarSetInteger("gSfxEditor_playing", 0);
}
} else {
if (ImGui::Button(previewButton.c_str())) {
if (CVar_GetS32("gSfxEditor_playing", 0) != 0) {
if (CVarGetInteger("gSfxEditor_playing", 0) != 0) {
func_800F5C2C();
CVar_SetS32("gSfxEditor_playing", 0);
CVarSetInteger("gSfxEditor_playing", 0);
} else {
if (type == SEQ_SFX) {
Audio_PlaySoundGeneral(defaultValue, &pos, 4, &freqScale, &freqScale, &reverbAdd);
@ -318,7 +318,7 @@ void Draw_SfxTab(const std::string& tabId, const std::map<u16, std::tuple<std::s
} else {
// TODO: Cant do both here, so have to click preview button twice
func_800F5ACC(defaultValue);
CVar_SetS32("gSfxEditor_playing", currentValue);
CVarSetInteger("gSfxEditor_playing", currentValue);
}
}
}
@ -326,7 +326,7 @@ void Draw_SfxTab(const std::string& tabId, const std::map<u16, std::tuple<std::s
ImGui::SameLine();
ImGui::PushItemWidth(-FLT_MIN);
if (ImGui::Button(resetButton.c_str())) {
CVar_SetS32(cvarKey.c_str(), defaultValue);
CVarSetInteger(cvarKey.c_str(), defaultValue);
SohImGui::RequestCvarSaveOnNextTick();
UpdateCurrentBGM(defaultValue, seqType);
}
@ -338,7 +338,7 @@ void Draw_SfxTab(const std::string& tabId, const std::map<u16, std::tuple<std::s
const auto& [value, seqData] = *std::next(it, rand() % map.size());
const auto& [name, sfxKey, seqType] = seqData;
if (seqType & type) {
CVar_SetS32(cvarKey.c_str(), value);
CVarSetInteger(cvarKey.c_str(), value);
SohImGui::RequestCvarSaveOnNextTick();
UpdateCurrentBGM(defaultValue, type);
break;
@ -354,7 +354,7 @@ extern "C" u16 SfxEditor_GetReplacementSeq(u16 seqId) {
// for Hyrule Field instead. Otherwise, leave it alone, so that without any sfx editor modifications we will
// play the normal track as usual.
if (seqId == NA_BGM_FIELD_MORNING) {
if (CVar_GetS32("gSfxEditor_NA_BGM_FIELD_LOGIC", NA_BGM_FIELD_LOGIC) != NA_BGM_FIELD_LOGIC) {
if (CVarGetInteger("gSfxEditor_NA_BGM_FIELD_LOGIC", NA_BGM_FIELD_LOGIC) != NA_BGM_FIELD_LOGIC) {
seqId = NA_BGM_FIELD_LOGIC;
}
}
@ -365,7 +365,7 @@ extern "C" u16 SfxEditor_GetReplacementSeq(u16 seqId) {
const auto& [name, sfxKey, seqType] = sfxEditorSequenceMap.at(seqId);
const std::string cvarKey = "gSfxEditor_" + sfxKey;
int replacementSeq = CVar_GetS32(cvarKey.c_str(), seqId);
int replacementSeq = CVarGetInteger(cvarKey.c_str(), seqId);
if (!sfxEditorSequenceMap.contains(replacementSeq)) {
replacementSeq = seqId;
}
@ -376,7 +376,7 @@ extern "C" u16 SfxEditor_GetReverseReplacementSeq(u16 seqId) {
for (const auto& [id, nameAndsfxKey] : sfxEditorSequenceMap) {
const auto& [name, sfxKey, seqType] = sfxEditorSequenceMap.at(id);
const std::string cvarKey = "gSfxEditor_" + sfxKey;
if (CVar_GetS32(cvarKey.c_str(), id) == seqId){
if (CVarGetInteger(cvarKey.c_str(), id) == seqId){
return static_cast<u16>(id);
}
}
@ -386,7 +386,7 @@ extern "C" u16 SfxEditor_GetReverseReplacementSeq(u16 seqId) {
void DrawSfxEditor(bool& open) {
if (!open) {
CVar_SetS32("gSfxEditor", 0);
CVarSetInteger("gSfxEditor", 0);
return;
}
ImGui::SetNextWindowSize(ImVec2(900, 630), ImGuiCond_FirstUseEver);

230
soh/soh/GameMenuBar.cpp
View File

@ -12,11 +12,11 @@
#define IMGUI_DEFINE_MATH_OPERATORS
#include <ImGui/imgui_internal.h>
#include <ImGuiImpl.h>
#include <Cvar.h>
#include <libultraship/bridge.h>
#include <Hooks.h>
#include <ultra64/types.h>
#include <ultra64/pi.h>
#include <ultra64/sptask.h>
#include <libultraship/libultra/types.h>
#include <libultraship/libultra/pi.h>
#include <libultraship/libultra/sptask.h>
#ifdef __SWITCH__
#include <port/switch/SwitchImpl.h>
@ -82,22 +82,22 @@ namespace GameMenuBar {
}
void BindAudioSlider(const char* name, const char* key, float defaultValue, SeqPlayers playerId) {
float value = CVar_GetFloat(key, defaultValue);
float value = CVarGetFloat(key, defaultValue);
ImGui::Text(name, static_cast<int>(100 * value));
if (ImGui::SliderFloat((std::string("##") + key).c_str(), &value, 0.0f, 1.0f, "")) {
const float volume = floorf(value * 100) / 100;
CVar_SetFloat(key, volume);
CVarSetFloat(key, volume);
SohImGui::RequestCvarSaveOnNextTick();
Audio_SetGameVolume(playerId, volume);
}
}
void UpdateAudio() {
Audio_SetGameVolume(SEQ_BGM_MAIN, CVar_GetFloat("gMainMusicVolume", 1));
Audio_SetGameVolume(SEQ_BGM_SUB, CVar_GetFloat("gSubMusicVolume", 1));
Audio_SetGameVolume(SEQ_FANFARE, CVar_GetFloat("gSFXMusicVolume", 1));
Audio_SetGameVolume(SEQ_SFX, CVar_GetFloat("gFanfareVolume", 1));
Audio_SetGameVolume(SEQ_BGM_MAIN, CVarGetFloat("gMainMusicVolume", 1));
Audio_SetGameVolume(SEQ_BGM_SUB, CVarGetFloat("gSubMusicVolume", 1));
Audio_SetGameVolume(SEQ_FANFARE, CVarGetFloat("gSFXMusicVolume", 1));
Audio_SetGameVolume(SEQ_SFX, CVarGetFloat("gFanfareVolume", 1));
}
// MARK: - Delegates
@ -153,12 +153,12 @@ namespace GameMenuBar {
ImGui::PushStyleVar(ImGuiStyleVar_ButtonTextAlign, ImVec2(0, 0));
ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 1.0f);
ImGui::PushStyleColor(ImGuiCol_Border, ImVec4(0.22f, 0.38f, 0.56f, 1.0f));
if (ImGui::Button(GetWindowButtonText("Controller Configuration", CVar_GetS32("gControllerConfigurationEnabled", 0)).c_str()))
if (ImGui::Button(GetWindowButtonText("Controller Configuration", CVarGetInteger("gControllerConfigurationEnabled", 0)).c_str()))
{
bool currentValue = CVar_GetS32("gControllerConfigurationEnabled", 0);
CVar_SetS32("gControllerConfigurationEnabled", !currentValue);
bool currentValue = CVarGetInteger("gControllerConfigurationEnabled", 0);
CVarSetInteger("gControllerConfigurationEnabled", !currentValue);
SohImGui::RequestCvarSaveOnNextTick();
SohImGui::ToggleInputEditorWindow(CVar_GetS32("gControllerConfigurationEnabled", 0));
SohImGui::ToggleInputEditorWindow(CVarGetInteger("gControllerConfigurationEnabled", 0));
}
ImGui::PopStyleColor(1);
ImGui::PopStyleVar(3);
@ -188,18 +188,18 @@ namespace GameMenuBar {
#ifndef __APPLE__
UIWidgets::EnhancementSliderFloat("Internal Resolution: %d %%", "##IMul", "gInternalResolution", 0.5f, 2.0f, "", 1.0f, true, true);
UIWidgets::Tooltip("Multiplies your output resolution by the value inputted, as a more intensive but effective form of anti-aliasing");
SohImGui::SetResolutionMultiplier(CVar_GetFloat("gInternalResolution", 1));
SohImGui::SetResolutionMultiplier(CVarGetFloat("gInternalResolution", 1));
#endif
#ifndef __WIIU__
UIWidgets::PaddedEnhancementSliderInt("MSAA: %d", "##IMSAA", "gMSAAValue", 1, 8, "", 1, false, true, false);
UIWidgets::Tooltip("Activates multi-sample anti-aliasing when above 1x up to 8x for 8 samples for every pixel");
SohImGui::SetMSAALevel(CVar_GetS32("gMSAAValue", 1));
SohImGui::SetMSAALevel(CVarGetInteger("gMSAAValue", 1));
#endif
if (SohImGui::WindowBackend() == SohImGui::Backend::DX11)
{
const char* cvar = "gExtraLatencyThreshold";
int val = CVar_GetS32(cvar, 80);
int val = CVarGetInteger(cvar, 80);
val = fmax(fmin(val, 360), 0);
int fps = val;
@ -218,7 +218,7 @@ namespace GameMenuBar {
std::string PlusBTNELT = " + ##ExtraLatencyThreshold";
if (ImGui::Button(MinusBTNELT.c_str())) {
val--;
CVar_SetS32(cvar, val);
CVarSetInteger(cvar, val);
SohImGui::RequestCvarSaveOnNextTick();
}
ImGui::SameLine();
@ -232,7 +232,7 @@ namespace GameMenuBar {
#endif
if (ImGui::SliderInt("##ExtraLatencyThreshold", &val, 0, 360, "", ImGuiSliderFlags_AlwaysClamp))
{
CVar_SetS32(cvar, val);
CVarSetInteger(cvar, val);
SohImGui::RequestCvarSaveOnNextTick();
}
ImGui::PopItemWidth();
@ -242,7 +242,7 @@ namespace GameMenuBar {
ImGui::SetCursorPosX(ImGui::GetCursorPosX() - 7.0f);
if (ImGui::Button(PlusBTNELT.c_str())) {
val++;
CVar_SetS32(cvar, val);
CVarSetInteger(cvar, val);
SohImGui::RequestCvarSaveOnNextTick();
}
@ -338,11 +338,11 @@ namespace GameMenuBar {
" - Skulltula Tokens: Small skulltula chest\n"
);
if (UIWidgets::EnhancementCombobox("gChestSizeAndTextureMatchesContents", chestSizeAndTextureMatchesContentsOptions, 4, 0)) {
if (CVar_GetS32("gChestSizeAndTextureMatchesContents", 0) == 0) {
CVar_SetS32("gChestSizeDependsStoneOfAgony", 0);
if (CVarGetInteger("gChestSizeAndTextureMatchesContents", 0) == 0) {
CVarSetInteger("gChestSizeDependsStoneOfAgony", 0);
}
}
if (CVar_GetS32("gChestSizeAndTextureMatchesContents", 0) > 0) {
if (CVarGetInteger("gChestSizeAndTextureMatchesContents", 0) > 0) {
UIWidgets::PaddedEnhancementCheckbox("Chests of Agony", "gChestSizeDependsStoneOfAgony", true, false);
UIWidgets::Tooltip("Only change the size/texture of chests if you have the Stone of Agony.");
}
@ -461,7 +461,7 @@ namespace GameMenuBar {
{
UIWidgets::EnhancementCheckbox("Change Red Potion Effect", "gRedPotionEffect");
UIWidgets::Tooltip("Enable the following changes to the amount of health restored by Red Potions");
bool disabledRedPotion = !CVar_GetS32("gRedPotionEffect", 0);
bool disabledRedPotion = !CVarGetInteger("gRedPotionEffect", 0);
const char* disabledTooltipRedPotion = "This option is disabled because \"Change Red Potion Effect\" is turned off";
UIWidgets::EnhancementSliderInt("Red Potion Health: %d", "##REDPOTIONHEALTH", "gRedPotionHealth", 1, 100, "", 0, true, disabledRedPotion, disabledTooltipRedPotion);
UIWidgets::Tooltip("Changes the amount of health restored by Red Potions");
@ -472,7 +472,7 @@ namespace GameMenuBar {
UIWidgets::EnhancementCheckbox("Change Green Potion Effect", "gGreenPotionEffect");
UIWidgets::Tooltip("Enable the following changes to the amount of mana restored by Green Potions");
bool disabledGreenPotion = !CVar_GetS32("gGreenPotionEffect", 0);
bool disabledGreenPotion = !CVarGetInteger("gGreenPotionEffect", 0);
const char* disabledTooltipGreenPotion = "This option is disabled because \"Change Green Potion Effect\" is turned off";
UIWidgets::EnhancementSliderInt("Green Potion Mana: %d", "##GREENPOTIONMANA", "gGreenPotionMana", 1, 100, "", 0, true, disabledGreenPotion, disabledTooltipGreenPotion);
UIWidgets::Tooltip("Changes the amount of mana restored by Green Potions, base max mana is 48, max upgraded mana is 96");
@ -483,7 +483,7 @@ namespace GameMenuBar {
UIWidgets::EnhancementCheckbox("Change Blue Potion Effects", "gBluePotionEffects");
UIWidgets::Tooltip("Enable the following changes to the amount of health and mana restored by Blue Potions");
bool disabledBluePotion = !CVar_GetS32("gBluePotionEffects", 0);
bool disabledBluePotion = !CVarGetInteger("gBluePotionEffects", 0);
const char* disabledTooltipBluePotion = "This option is disabled because \"Change Blue Potion Effects\" is turned off";
UIWidgets::EnhancementSliderInt("Blue Potion Health: %d", "##BLUEPOTIONHEALTH", "gBluePotionHealth", 1, 100, "", 0, true, disabledBluePotion, disabledTooltipBluePotion);
UIWidgets::Tooltip("Changes the amount of health restored by Blue Potions");
@ -501,7 +501,7 @@ namespace GameMenuBar {
UIWidgets::EnhancementCheckbox("Change Milk Effect", "gMilkEffect");
UIWidgets::Tooltip("Enable the following changes to the amount of health restored by Milk");
bool disabledMilk = !CVar_GetS32("gMilkEffect", 0);
bool disabledMilk = !CVarGetInteger("gMilkEffect", 0);
const char* disabledTooltipMilk = "This option is disabled because \"Change Milk Effect\" is turned off";
UIWidgets::EnhancementSliderInt("Milk Health: %d", "##MILKHEALTH", "gMilkHealth", 1, 100, "", 0, true, disabledMilk, disabledTooltipMilk);
UIWidgets::Tooltip("Changes the amount of health restored by Milk");
@ -512,7 +512,7 @@ namespace GameMenuBar {
UIWidgets::EnhancementCheckbox("Separate Half Milk Effect", "gSeparateHalfMilkEffect", disabledMilk, disabledTooltipMilk);
UIWidgets::Tooltip("Enable the following changes to the amount of health restored by Half Milk\nIf this is disabled, Half Milk will behave the same as Full Milk.");
bool disabledHalfMilk = disabledMilk || !CVar_GetS32("gSeparateHalfMilkEffect", 0);
bool disabledHalfMilk = disabledMilk || !CVarGetInteger("gSeparateHalfMilkEffect", 0);
const char* disabledTooltipHalfMilk = "This option is disabled because \"Separate Half Milk Effect\" is turned off";
UIWidgets::EnhancementSliderInt("Half Milk Health: %d", "##HALFMILKHEALTH", "gHalfMilkHealth", 1, 100, "", 0, true, disabledHalfMilk, disabledTooltipHalfMilk);
UIWidgets::Tooltip("Changes the amount of health restored by Half Milk");
@ -523,7 +523,7 @@ namespace GameMenuBar {
UIWidgets::EnhancementCheckbox("Change Fairy Effect", "gFairyEffect");
UIWidgets::Tooltip("Enable the following changes to the amount of health restored by Fairies");
bool disabledFairy = !CVar_GetS32("gFairyEffect", 0);
bool disabledFairy = !CVarGetInteger("gFairyEffect", 0);
const char* disabledTooltipFairy = "This option is disabled because \"Change Fairy Effect\" is turned off";
UIWidgets::EnhancementSliderInt("Fairy: %d", "##FAIRYHEALTH", "gFairyHealth", 1, 100, "", 0, true, disabledFairy, disabledTooltipFairy);
UIWidgets::Tooltip("Changes the amount of health restored by Fairies");
@ -534,7 +534,7 @@ namespace GameMenuBar {
UIWidgets::EnhancementCheckbox("Change Fairy Revive Effect", "gFairyReviveEffect");
UIWidgets::Tooltip("Enable the following changes to the amount of health restored by Fairy Revivals");
bool disabledFairyRevive = !CVar_GetS32("gFairyReviveEffect", 0);
bool disabledFairyRevive = !CVarGetInteger("gFairyReviveEffect", 0);
const char* disabledTooltipFairyRevive = "This option is disabled because \"Change Fairy Revive Effect\" is turned off";
UIWidgets::EnhancementSliderInt("Fairy Revival: %d", "##FAIRYREVIVEHEALTH", "gFairyReviveHealth", 1, 100, "", 0, true, disabledFairyRevive, disabledTooltipFairyRevive);
UIWidgets::Tooltip("Changes the amount of health restored by Fairy Revivals");
@ -549,7 +549,7 @@ namespace GameMenuBar {
if (ImGui::BeginMenu("Shooting Gallery")) {
UIWidgets::EnhancementCheckbox("Customize Behavior", "gCustomizeShootingGallery");
UIWidgets::Tooltip("Turn on/off changes to the shooting gallery behavior");
bool disabled = !CVar_GetS32("gCustomizeShootingGallery", 0);
bool disabled = !CVarGetInteger("gCustomizeShootingGallery", 0);
const char* disabledTooltip = "This option is disabled because \"Customize Behavior\" is turned off";
UIWidgets::PaddedEnhancementCheckbox("Instant Win", "gInstantShootingGalleryWin", true, false, disabled, disabledTooltip);
UIWidgets::Tooltip("Skips the shooting gallery minigame");
@ -567,7 +567,7 @@ namespace GameMenuBar {
if (ImGui::BeginMenu("Bombchu Bowling")) {
UIWidgets::EnhancementCheckbox("Customize Behavior", "gCustomizeBombchuBowling");
UIWidgets::Tooltip("Turn on/off changes to the bombchu bowling behavior");
bool disabled = CVar_GetS32("gCustomizeBombchuBowling", 0) == 0;
bool disabled = CVarGetInteger("gCustomizeBombchuBowling", 0) == 0;
const char* disabledTooltip = "This option is disabled because \"Customize Behavior\" is turned off";
UIWidgets::PaddedEnhancementCheckbox("Remove Small Cucco", "gBombchuBowlingNoSmallCucco", true, false, disabled, disabledTooltip);
UIWidgets::Tooltip("Prevents the small cucco from appearing in the bombchu bowling minigame");
@ -583,7 +583,7 @@ namespace GameMenuBar {
if (ImGui::BeginMenu("Fishing")) {
UIWidgets::EnhancementCheckbox("Customize Behavior", "gCustomizeFishing");
UIWidgets::Tooltip("Turn on/off changes to the fishing behavior");
bool disabled = !CVar_GetS32("gCustomizeFishing", 0);
bool disabled = !CVarGetInteger("gCustomizeFishing", 0);
const char* disabledTooltip = "This option is disabled because \"Customize Behavior\" is turned off";
UIWidgets::PaddedEnhancementCheckbox("Instant Fishing", "gInstantFishing", true, false, disabled, disabledTooltip);
UIWidgets::Tooltip("All fish will be caught instantly");
@ -669,7 +669,7 @@ namespace GameMenuBar {
UIWidgets::Tooltip("Allow you to rotate Link on the Equipment menu with the C-buttons\nUse C-Up or C-Down to reset Link's rotation");
UIWidgets::EnhancementRadioButton("Rotate Link with Right Stick", "gPauseLiveLinkRotation", 3);
UIWidgets::Tooltip("Allow you to rotate Link on the Equipment menu with the Right Stick\nYou can zoom in by pointing up and reset Link's rotation by pointing down");
if (CVar_GetS32("gPauseLiveLinkRotation", 0) != 0) {
if (CVarGetInteger("gPauseLiveLinkRotation", 0) != 0) {
UIWidgets::EnhancementSliderInt("Rotation Speed: %d", "##MinRotationSpeed", "gPauseLiveLinkRotationSpeed", 1, 20, "");
}
UIWidgets::PaddedSeparator();
@ -697,7 +697,7 @@ namespace GameMenuBar {
UIWidgets::Tooltip("Randomize the animation played on the menu after a certain time");
UIWidgets::EnhancementRadioButton("Random cycle (Idle)", "gPauseLiveLink", 17);
UIWidgets::Tooltip("Randomize the animation played on the menu after a certain time (Idle animations only)");
if (CVar_GetS32("gPauseLiveLink", 0) >= 16) {
if (CVarGetInteger("gPauseLiveLink", 0) >= 16) {
UIWidgets::EnhancementSliderInt("Frame to wait: %d", "##MinFrameCount", "gMinFrameCount", 1, 1000, "", 0, true);
}
@ -741,8 +741,8 @@ namespace GameMenuBar {
UIWidgets::Tooltip("Make Anubis fireballs do fire damage when reflected back at them with the Mirror Shield");
UIWidgets::PaddedEnhancementCheckbox("Fix Megaton Hammer crouch stab", "gCrouchStabHammerFix", true, false);
UIWidgets::Tooltip("Make the Megaton Hammer's crouch stab able to destroy rocks without first swinging it normally");
if (CVar_GetS32("gCrouchStabHammerFix", 0) == 0) {
CVar_SetS32("gCrouchStabFix", 0);
if (CVarGetInteger("gCrouchStabHammerFix", 0) == 0) {
CVarSetInteger("gCrouchStabFix", 0);
} else {
UIWidgets::PaddedEnhancementCheckbox("Remove power crouch stab", "gCrouchStabFix", true, false);
UIWidgets::Tooltip("Make crouch stabbing always do the same damage as a regular slash");
@ -792,32 +792,32 @@ namespace GameMenuBar {
ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 1.0f);
ImGui::PushStyleColor(ImGuiCol_Border, ImVec4(0.22f, 0.38f, 0.56f, 1.0f));
if (ImGui::Button(GetWindowButtonText("Customize Game Controls", CVar_GetS32("gGameControlEditorEnabled", 0)).c_str(), ImVec2(-1.0f, 0.0f)))
if (ImGui::Button(GetWindowButtonText("Customize Game Controls", CVarGetInteger("gGameControlEditorEnabled", 0)).c_str(), ImVec2(-1.0f, 0.0f)))
{
bool currentValue = CVar_GetS32("gGameControlEditorEnabled", 0);
CVar_SetS32("gGameControlEditorEnabled", !currentValue);
bool currentValue = CVarGetInteger("gGameControlEditorEnabled", 0);
CVarSetInteger("gGameControlEditorEnabled", !currentValue);
SohImGui::RequestCvarSaveOnNextTick();
SohImGui::EnableWindow("Game Control Editor", CVar_GetS32("gGameControlEditorEnabled", 0));
SohImGui::EnableWindow("Game Control Editor", CVarGetInteger("gGameControlEditorEnabled", 0));
}
if (ImGui::Button(GetWindowButtonText("Cosmetics Editor", CVar_GetS32("gCosmeticsEditorEnabled", 0)).c_str(), ImVec2(-1.0f, 0.0f)))
if (ImGui::Button(GetWindowButtonText("Cosmetics Editor", CVarGetInteger("gCosmeticsEditorEnabled", 0)).c_str(), ImVec2(-1.0f, 0.0f)))
{
bool currentValue = CVar_GetS32("gCosmeticsEditorEnabled", 0);
CVar_SetS32("gCosmeticsEditorEnabled", !currentValue);
bool currentValue = CVarGetInteger("gCosmeticsEditorEnabled", 0);
CVarSetInteger("gCosmeticsEditorEnabled", !currentValue);
SohImGui::RequestCvarSaveOnNextTick();
SohImGui::EnableWindow("Cosmetics Editor", CVar_GetS32("gCosmeticsEditorEnabled", 0));
SohImGui::EnableWindow("Cosmetics Editor", CVarGetInteger("gCosmeticsEditorEnabled", 0));
}
if (ImGui::Button(GetWindowButtonText("SFX Editor", CVar_GetS32("gSfxEditor", 0)).c_str(), ImVec2(-1.0f, 0.0f)))
if (ImGui::Button(GetWindowButtonText("SFX Editor", CVarGetInteger("gSfxEditor", 0)).c_str(), ImVec2(-1.0f, 0.0f)))
{
bool currentValue = CVar_GetS32("gSfxEditor", 0);
CVar_SetS32("gSfxEditor", !currentValue);
bool currentValue = CVarGetInteger("gSfxEditor", 0);
CVarSetInteger("gSfxEditor", !currentValue);
SohImGui::RequestCvarSaveOnNextTick();
SohImGui::EnableWindow("SFX Editor", CVar_GetS32("gSfxEditor", 0));
SohImGui::EnableWindow("SFX Editor", CVarGetInteger("gSfxEditor", 0));
}
if (ImGui::Button(GetWindowButtonText("Gameplay Stats", CVar_GetS32("gGameplayStatsEnabled", 0)).c_str(), ImVec2(-1.0f, 0.0f))) {
bool currentValue = CVar_GetS32("gGameplayStatsEnabled", 0);
CVar_SetS32("gGameplayStatsEnabled", !currentValue);
if (ImGui::Button(GetWindowButtonText("Gameplay Stats", CVarGetInteger("gGameplayStatsEnabled", 0)).c_str(), ImVec2(-1.0f, 0.0f))) {
bool currentValue = CVarGetInteger("gGameplayStatsEnabled", 0);
CVarSetInteger("gGameplayStatsEnabled", !currentValue);
SohImGui::RequestCvarSaveOnNextTick();
SohImGui::EnableWindow("Gameplay Stats", CVar_GetS32("gGameplayStatsEnabled", 0));
SohImGui::EnableWindow("Gameplay Stats", CVarGetInteger("gGameplayStatsEnabled", 0));
}
ImGui::PopStyleVar(3);
ImGui::PopStyleColor(1);
@ -834,7 +834,7 @@ namespace GameMenuBar {
int maxFps = 360;
#endif
int val = CVar_GetS32(fps_cvar, minFps);
int val = CVarGetInteger(fps_cvar, minFps);
val = fmax(fmin(val, maxFps), 20);
#ifdef __WIIU__
@ -862,7 +862,7 @@ namespace GameMenuBar {
#else
val--;
#endif
CVar_SetS32(fps_cvar, val);
CVarSetInteger(fps_cvar, val);
SohImGui::RequestCvarSaveOnNextTick();
}
ImGui::SameLine();
@ -889,7 +889,7 @@ namespace GameMenuBar {
val = 20;
}
CVar_SetS32(fps_cvar, val);
CVarSetInteger(fps_cvar, val);
SohImGui::RequestCvarSaveOnNextTick();
}
ImGui::PopItemWidth();
@ -909,7 +909,7 @@ namespace GameMenuBar {
#else
val++;
#endif
CVar_SetS32(fps_cvar, val);
CVarSetInteger(fps_cvar, val);
SohImGui::RequestCvarSaveOnNextTick();
}
}
@ -923,7 +923,7 @@ namespace GameMenuBar {
int hz = roundf(SohImGui::WindowRefreshRate());
if (hz >= 20 && hz <= 360)
{
CVar_SetS32(fps_cvar, hz);
CVarSetInteger(fps_cvar, hz);
SohImGui::RequestCvarSaveOnNextTick();
}
}
@ -933,12 +933,12 @@ namespace GameMenuBar {
UIWidgets::EnhancementCheckbox("Disable LOD", "gDisableLOD");
UIWidgets::Tooltip("Turns off the Level of Detail setting, making models use their higher-poly variants at any distance");
if (UIWidgets::PaddedEnhancementCheckbox("Disable Draw Distance", "gDisableDrawDistance", true, false)) {
if (CVar_GetS32("gDisableDrawDistance", 0) == 0) {
CVar_SetS32("gDisableKokiriDrawDistance", 0);
if (CVarGetInteger("gDisableDrawDistance", 0) == 0) {
CVarSetInteger("gDisableKokiriDrawDistance", 0);
}
}
UIWidgets::Tooltip("Turns off the objects draw distance, making objects being visible from a longer range");
if (CVar_GetS32("gDisableDrawDistance", 0) == 1) {
if (CVarGetInteger("gDisableDrawDistance", 0) == 1) {
UIWidgets::PaddedEnhancementCheckbox("Kokiri Draw Distance", "gDisableKokiriDrawDistance", true, false);
UIWidgets::Tooltip("The Kokiri are mystical beings that fade into view when approached\nEnabling this will remove their draw distance");
}
@ -947,13 +947,13 @@ namespace GameMenuBar {
#ifdef __SWITCH__
UIWidgets::Spacer(0);
int slot = CVar_GetS32("gSwitchPerfMode", (int)Ship::SwitchProfiles::STOCK);
int slot = CVarGetInteger("gSwitchPerfMode", (int)Ship::SwitchProfiles::STOCK);
ImGui::Text("Switch performance mode");
if (ImGui::BeginCombo("##perf", SWITCH_CPU_PROFILES[slot])) {
for (int sId = 0; sId <= Ship::SwitchProfiles::POWERSAVINGM3; sId++) {
if (ImGui::Selectable(SWITCH_CPU_PROFILES[sId], sId == slot)) {
SPDLOG_INFO("Profile:: %s", SWITCH_CPU_PROFILES[sId]);
CVar_SetS32("gSwitchPerfMode", sId);
CVarSetInteger("gSwitchPerfMode", sId);
Ship::Switch::ApplyOverclock();
SohImGui::RequestCvarSaveOnNextTick();
}
@ -1011,9 +1011,9 @@ namespace GameMenuBar {
UIWidgets::Tooltip("This syncs the ingame time with the real world time");
{
static int32_t betaQuestEnabled = CVar_GetS32("gEnableBetaQuest", 0);
static int32_t betaQuestEnabled = CVarGetInteger("gEnableBetaQuest", 0);
static int32_t lastBetaQuestEnabled = betaQuestEnabled;
static int32_t betaQuestWorld = CVar_GetS32("gBetaQuestWorld", 0xFFEF);
static int32_t betaQuestWorld = CVarGetInteger("gBetaQuestWorld", 0xFFEF);
static int32_t lastBetaQuestWorld = betaQuestWorld;
if (!isBetaQuestEnabled) {
@ -1023,7 +1023,7 @@ namespace GameMenuBar {
UIWidgets::PaddedEnhancementCheckbox("Enable Beta Quest", "gEnableBetaQuest", true, false);
UIWidgets::Tooltip("Turns on OoT Beta Quest. *WARNING* This will reset your game.");
betaQuestEnabled = CVar_GetS32("gEnableBetaQuest", 0);
betaQuestEnabled = CVarGetInteger("gEnableBetaQuest", 0);
if (betaQuestEnabled) {
if (betaQuestEnabled != lastBetaQuestEnabled) {
betaQuestWorld = 0;
@ -1055,15 +1055,15 @@ namespace GameMenuBar {
}
else {
lastBetaQuestWorld = betaQuestWorld = 0xFFEF;
CVar_SetS32("gBetaQuestWorld", betaQuestWorld);
CVarSetInteger("gBetaQuestWorld", betaQuestWorld);
}
if (betaQuestEnabled != lastBetaQuestEnabled || betaQuestWorld != lastBetaQuestWorld)
{
// Reset the game if the beta quest state or world changed because beta quest happens on redirecting the title screen cutscene.
lastBetaQuestEnabled = betaQuestEnabled;
lastBetaQuestWorld = betaQuestWorld;
CVar_SetS32("gEnableBetaQuest", betaQuestEnabled);
CVar_SetS32("gBetaQuestWorld", betaQuestWorld);
CVarSetInteger("gEnableBetaQuest", betaQuestEnabled);
CVarSetInteger("gBetaQuestWorld", betaQuestWorld);
SohImGui::DispatchConsoleCommand("reset");
@ -1077,7 +1077,7 @@ namespace GameMenuBar {
}
if (ImGui::Button("Change Age")) {
CVar_SetS32("gSwitchAge", 1);
CVarSetInteger("gSwitchAge", 1);
}
UIWidgets::Tooltip("Switches links age and reloads the area.");
@ -1094,7 +1094,7 @@ namespace GameMenuBar {
UIWidgets::Tooltip("Enables Skulltula Debug, when moving the cursor in the menu above various map icons (boss key, compass, map screen locations, etc) will set the GS bits in that area.\nUSE WITH CAUTION AS IT DOES NOT UPDATE THE GS COUNT.");
UIWidgets::PaddedEnhancementCheckbox("Fast File Select", "gSkipLogoTitle", true, false);
UIWidgets::Tooltip("Load the game to the selected menu or file\n\"Zelda Map Select\" require debug mode else you will fallback to File choose menu\nUsing a file number that don't have save will create a save file only if you toggle on \"Create a new save if none ?\" else it will bring you to the File choose menu");
if (CVar_GetS32("gSkipLogoTitle", 0)) {
if (CVarGetInteger("gSkipLogoTitle", 0)) {
const char* FastFileSelect[5] = {
"File N.1",
"File N.2",
@ -1114,46 +1114,46 @@ namespace GameMenuBar {
ImGui::PushStyleVar(ImGuiStyleVar_ButtonTextAlign, ImVec2(0,0));
ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 1.0f);
ImGui::PushStyleColor(ImGuiCol_Border, ImVec4(0.22f, 0.38f, 0.56f, 1.0f));
if (ImGui::Button(GetWindowButtonText("Stats", CVar_GetS32("gStatsEnabled", 0)).c_str(), ImVec2(-1.0f, 0.0f)))
if (ImGui::Button(GetWindowButtonText("Stats", CVarGetInteger("gStatsEnabled", 0)).c_str(), ImVec2(-1.0f, 0.0f)))
{
bool currentValue = CVar_GetS32("gStatsEnabled", 0);
CVar_SetS32("gStatsEnabled", !currentValue);
bool currentValue = CVarGetInteger("gStatsEnabled", 0);
CVarSetInteger("gStatsEnabled", !currentValue);
SohImGui::ToggleStatisticsWindow(true);
SohImGui::RequestCvarSaveOnNextTick();
}
UIWidgets::Tooltip("Shows the stats window, with your FPS and frametimes, and the OS you're playing on");
UIWidgets::Spacer(0);
if (ImGui::Button(GetWindowButtonText("Console", CVar_GetS32("gConsoleEnabled", 0)).c_str(), ImVec2(-1.0f, 0.0f)))
if (ImGui::Button(GetWindowButtonText("Console", CVarGetInteger("gConsoleEnabled", 0)).c_str(), ImVec2(-1.0f, 0.0f)))
{
bool currentValue = CVar_GetS32("gConsoleEnabled", 0);
CVar_SetS32("gConsoleEnabled", !currentValue);
bool currentValue = CVarGetInteger("gConsoleEnabled", 0);
CVarSetInteger("gConsoleEnabled", !currentValue);
SohImGui::RequestCvarSaveOnNextTick();
SohImGui::ToggleConsoleWindow(!currentValue);
}
UIWidgets::Tooltip("Enables the console window, allowing you to input commands, type help for some examples");
UIWidgets::Spacer(0);
if (ImGui::Button(GetWindowButtonText("Save Editor", CVar_GetS32("gSaveEditorEnabled", 0)).c_str(), ImVec2(-1.0f, 0.0f)))
if (ImGui::Button(GetWindowButtonText("Save Editor", CVarGetInteger("gSaveEditorEnabled", 0)).c_str(), ImVec2(-1.0f, 0.0f)))
{
bool currentValue = CVar_GetS32("gSaveEditorEnabled", 0);
CVar_SetS32("gSaveEditorEnabled", !currentValue);
bool currentValue = CVarGetInteger("gSaveEditorEnabled", 0);
CVarSetInteger("gSaveEditorEnabled", !currentValue);
SohImGui::RequestCvarSaveOnNextTick();
SohImGui::EnableWindow("Save Editor", CVar_GetS32("gSaveEditorEnabled", 0));
SohImGui::EnableWindow("Save Editor", CVarGetInteger("gSaveEditorEnabled", 0));
}
UIWidgets::Spacer(0);
if (ImGui::Button(GetWindowButtonText("Collision Viewer", CVar_GetS32("gCollisionViewerEnabled", 0)).c_str(), ImVec2(-1.0f, 0.0f)))
if (ImGui::Button(GetWindowButtonText("Collision Viewer", CVarGetInteger("gCollisionViewerEnabled", 0)).c_str(), ImVec2(-1.0f, 0.0f)))
{
bool currentValue = CVar_GetS32("gCollisionViewerEnabled", 0);
CVar_SetS32("gCollisionViewerEnabled", !currentValue);
bool currentValue = CVarGetInteger("gCollisionViewerEnabled", 0);
CVarSetInteger("gCollisionViewerEnabled", !currentValue);
SohImGui::RequestCvarSaveOnNextTick();
SohImGui::EnableWindow("Collision Viewer", CVar_GetS32("gCollisionViewerEnabled", 0));
SohImGui::EnableWindow("Collision Viewer", CVarGetInteger("gCollisionViewerEnabled", 0));
}
UIWidgets::Spacer(0);
if (ImGui::Button(GetWindowButtonText("Actor Viewer", CVar_GetS32("gActorViewerEnabled", 0)).c_str(), ImVec2(-1.0f, 0.0f)))
if (ImGui::Button(GetWindowButtonText("Actor Viewer", CVarGetInteger("gActorViewerEnabled", 0)).c_str(), ImVec2(-1.0f, 0.0f)))
{
bool currentValue = CVar_GetS32("gActorViewerEnabled", 0);
CVar_SetS32("gActorViewerEnabled", !currentValue);
bool currentValue = CVarGetInteger("gActorViewerEnabled", 0);
CVarSetInteger("gActorViewerEnabled", !currentValue);
SohImGui::RequestCvarSaveOnNextTick();
SohImGui::EnableWindow("Actor Viewer", CVar_GetS32("gActorViewerEnabled", 0));
SohImGui::EnableWindow("Actor Viewer", CVarGetInteger("gActorViewerEnabled", 0));
}
ImGui::PopStyleVar(3);
ImGui::PopStyleColor(1);
@ -1174,52 +1174,52 @@ namespace GameMenuBar {
#else
static ImVec2 buttonSize(200.0f, 0.0f);
#endif
if (ImGui::Button(GetWindowButtonText("Randomizer Settings", CVar_GetS32("gRandomizerSettingsEnabled", 0)).c_str(), buttonSize))
if (ImGui::Button(GetWindowButtonText("Randomizer Settings", CVarGetInteger("gRandomizerSettingsEnabled", 0)).c_str(), buttonSize))
{
bool currentValue = CVar_GetS32("gRandomizerSettingsEnabled", 0);
CVar_SetS32("gRandomizerSettingsEnabled", !currentValue);
bool currentValue = CVarGetInteger("gRandomizerSettingsEnabled", 0);
CVarSetInteger("gRandomizerSettingsEnabled", !currentValue);
SohImGui::RequestCvarSaveOnNextTick();
SohImGui::EnableWindow("Randomizer Settings", CVar_GetS32("gRandomizerSettingsEnabled", 0));
SohImGui::EnableWindow("Randomizer Settings", CVarGetInteger("gRandomizerSettingsEnabled", 0));
}
ImGui::Dummy(ImVec2(0.0f, 0.0f));
if (ImGui::Button(GetWindowButtonText("Item Tracker", CVar_GetS32("gItemTrackerEnabled", 0)).c_str(), buttonSize))
if (ImGui::Button(GetWindowButtonText("Item Tracker", CVarGetInteger("gItemTrackerEnabled", 0)).c_str(), buttonSize))
{
bool currentValue = CVar_GetS32("gItemTrackerEnabled", 0);
CVar_SetS32("gItemTrackerEnabled", !currentValue);
bool currentValue = CVarGetInteger("gItemTrackerEnabled", 0);
CVarSetInteger("gItemTrackerEnabled", !currentValue);
SohImGui::RequestCvarSaveOnNextTick();
SohImGui::EnableWindow("Item Tracker", CVar_GetS32("gItemTrackerEnabled", 0));
SohImGui::EnableWindow("Item Tracker", CVarGetInteger("gItemTrackerEnabled", 0));
}
ImGui::Dummy(ImVec2(0.0f, 0.0f));
if (ImGui::Button(GetWindowButtonText("Item Tracker Settings", CVar_GetS32("gItemTrackerSettingsEnabled", 0)).c_str(), buttonSize))
if (ImGui::Button(GetWindowButtonText("Item Tracker Settings", CVarGetInteger("gItemTrackerSettingsEnabled", 0)).c_str(), buttonSize))
{
bool currentValue = CVar_GetS32("gItemTrackerSettingsEnabled", 0);
CVar_SetS32("gItemTrackerSettingsEnabled", !currentValue);
bool currentValue = CVarGetInteger("gItemTrackerSettingsEnabled", 0);
CVarSetInteger("gItemTrackerSettingsEnabled", !currentValue);
SohImGui::RequestCvarSaveOnNextTick();
SohImGui::EnableWindow("Item Tracker Settings", CVar_GetS32("gItemTrackerSettingsEnabled", 0));
SohImGui::EnableWindow("Item Tracker Settings", CVarGetInteger("gItemTrackerSettingsEnabled", 0));
}
ImGui::Dummy(ImVec2(0.0f, 0.0f));
if (ImGui::Button(GetWindowButtonText("Entrance Tracker", CVar_GetS32("gEntranceTrackerEnabled", 0)).c_str(), buttonSize))
if (ImGui::Button(GetWindowButtonText("Entrance Tracker", CVarGetInteger("gEntranceTrackerEnabled", 0)).c_str(), buttonSize))
{
bool currentValue = CVar_GetS32("gEntranceTrackerEnabled", 0);
CVar_SetS32("gEntranceTrackerEnabled", !currentValue);
bool currentValue = CVarGetInteger("gEntranceTrackerEnabled", 0);
CVarSetInteger("gEntranceTrackerEnabled", !currentValue);
SohImGui::RequestCvarSaveOnNextTick();
SohImGui::EnableWindow("Entrance Tracker", CVar_GetS32("gEntranceTrackerEnabled", 0));
SohImGui::EnableWindow("Entrance Tracker", CVarGetInteger("gEntranceTrackerEnabled", 0));
}
ImGui::Dummy(ImVec2(0.0f, 0.0f));
if (ImGui::Button(GetWindowButtonText("Check Tracker", CVar_GetS32("gCheckTrackerEnabled", 0)).c_str(), buttonSize))
if (ImGui::Button(GetWindowButtonText("Check Tracker", CVarGetInteger("gCheckTrackerEnabled", 0)).c_str(), buttonSize))
{
bool currentValue = CVar_GetS32("gCheckTrackerEnabled", 0);
CVar_SetS32("gCheckTrackerEnabled", !currentValue);
bool currentValue = CVarGetInteger("gCheckTrackerEnabled", 0);
CVarSetInteger("gCheckTrackerEnabled", !currentValue);
SohImGui::RequestCvarSaveOnNextTick();
SohImGui::EnableWindow("Check Tracker", CVar_GetS32("gCheckTrackerEnabled", 0));
SohImGui::EnableWindow("Check Tracker", CVarGetInteger("gCheckTrackerEnabled", 0));
}
ImGui::Dummy(ImVec2(0.0f, 0.0f));
if (ImGui::Button(GetWindowButtonText("Check Tracker Settings", CVar_GetS32("gCheckTrackerSettingsEnabled", 0)).c_str(), buttonSize))
if (ImGui::Button(GetWindowButtonText("Check Tracker Settings", CVarGetInteger("gCheckTrackerSettingsEnabled", 0)).c_str(), buttonSize))
{
bool currentValue = CVar_GetS32("gCheckTrackerSettingsEnabled", 0);
CVar_SetS32("gCheckTrackerSettingsEnabled", !currentValue);
bool currentValue = CVarGetInteger("gCheckTrackerSettingsEnabled", 0);
CVarSetInteger("gCheckTrackerSettingsEnabled", !currentValue);
SohImGui::RequestCvarSaveOnNextTick();
SohImGui::EnableWindow("Check Tracker Settings", CVar_GetS32("gCheckTrackerSettingsEnabled", 0));
SohImGui::EnableWindow("Check Tracker Settings", CVarGetInteger("gCheckTrackerSettingsEnabled", 0));
}
ImGui::PopStyleVar(3);
ImGui::PopStyleColor(1);
@ -1278,7 +1278,7 @@ namespace GameMenuBar {
UIWidgets::EnhancementCheckbox("Crowd Control", "gCrowdControl");
UIWidgets::Tooltip("Will attempt to connect to the Crowd Control server. Check out crowdcontrol.live for more information.");
if (CVar_GetS32("gCrowdControl", 0)) {
if (CVarGetInteger("gCrowdControl", 0)) {
CrowdControl::Instance->Enable();
} else {
CrowdControl::Instance->Disable();
@ -1293,7 +1293,7 @@ namespace GameMenuBar {
"Enemies that need more than Deku Nuts + either Deku Sticks or a sword to kill are excluded from spawning in \"clear enemy\" rooms."
);
if (CVar_GetS32("gRandomizedEnemies", 0)) {
if (CVarGetInteger("gRandomizedEnemies", 0)) {
bool disableSeededEnemies = !gSaveContext.n64ddFlag && gSaveContext.fileNum >= 0 && gSaveContext.fileNum <= 2;
const char* disableSeededEnemiesText = "This setting is disabled because it relies on a randomizer savefile.";

4
soh/soh/GbiWrap.cpp
View File

@ -16,10 +16,10 @@ int32_t OTRGetLastScancode();
void ResourceMgr_CacheDirectory(const char* resName);
void ResourceMgr_LoadFile(const char* resName);
char* ResourceMgr_LoadFileFromDisk(const char* filePath);
char* ResourceMgr_LoadTexByName(char* texPath);
char* GetResourceDataByName(char* texPath);
uint16_t ResourceMgr_LoadTexWidthByName(char* texPath);
uint16_t ResourceMgr_LoadTexHeightByName(char* texPath);
uint32_t ResourceMgr_LoadTexSizeByName(char* texPath);
size_t GetResourceTexSizeByName(const char* name);
char* ResourceMgr_LoadTexOrDListByName(char* filePath);
char* ResourceMgr_LoadPlayerAnimByName(char* animPath);
char* ResourceMgr_GetNameByCRC(uint64_t crc, char* alloc);

689
soh/soh/OTRGlobals.cpp
View File

@ -7,24 +7,19 @@
#include <ResourceMgr.h>
#include <DisplayList.h>
#include <PlayerAnimation.h>
#include <Skeleton.h>
#include <Window.h>
#include <GameVersions.h>
#include "z64animation.h"
#include "z64bgcheck.h"
#include "Enhancements/gameconsole.h"
#include <ultra64/gbi.h>
#include <Animation.h>
#include <libultraship/libultra/gbi.h>
#ifdef _WIN32
#include <Windows.h>
#else
#include <time.h>
#endif
#include <CollisionHeader.h>
#include <Array.h>
#include <Cutscene.h>
#include <stb/stb_image.h>
#define DRMP3_IMPLEMENTATION
#include <dr_libs/mp3.h>
@ -66,8 +61,6 @@
#endif
#include <Audio.h>
#include "Enhancements/custom-message/CustomMessageTypes.h"
#include <functions.h>
#include "Enhancements/item-tables/ItemTableManager.h"
@ -78,6 +71,35 @@
CrowdControl* CrowdControl::Instance;
#endif
#include "libultraship/libultraship.h"
// Resource Types/Factories
#include "soh/resource/type/Animation.h"
#include "soh/resource/type/AudioSample.h"
#include "soh/resource/type/AudioSequence.h"
#include "soh/resource/type/AudioSoundFont.h"
#include "soh/resource/type/CollisionHeader.h"
#include "soh/resource/type/Cutscene.h"
#include "soh/resource/type/Path.h"
#include "soh/resource/type/PlayerAnimation.h"
#include "soh/resource/type/Scene.h"
#include "soh/resource/type/Skeleton.h"
#include "soh/resource/type/SkeletonLimb.h"
#include "soh/resource/type/Text.h"
#include "soh/resource/importer/AnimationFactory.h"
#include "soh/resource/importer/AudioSampleFactory.h"
#include "soh/resource/importer/AudioSequenceFactory.h"
#include "soh/resource/importer/AudioSoundFontFactory.h"
#include "soh/resource/importer/CollisionHeaderFactory.h"
#include "soh/resource/importer/CutsceneFactory.h"
#include "soh/resource/importer/PathFactory.h"
#include "soh/resource/importer/PlayerAnimationFactory.h"
#include "soh/resource/importer/SceneFactory.h"
#include "soh/resource/importer/SkeletonFactory.h"
#include "soh/resource/importer/SkeletonLimbFactory.h"
#include "soh/resource/importer/TextFactory.h"
#include "soh/resource/importer/BackgroundFactory.h"
OTRGlobals* OTRGlobals::Instance;
SaveManager* SaveManager::Instance;
CustomMessageManager* CustomMessageManager::Instance;
@ -121,6 +143,21 @@ OTRGlobals::OTRGlobals() {
OOT_PAL_GC_DBG2
};
context = Ship::Window::CreateInstance("Ship of Harkinian", OTRFiles);
context->GetResourceManager()->GetResourceLoader()->RegisterResourceFactory(Ship::ResourceType::SOH_Animation, std::make_shared<Ship::AnimationFactory>());
context->GetResourceManager()->GetResourceLoader()->RegisterResourceFactory(Ship::ResourceType::SOH_PlayerAnimation, std::make_shared<Ship::PlayerAnimationFactory>());
context->GetResourceManager()->GetResourceLoader()->RegisterResourceFactory(Ship::ResourceType::SOH_Room, std::make_shared<Ship::SceneFactory>()); // Is room scene? maybe?
context->GetResourceManager()->GetResourceLoader()->RegisterResourceFactory(Ship::ResourceType::SOH_CollisionHeader, std::make_shared<Ship::CollisionHeaderFactory>());
context->GetResourceManager()->GetResourceLoader()->RegisterResourceFactory(Ship::ResourceType::SOH_Skeleton, std::make_shared<Ship::SkeletonFactory>());
context->GetResourceManager()->GetResourceLoader()->RegisterResourceFactory(Ship::ResourceType::SOH_SkeletonLimb, std::make_shared<Ship::SkeletonLimbFactory>());
context->GetResourceManager()->GetResourceLoader()->RegisterResourceFactory(Ship::ResourceType::SOH_Path, std::make_shared<Ship::PathFactory>());
context->GetResourceManager()->GetResourceLoader()->RegisterResourceFactory(Ship::ResourceType::SOH_Cutscene, std::make_shared<Ship::CutsceneFactory>());
context->GetResourceManager()->GetResourceLoader()->RegisterResourceFactory(Ship::ResourceType::SOH_Text, std::make_shared<Ship::TextFactory>());
context->GetResourceManager()->GetResourceLoader()->RegisterResourceFactory(Ship::ResourceType::SOH_AudioSample, std::make_shared<Ship::AudioSampleFactory>());
context->GetResourceManager()->GetResourceLoader()->RegisterResourceFactory(Ship::ResourceType::SOH_AudioSoundFont, std::make_shared<Ship::AudioSoundFontFactory>());
context->GetResourceManager()->GetResourceLoader()->RegisterResourceFactory(Ship::ResourceType::SOH_AudioSequence, std::make_shared<Ship::AudioSequenceFactory>());
context->GetResourceManager()->GetResourceLoader()->RegisterResourceFactory(Ship::ResourceType::SOH_Background, std::make_shared<Ship::BackgroundFactory>());
gSaveStateMgr = std::make_shared<SaveStateMgr>();
gRandomizer = std::make_shared<Randomizer>();
@ -454,9 +491,9 @@ extern "C" void InitOTR() {
time_t now = time(NULL);
tm *tm_now = localtime(&now);
if (tm_now->tm_mon == 11 && tm_now->tm_mday >= 24 && tm_now->tm_mday <= 25) {
CVar_RegisterS32("gLetItSnow", 1);
CVarRegisterInteger("gLetItSnow", 1);
} else {
CVar_Clear("gLetItSnow");
CVarClear("gLetItSnow");
}
#ifdef ENABLE_CROWD_CONTROL
CrowdControl::Instance = new CrowdControl();
@ -586,7 +623,7 @@ extern "C" void Graph_ProcessGfxCommands(Gfx* commands) {
audio.cv_to_thread.notify_one();
std::vector<std::unordered_map<Mtx*, MtxF>> mtx_replacements;
int target_fps = CVar_GetS32("gInterpolationFPS", 20);
int target_fps = CVarGetInteger("gInterpolationFPS", 20);
static int last_fps;
static int last_update_rate;
static int time;
@ -617,7 +654,7 @@ extern "C" void Graph_ProcessGfxCommands(Gfx* commands) {
OTRGlobals::Instance->context->SetTargetFps(fps);
int threshold = CVar_GetS32("gExtraLatencyThreshold", 80);
int threshold = CVarGetInteger("gExtraLatencyThreshold", 80);
OTRGlobals::Instance->context->SetMaximumFrameLatency(threshold > 0 && target_fps >= threshold ? 2 : 1);
RunCommands(commands, mtx_replacements);
@ -795,21 +832,17 @@ extern "C" char* ResourceMgr_LoadJPEG(char* data, int dataSize)
return (char*)finalBuffer;
}
extern "C" char* ResourceMgr_LoadTexByName(const char* texPath);
extern "C" uint16_t ResourceMgr_LoadTexWidthByName(char* texPath);
extern "C" uint16_t ResourceMgr_LoadTexHeightByName(char* texPath);
extern "C" uint32_t ResourceMgr_LoadTexSizeByName(const char* texPath);
extern "C" char* ResourceMgr_LoadTexOrDListByName(const char* filePath) {
auto res = ResourceMgr_LoadResource(filePath);
if (res->ResType == Ship::ResourceType::DisplayList)
return (char*)&((std::static_pointer_cast<Ship::DisplayList>(res))->instructions[0]);
else if (res->ResType == Ship::ResourceType::Array)
return (char*)(std::static_pointer_cast<Ship::Array>(res))->vertices.data();
if (res->Type == Ship::ResourceType::DisplayList)
return (char*)&((std::static_pointer_cast<Ship::DisplayList>(res))->Instructions[0]);
else if (res->Type == Ship::ResourceType::Array)
return (char*)(std::static_pointer_cast<Ship::Array>(res))->Vertices.data();
else {
std::string Path = filePath;
if (ResourceMgr_IsGameMasterQuest()) {
@ -818,7 +851,7 @@ extern "C" char* ResourceMgr_LoadTexOrDListByName(const char* filePath) {
Path.replace(pos, 7, "/mq/");
}
}
return ResourceMgr_LoadTexByName(Path.c_str());
return (char*)GetResourceDataByName(Path.c_str(), false);
}
}
@ -835,7 +868,7 @@ extern "C" char* ResourceMgr_LoadPlayerAnimByName(const char* animPath) {
extern "C" Gfx* ResourceMgr_LoadGfxByName(const char* path)
{
auto res = std::static_pointer_cast<Ship::DisplayList>(ResourceMgr_LoadResource(path));
return (Gfx*)&res->instructions[0];
return (Gfx*)&res->Instructions[0];
}
typedef struct {
@ -865,11 +898,11 @@ extern "C" void ResourceMgr_PatchGfxByName(const char* path, const char* patchNa
}*/
// Index refers to individual gfx words, which are half the size on 32-bit
if (sizeof(uintptr_t) < 8) {
index /= 2;
}
// if (sizeof(uintptr_t) < 8) {
// index /= 2;
// }
Gfx* gfx = (Gfx*)&res->instructions[index];
Gfx* gfx = (Gfx*)&res->Instructions[index];
if (!originalGfx.contains(path) || !originalGfx[path].contains(patchName)) {
originalGfx[path][patchName] = {
@ -886,7 +919,7 @@ extern "C" void ResourceMgr_UnpatchGfxByName(const char* path, const char* patch
auto res = std::static_pointer_cast<Ship::DisplayList>(
OTRGlobals::Instance->context->GetResourceManager()->LoadResource(path));
Gfx* gfx = (Gfx*)&res->instructions[originalGfx[path][patchName].index];
Gfx* gfx = (Gfx*)&res->Instructions[originalGfx[path][patchName].index];
*gfx = originalGfx[path][patchName].instruction;
originalGfx[path].erase(patchName);
@ -897,154 +930,48 @@ extern "C" char* ResourceMgr_LoadArrayByName(const char* path)
{
auto res = std::static_pointer_cast<Ship::Array>(ResourceMgr_LoadResource(path));
return (char*)res->scalars.data();
return (char*)res->Scalars.data();
}
extern "C" char* ResourceMgr_LoadArrayByNameAsVec3s(const char* path) {
auto res = std::static_pointer_cast<Ship::Array>(ResourceMgr_LoadResource(path));
if (res->CachedGameAsset != nullptr)
return (char*)res->CachedGameAsset;
else
{
Vec3s* data = (Vec3s*)malloc(sizeof(Vec3s) * res->scalars.size());
// if (res->CachedGameAsset != nullptr)
// return (char*)res->CachedGameAsset;
// else
// {
Vec3s* data = (Vec3s*)malloc(sizeof(Vec3s) * res->Scalars.size());
for (size_t i = 0; i < res->scalars.size(); i += 3) {
data[(i / 3)].x = res->scalars[i + 0].s16;
data[(i / 3)].y = res->scalars[i + 1].s16;
data[(i / 3)].z = res->scalars[i + 2].s16;
for (size_t i = 0; i < res->Scalars.size(); i += 3) {
data[(i / 3)].x = res->Scalars[i + 0].s16;
data[(i / 3)].y = res->Scalars[i + 1].s16;
data[(i / 3)].z = res->Scalars[i + 2].s16;
}
res->CachedGameAsset = data;
// res->CachedGameAsset = data;
return (char*)data;
}
// }
}
extern "C" CollisionHeader* ResourceMgr_LoadColByName(const char* path)
{
auto colRes = std::static_pointer_cast<Ship::CollisionHeader>(ResourceMgr_LoadResource(path));
if (colRes->CachedGameAsset != nullptr)
return (CollisionHeader*)colRes->CachedGameAsset;
CollisionHeader* colHeader = (CollisionHeader*)malloc(sizeof(CollisionHeader));
colHeader->minBounds.x = colRes->absMinX;
colHeader->minBounds.y = colRes->absMinY;
colHeader->minBounds.z = colRes->absMinZ;
colHeader->maxBounds.x = colRes->absMaxX;
colHeader->maxBounds.y = colRes->absMaxY;
colHeader->maxBounds.z = colRes->absMaxZ;
colHeader->vtxList = (Vec3s*)malloc(sizeof(Vec3s) * colRes->vertices.size());
colHeader->numVertices = colRes->vertices.size();
for (size_t i = 0; i < colRes->vertices.size(); i++)
{
colHeader->vtxList[i].x = colRes->vertices[i].x;
colHeader->vtxList[i].y = colRes->vertices[i].y;
colHeader->vtxList[i].z = colRes->vertices[i].z;
}
colHeader->polyList = (CollisionPoly*)malloc(sizeof(CollisionPoly) * colRes->polygons.size());
colHeader->numPolygons = colRes->polygons.size();
for (size_t i = 0; i < colRes->polygons.size(); i++)
{
colHeader->polyList[i].type = colRes->polygons[i].type;
colHeader->polyList[i].flags_vIA = colRes->polygons[i].vtxA;
colHeader->polyList[i].flags_vIB = colRes->polygons[i].vtxB;
colHeader->polyList[i].vIC = colRes->polygons[i].vtxC;
colHeader->polyList[i].normal.x = colRes->polygons[i].a;
colHeader->polyList[i].normal.y = colRes->polygons[i].b;
colHeader->polyList[i].normal.z = colRes->polygons[i].c;
colHeader->polyList[i].dist = colRes->polygons[i].d;
}
colHeader->surfaceTypeList = (SurfaceType*)malloc(colRes->polygonTypes.size() * sizeof(SurfaceType));
for (size_t i = 0; i < colRes->polygonTypes.size(); i++)
{
colHeader->surfaceTypeList[i].data[0] = colRes->polygonTypes[i] >> 32;
colHeader->surfaceTypeList[i].data[1] = colRes->polygonTypes[i] & 0xFFFFFFFF;
}
colHeader->cameraDataList = (CamData*)malloc(sizeof(CamData) * colRes->camData->entries.size());
for (size_t i = 0; i < colRes->camData->entries.size(); i++)
{
colHeader->cameraDataList[i].cameraSType = colRes->camData->entries[i]->cameraSType;
colHeader->cameraDataList[i].numCameras = colRes->camData->entries[i]->numData;
int idx = colRes->camData->entries[i]->cameraPosDataIdx;
colHeader->cameraDataList[i].camPosData = (Vec3s*)malloc(sizeof(Vec3s));
if (colRes->camData->cameraPositionData.size() > 0)
{
colHeader->cameraDataList[i].camPosData->x = colRes->camData->cameraPositionData[idx]->x;
colHeader->cameraDataList[i].camPosData->y = colRes->camData->cameraPositionData[idx]->y;
colHeader->cameraDataList[i].camPosData->z = colRes->camData->cameraPositionData[idx]->z;
}
else
{
colHeader->cameraDataList[i].camPosData->x = 0;
colHeader->cameraDataList[i].camPosData->y = 0;
colHeader->cameraDataList[i].camPosData->z = 0;
}
}
colHeader->numWaterBoxes = colRes->waterBoxes.size();
colHeader->waterBoxes = (WaterBox*)malloc(sizeof(WaterBox) * colHeader->numWaterBoxes);
for (int i = 0; i < colHeader->numWaterBoxes; i++)
{
colHeader->waterBoxes[i].xLength = colRes->waterBoxes[i].xLength;
colHeader->waterBoxes[i].ySurface = colRes->waterBoxes[i].ySurface;
colHeader->waterBoxes[i].xMin = colRes->waterBoxes[i].xMin;
colHeader->waterBoxes[i].zMin = colRes->waterBoxes[i].zMin;
colHeader->waterBoxes[i].xLength = colRes->waterBoxes[i].xLength;
colHeader->waterBoxes[i].zLength = colRes->waterBoxes[i].zLength;
colHeader->waterBoxes[i].properties = colRes->waterBoxes[i].properties;
}
colRes->CachedGameAsset = colHeader;
return (CollisionHeader*)colHeader;
extern "C" CollisionHeader* ResourceMgr_LoadColByName(const char* path) {
return (CollisionHeader*)GetResourceDataByName(path, false);
}
extern "C" Vtx* ResourceMgr_LoadVtxByName(const char* path)
{
auto res = std::static_pointer_cast<Ship::Array>(ResourceMgr_LoadResource(path));
return (Vtx*)res->vertices.data();
extern "C" Vtx* ResourceMgr_LoadVtxByName(char* path) {
return (Vtx*)GetResourceDataByName(path, false);
}
extern "C" SequenceData ResourceMgr_LoadSeqByName(const char* path)
{
auto file = std::static_pointer_cast<Ship::AudioSequence>(OTRGlobals::Instance->context->GetResourceManager()
->LoadResource(path));
SequenceData seqData;
seqData.seqNumber = file->seqNumber;
seqData.medium = file->medium;
seqData.cachePolicy = file->cachePolicy;
seqData.numFonts = file->fonts.size();
for (int i = 0; i < seqData.numFonts; i++)
seqData.fonts[i] = file->fonts[i];
seqData.seqData = file->seqData.data();
seqData.seqDataSize = file->seqData.size();
return seqData;
extern "C" SequenceData ResourceMgr_LoadSeqByName(const char* path) {
SequenceData* sequence = (SequenceData*)GetResourceDataByName(path, false);
return *sequence;
}
std::map<std::string, SoundFontSample*> cachedCustomSFs;
extern "C" SoundFontSample* ReadCustomSample(const char* path) {
return nullptr;
/*
if (!ExtensionCache.contains(path))
return nullptr;
@ -1097,189 +1024,15 @@ extern "C" SoundFontSample* ReadCustomSample(const char* path) {
}
return nullptr;
*/
}
extern "C" SoundFontSample* ResourceMgr_LoadAudioSample(const char* path)
{
if (std::string(path) == "")
return nullptr;
if (cachedCustomSFs.find(path) != cachedCustomSFs.end())
return cachedCustomSFs[path];
SoundFontSample* cSample = ReadCustomSample(path);
if (cSample != nullptr)
return cSample;
auto sample = std::static_pointer_cast<Ship::AudioSample>(ResourceMgr_LoadResource(path));
if (sample == nullptr)
return NULL;
if (sample->CachedGameAsset != nullptr)
{
SoundFontSample* sampleC = (SoundFontSample*)sample->CachedGameAsset;
return (SoundFontSample*)sample->CachedGameAsset;
}
else
{
SoundFontSample* sampleC = new SoundFontSample;
sampleC->sampleAddr = sample->data.data();
sampleC->size = sample->data.size();
sampleC->codec = sample->codec;
sampleC->medium = sample->medium;
sampleC->unk_bit26 = sample->unk_bit26;
sampleC->unk_bit25 = sample->unk_bit25;
sampleC->book = (AdpcmBook*) malloc(sizeof(AdpcmBook) + sample->book.books.size() * sizeof(int16_t));
sampleC->book->npredictors = sample->book.npredictors;
sampleC->book->order = sample->book.order;
for (size_t i = 0; i < sample->book.books.size(); i++)
sampleC->book->book[i] = sample->book.books[i];
sampleC->loop = new AdpcmLoop;
sampleC->loop->start = sample->loop.start;
sampleC->loop->end = sample->loop.end;
sampleC->loop->count = sample->loop.count;
for (int i = 0; i < 16; i++)
sampleC->loop->state[i] = 0;
for (size_t i = 0; i < sample->loop.states.size(); i++)
sampleC->loop->state[i] = sample->loop.states[i];
sample->CachedGameAsset = sampleC;
return sampleC;
}
extern "C" SoundFontSample* ResourceMgr_LoadAudioSample(const char* path) {
return (SoundFontSample*)GetResourceDataByName(path, false);
}
extern "C" SoundFont* ResourceMgr_LoadAudioSoundFont(const char* path) {
auto soundFont = std::static_pointer_cast<Ship::AudioSoundFont>(ResourceMgr_LoadResource(path));
if (soundFont == nullptr)
return NULL;
if (soundFont->CachedGameAsset != nullptr)
{
return (SoundFont*)soundFont->CachedGameAsset;
}
else
{
SoundFont* soundFontC = (SoundFont*)malloc(sizeof(SoundFont));
soundFontC->fntIndex = soundFont->id;
soundFontC->numDrums = soundFont->drums.size();
soundFontC->numInstruments = soundFont->instruments.size();
soundFontC->numSfx = soundFont->soundEffects.size();
soundFontC->sampleBankId1 = soundFont->data1 >> 8;
soundFontC->sampleBankId2 = soundFont->data1 & 0xFF;
soundFontC->drums = (Drum**)malloc(sizeof(Drum*) * soundFont->drums.size());
for (size_t i = 0; i < soundFont->drums.size(); i++)
{
Drum* drum = (Drum*)malloc(sizeof(Drum));
drum->releaseRate = soundFont->drums[i].releaseRate;
drum->pan = soundFont->drums[i].pan;
drum->loaded = 0;
if (soundFont->drums[i].env.size() == 0)
drum->envelope = NULL;
else
{
drum->envelope = (AdsrEnvelope*)malloc(sizeof(AdsrEnvelope) * soundFont->drums[i].env.size());
for (size_t k = 0; k < soundFont->drums[i].env.size(); k++)
{
drum->envelope[k].delay = BE16SWAP(soundFont->drums[i].env[k]->delay);
drum->envelope[k].arg = BE16SWAP(soundFont->drums[i].env[k]->arg);
}
}
drum->sound.sample = ResourceMgr_LoadAudioSample(soundFont->drums[i].sampleFileName.c_str());
drum->sound.tuning = soundFont->drums[i].tuning;
soundFontC->drums[i] = drum;
}
soundFontC->instruments = (Instrument**)malloc(sizeof(Instrument*) * soundFont->instruments.size());
for (size_t i = 0; i < soundFont->instruments.size(); i++) {
if (soundFont->instruments[i].isValidEntry)
{
Instrument* inst = (Instrument*)malloc(sizeof(Instrument));
inst->loaded = 0;
inst->releaseRate = soundFont->instruments[i].releaseRate;
inst->normalRangeLo = soundFont->instruments[i].normalRangeLo;
inst->normalRangeHi = soundFont->instruments[i].normalRangeHi;
if (soundFont->instruments[i].env.size() == 0)
inst->envelope = NULL;
else
{
inst->envelope = (AdsrEnvelope*)malloc(sizeof(AdsrEnvelope) * soundFont->instruments[i].env.size());
for (int k = 0; k < soundFont->instruments[i].env.size(); k++)
{
inst->envelope[k].delay = BE16SWAP(soundFont->instruments[i].env[k]->delay);
inst->envelope[k].arg = BE16SWAP(soundFont->instruments[i].env[k]->arg);
}
}
if (soundFont->instruments[i].lowNotesSound != nullptr)
{
inst->lowNotesSound.sample =
ResourceMgr_LoadAudioSample(soundFont->instruments[i].lowNotesSound->sampleFileName.c_str());
inst->lowNotesSound.tuning = soundFont->instruments[i].lowNotesSound->tuning;
} else {
inst->lowNotesSound.sample = NULL;
inst->lowNotesSound.tuning = 0;
}
if (soundFont->instruments[i].normalNotesSound != nullptr) {
inst->normalNotesSound.sample =
ResourceMgr_LoadAudioSample(soundFont->instruments[i].normalNotesSound->sampleFileName.c_str());
inst->normalNotesSound.tuning = soundFont->instruments[i].normalNotesSound->tuning;
} else {
inst->normalNotesSound.sample = NULL;
inst->normalNotesSound.tuning = 0;
}
if (soundFont->instruments[i].highNotesSound != nullptr) {
inst->highNotesSound.sample =
ResourceMgr_LoadAudioSample(soundFont->instruments[i].highNotesSound->sampleFileName.c_str());
inst->highNotesSound.tuning = soundFont->instruments[i].highNotesSound->tuning;
} else {
inst->highNotesSound.sample = NULL;
inst->highNotesSound.tuning = 0;
}
soundFontC->instruments[i] = inst;
}
else
{
soundFontC->instruments[i] = nullptr;
}
}
soundFontC->soundEffects = (SoundFontSound*)malloc(sizeof(SoundFontSound) * soundFont->soundEffects.size());
for (size_t i = 0; i < soundFont->soundEffects.size(); i++)
{
soundFontC->soundEffects[i].sample = ResourceMgr_LoadAudioSample(soundFont->soundEffects[i]->sampleFileName.c_str());
soundFontC->soundEffects[i].tuning = soundFont->soundEffects[i]->tuning;
}
soundFont->CachedGameAsset = soundFontC;
return soundFontC;
}
return (SoundFont*)GetResourceDataByName(path, false);
}
extern "C" int ResourceMgr_OTRSigCheck(char* imgData)
@ -1301,263 +1054,15 @@ extern "C" int ResourceMgr_OTRSigCheck(char* imgData)
}
extern "C" AnimationHeaderCommon* ResourceMgr_LoadAnimByName(const char* path) {
auto res = std::static_pointer_cast<Ship::Animation>(ResourceMgr_LoadResource(path));
if (res->CachedGameAsset != nullptr)
return (AnimationHeaderCommon*)res->CachedGameAsset;
AnimationHeaderCommon* anim = nullptr;
if (res->type == Ship::AnimationType::Normal) {
AnimationHeader* animNormal = (AnimationHeader*)malloc(sizeof(AnimationHeader));
animNormal->common.frameCount = res->frameCount;
animNormal->frameData = (int16_t*)malloc(res->rotationValues.size() * sizeof(int16_t));
for (size_t i = 0; i < res->rotationValues.size(); i++)
animNormal->frameData[i] = res->rotationValues[i];
animNormal->jointIndices = (JointIndex*)malloc(res->rotationIndices.size() * sizeof(Vec3s));
for (size_t i = 0; i < res->rotationIndices.size(); i++) {
animNormal->jointIndices[i].x = res->rotationIndices[i].x;
animNormal->jointIndices[i].y = res->rotationIndices[i].y;
animNormal->jointIndices[i].z = res->rotationIndices[i].z;
}
animNormal->staticIndexMax = res->limit;
anim = (AnimationHeaderCommon*)animNormal;
}
else if (res->type == Ship::AnimationType::Curve)
{
TransformUpdateIndex* animCurve = (TransformUpdateIndex*)malloc(sizeof(TransformUpdateIndex));
animCurve->copyValues = (s16*)malloc(res->copyValuesArr.size() * sizeof(s16));
for (size_t i = 0; i < res->copyValuesArr.size(); i++)
animCurve->copyValues[i] = res->copyValuesArr[i];
animCurve->transformData = (TransformData*)malloc(res->transformDataArr.size() * sizeof(TransformData));
for (size_t i = 0; i < res->transformDataArr.size(); i++)
{
animCurve->transformData[i].unk_00 = res->transformDataArr[i].unk_00;
animCurve->transformData[i].unk_02 = res->transformDataArr[i].unk_02;
animCurve->transformData[i].unk_04 = res->transformDataArr[i].unk_04;
animCurve->transformData[i].unk_06 = res->transformDataArr[i].unk_06;
animCurve->transformData[i].unk_08 = res->transformDataArr[i].unk_08;
}
animCurve->refIndex = (u8*)malloc(res->refIndexArr.size());
for (size_t i = 0; i < res->refIndexArr.size(); i++)
animCurve->refIndex[i] = res->refIndexArr[i];
anim = (AnimationHeaderCommon*)animCurve;
}
else {
LinkAnimationHeader* animLink = (LinkAnimationHeader*)malloc(sizeof(LinkAnimationHeader));
animLink->common.frameCount = res->frameCount;
animLink->segment = (void*)res->segPtr;
anim = (AnimationHeaderCommon*)animLink;
}
res->CachedGameAsset = anim;
return anim;
return (AnimationHeaderCommon*)GetResourceDataByName(path, false);
}
extern "C" SkeletonHeader* ResourceMgr_LoadSkeletonByName(const char* path) {
auto res = std::static_pointer_cast<Ship::Skeleton>(ResourceMgr_LoadResource(path));
if (res->CachedGameAsset != nullptr)
return (SkeletonHeader*)res->CachedGameAsset;
SkeletonHeader* baseHeader = nullptr;
if (res->type == Ship::SkeletonType::Normal)
{
baseHeader = (SkeletonHeader*)malloc(sizeof(SkeletonHeader));
}
else if (res->type == Ship::SkeletonType::Curve)
{
SkelCurveLimbList* curve = (SkelCurveLimbList*)malloc(sizeof(SkelCurveLimbList));
curve->limbCount = res->limbCount;
curve->limbs = (SkelCurveLimb**)malloc(res->limbCount * sizeof(SkelCurveLimb*));
baseHeader = (SkeletonHeader*)curve;
}
else {
FlexSkeletonHeader* flex = (FlexSkeletonHeader*)malloc(sizeof(FlexSkeletonHeader));
flex->dListCount = res->dListCount;
baseHeader = (SkeletonHeader*)flex;
}
if (res->type != Ship::SkeletonType::Curve)
{
baseHeader->limbCount = res->limbCount;
baseHeader->segment = (void**)malloc(sizeof(StandardLimb*) * res->limbTable.size());
}
for (size_t i = 0; i < res->limbTable.size(); i++) {
std::string limbStr = res->limbTable[i];
auto limb = std::static_pointer_cast<Ship::SkeletonLimb>(ResourceMgr_LoadResource(limbStr.c_str()));
if (limb->limbType == Ship::LimbType::LOD) {
LodLimb* limbC = (LodLimb*)malloc(sizeof(LodLimb));
limbC->jointPos.x = limb->transX;
limbC->jointPos.y = limb->transY;
limbC->jointPos.z = limb->transZ;
limbC->child = limb->childIndex;
limbC->sibling = limb->siblingIndex;
if (limb->dListPtr != "") {
auto dList = ResourceMgr_LoadGfxByName(limb->dListPtr.c_str());
limbC->dLists[0] = dList;
} else {
limbC->dLists[0] = nullptr;
}
if (limb->dList2Ptr != "") {
auto dList = ResourceMgr_LoadGfxByName(limb->dList2Ptr.c_str());
limbC->dLists[1] = dList;
} else {
limbC->dLists[1] = nullptr;
}
baseHeader->segment[i] = limbC;
}
else if (limb->limbType == Ship::LimbType::Standard)
{
const auto limbC = new StandardLimb;
limbC->jointPos.x = limb->transX;
limbC->jointPos.y = limb->transY;
limbC->jointPos.z = limb->transZ;
limbC->child = limb->childIndex;
limbC->sibling = limb->siblingIndex;
limbC->dList = nullptr;
if (!limb->dListPtr.empty()) {
const auto dList = ResourceMgr_LoadGfxByName(limb->dListPtr.c_str());
limbC->dList = dList;
}
baseHeader->segment[i] = limbC;
}
else if (limb->limbType == Ship::LimbType::Curve)
{
const auto limbC = new SkelCurveLimb;
limbC->firstChildIdx = limb->childIndex;
limbC->nextLimbIdx = limb->siblingIndex;
limbC->dList[0] = nullptr;
limbC->dList[1] = nullptr;
if (!limb->dListPtr.empty()) {
const auto dList = ResourceMgr_LoadGfxByName(limb->dListPtr.c_str());
limbC->dList[0] = dList;
}
if (!limb->dList2Ptr.empty()) {
const auto dList = ResourceMgr_LoadGfxByName(limb->dList2Ptr.c_str());
limbC->dList[1] = dList;
}
const auto curve = reinterpret_cast<SkelCurveLimbList*>(baseHeader);
curve->limbs[i] = limbC;
}
else if (limb->limbType == Ship::LimbType::Skin)
{
const auto limbC = new SkinLimb;
limbC->jointPos.x = limb->transX;
limbC->jointPos.y = limb->transY;
limbC->jointPos.z = limb->transZ;
limbC->child = limb->childIndex;
limbC->sibling = limb->siblingIndex;
if (limb->skinSegmentType == Ship::ZLimbSkinType::SkinType_DList)
limbC->segmentType = static_cast<int32_t>(limb->skinSegmentType);
else if (limb->skinSegmentType == Ship::ZLimbSkinType::SkinType_4)
limbC->segmentType = 4;
else if (limb->skinSegmentType == Ship::ZLimbSkinType::SkinType_5)
limbC->segmentType = 5;
else
limbC->segmentType = 0;
if (limb->skinSegmentType == Ship::ZLimbSkinType::SkinType_DList)
limbC->segment = ResourceMgr_LoadGfxByName(limb->skinDList.c_str());
else if (limb->skinSegmentType == Ship::ZLimbSkinType::SkinType_4) {
const auto animData = new SkinAnimatedLimbData;
const int skinDataSize = limb->skinData.size();
animData->totalVtxCount = limb->skinVtxCnt;
animData->limbModifCount = skinDataSize;
animData->limbModifications = new SkinLimbModif[animData->limbModifCount];
animData->dlist = ResourceMgr_LoadGfxByName(limb->skinDList2.c_str());
for (size_t i = 0; i < skinDataSize; i++)
{
animData->limbModifications[i].vtxCount = limb->skinData[i].unk_8_arr.size();
animData->limbModifications[i].transformCount = limb->skinData[i].unk_C_arr.size();
animData->limbModifications[i].unk_4 = limb->skinData[i].unk_4;
animData->limbModifications[i].skinVertices = new SkinVertex[limb->skinData[i].unk_8_arr.size()];
for (int k = 0; k < limb->skinData[i].unk_8_arr.size(); k++)
{
animData->limbModifications[i].skinVertices[k].index = limb->skinData[i].unk_8_arr[k].unk_0;
animData->limbModifications[i].skinVertices[k].s = limb->skinData[i].unk_8_arr[k].unk_2;
animData->limbModifications[i].skinVertices[k].t = limb->skinData[i].unk_8_arr[k].unk_4;
animData->limbModifications[i].skinVertices[k].normX = limb->skinData[i].unk_8_arr[k].unk_6;
animData->limbModifications[i].skinVertices[k].normY = limb->skinData[i].unk_8_arr[k].unk_7;
animData->limbModifications[i].skinVertices[k].normZ = limb->skinData[i].unk_8_arr[k].unk_8;
animData->limbModifications[i].skinVertices[k].alpha = limb->skinData[i].unk_8_arr[k].unk_9;
}
animData->limbModifications[i].limbTransformations =
new SkinTransformation[limb->skinData[i].unk_C_arr.size()];
for (int k = 0; k < limb->skinData[i].unk_C_arr.size(); k++)
{
animData->limbModifications[i].limbTransformations[k].limbIndex = limb->skinData[i].unk_C_arr[k].unk_0;
animData->limbModifications[i].limbTransformations[k].x = limb->skinData[i].unk_C_arr[k].x;
animData->limbModifications[i].limbTransformations[k].y = limb->skinData[i].unk_C_arr[k].y;
animData->limbModifications[i].limbTransformations[k].z = limb->skinData[i].unk_C_arr[k].z;
animData->limbModifications[i].limbTransformations[k].scale = limb->skinData[i].unk_C_arr[k].unk_8;
}
}
limbC->segment = animData;
//limbC->segment = nullptr;
}
/*if (limb->dListPtr != "") {
auto dList = ResourceMgr_LoadGfxByName((char*)limb->dListPtr.c_str());
limbC->unk_8 = dList;
}
else {
limbC->unk_8 = nullptr;
}*/
baseHeader->segment[i] = limbC;
}
else
{
// OTRTODO: Print error here...
}
}
res->CachedGameAsset = baseHeader;
return baseHeader;
return (SkeletonHeader*)GetResourceDataByName(path, false);
}
extern "C" s32* ResourceMgr_LoadCSByName(const char* path)
{
auto res = std::static_pointer_cast<Ship::Cutscene>(ResourceMgr_LoadResource(path));
return (s32*)res->commands.data();
extern "C" s32* ResourceMgr_LoadCSByName(const char* path) {
return (s32*)GetResourceDataByName(path, false);
}
std::filesystem::path GetSaveFile(std::shared_ptr<Mercury> Conf) {
@ -1936,7 +1441,7 @@ extern "C" int CustomMessage_RetrieveIfExists(PlayState* play) {
if (player->getItemEntry.getItemId == RG_ICE_TRAP) {
u16 iceTrapTextId = Random(0, NUM_ICE_TRAP_MESSAGES);
messageEntry = CustomMessageManager::Instance->RetrieveMessage(Randomizer::IceTrapRandoMessageTableID, iceTrapTextId);
if (CVar_GetS32("gLetItSnow", 0)) {
if (CVarGetInteger("gLetItSnow", 0)) {
messageEntry = CustomMessageManager::Instance->RetrieveMessage(Randomizer::IceTrapRandoMessageTableID, NUM_ICE_TRAP_MESSAGES + 1);
}
} else if (player->getItemEntry.getItemId >= RG_DEKU_TREE_MAP && player->getItemEntry.getItemId <= RG_ICE_CAVERN_MAP) {
@ -1998,12 +1503,12 @@ extern "C" int CustomMessage_RetrieveIfExists(PlayState* play) {
RandomizerInf randoInf = (RandomizerInf)((textId - (TEXT_SHOP_ITEM_RANDOM + NUM_SHOP_ITEMS)) + RAND_INF_SHOP_ITEMS_KF_SHOP_ITEM_1);
messageEntry = OTRGlobals::Instance->gRandomizer->GetMerchantMessage(randoInf, TEXT_SHOP_ITEM_RANDOM_CONFIRM);
}
} else if (CVar_GetS32("gRandomizeRupeeNames", 0) &&
} else if (CVarGetInteger("gRandomizeRupeeNames", 0) &&
(textId == TEXT_BLUE_RUPEE || textId == TEXT_RED_RUPEE || textId == TEXT_PURPLE_RUPEE ||
textId == TEXT_HUGE_RUPEE)) {
messageEntry = Randomizer::GetRupeeMessage(textId);
// In rando, replace Navi's general overworld hints with rando-related gameplay tips
} else if (CVar_GetS32("gRandoRelevantNavi", 1) && textId >= 0x0140 && textId <= 0x015F) {
} else if (CVarGetInteger("gRandoRelevantNavi", 1) && textId >= 0x0140 && textId <= 0x015F) {
u16 naviTextId = Random(0, NUM_NAVI_MESSAGES);
messageEntry = CustomMessageManager::Instance->RetrieveMessage(Randomizer::NaviRandoMessageTableID, naviTextId);
} else if (Randomizer_GetSettingValue(RSK_SHUFFLE_MAGIC_BEANS) && textId == TEXT_BEAN_SALESMAN) {
@ -2024,7 +1529,7 @@ extern "C" int CustomMessage_RetrieveIfExists(PlayState* play) {
}
}
if (textId == TEXT_GS_NO_FREEZE || textId == TEXT_GS_FREEZE) {
if (CVar_GetS32("gInjectItemCounts", 0) != 0) {
if (CVarGetInteger("gInjectItemCounts", 0) != 0) {
// The freeze text cannot be manually dismissed and must be auto-dismissed.
// This is fine and even wanted when skull tokens are not shuffled, but when
// when they are shuffled we don't want to be able to manually dismiss the box.
@ -2032,7 +1537,7 @@ extern "C" int CustomMessage_RetrieveIfExists(PlayState* play) {
// animation until the text box auto-dismisses.
// RANDOTODO: Implement a way to determine if an item came from a skulltula and
// inject the auto-dismiss control code if it did.
if (CVar_GetS32("gSkulltulaFreeze", 0) != 0 &&
if (CVarGetInteger("gSkulltulaFreeze", 0) != 0 &&
!(gSaveContext.n64ddFlag && Randomizer_GetSettingValue(RSK_SHUFFLE_TOKENS) != RO_TOKENSANITY_OFF)) {
textId = TEXT_GS_NO_FREEZE;
} else {
@ -2042,15 +1547,15 @@ extern "C" int CustomMessage_RetrieveIfExists(PlayState* play) {
CustomMessageManager::ReplaceStringInMessage(messageEntry, "{{gsCount}}", std::to_string(gSaveContext.inventory.gsTokens + 1));
}
}
if (textId == TEXT_HEART_CONTAINER && CVar_GetS32("gInjectItemCounts", 0)) {
if (textId == TEXT_HEART_CONTAINER && CVarGetInteger("gInjectItemCounts", 0)) {
messageEntry = CustomMessageManager::Instance->RetrieveMessage(customMessageTableID, TEXT_HEART_CONTAINER);
CustomMessageManager::ReplaceStringInMessage(messageEntry, "{{heartContainerCount}}", std::to_string(gSaveContext.sohStats.heartContainers + 1));
}
if (textId == TEXT_HEART_PIECE && CVar_GetS32("gInjectItemCounts", 0)) {
if (textId == TEXT_HEART_PIECE && CVarGetInteger("gInjectItemCounts", 0)) {
messageEntry = CustomMessageManager::Instance->RetrieveMessage(customMessageTableID, TEXT_HEART_PIECE);
CustomMessageManager::ReplaceStringInMessage(messageEntry, "{{heartPieceCount}}", std::to_string(gSaveContext.sohStats.heartPieces + 1));
}
if (textId == TEXT_MARKET_GUARD_NIGHT && CVar_GetS32("gMarketSneak", 0) && play->sceneNum == SCENE_ENTRA_N) {
if (textId == TEXT_MARKET_GUARD_NIGHT && CVarGetInteger("gMarketSneak", 0) && play->sceneNum == SCENE_ENTRA_N) {
messageEntry = CustomMessageManager::Instance->RetrieveMessage(customMessageTableID, TEXT_MARKET_GUARD_NIGHT);
}
if (messageEntry.textBoxType != -1) {

4
soh/soh/OTRGlobals.h
View File

@ -62,10 +62,8 @@ char** ResourceMgr_ListFiles(const char* searchMask, int* resultSize);
void ResourceMgr_LoadFile(const char* resName);
char* ResourceMgr_LoadFileFromDisk(const char* filePath);
char* ResourceMgr_LoadJPEG(char* data, int dataSize);
char* ResourceMgr_LoadTexByName(const char* texPath);
uint16_t ResourceMgr_LoadTexWidthByName(char* texPath);
uint16_t ResourceMgr_LoadTexHeightByName(char* texPath);
uint32_t ResourceMgr_LoadTexSizeByName(char* texPath);
char* ResourceMgr_LoadTexOrDListByName(const char* filePath);
char* ResourceMgr_LoadPlayerAnimByName(const char* animPath);
AnimationHeaderCommon* ResourceMgr_LoadAnimByName(const char* path);
@ -77,7 +75,7 @@ void ResourceMgr_UnpatchGfxByName(const char* path, const char* patchName);
char* ResourceMgr_LoadArrayByNameAsVec3s(const char* path);
Vtx* ResourceMgr_LoadVtxByCRC(uint64_t crc);
Vtx* ResourceMgr_LoadVtxByName(const char* path);
Vtx* ResourceMgr_LoadVtxByName(char* path);
SoundFont* ResourceMgr_LoadAudioSoundFont(const char* path);
SequenceData ResourceMgr_LoadSeqByName(const char* path);
SoundFontSample* ResourceMgr_LoadAudioSample(const char* path);

6
soh/soh/SaveManager.cpp
View File

@ -5,7 +5,7 @@
#include "functions.h"
#include "macros.h"
#include <Hooks.h>
#include <Cvar.h>
#include <libultraship/bridge.h>
#define NOGDI // avoid various windows defines that conflict with things in z64.h
#include <spdlog/spdlog.h>
@ -801,7 +801,7 @@ void SaveManager::AddPostFunction(const std::string& name, PostFunc func) {
void SaveManager::CreateDefaultGlobal() {
gSaveContext.audioSetting = 0;
gSaveContext.zTargetSetting = 0;
gSaveContext.language = CVar_GetS32("gLanguages", LANGUAGE_ENG);
gSaveContext.language = CVarGetInteger("gLanguages", LANGUAGE_ENG);
SaveGlobal();
}
@ -1962,7 +1962,7 @@ void SaveManager::ConvertFromUnversioned() {
gSaveContext.zTargetSetting = data[SRAM_HEADER_ZTARGET] & 1;
gSaveContext.language = data[SRAM_HEADER_LANGUAGE];
if (gSaveContext.language >= LANGUAGE_MAX) {
gSaveContext.language = CVar_GetS32("gLanguages", LANGUAGE_ENG);
gSaveContext.language = CVarGetInteger("gLanguages", LANGUAGE_ENG);
}
SaveGlobal();

2
soh/soh/SaveManager.h
View File

@ -1,6 +1,6 @@
#pragma once
#include <ultra64/gbi.h>
#include <libultraship/libultra/gbi.h>
typedef struct {
u8 valid;

62
soh/soh/UIWidgets.cpp
View File

@ -10,9 +10,9 @@
#define IMGUI_DEFINE_MATH_OPERATORS
#include <ImGui/imgui_internal.h>
#include <ImGuiImpl.h>
#include <Cvar.h>
#include <libultraship/bridge.h>
#include <ultra64/types.h>
#include <libultraship/libultra/types.h>
#include "soh/Enhancements/cosmetics/CosmeticsEditor.h"
namespace UIWidgets {
@ -59,7 +59,7 @@ namespace UIWidgets {
defaultColors.b = default_colors.z;
defaultColors.a = default_colors.w;
Color_RGBA8 cvarColor = CVar_GetRGBA(cvarname, defaultColors);
Color_RGBA8 cvarColor = CVarGetColor(cvarname, defaultColors);
ColorArray.x = cvarColor.r / 255.0;
ColorArray.y = cvarColor.g / 255.0;
@ -202,9 +202,9 @@ namespace UIWidgets {
ImGui::PushItemFlag(ImGuiItemFlags_Disabled, true);
ImGui::PushStyleVar(ImGuiStyleVar_Alpha, ImGui::GetStyle().Alpha * 0.5f);
}
bool val = (bool)CVar_GetS32(cvarName, defaultValue);
bool val = (bool)CVarGetInteger(cvarName, defaultValue);
if (CustomCheckbox(text, &val, disabled, disabledGraphic)) {
CVar_SetS32(cvarName, val);
CVarSetInteger(cvarName, val);
SohImGui::RequestCvarSaveOnNextTick();
changed = true;
}
@ -233,10 +233,10 @@ namespace UIWidgets {
}
void EnhancementCombo(const std::string& name, const char* cvarName, const std::vector<std::string>& items, int defaultValue) {
if (ImGui::BeginCombo(name.c_str(), items[static_cast<int>(CVar_GetS32(cvarName, defaultValue))].c_str())) {
if (ImGui::BeginCombo(name.c_str(), items[static_cast<int>(CVarGetInteger(cvarName, defaultValue))].c_str())) {
for (int settingIndex = 0; settingIndex < (int) items.size(); settingIndex++) {
if (ImGui::Selectable(items[settingIndex].c_str())) {
CVar_SetS32(cvarName, settingIndex);
CVarSetInteger(cvarName, settingIndex);
SohImGui::RequestCvarSaveOnNextTick();
}
@ -250,14 +250,14 @@ namespace UIWidgets {
if (FirstTimeValue <= 0) {
FirstTimeValue = 0;
}
uint8_t selected = CVar_GetS32(name, FirstTimeValue);
uint8_t selected = CVarGetInteger(name, FirstTimeValue);
uint8_t DefaultValue = selected;
std::string comboName = std::string("##") + std::string(name);
if (ImGui::BeginCombo(comboName.c_str(), ComboArray[DefaultValue])) {
for (uint8_t i = 0; i < arraySize; i++) {
if (strlen(ComboArray[i]) > 1) {
if (ImGui::Selectable(ComboArray[i], i == selected)) {
CVar_SetS32(name, i);
CVarSetInteger(name, i);
selected = i;
changed = true;
SohImGui::RequestCvarSaveOnNextTick();
@ -294,7 +294,7 @@ namespace UIWidgets {
bool EnhancementSliderInt(const char* text, const char* id, const char* cvarName, int min, int max, const char* format, int defaultValue, bool PlusMinusButton, bool disabled, const char* disabledTooltipText) {
bool changed = false;
int val = CVar_GetS32(cvarName, defaultValue);
int val = CVarGetInteger(cvarName, defaultValue);
float alpha;
if (disabled) {
@ -315,7 +315,7 @@ namespace UIWidgets {
MinusBTNName += cvarName;
if (ImGui::Button(MinusBTNName.c_str())) {
val--;
CVar_SetS32(cvarName, val);
CVarSetInteger(cvarName, val);
SohImGui::RequestCvarSaveOnNextTick();
changed = true;
}
@ -337,7 +337,7 @@ namespace UIWidgets {
}
if (ImGui::SliderInt(id, &val, min, max, format))
{
CVar_SetS32(cvarName, val);
CVarSetInteger(cvarName, val);
SohImGui::RequestCvarSaveOnNextTick();
changed = true;
}
@ -355,7 +355,7 @@ namespace UIWidgets {
ImGui::SetCursorPosX(ImGui::GetCursorPosX() - 7.0f);
if (ImGui::Button(PlusBTNName.c_str())) {
val++;
CVar_SetS32(cvarName, val);
CVarSetInteger(cvarName, val);
SohImGui::RequestCvarSaveOnNextTick();
changed = true;
}
@ -372,7 +372,7 @@ namespace UIWidgets {
if (val < min)
{
val = min;
CVar_SetS32(cvarName, val);
CVarSetInteger(cvarName, val);
SohImGui::RequestCvarSaveOnNextTick();
changed = true;
}
@ -380,7 +380,7 @@ namespace UIWidgets {
if (val > max)
{
val = max;
CVar_SetS32(cvarName, val);
CVarSetInteger(cvarName, val);
SohImGui::RequestCvarSaveOnNextTick();
changed = true;
}
@ -390,7 +390,7 @@ namespace UIWidgets {
bool EnhancementSliderFloat(const char* text, const char* id, const char* cvarName, float min, float max, const char* format, float defaultValue, bool isPercentage, bool PlusMinusButton, bool disabled, const char* disabledTooltipText) {
bool changed = false;
float val = CVar_GetFloat(cvarName, defaultValue);
float val = CVarGetFloat(cvarName, defaultValue);
if (disabled) {
ImGui::PushItemFlag(ImGuiItemFlags_Disabled, true);
@ -412,7 +412,7 @@ namespace UIWidgets {
} else {
val -= 0.01f;
}
CVar_SetFloat(cvarName, val);
CVarSetFloat(cvarName, val);
SohImGui::RequestCvarSaveOnNextTick();
changed = true;
}
@ -430,9 +430,9 @@ namespace UIWidgets {
}
if (ImGui::SliderFloat(id, &val, min, max, format)) {
if (isPercentage) {
CVar_SetFloat(cvarName, roundf(val * 100) / 100);
CVarSetFloat(cvarName, roundf(val * 100) / 100);
} else {
CVar_SetFloat(cvarName, val);
CVarSetFloat(cvarName, val);
}
SohImGui::RequestCvarSaveOnNextTick();
changed = true;
@ -451,7 +451,7 @@ namespace UIWidgets {
} else {
val += 0.01f;
}
CVar_SetFloat(cvarName, val);
CVarSetFloat(cvarName, val);
SohImGui::RequestCvarSaveOnNextTick();
changed = true;
}
@ -467,14 +467,14 @@ namespace UIWidgets {
if (val < min) {
val = min;
CVar_SetFloat(cvarName, val);
CVarSetFloat(cvarName, val);
SohImGui::RequestCvarSaveOnNextTick();
changed = true;
}
if (val > max) {
val = max;
CVar_SetFloat(cvarName, val);
CVarSetFloat(cvarName, val);
SohImGui::RequestCvarSaveOnNextTick();
changed = true;
}
@ -507,9 +507,9 @@ namespace UIWidgets {
make_invisible += text;
make_invisible += cvarName;
int val = CVar_GetS32(cvarName, 0);
int val = CVarGetInteger(cvarName, 0);
if (ImGui::RadioButton(make_invisible.c_str(), id == val)) {
CVar_SetS32(cvarName, id);
CVarSetInteger(cvarName, id);
SohImGui::RequestCvarSaveOnNextTick();
}
ImGui::SameLine();
@ -536,8 +536,8 @@ namespace UIWidgets {
colorsRGBA.b = defaultcolors.z;
colorsRGBA.a = has_alpha ? defaultcolors.w : 255.0f;
CVar_SetRGBA(cvarName, colorsRGBA);
CVar_SetS32(Cvar_RBM.c_str(), 0); //On click disable rainbow mode.
CVarSetColor(cvarName, colorsRGBA);
CVarSetInteger(Cvar_RBM.c_str(), 0); //On click disable rainbow mode.
SohImGui::RequestCvarSaveOnNextTick();
changed = true;
}
@ -566,8 +566,8 @@ namespace UIWidgets {
NewColors.r = fmin(fmax(colors->x * 255, 0), 255);
NewColors.g = fmin(fmax(colors->y * 255, 0), 255);
NewColors.b = fmin(fmax(colors->z * 255, 0), 255);
CVar_SetRGBA(cvarName, NewColors);
CVar_SetS32(Cvar_RBM.c_str(), 0); // On click disable rainbow mode.
CVarSetColor(cvarName, NewColors);
CVarSetInteger(Cvar_RBM.c_str(), 0); // On click disable rainbow mode.
SohImGui::RequestCvarSaveOnNextTick();
changed = true;
}
@ -578,7 +578,7 @@ namespace UIWidgets {
void DrawLockColorCheckbox(const char* cvarName) {
std::string Cvar_Lock = cvarName;
Cvar_Lock += "Lock";
s32 lock = CVar_GetS32(Cvar_Lock.c_str(), 0);
s32 lock = CVarGetInteger(Cvar_Lock.c_str(), 0);
std::string FullName = "Lock##" + Cvar_Lock;
EnhancementCheckbox(FullName.c_str(), Cvar_Lock.c_str());
Tooltip("Prevents this color from being changed upon selecting \"Randomize all\"");
@ -618,7 +618,7 @@ namespace UIWidgets {
colors.b = ColorRGBA.z * 255.0;
colors.a = 255.0;
CVar_SetRGBA(cvarName, colors);
CVarSetColor(cvarName, colors);
SohImGui::RequestCvarSaveOnNextTick();
changed = true;
}
@ -634,7 +634,7 @@ namespace UIWidgets {
colors.b = ColorRGBA.z * 255.0;
colors.a = ColorRGBA.w * 255.0;
CVar_SetRGBA(cvarName, colors);
CVarSetColor(cvarName, colors);
SohImGui::RequestCvarSaveOnNextTick();
changed = true;
}

4
soh/soh/frame_interpolation.cpp
View File

@ -1,4 +1,4 @@
#include <Cvar.h>
#include <libultraship/bridge.h>
#include <vector>
#include <map>
@ -451,7 +451,7 @@ void FrameInterpolation_StartRecord(void) {
current_recording = {};
current_path.clear();
current_path.push_back(&current_recording.root_path);
if (CVar_GetS32("gInterpolationFPS", 20) != 20) {
if (CVarGetInteger("gInterpolationFPS", 20) != 20) {
is_recording = true;
}
}

103
soh/soh/resource/importer/AnimationFactory.cpp Normal file
View File

@ -0,0 +1,103 @@
#include "soh/resource/importer/AnimationFactory.h"
#include "soh/resource/type/Animation.h"
#include "spdlog/spdlog.h"
namespace Ship {
std::shared_ptr<Resource> AnimationFactory::ReadResource(uint32_t version, std::shared_ptr<BinaryReader> reader) {
auto resource = std::make_shared<Animation>();
std::shared_ptr<ResourceVersionFactory> factory = nullptr;
switch (version) {
case 0:
factory = std::make_shared<AnimationFactoryV0>();
break;
}
if (factory == nullptr) {
SPDLOG_ERROR("Failed to load Animation with version {}", version);
return nullptr;
}
factory->ParseFileBinary(reader, resource);
return resource;
}
void Ship::AnimationFactoryV0::ParseFileBinary(std::shared_ptr<BinaryReader> reader, std::shared_ptr<Resource> resource) {
std::shared_ptr<Animation> animation = std::static_pointer_cast<Animation>(resource);
ResourceVersionFactory::ParseFileBinary(reader, animation);
AnimationType animType = (AnimationType)reader->ReadUInt32();
animation->type = animType;
if (animType == AnimationType::Normal) {
// Set frame count
animation->animationData.animationHeader.common.frameCount = reader->ReadInt16();
// Populate frame data
uint32_t rotValuesCnt = reader->ReadUInt32();
animation->rotationValues.reserve(rotValuesCnt);
for (uint32_t i = 0; i < rotValuesCnt; i++) {
animation->rotationValues.push_back(reader->ReadUInt16());
}
animation->animationData.animationHeader.frameData = (int16_t*)animation->rotationValues.data();
// Populate joint indices
uint32_t rotIndCnt = reader->ReadUInt32();
animation->rotationIndices.reserve(rotIndCnt);
for (size_t i = 0; i < rotIndCnt; i++) {
uint16_t x = reader->ReadUInt16();
uint16_t y = reader->ReadUInt16();
uint16_t z = reader->ReadUInt16();
animation->rotationIndices.push_back(RotationIndex(x, y, z));
}
animation->animationData.animationHeader.jointIndices = (JointIndex*)animation->rotationIndices.data();
// Set static index max
animation->animationData.animationHeader.staticIndexMax = reader->ReadInt16();
} else if (animType == AnimationType::Curve) {
// Read frame count (unused in this animation type)
reader->ReadInt16();
// Set refIndex
uint32_t refArrCnt = reader->ReadUInt32();
animation->refIndexArr.reserve(refArrCnt);
for (uint32_t i = 0; i < refArrCnt; i++) {
animation->refIndexArr.push_back(reader->ReadUByte());
}
animation->animationData.transformUpdateIndex.refIndex = animation->refIndexArr.data();
// Populate transform data
uint32_t transformDataCnt = reader->ReadUInt32();
animation->transformDataArr.reserve(transformDataCnt);
for (uint32_t i = 0; i < transformDataCnt; i++) {
TransformData data;
data.unk_00 = reader->ReadUInt16();
data.unk_02 = reader->ReadInt16();
data.unk_04 = reader->ReadInt16();
data.unk_06 = reader->ReadInt16();
data.unk_08 = reader->ReadFloat();
animation->transformDataArr.push_back(data);
}
animation->animationData.transformUpdateIndex.transformData = animation->transformDataArr.data();
// Populate copy values
uint32_t copyValuesCnt = reader->ReadUInt32();
animation->copyValuesArr.reserve(copyValuesCnt);
for (uint32_t i = 0; i < copyValuesCnt; i++) {
animation->copyValuesArr.push_back(reader->ReadInt16());
}
animation->animationData.transformUpdateIndex.copyValues = animation->copyValuesArr.data();
} else if (animType == AnimationType::Link) {
// Read the frame count
animation->animationData.linkAnimationHeader.common.frameCount = reader->ReadInt16();
// Read the segment pointer (always 32 bit, doesn't adjust for system pointer size)
animation->animationData.linkAnimationHeader.segment = (void*)reader->ReadUInt32();
} else if (animType == AnimationType::Legacy) {
SPDLOG_DEBUG("BEYTAH ANIMATION?!");
}
}
} // namespace Ship

16
soh/soh/resource/importer/AnimationFactory.h Normal file
View File

@ -0,0 +1,16 @@
#pragma once
#include "Resource.h"
#include "ResourceFactory.h"
namespace Ship {
class AnimationFactory : public ResourceFactory {
public:
std::shared_ptr<Resource> ReadResource(uint32_t version, std::shared_ptr<BinaryReader> reader);
};
class AnimationFactoryV0 : public ResourceVersionFactory {
public:
void ParseFileBinary(std::shared_ptr<BinaryReader> reader, std::shared_ptr<Resource> resource) override;
};
}; // namespace Ship

143
soh/soh/resource/importer/AudioSampleFactory.cpp Normal file
View File

@ -0,0 +1,143 @@
#include "soh/resource/importer/AudioSampleFactory.h"
#include "soh/resource/type/AudioSample.h"
#include "spdlog/spdlog.h"
namespace Ship {
std::shared_ptr<Resource> AudioSampleFactory::ReadResource(uint32_t version, std::shared_ptr<BinaryReader> reader)
{
auto resource = std::make_shared<AudioSample>();
std::shared_ptr<ResourceVersionFactory> factory = nullptr;
switch (version)
{
case 2:
factory = std::make_shared<AudioSampleFactoryV0>();
break;
}
if (factory == nullptr)
{
SPDLOG_ERROR("Failed to load AudioSample with version {}", version);
return nullptr;
}
factory->ParseFileBinary(reader, resource);
return resource;
}
void Ship::AudioSampleFactoryV0::ParseFileBinary(std::shared_ptr<BinaryReader> reader,
std::shared_ptr<Resource> resource)
{
std::shared_ptr<AudioSample> audioSample = std::static_pointer_cast<AudioSample>(resource);
ResourceVersionFactory::ParseFileBinary(reader, audioSample);
audioSample->sample.codec = reader->ReadUByte();
audioSample->sample.medium = reader->ReadUByte();
audioSample->sample.unk_bit26 = reader->ReadUByte();
audioSample->sample.unk_bit25 = reader->ReadUByte();
audioSample->sample.size = reader->ReadUInt32();
audioSample->audioSampleData.reserve(audioSample->sample.size);
for (uint32_t i = 0; i < audioSample->sample.size; i++) {
audioSample->audioSampleData.push_back(reader->ReadUByte());
}
audioSample->sample.sampleAddr = audioSample->audioSampleData.data();
audioSample->loop.start = reader->ReadUInt32();
audioSample->loop.end = reader->ReadUInt32();
audioSample->loop.count = reader->ReadUInt32();
audioSample->loopStateCount = reader->ReadUInt32();
for (int i = 0; i < 16; i++) {
audioSample->loop.state[i] = 0;
}
for (uint32_t i = 0; i < audioSample->loopStateCount; i++) {
audioSample->loop.state[i] = reader->ReadInt16();
}
audioSample->sample.loop = &audioSample->loop;
audioSample->book.order = reader->ReadInt32();
audioSample->book.npredictors = reader->ReadInt32();
audioSample->bookDataCount = reader->ReadUInt32();
audioSample->bookData.reserve(audioSample->bookDataCount);
for (uint32_t i = 0; i < audioSample->bookDataCount; i++) {
audioSample->bookData.push_back(reader->ReadInt16());
}
audioSample->book.book = audioSample->bookData.data();
audioSample->sample.book = &audioSample->book;
}
} // namespace Ship
/*
in ResourceMgr_LoadAudioSample we used to have
--------------
if (cachedCustomSFs.find(path) != cachedCustomSFs.end())
return cachedCustomSFs[path];
SoundFontSample* cSample = ReadCustomSample(path);
if (cSample != nullptr)
return cSample;
--------------
before the rest of the standard sample reading, this is the ReadCustomSample code we used to have
extern "C" SoundFontSample* ReadCustomSample(const char* path) {
if (!ExtensionCache.contains(path))
return nullptr;
ExtensionEntry entry = ExtensionCache[path];
auto sampleRaw = OTRGlobals::Instance->context->GetResourceManager()->LoadFile(entry.path);
uint32_t* strem = (uint32_t*)sampleRaw->Buffer.get();
uint8_t* strem2 = (uint8_t*)strem;
SoundFontSample* sampleC = new SoundFontSample;
if (entry.ext == "wav") {
drwav_uint32 channels;
drwav_uint32 sampleRate;
drwav_uint64 totalPcm;
drmp3_int16* pcmData =
drwav_open_memory_and_read_pcm_frames_s16(strem2, sampleRaw->BufferSize, &channels, &sampleRate, &totalPcm, NULL);
sampleC->size = totalPcm;
sampleC->sampleAddr = (uint8_t*)pcmData;
sampleC->codec = CODEC_S16;
sampleC->loop = new AdpcmLoop;
sampleC->loop->start = 0;
sampleC->loop->end = sampleC->size - 1;
sampleC->loop->count = 0;
sampleC->sampleRateMagicValue = 'RIFF';
sampleC->sampleRate = sampleRate;
cachedCustomSFs[path] = sampleC;
return sampleC;
} else if (entry.ext == "mp3") {
drmp3_config mp3Info;
drmp3_uint64 totalPcm;
drmp3_int16* pcmData =
drmp3_open_memory_and_read_pcm_frames_s16(strem2, sampleRaw->BufferSize, &mp3Info, &totalPcm, NULL);
sampleC->size = totalPcm * mp3Info.channels * sizeof(short);
sampleC->sampleAddr = (uint8_t*)pcmData;
sampleC->codec = CODEC_S16;
sampleC->loop = new AdpcmLoop;
sampleC->loop->start = 0;
sampleC->loop->end = sampleC->size;
sampleC->loop->count = 0;
sampleC->sampleRateMagicValue = 'RIFF';
sampleC->sampleRate = mp3Info.sampleRate;
cachedCustomSFs[path] = sampleC;
return sampleC;
}
return nullptr;
}
*/

18
soh/soh/resource/importer/AudioSampleFactory.h Normal file
View File

@ -0,0 +1,18 @@
#pragma once
#include "Resource.h"
#include "ResourceFactory.h"
namespace Ship {
class AudioSampleFactory : public ResourceFactory
{
public:
std::shared_ptr<Resource> ReadResource(uint32_t version, std::shared_ptr<BinaryReader> reader);
};
class AudioSampleFactoryV0 : public ResourceVersionFactory
{
public:
void ParseFileBinary(std::shared_ptr<BinaryReader> reader, std::shared_ptr<Resource> resource) override;
};
}; // namespace Ship

54
soh/soh/resource/importer/AudioSequenceFactory.cpp Normal file
View File

@ -0,0 +1,54 @@
#include "soh/resource/importer/AudioSequenceFactory.h"
#include "soh/resource/type/AudioSequence.h"
#include "spdlog/spdlog.h"
namespace Ship {
std::shared_ptr<Resource> AudioSequenceFactory::ReadResource(uint32_t version, std::shared_ptr<BinaryReader> reader)
{
auto resource = std::make_shared<AudioSequence>();
std::shared_ptr<ResourceVersionFactory> factory = nullptr;
switch (version)
{
case 2:
factory = std::make_shared<AudioSequenceFactoryV0>();
break;
}
if (factory == nullptr)
{
SPDLOG_ERROR("Failed to load AudioSequence with version {}", version);
return nullptr;
}
factory->ParseFileBinary(reader, resource);
return resource;
}
void Ship::AudioSequenceFactoryV0::ParseFileBinary(std::shared_ptr<BinaryReader> reader,
std::shared_ptr<Resource> resource)
{
std::shared_ptr<AudioSequence> audioSequence = std::static_pointer_cast<AudioSequence>(resource);
ResourceVersionFactory::ParseFileBinary(reader, audioSequence);
audioSequence->sequence.seqDataSize = reader->ReadInt32();
audioSequence->sequenceData.reserve(audioSequence->sequence.seqDataSize);
for (uint32_t i = 0; i < audioSequence->sequence.seqDataSize; i++) {
audioSequence->sequenceData.push_back(reader->ReadChar());
}
audioSequence->sequence.seqData = audioSequence->sequenceData.data();
audioSequence->sequence.seqNumber = reader->ReadUByte();
audioSequence->sequence.medium = reader->ReadUByte();
audioSequence->sequence.cachePolicy = reader->ReadUByte();
audioSequence->sequence.numFonts = reader->ReadUInt32();
for (uint32_t i = 0; i < 16; i++) {
audioSequence->sequence.fonts[i] = 0;
}
for (uint32_t i = 0; i < audioSequence->sequence.numFonts; i++) {
audioSequence->sequence.fonts[i] = reader->ReadUByte();
}
}
} // namespace Ship

18
soh/soh/resource/importer/AudioSequenceFactory.h Normal file
View File

@ -0,0 +1,18 @@
#pragma once
#include "Resource.h"
#include "ResourceFactory.h"
namespace Ship {
class AudioSequenceFactory : public ResourceFactory
{
public:
std::shared_ptr<Resource> ReadResource(uint32_t version, std::shared_ptr<BinaryReader> reader);
};
class AudioSequenceFactoryV0 : public ResourceVersionFactory
{
public:
void ParseFileBinary(std::shared_ptr<BinaryReader> reader, std::shared_ptr<Resource> resource) override;
};
}; // namespace Ship

187
soh/soh/resource/importer/AudioSoundFontFactory.cpp Normal file
View File

@ -0,0 +1,187 @@
#include "soh/resource/importer/AudioSoundFontFactory.h"
#include "soh/resource/type/AudioSoundFont.h"
#include "spdlog/spdlog.h"
#include "libultraship/bridge.h"
namespace Ship {
std::shared_ptr<Resource> AudioSoundFontFactory::ReadResource(uint32_t version, std::shared_ptr<BinaryReader> reader)
{
auto resource = std::make_shared<AudioSoundFont>();
std::shared_ptr<ResourceVersionFactory> factory = nullptr;
switch (version)
{
case 2:
factory = std::make_shared<AudioSoundFontFactoryV0>();
break;
}
if (factory == nullptr)
{
SPDLOG_ERROR("Failed to load AudioSoundFont with version {}", version);
return nullptr;
}
factory->ParseFileBinary(reader, resource);
return resource;
}
void Ship::AudioSoundFontFactoryV0::ParseFileBinary(std::shared_ptr<BinaryReader> reader,
std::shared_ptr<Resource> resource)
{
std::shared_ptr<AudioSoundFont> audioSoundFont = std::static_pointer_cast<AudioSoundFont>(resource);
ResourceVersionFactory::ParseFileBinary(reader, audioSoundFont);
audioSoundFont->soundFont.fntIndex = reader->ReadInt32();
audioSoundFont->medium = reader->ReadInt8();
audioSoundFont->cachePolicy = reader->ReadInt8();
audioSoundFont->data1 = reader->ReadUInt16();
audioSoundFont->soundFont.sampleBankId1 = audioSoundFont->data1 >> 8;
audioSoundFont->soundFont.sampleBankId2 = audioSoundFont->data1 & 0xFF;
audioSoundFont->data2 = reader->ReadUInt16();
audioSoundFont->data3 = reader->ReadUInt16();
uint32_t drumCount = reader->ReadUInt32();
audioSoundFont->soundFont.numDrums = drumCount;
uint32_t instrumentCount = reader->ReadUInt32();
audioSoundFont->soundFont.numInstruments = instrumentCount;
uint32_t soundEffectCount = reader->ReadUInt32();
audioSoundFont->soundFont.numSfx = soundEffectCount;
// 🥁 DRUMS 🥁
audioSoundFont->drums.reserve(audioSoundFont->soundFont.numDrums);
audioSoundFont->drumAddresses.reserve(audioSoundFont->soundFont.numDrums);
for (uint32_t i = 0; i < audioSoundFont->soundFont.numDrums; i++) {
Drum drum;
drum.releaseRate = reader->ReadUByte();
drum.pan = reader->ReadUByte();
drum.loaded = reader->ReadUByte();
drum.loaded = 0; // this was always getting set to zero in ResourceMgr_LoadAudioSoundFont
uint32_t envelopeCount = reader->ReadUInt32();
audioSoundFont->drumEnvelopeCounts.push_back(envelopeCount);
std::vector<AdsrEnvelope> drumEnvelopes;
drumEnvelopes.reserve(audioSoundFont->drumEnvelopeCounts[i]);
for (uint32_t j = 0; j < audioSoundFont->drumEnvelopeCounts.back(); j++) {
AdsrEnvelope env;
int16_t delay = reader->ReadInt16();
int16_t arg = reader->ReadInt16();
env.delay = BE16SWAP(delay);
env.arg = BE16SWAP(arg);
drumEnvelopes.push_back(env);
}
audioSoundFont->drumEnvelopeArrays.push_back(drumEnvelopes);
drum.envelope = audioSoundFont->drumEnvelopeArrays.back().data();
bool hasSample = reader->ReadInt8();
std::string sampleFileName = reader->ReadString();
drum.sound.tuning = reader->ReadFloat();
if (sampleFileName.empty()) {
drum.sound.sample = nullptr;
} else {
drum.sound.sample = static_cast<Sample*>(GetResourceDataByName(sampleFileName.c_str(), true));
}
audioSoundFont->drums.push_back(drum);
audioSoundFont->drumAddresses.push_back(&audioSoundFont->drums.back());
}
audioSoundFont->soundFont.drums = audioSoundFont->drumAddresses.data();
// 🎺🎻🎷🎸🎹 INSTRUMENTS 🎹🎸🎷🎻🎺
audioSoundFont->instruments.reserve(audioSoundFont->soundFont.numInstruments);
for (uint32_t i = 0; i < audioSoundFont->soundFont.numInstruments; i++) {
Instrument instrument;
uint8_t isValidEntry = reader->ReadUByte();
instrument.loaded = reader->ReadUByte();
instrument.loaded = 0; // this was always getting set to zero in ResourceMgr_LoadAudioSoundFont
instrument.normalRangeLo = reader->ReadUByte();
instrument.normalRangeHi = reader->ReadUByte();
instrument.releaseRate = reader->ReadUByte();
uint32_t envelopeCount = reader->ReadInt32();
audioSoundFont->instrumentEnvelopeCounts.push_back(envelopeCount);
std::vector<AdsrEnvelope> instrumentEnvelopes;
for (uint32_t j = 0; j < audioSoundFont->instrumentEnvelopeCounts.back(); j++) {
AdsrEnvelope env;
int16_t delay = reader->ReadInt16();
int16_t arg = reader->ReadInt16();
env.delay = BE16SWAP(delay);
env.arg = BE16SWAP(arg);
instrumentEnvelopes.push_back(env);
}
audioSoundFont->instrumentEnvelopeArrays.push_back(instrumentEnvelopes);
instrument.envelope = audioSoundFont->instrumentEnvelopeArrays.back().data();
bool hasLowNoteSoundFontEntry = reader->ReadInt8();
if (hasLowNoteSoundFontEntry) {
bool hasSampleRef = reader->ReadInt8();
std::string sampleFileName = reader->ReadString();
instrument.lowNotesSound.tuning = reader->ReadFloat();
instrument.lowNotesSound.sample = static_cast<Sample*>(GetResourceDataByName(sampleFileName.c_str(), true));
} else {
instrument.lowNotesSound.sample = nullptr;
instrument.lowNotesSound.tuning = 0;
}
bool hasNormalNoteSoundFontEntry = reader->ReadInt8();
if (hasNormalNoteSoundFontEntry) {
bool hasSampleRef = reader->ReadInt8();
std::string sampleFileName = reader->ReadString();
instrument.normalNotesSound.tuning = reader->ReadFloat();
instrument.normalNotesSound.sample = static_cast<Sample*>(GetResourceDataByName(sampleFileName.c_str(), true));
} else {
instrument.normalNotesSound.sample = nullptr;
instrument.normalNotesSound.tuning = 0;
}
bool hasHighNoteSoundFontEntry = reader->ReadInt8();
if (hasHighNoteSoundFontEntry) {
bool hasSampleRef = reader->ReadInt8();
std::string sampleFileName = reader->ReadString();
instrument.highNotesSound.tuning = reader->ReadFloat();
instrument.highNotesSound.sample = static_cast<Sample*>(GetResourceDataByName(sampleFileName.c_str(), true));
} else {
instrument.highNotesSound.sample = nullptr;
instrument.highNotesSound.tuning = 0;
}
audioSoundFont->instruments.push_back(instrument);
audioSoundFont->instrumentAddresses.push_back(isValidEntry ?
&audioSoundFont->instruments.back() :
nullptr);
}
audioSoundFont->soundFont.instruments = audioSoundFont->instrumentAddresses.data();
// 🔊 SOUND EFFECTS 🔊
audioSoundFont->soundEffects.reserve(audioSoundFont->soundFont.numSfx);
for (uint32_t i = 0; i < audioSoundFont->soundFont.numSfx; i++) {
SoundFontSound soundEffect;
bool hasSFEntry = reader->ReadInt8();
if (hasSFEntry) {
bool hasSampleRef = reader->ReadInt8();
std::string sampleFileName = reader->ReadString();
soundEffect.tuning = reader->ReadFloat();
soundEffect.sample = static_cast<Sample*>(GetResourceDataByName(sampleFileName.c_str(), true));
}
audioSoundFont->soundEffects.push_back(soundEffect);
}
audioSoundFont->soundFont.soundEffects = audioSoundFont->soundEffects.data();
}
} // namespace Ship

18
soh/soh/resource/importer/AudioSoundFontFactory.h Normal file
View File

@ -0,0 +1,18 @@
#pragma once
#include "Resource.h"
#include "ResourceFactory.h"
namespace Ship {
class AudioSoundFontFactory : public ResourceFactory
{
public:
std::shared_ptr<Resource> ReadResource(uint32_t version, std::shared_ptr<BinaryReader> reader);
};
class AudioSoundFontFactoryV0 : public ResourceVersionFactory
{
public:
void ParseFileBinary(std::shared_ptr<BinaryReader> reader, std::shared_ptr<Resource> resource) override;
};
}; // namespace Ship

38
soh/soh/resource/importer/BackgroundFactory.cpp Normal file
View File

@ -0,0 +1,38 @@
#include "soh/resource/importer/BackgroundFactory.h"
#include "soh/resource/type/Background.h"
#include "spdlog/spdlog.h"
namespace Ship {
std::shared_ptr<Resource> BackgroundFactory::ReadResource(uint32_t version, std::shared_ptr<BinaryReader> reader) {
auto resource = std::make_shared<Background>();
std::shared_ptr<ResourceVersionFactory> factory = nullptr;
switch (version) {
case 0:
factory = std::make_shared<BackgroundFactoryV0>();
break;
}
if (factory == nullptr) {
SPDLOG_ERROR("Failed to load Background with version {}", version);
return nullptr;
}
factory->ParseFileBinary(reader, resource);
return resource;
}
void BackgroundFactoryV0::ParseFileBinary(std::shared_ptr<BinaryReader> reader, std::shared_ptr<Resource> resource) {
std::shared_ptr<Background> background = std::static_pointer_cast<Background>(resource);
ResourceVersionFactory::ParseFileBinary(reader, background);
uint32_t dataSize = reader->ReadUInt32();
background->Data.reserve(dataSize);
for (uint32_t i = 0; i < dataSize; i++) {
background->Data.push_back(reader->ReadUByte());
}
}
} // namespace Ship

16
soh/soh/resource/importer/BackgroundFactory.h Normal file
View File

@ -0,0 +1,16 @@
#pragma once
#include "resource/Resource.h"
#include "resource/ResourceFactory.h"
namespace Ship {
class BackgroundFactory : public ResourceFactory {
public:
std::shared_ptr<Resource> ReadResource(uint32_t version, std::shared_ptr<BinaryReader> reader);
};
class BackgroundFactoryV0 : public ResourceVersionFactory {
public:
void ParseFileBinary(std::shared_ptr<BinaryReader> reader, std::shared_ptr<Resource> resource) override;
};
}; // namespace Ship

144
soh/soh/resource/importer/CollisionHeaderFactory.cpp Normal file
View File

@ -0,0 +1,144 @@
#include "soh/resource/importer/CollisionHeaderFactory.h"
#include "soh/resource/type/CollisionHeader.h"
#include "spdlog/spdlog.h"
namespace Ship {
std::shared_ptr<Resource> CollisionHeaderFactory::ReadResource(uint32_t version, std::shared_ptr<BinaryReader> reader)
{
auto resource = std::make_shared<CollisionHeader>();
std::shared_ptr<ResourceVersionFactory> factory = nullptr;
switch (version)
{
case 0:
factory = std::make_shared<CollisionHeaderFactoryV0>();
break;
}
if (factory == nullptr)
{
SPDLOG_ERROR("Failed to load Collision Header with version {}", version);
return nullptr;
}
factory->ParseFileBinary(reader, resource);
return resource;
}
void Ship::CollisionHeaderFactoryV0::ParseFileBinary(std::shared_ptr<BinaryReader> reader,
std::shared_ptr<Resource> resource)
{
std::shared_ptr<CollisionHeader> collisionHeader = std::static_pointer_cast<CollisionHeader>(resource);
ResourceVersionFactory::ParseFileBinary(reader, collisionHeader);
collisionHeader->collisionHeaderData.minBounds.x = reader->ReadInt16();
collisionHeader->collisionHeaderData.minBounds.y = reader->ReadInt16();
collisionHeader->collisionHeaderData.minBounds.z = reader->ReadInt16();
collisionHeader->collisionHeaderData.maxBounds.x = reader->ReadInt16();
collisionHeader->collisionHeaderData.maxBounds.y = reader->ReadInt16();
collisionHeader->collisionHeaderData.maxBounds.z = reader->ReadInt16();
collisionHeader->collisionHeaderData.numVertices = reader->ReadInt32();
collisionHeader->vertices.reserve(collisionHeader->collisionHeaderData.numVertices);
for (int32_t i = 0; i < collisionHeader->collisionHeaderData.numVertices; i++) {
Vec3s vtx;
vtx.x = reader->ReadInt16();
vtx.y = reader->ReadInt16();
vtx.z = reader->ReadInt16();
collisionHeader->vertices.push_back(vtx);
}
collisionHeader->collisionHeaderData.vtxList = collisionHeader->vertices.data();
collisionHeader->collisionHeaderData.numPolygons = reader->ReadUInt32();
collisionHeader->polygons.reserve(collisionHeader->collisionHeaderData.numPolygons);
for (uint32_t i = 0; i < collisionHeader->collisionHeaderData.numPolygons; i++) {
CollisionPoly polygon;
polygon.type = reader->ReadUInt16();
polygon.flags_vIA = reader->ReadUInt16();
polygon.flags_vIB = reader->ReadUInt16();
polygon.vIC = reader->ReadUInt16();
polygon.normal.x = reader->ReadUInt16();
polygon.normal.y = reader->ReadUInt16();
polygon.normal.z = reader->ReadUInt16();
polygon.dist = reader->ReadUInt16();
collisionHeader->polygons.push_back(polygon);
}
collisionHeader->collisionHeaderData.polyList = collisionHeader->polygons.data();
collisionHeader->surfaceTypesCount = reader->ReadUInt32();
collisionHeader->surfaceTypes.reserve(collisionHeader->surfaceTypesCount);
for (uint32_t i = 0; i < collisionHeader->surfaceTypesCount; i++) {
SurfaceType surfaceType;
surfaceType.data[1] = reader->ReadUInt32();
surfaceType.data[0] = reader->ReadUInt32();
collisionHeader->surfaceTypes.push_back(surfaceType);
}
collisionHeader->collisionHeaderData.surfaceTypeList = collisionHeader->surfaceTypes.data();
collisionHeader->camDataCount = reader->ReadUInt32();
collisionHeader->camData.reserve(collisionHeader->camDataCount);
collisionHeader->camPosDataIndices.reserve(collisionHeader->camDataCount);
for (uint32_t i = 0; i < collisionHeader->camDataCount; i++) {
CamData camDataEntry;
camDataEntry.cameraSType = reader->ReadUInt16();
camDataEntry.numCameras = reader->ReadInt16();
collisionHeader->camData.push_back(camDataEntry);
int32_t camPosDataIdx = reader->ReadInt32();
collisionHeader->camPosDataIndices.push_back(camPosDataIdx);
}
collisionHeader->camPosCount = reader->ReadInt32();
collisionHeader->camPosData.reserve(collisionHeader->camPosCount);
for (int32_t i = 0; i < collisionHeader->camPosCount; i++) {
Vec3s pos;
pos.x = reader->ReadInt16();
pos.y = reader->ReadInt16();
pos.z = reader->ReadInt16();
collisionHeader->camPosData.push_back(pos);
}
Vec3s zero;
zero.x = 0;
zero.y = 0;
zero.z = 0;
collisionHeader->camPosDataZero = zero;
for (size_t i = 0; i < collisionHeader->camDataCount; i++) {
int32_t idx = collisionHeader->camPosDataIndices[i];
if (collisionHeader->camPosCount > 0) {
collisionHeader->camData[i].camPosData = &collisionHeader->camPosData[idx];
} else {
collisionHeader->camData[i].camPosData = &collisionHeader->camPosDataZero;
}
}
collisionHeader->collisionHeaderData.cameraDataList = collisionHeader->camData.data();
collisionHeader->collisionHeaderData.cameraDataListLen = collisionHeader->camDataCount;
collisionHeader->collisionHeaderData.numWaterBoxes = reader->ReadInt32();
collisionHeader->waterBoxes.reserve(collisionHeader->collisionHeaderData.numWaterBoxes);
for (int32_t i = 0; i < collisionHeader->collisionHeaderData.numWaterBoxes; i++) {
WaterBox waterBox;
waterBox.xMin = reader->ReadInt16();
waterBox.ySurface = reader->ReadInt16();
waterBox.zMin = reader->ReadInt16();
waterBox.xLength = reader->ReadInt16();
waterBox.zLength = reader->ReadInt16();
waterBox.properties = reader->ReadInt32();
collisionHeader->waterBoxes.push_back(waterBox);
}
collisionHeader->collisionHeaderData.waterBoxes = collisionHeader->waterBoxes.data();
}
}

16
soh/soh/resource/importer/CollisionHeaderFactory.h Normal file
View File

@ -0,0 +1,16 @@
#pragma once
#include "Resource.h"
#include "ResourceFactory.h"
namespace Ship {
class CollisionHeaderFactory : public ResourceFactory {
public:
std::shared_ptr<Resource> ReadResource(uint32_t version, std::shared_ptr<BinaryReader> reader);
};
class CollisionHeaderFactoryV0 : public ResourceVersionFactory {
public:
void ParseFileBinary(std::shared_ptr<BinaryReader> reader, std::shared_ptr<Resource> resource) override;
};
}; // namespace Ship

473
soh/soh/resource/importer/CutsceneFactory.cpp Normal file
View File

@ -0,0 +1,473 @@
#include "soh/resource/importer/CutsceneFactory.h"
#include "soh/resource/type/Cutscene.h"
#include "spdlog/spdlog.h"
namespace Ship {
std::shared_ptr<Resource> CutsceneFactory::ReadResource(uint32_t version, std::shared_ptr<BinaryReader> reader)
{
auto resource = std::make_shared<Cutscene>();
std::shared_ptr<ResourceVersionFactory> factory = nullptr;
switch (version)
{
case 0:
factory = std::make_shared<CutsceneFactoryV0>();
break;
}
if (factory == nullptr)
{
SPDLOG_ERROR("Failed to load Cutscene with version {}", version);
return nullptr;
}
factory->ParseFileBinary(reader, resource);
return resource;
}
static inline uint32_t read_CMD_BBBB(std::shared_ptr<BinaryReader> reader) {
uint32_t v;
reader->Read((char*)&v, sizeof(uint32_t));
return v;
}
static inline uint32_t read_CMD_BBH(std::shared_ptr<BinaryReader> reader) {
uint32_t v;
reader->Read((char*)&v, sizeof(uint32_t));
// swap the half word to match endianness
if (reader->GetEndianness() != Ship::Endianness::Native) {
uint8_t* b = (uint8_t*)&v;
uint8_t tmp = b[2];
b[2] = b[3];
b[3] = tmp;
}
return v;
}
static inline uint32_t read_CMD_HBB(std::shared_ptr<BinaryReader> reader) {
uint32_t v;
reader->Read((char*)&v, sizeof(uint32_t));
// swap the half word to match endianness
if (reader->GetEndianness() != Ship::Endianness::Native) {
uint8_t* b = (uint8_t*)&v;
uint8_t tmp = b[0];
b[0] = b[1];
b[1] = tmp;
}
return v;
}
static inline uint32_t read_CMD_HH(std::shared_ptr<BinaryReader> reader) {
uint32_t v;
reader->Read((char*)&v, sizeof(uint32_t));
// swap the half words to match endianness
if (reader->GetEndianness() != Ship::Endianness::Native) {
uint8_t* b = (uint8_t*)&v;
uint8_t tmp = b[0];
b[0] = b[1];
b[1] = tmp;
tmp = b[2];
b[2] = b[3];
b[3] = tmp;
}
return v;
}
void Ship::CutsceneFactoryV0::ParseFileBinary(std::shared_ptr<BinaryReader> reader,
std::shared_ptr<Resource> resource)
{
std::shared_ptr<Cutscene> cutscene = std::static_pointer_cast<Cutscene>(resource);
ResourceVersionFactory::ParseFileBinary(reader, cutscene);
uint32_t numEntries = reader->ReadUInt32();
cutscene->commands.reserve(numEntries);
cutscene->numCommands = reader->ReadUInt32();
cutscene->commands.push_back(cutscene->numCommands);
cutscene->endFrame = reader->ReadUInt32();
cutscene->commands.push_back(cutscene->endFrame);
while (true) {
uint32_t commandId = reader->ReadUInt32();
cutscene->commands.push_back(commandId);
switch (commandId) {
case (uint32_t)CutsceneCommands::SetCameraPos: {
cutscene->commands.push_back(read_CMD_HH(reader));
cutscene->commands.push_back(read_CMD_HH(reader));
while (true) {
uint32_t val = read_CMD_BBH(reader);
int8_t continueFlag = ((int8_t*)&val)[0];
cutscene->commands.push_back(val);
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(read_CMD_HH(reader));
cutscene->commands.push_back(read_CMD_HH(reader));
if (continueFlag == -1) {
break;
}
}
} break;
case (uint32_t)CutsceneCommands::SetCameraFocus: {
cutscene->commands.push_back(read_CMD_HH(reader));
cutscene->commands.push_back(read_CMD_HH(reader));
while (true) {
uint32_t val = read_CMD_BBH(reader);
int8_t continueFlag = ((int8_t*)&val)[0];
cutscene->commands.push_back(val);
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(read_CMD_HH(reader));
cutscene->commands.push_back(read_CMD_HH(reader));
if (continueFlag == -1) {
break;
}
}
break;
}
case (uint32_t)CutsceneCommands::SpecialAction: {
uint32_t size = reader->ReadUInt32();
cutscene->commands.push_back(size);
for (uint32_t i = 0; i < size; i++) {
cutscene->commands.push_back(read_CMD_HH(reader));
cutscene->commands.push_back(read_CMD_HH(reader));
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
}
break;
}
case (uint32_t)CutsceneCommands::SetLighting: {
uint32_t size = reader->ReadUInt32();
cutscene->commands.push_back(size);
for (uint32_t i = 0; i < size; i++) {
cutscene->commands.push_back(read_CMD_HH(reader));
cutscene->commands.push_back(read_CMD_HH(reader));
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
}
break;
}
case (uint32_t)CutsceneCommands::SetCameraPosLink: {
cutscene->commands.push_back(read_CMD_HH(reader));
cutscene->commands.push_back(read_CMD_HH(reader));
while (true) {
uint32_t val = read_CMD_BBH(reader);
int8_t continueFlag = ((int8_t*)&val)[0];
cutscene->commands.push_back(val);
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(read_CMD_HH(reader));
cutscene->commands.push_back(read_CMD_HH(reader));
if (continueFlag == -1) {
break;
}
}
break;
}
case (uint32_t)CutsceneCommands::SetCameraFocusLink: {
cutscene->commands.push_back(read_CMD_HH(reader));
cutscene->commands.push_back(read_CMD_HH(reader));
while (true) {
uint32_t val = read_CMD_BBH(reader);
int8_t continueFlag = ((int8_t*)&val)[0];
cutscene->commands.push_back(val);
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(read_CMD_HH(reader));
cutscene->commands.push_back(read_CMD_HH(reader));
if (continueFlag == -1) {
break;
}
}
break;
}
case (uint32_t)CutsceneCommands::Cmd09: {
uint32_t size = reader->ReadUInt32();
cutscene->commands.push_back(size);
for (uint32_t i = 0; i < size; i++) {
cutscene->commands.push_back(read_CMD_HH(reader));
cutscene->commands.push_back(read_CMD_HBB(reader));
cutscene->commands.push_back(read_CMD_BBH(reader));
}
break;
}
case 0x15:
case (uint32_t)CutsceneCommands::Unknown: {
uint32_t size = reader->ReadUInt32();
cutscene->commands.push_back(size);
for (uint32_t i = 0; i < size; i++) {
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
}
} break;
case (uint32_t)CutsceneCommands::Textbox: {
uint32_t size = reader->ReadUInt32();
cutscene->commands.push_back(size);
for (uint32_t i = 0; i < size; i++) {
cutscene->commands.push_back(read_CMD_HH(reader));
cutscene->commands.push_back(read_CMD_HH(reader));
cutscene->commands.push_back(read_CMD_HH(reader));
}
break;
}
case (uint32_t)CutsceneCommands::SetActorAction0:
case (uint32_t)CutsceneCommands::SetActorAction1:
case 17:
case 18:
case 23:
case 34:
case 39:
case 46:
case 76:
case 85:
case 93:
case 105:
case 107:
case 110:
case 119:
case 123:
case 138:
case 139:
case 144:
case (uint32_t)CutsceneCommands::SetActorAction2:
case 16:
case 24:
case 35:
case 40:
case 48:
case 64:
case 68:
case 70:
case 78:
case 80:
case 94:
case 116:
case 118:
case 120:
case 125:
case 131:
case 141:
case (uint32_t)CutsceneCommands::SetActorAction3:
case 36:
case 41:
case 50:
case 67:
case 69:
case 72:
case 74:
case 81:
case 106:
case 117:
case 121:
case 126:
case 132:
case (uint32_t)CutsceneCommands::SetActorAction4:
case 37:
case 42:
case 51:
case 53:
case 63:
case 65:
case 66:
case 75:
case 82:
case 108:
case 127:
case 133:
case (uint32_t)CutsceneCommands::SetActorAction5:
case 38:
case 43:
case 47:
case 54:
case 79:
case 83:
case 128:
case 135:
case (uint32_t)CutsceneCommands::SetActorAction6:
case 55:
case 77:
case 84:
case 90:
case 129:
case 136:
case (uint32_t)CutsceneCommands::SetActorAction7:
case 52:
case 57:
case 58:
case 88:
case 115:
case 130:
case 137:
case (uint32_t)CutsceneCommands::SetActorAction8:
case 60:
case 89:
case 111:
case 114:
case 134:
case 142:
case (uint32_t)CutsceneCommands::SetActorAction9:
case (uint32_t)CutsceneCommands::SetActorAction10: {
uint32_t size = reader->ReadUInt32();
cutscene->commands.push_back(size);
for (uint32_t i = 0; i < size; i++) {
cutscene->commands.push_back(read_CMD_HH(reader));
cutscene->commands.push_back(read_CMD_HH(reader));
cutscene->commands.push_back(read_CMD_HH(reader));
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
}
break;
}
case (uint32_t)CutsceneCommands::SetSceneTransFX: {
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(read_CMD_HH(reader));
cutscene->commands.push_back(read_CMD_HH(reader));
break;
}
case (uint32_t)CutsceneCommands::PlayBGM: {
uint32_t size = reader->ReadUInt32();
cutscene->commands.push_back(size);
for (uint32_t i = 0; i < size; i++) {
cutscene->commands.push_back(read_CMD_HH(reader));
cutscene->commands.push_back(read_CMD_HH(reader));
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
}
break;
}
case (uint32_t)CutsceneCommands::StopBGM: {
uint32_t size = reader->ReadUInt32();
cutscene->commands.push_back(size);
for (uint32_t i = 0; i < size; i++) {
cutscene->commands.push_back(read_CMD_HH(reader));
cutscene->commands.push_back(read_CMD_HH(reader));
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
}
break;
}
case (uint32_t)CutsceneCommands::FadeBGM: {
uint32_t size = reader->ReadUInt32();
cutscene->commands.push_back(size);
for (uint32_t i = 0; i < size; i++) {
cutscene->commands.push_back(read_CMD_HH(reader));
cutscene->commands.push_back(read_CMD_HH(reader));
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(reader->ReadUInt32());
}
break;
}
case (uint32_t)CutsceneCommands::SetTime: {
uint32_t size = reader->ReadUInt32();
cutscene->commands.push_back(size);
for (uint32_t i = 0; i < size; i++) {
cutscene->commands.push_back(read_CMD_HH(reader));
cutscene->commands.push_back(read_CMD_HBB(reader));
cutscene->commands.push_back(reader->ReadUInt32());
}
break;
}
case (uint32_t)CutsceneCommands::Terminator: {
cutscene->commands.push_back(reader->ReadUInt32());
cutscene->commands.push_back(read_CMD_HH(reader));
cutscene->commands.push_back(read_CMD_HH(reader));
break;
}
case 0xFFFFFFFF: // CS_END
{
cutscene->commands.push_back(reader->ReadUInt32());
return;
}
default:
SPDLOG_TRACE("CutsceneV0: Unknown command {}\n", commandId);
// error?
break;
}
}
}
} // namespace Ship

18
soh/soh/resource/importer/CutsceneFactory.h Normal file
View File

@ -0,0 +1,18 @@
#pragma once
#include "Resource.h"
#include "ResourceFactory.h"
namespace Ship {
class CutsceneFactory : public ResourceFactory
{
public:
std::shared_ptr<Resource> ReadResource(uint32_t version, std::shared_ptr<BinaryReader> reader);
};
class CutsceneFactoryV0 : public ResourceVersionFactory
{
public:
void ParseFileBinary(std::shared_ptr<BinaryReader> reader, std::shared_ptr<Resource> resource) override;
};
}; // namespace Ship

59
soh/soh/resource/importer/PathFactory.cpp Normal file
View File

@ -0,0 +1,59 @@
#include "soh/resource/importer/PathFactory.h"
#include "soh/resource/type/Path.h"
#include "spdlog/spdlog.h"
namespace Ship {
std::shared_ptr<Resource> PathFactory::ReadResource(uint32_t version, std::shared_ptr<BinaryReader> reader)
{
auto resource = std::make_shared<Path>();
std::shared_ptr<ResourceVersionFactory> factory = nullptr;
switch (version)
{
case 0:
factory = std::make_shared<PathFactoryV0>();
break;
}
if (factory == nullptr)
{
SPDLOG_ERROR("Failed to load Path with version {}", version);
return nullptr;
}
factory->ParseFileBinary(reader, resource);
return resource;
}
void Ship::PathFactoryV0::ParseFileBinary(std::shared_ptr<BinaryReader> reader,
std::shared_ptr<Resource> resource)
{
std::shared_ptr<Path> path = std::static_pointer_cast<Path>(resource);
ResourceVersionFactory::ParseFileBinary(reader, path);
path->numPaths = reader->ReadUInt32();
path->paths.reserve(path->numPaths);
for (uint32_t k = 0; k < path->numPaths; k++) {
std::vector<Vec3s> points;
uint32_t pointCount = reader->ReadUInt32();
points.reserve(pointCount);
for (uint32_t i = 0; i < pointCount; i++) {
Vec3s point;
point.x = reader->ReadInt16();
point.y = reader->ReadInt16();
point.z = reader->ReadInt16();
points.push_back(point);
}
PathData pathDataEntry;
pathDataEntry.count = pointCount;
path->paths.push_back(points);
pathDataEntry.points = path->paths.back().data();
path->pathData.push_back(pathDataEntry);
}
}
} // namespace Ship

18
soh/soh/resource/importer/PathFactory.h Normal file
View File

@ -0,0 +1,18 @@
#pragma once
#include "Resource.h"
#include "ResourceFactory.h"
namespace Ship {
class PathFactory : public ResourceFactory
{
public:
std::shared_ptr<Resource> ReadResource(uint32_t version, std::shared_ptr<BinaryReader> reader);
};
class PathFactoryV0 : public ResourceVersionFactory
{
public:
void ParseFileBinary(std::shared_ptr<BinaryReader> reader, std::shared_ptr<Resource> resource) override;
};
}; // namespace Ship

42
soh/soh/resource/importer/PlayerAnimationFactory.cpp Normal file
View File

@ -0,0 +1,42 @@
#include "soh/resource/importer/PlayerAnimationFactory.h"
#include "soh/resource/type/PlayerAnimation.h"
#include "spdlog/spdlog.h"
namespace Ship {
std::shared_ptr<Resource> PlayerAnimationFactory::ReadResource(uint32_t version, std::shared_ptr<BinaryReader> reader)
{
auto resource = std::make_shared<PlayerAnimation>();
std::shared_ptr<ResourceVersionFactory> factory = nullptr;
switch (version)
{
case 0:
factory = std::make_shared<PlayerAnimationFactoryV0>();
break;
}
if (factory == nullptr)
{
SPDLOG_ERROR("Failed to load PlayerAnimation with version {}", version);
return nullptr;
}
factory->ParseFileBinary(reader, resource);
return resource;
}
void Ship::PlayerAnimationFactoryV0::ParseFileBinary(std::shared_ptr<BinaryReader> reader,
std::shared_ptr<Resource> resource)
{
std::shared_ptr<PlayerAnimation> playerAnimation = std::static_pointer_cast<PlayerAnimation>(resource);
ResourceVersionFactory::ParseFileBinary(reader, playerAnimation);
uint32_t numEntries = reader->ReadUInt32();
playerAnimation->limbRotData.reserve(numEntries);
for (uint32_t i = 0; i < numEntries; i++) {
playerAnimation->limbRotData.push_back(reader->ReadInt16());
}
}
} // namespace Ship

16
soh/soh/resource/importer/PlayerAnimationFactory.h Normal file
View File

@ -0,0 +1,16 @@
#pragma once
#include "Resource.h"
#include "ResourceFactory.h"
namespace Ship {
class PlayerAnimationFactory : public ResourceFactory {
public:
std::shared_ptr<Resource> ReadResource(uint32_t version, std::shared_ptr<BinaryReader> reader);
};
class PlayerAnimationFactoryV0 : public ResourceVersionFactory {
public:
void ParseFileBinary(std::shared_ptr<BinaryReader> reader, std::shared_ptr<Resource> resource) override;
};
}; // namespace Ship

118
soh/soh/resource/importer/SceneFactory.cpp Normal file
View File

@ -0,0 +1,118 @@
#include "spdlog/spdlog.h"
#include "soh/resource/importer/SceneFactory.h"
#include "soh/resource/type/Scene.h"
#include "soh/resource/type/scenecommand/SceneCommand.h"
#include "soh/resource/importer/scenecommand/SetLightingSettingsFactory.h"
#include "soh/resource/importer/scenecommand/SetWindSettingsFactory.h"
#include "soh/resource/importer/scenecommand/SetExitListFactory.h"
#include "soh/resource/importer/scenecommand/SetTimeSettingsFactory.h"
#include "soh/resource/importer/scenecommand/SetSkyboxModifierFactory.h"
#include "soh/resource/importer/scenecommand/SetEchoSettingsFactory.h"
#include "soh/resource/importer/scenecommand/SetSoundSettingsFactory.h"
#include "soh/resource/importer/scenecommand/SetSkyboxSettingsFactory.h"
#include "soh/resource/importer/scenecommand/SetRoomBehaviorFactory.h"
#include "soh/resource/importer/scenecommand/SetCsCameraFactory.h"
#include "soh/resource/importer/scenecommand/SetCameraSettingsFactory.h"
#include "soh/resource/importer/scenecommand/SetRoomListFactory.h"
#include "soh/resource/importer/scenecommand/SetCollisionHeaderFactory.h"
#include "soh/resource/importer/scenecommand/SetEntranceListFactory.h"
#include "soh/resource/importer/scenecommand/SetSpecialObjectsFactory.h"
#include "soh/resource/importer/scenecommand/SetObjectListFactory.h"
#include "soh/resource/importer/scenecommand/SetStartPositionListFactory.h"
#include "soh/resource/importer/scenecommand/SetActorListFactory.h"
#include "soh/resource/importer/scenecommand/SetTransitionActorListFactory.h"
#include "soh/resource/importer/scenecommand/EndMarkerFactory.h"
#include "soh/resource/importer/scenecommand/SetAlternateHeadersFactory.h"
#include "soh/resource/importer/scenecommand/SetPathwaysFactory.h"
#include "soh/resource/importer/scenecommand/SetCutscenesFactory.h"
#include "soh/resource/importer/scenecommand/SetLightListFactory.h"
#include "soh/resource/importer/scenecommand/SetMeshFactory.h"
namespace Ship {
std::shared_ptr<Resource> SceneFactory::ReadResource(uint32_t version, std::shared_ptr<BinaryReader> reader)
{
if (SceneFactory::sceneCommandFactories.empty()) {
SceneFactory::sceneCommandFactories[Ship::SceneCommandID::SetLightingSettings] = std::make_shared<SetLightingSettingsFactory>();
SceneFactory::sceneCommandFactories[Ship::SceneCommandID::SetWind] = std::make_shared<SetWindSettingsFactory>();
SceneFactory::sceneCommandFactories[Ship::SceneCommandID::SetExitList] = std::make_shared<SetExitListFactory>();
SceneFactory::sceneCommandFactories[Ship::SceneCommandID::SetTimeSettings] = std::make_shared<SetTimeSettingsFactory>();
SceneFactory::sceneCommandFactories[Ship::SceneCommandID::SetSkyboxModifier] = std::make_shared<SetSkyboxModifierFactory>();
SceneFactory::sceneCommandFactories[Ship::SceneCommandID::SetEchoSettings] = std::make_shared<SetEchoSettingsFactory>();
SceneFactory::sceneCommandFactories[Ship::SceneCommandID::SetSoundSettings] = std::make_shared<SetSoundSettingsFactory>();
SceneFactory::sceneCommandFactories[Ship::SceneCommandID::SetSkyboxSettings] = std::make_shared<SetSkyboxSettingsFactory>();
SceneFactory::sceneCommandFactories[Ship::SceneCommandID::SetRoomBehavior] = std::make_shared<SetRoomBehaviorFactory>();
SceneFactory::sceneCommandFactories[Ship::SceneCommandID::SetCsCamera] = std::make_shared<SetCsCameraFactory>();
SceneFactory::sceneCommandFactories[Ship::SceneCommandID::SetCameraSettings] = std::make_shared<SetCameraSettingsFactory>();
SceneFactory::sceneCommandFactories[Ship::SceneCommandID::SetRoomList] = std::make_shared<SetRoomListFactory>();
SceneFactory::sceneCommandFactories[Ship::SceneCommandID::SetCollisionHeader] = std::make_shared<SetCollisionHeaderFactory>();
SceneFactory::sceneCommandFactories[Ship::SceneCommandID::SetEntranceList] = std::make_shared<SetEntranceListFactory>();
SceneFactory::sceneCommandFactories[Ship::SceneCommandID::SetSpecialObjects] = std::make_shared<SetSpecialObjectsFactory>();
SceneFactory::sceneCommandFactories[Ship::SceneCommandID::SetObjectList] = std::make_shared<SetObjectListFactory>();
SceneFactory::sceneCommandFactories[Ship::SceneCommandID::SetStartPositionList] = std::make_shared<SetStartPositionListFactory>();
SceneFactory::sceneCommandFactories[Ship::SceneCommandID::SetActorList] = std::make_shared<SetActorListFactory>();
SceneFactory::sceneCommandFactories[Ship::SceneCommandID::SetTransitionActorList] = std::make_shared<SetTransitionActorListFactory>();
SceneFactory::sceneCommandFactories[Ship::SceneCommandID::EndMarker] = std::make_shared<EndMarkerFactory>();
SceneFactory::sceneCommandFactories[Ship::SceneCommandID::SetAlternateHeaders] = std::make_shared<SetAlternateHeadersFactory>();
SceneFactory::sceneCommandFactories[Ship::SceneCommandID::SetPathways] = std::make_shared<SetPathwaysFactory>();
SceneFactory::sceneCommandFactories[Ship::SceneCommandID::SetCutscenes] = std::make_shared<SetCutscenesFactory>();
SceneFactory::sceneCommandFactories[Ship::SceneCommandID::SetLightList] = std::make_shared<SetLightListFactory>();
SceneFactory::sceneCommandFactories[Ship::SceneCommandID::SetMesh] = std::make_shared<SetMeshFactory>();
}
auto resource = std::make_shared<Scene>();
std::shared_ptr<ResourceVersionFactory> factory = nullptr;
resource->ResourceVersion = version;
switch (version)
{
case 0:
factory = std::make_shared<SceneFactoryV0>();
break;
}
if (factory == nullptr)
{
SPDLOG_ERROR("Failed to load Scene with version {}", version);
return nullptr;
}
factory->ParseFileBinary(reader, resource);
return resource;
}
void SceneFactoryV0::ParseFileBinary(std::shared_ptr<BinaryReader> reader,
std::shared_ptr<Resource> resource)
{
std::shared_ptr<Scene> scene = std::static_pointer_cast<Scene>(resource);
ResourceVersionFactory::ParseFileBinary(reader, scene);
uint32_t commandCount = reader->ReadUInt32();
scene->commands.reserve(commandCount);
for (uint32_t i = 0; i < commandCount; i++) {
scene->commands.push_back(ParseSceneCommand(resource->ResourceVersion, reader));
}
}
std::shared_ptr<SceneCommand> SceneFactoryV0::ParseSceneCommand(uint32_t version, std::shared_ptr<BinaryReader> reader) {
SceneCommandID cmdID = (SceneCommandID)reader->ReadInt32();
reader->Seek(-sizeof(int32_t), SeekOffsetType::Current);
std::shared_ptr<SceneCommand> result = nullptr;
std::shared_ptr<SceneCommandFactory> commandFactory = SceneFactory::sceneCommandFactories[cmdID];
if (commandFactory != nullptr) {
result = std::static_pointer_cast<SceneCommand>(commandFactory->ReadResource(version, reader));
}
if (result == nullptr) {
SPDLOG_ERROR("Failed to load scene command of type {}", (uint32_t)cmdID);
}
return result;
}
} // namespace Ship

Some files were not shown because too many files have changed in this diff Show More