diff --git a/Makefile b/Makefile index d8609c3..8718c92 100644 --- a/Makefile +++ b/Makefile @@ -20,10 +20,10 @@ starlight: starlight_patch_$(S2VER)/*.ips: patches/*.slpatch patches/configs/$(S2VER).config patches/maps/$(S2VER)/*.map \ build$(S2VER)/$(shell basename $(CURDIR))$(S2VER).map scripts/genPatch.py @rm -f starlight_patch_$(S2VER)/*.ips - python3 scripts/genPatch.py $(S2VER) + python scripts/genPatch.py $(S2VER) send: all - python3.7 scripts/sendPatch.py $(IP) $(S2ROMTYPE) $(S2VER) + python scripts/sendPatch.py $(IP) $(S2ROMTYPE) $(S2VER) clean: $(MAKE) clean -f MakefileNSO diff --git a/README.md b/README.md index 3be3c36..fa7c443 100644 --- a/README.md +++ b/README.md @@ -1,64 +1,114 @@ -# Practice Mod +# SMO Practice Mod -This is a mod for Super Mario Odyssey that adds different features that intend to aid in speedrun practice (but can also be used for other reasons) +This is a mod for Super Mario Odyssey that adds different features that intend to aid in speedrun practice (but can also be used for other reasons). -The mod is compatible with versions 1.0.0 and 1.3.0 of Super Mario Odyssey, note that the 1.0.0 version is more feature-complete than the 1.3.0 version -### Features -- Position saving and restoring -- Moon refreshing -- Toggle Autosaving on/off -- Stage warping -- Info display (player position, velocity, speed, etc.) -- TAS Script Player -- Other small features +The mod is compatible with versions 1.0.0 and 1.3.0 of Super Mario Odyssey. + +This is a continuation of the [original version of this mod by fruityloops1](https://github.com/fruityloops1/smo-practice). + +## Features + +- Teleporting (position saving and restoring). +- Moon refreshing (collect the same moon multiple times without reloading). +- Turn autosaving on/off. +- Stage warping. +- Info display (player position, velocity, speed, etc.). +- TAS Script Player (v1.0.0 only). +- Other small features. ## Prerequisites -- [devkitPro](https://devkitpro.org/) -- Python 3 -- The [Keystone-Engine](https://www.keystone-engine.org/) Python Module +- [devkitPro](https://devkitpro.org/). +- [Python 3](https://www.python.org/). +- The [Keystone](https://www.keystone-engine.org/) Python module. ## Building -Build has only been tested on Arch Linux +By default, the mod is compiled for the SMO version 1.0.0. To compile for 1.3.0, you can set +``` +S2VER ?= 130 +S2VERSTR ?= 1.3.0 +``` +in Makefile. Alternatively, you can follow platform-specific instructions below. + +Build has been tested on Arch Linux and Windows 10. + +### Arch Linux Just run: + ``` DEVKITPRO={path_to_devkitpro} make ``` -devkitPro will be installed to `/opt/devkitpro` on most Unix-based systems -By default, the mod is compiled for the SMO `1.0.0` version. -To compile for the `1.3.0` version, you can run the following command. +devkitPro will be installed to `/opt/devkitpro` on most Unix-based systems. To compile for 1.3.0, run: ``` DEVKITPRO={path_to_devkitpro} make S2VER=130 S2VERSTR=1.3.0 ``` -## Installing (Atmosphère) +### Windows + +After setting the environment variables for devkitPro, just run: + +``` +make +``` + +To compile for 1.3.0, run: + +``` +make S2VER=130 S2VERSTR=1.3.0 +``` + +## Building and Installing Through FTP + +If you want to install the mod on your Switch through FTP immediately upon building, make sure you add the Switch's local IP address in Makefile, e.g.: + +``` +IP ?= 192.168.0.2 +``` + +If necessary, the password and username for the FTP connection should be added to sendPatch.py. Uncomment the following line (remove the #) and change the information accordingly: + +``` +#ftp.login(user="admin", passwd="admin") +``` + +Once this is set up, instead of `make`, run: + +``` +make send +``` + +## Installing + +### Atmosphère + +To install the prebuilt release version, copy the atmosphere folder to the root of your SD card. + +If you have FTP set up on your Switch, see the previous section for instructions on how to send the files to your switch automatically upon building. -After a successful build, transfer: +Alternatively, after running `make` to build it, you can transfer the files manually as detailed below. -For the SMO version `1.0.0`, +For SMO version 1.0.0, transfer: -- `smo-practice100.nso` to `/atmosphere/contents/0100000000010000/exefs/subsdk1` (note: no extension) -- `starlight_patch_100/3CA12DFAAF9C82DA064D1698DF79CDA1.ips` to `/atmosphere/exefs_patches/starlight_patch_100/3CA12DFAAF9C82DA064D1698DF79CDA1.ips` -- `romfs` to `/atmosphere/contents/0100000000010000/romfs` +- `smo-practice100.nso` to `/atmosphere/contents/0100000000010000/exefs/subsdk1` (note: no extension). +- `starlight_patch_100/3CA12DFAAF9C82DA064D1698DF79CDA1.ips` to `/atmosphere/exefs_patches/starlight_patch_100/3CA12DFAAF9C82DA064D1698DF79CDA1.ips`. +- `romfs` to `/atmosphere/contents/0100000000010000/romfs`. -For the SMO version `1.3.0`, +For SMO version 1.3.0, transfer: -- `smo-practice130.nso` to `/atmosphere/contents/0100000000010000/exefs/subsdk1` (note: no extension) -- `starlight_patch_130/B424BE150A8E7D78701CBE7A439D9EBF.ips` to `/atmosphere/exefs_patches/starlight_patch_130/B424BE150A8E7D78701CBE7A439D9EBF.ips` -- `romfs` to `/atmosphere/contents/0100000000010000/romfs` +- `smo-practice130.nso` to `/atmosphere/contents/0100000000010000/exefs/subsdk1` (note: no extension). +- `starlight_patch_130/B424BE150A8E7D78701CBE7A439D9EBF.ips` to `/atmosphere/exefs_patches/starlight_patch_130/B424BE150A8E7D78701CBE7A439D9EBF.ips`. +- `romfs` to `/atmosphere/contents/0100000000010000/romfs`. -## Install (Yuzu) +### Yuzu -First open the Yuzu `Mod Data Location` for SMO. -It can be opened by right-clicking on the game in yuzu (alternatively `%YUZU_DIR%/load/0100000000010000`). -Then make a new folder for the practice mod and transfer the following files into the newly created folder. -- `smo-practice100.nso` to `/exefs/subsdk1` (note: no extension) -- `starlight_patch_100/3CA12DFAAF9C82DA064D1698DF79CDA1.ips` to `/exefs/3CA12DFAAF9C82DA064D1698DF79CDA1.ips` -- `romfs` to `/romfs` +First open the Yuzu `Mod Data Location` for SMO. It can be opened by right-clicking on the game in Yuzu (alternatively `%YUZU_DIR%/load/0100000000010000`). Then make a new folder for the practice mod and transfer the following files into the newly created folder: +- `smo-practice100.nso` to `/exefs/subsdk1` (note: no extension). +- `starlight_patch_100/3CA12DFAAF9C82DA064D1698DF79CDA1.ips` to `/exefs/3CA12DFAAF9C82DA064D1698DF79CDA1.ips`. +- `romfs` to `/romfs`. After the file transfer, the new folder should have the following structure, @@ -74,13 +124,13 @@ After the file transfer, the new folder should have the following structure, │   └── ... ``` -For SMO version `1.3.0`, transfer the `smo-practice130.nso` and `starlight_patch_130/B424BE150A8E7D78701CBE7A439D9EBF.ips` instead. +For SMO version 1.3.0, transfer `smo-practice130.nso` and `starlight_patch_130/B424BE150A8E7D78701CBE7A439D9EBF.ips` instead. For more information, check out Yuzu's [official help page for game modding](https://yuzu-emu.org/help/feature/game-modding/). -## Building TAS Server +## Building TAS Server (v1.0.0) -Build has only been tested on Arch Linux, CMake is required +Build has only been tested on Arch Linux. CMake is required. ``` cd smo-tas-server @@ -89,8 +139,9 @@ cmake .. make ``` -# Credits -- CraftyBoss - [work on TextWriter](https://github.com/CraftyBoss/Starlight-SMO-LayoutEditing) -- bryce_____ - [Example](https://github.com/brycewithfiveunderscores/Starlight-SMO-Example) -- devkitA64 -- libnx - switch build rules \ No newline at end of file +## Credits +- [Fruityloops](https://github.com/fruityloops1), for the [earlier versions of this mod](https://github.com/fruityloops1/smo-practice). +- [CraftyBoss](https://github.com/CraftyBoss), for his [work on TextWriter](https://github.com/CraftyBoss/Starlight-SMO-LayoutEditing). +- [bryce_____](https://github.com/brycewithfiveunderscores), for his [Starlight SMO example](https://github.com/brycewithfiveunderscores/Starlight-SMO-Example). +- devkitA64. +- [libnx](https://github.com/switchbrew/libnx), for the Switch build rules. diff --git a/exported.txt b/exported.txt index 1d0f074..f27b67c 100644 --- a/exported.txt +++ b/exported.txt @@ -1,99 +1,41 @@ { global: _Z21stageSceneControlHookv; + _Z18stageSceneKillHookv; _Z14setupDebugMenuP10GameSystem; _Z14setGotShineVar20GameDataHolderWriterPK9ShineInfo; _Z13isGotShineVar22GameDataHolderAccessorPK9ShineInfo; _Z25isEnableCheckpointWarpVarP9MapLayout; _Z15isEnableSaveVarP10StageScene; _Z19isDefeatKoopaLv1VarP10StageScene; + _Z20setPlayerJointUpdateP24PlayerJointControlKeeper; + _Z31isTriggerRollingRestartSwingVarP11PlayerInput; + _Z30setLoadDataSelectingCurrentVarv; + _Z30setLoadDataSelectingConfirmVarv; + _Z21setRepeatCapBounceVarv; + _Z23setRepeatRainbowSpinVarv; + _Z23setWallJumpCapBounceVarv; + _Z18storeActorInitInfov; + _Z18stageSceneCtorHookv; + _Z12setDamageVarP18PlayerHitPointData; + _Z21findUnlockShineNumVarP14GameDataHolderPbi; _Z22isTriggerAmiiboModeVarPKN2al18IUseSceneObjHolderE; _Z24isTriggerSnapShotModeVarPKN2al18IUseSceneObjHolderE; - _Z12drawMainHookP16HakoniwaSequencePN4sead8ViewportEPNS1_11DrawContextE; - - _Z14fgetRightSticki; - _Z13fgetLeftSticki; - - _Z14fisPadTriggerAi; - _Z14fisPadTriggerBi; - _Z14fisPadTriggerXi; - _Z14fisPadTriggerYi; - _Z14fisPadTriggerLi; - _Z14fisPadTriggerRi; - _Z15fisPadTriggerZLi; - _Z15fisPadTriggerZRi; - _Z28fisPadTriggerPressRightSticki; - _Z17fisPadTriggerPlusi; - _Z18fisPadTriggerMinusi; - _Z15fisPadTriggerUpi; - _Z18fisPadTriggerRighti; - _Z17fisPadTriggerDowni; - _Z17fisPadTriggerLefti; - _Z23fisPadTriggerUiCursorUpi; - _Z25fisPadTriggerUiCursorDowni; - _Z25fisPadTriggerUiCursorLefti; - _Z26fisPadTriggerUiCursorRighti; - - _Z11fisPadHoldAi; - _Z11fisPadHoldBi; - _Z11fisPadHoldXi; - _Z11fisPadHoldYi; - _Z11fisPadHoldLi; - _Z11fisPadHoldRi; - _Z12fisPadHoldZLi; - _Z12fisPadHoldZRi; - _Z25fisPadHoldPressRightSticki; - _Z14fisPadHoldPlusi; - _Z15fisPadHoldMinusi; - _Z12fisPadHoldUpi; - _Z15fisPadHoldRighti; - _Z14fisPadHoldDowni; - _Z14fisPadHoldLefti; - _Z20fisPadHoldUiCursorUpi; - _Z22fisPadHoldUiCursorDowni; - _Z22fisPadHoldUiCursorLefti; - _Z23fisPadHoldUiCursorRighti; - - _Z11fisPadHoldAi; - _Z11fisPadHoldBi; - _Z11fisPadHoldXi; - _Z11fisPadHoldYi; - _Z11fisPadHoldLi; - _Z11fisPadHoldRi; - _Z12fisPadHoldZLi; - _Z12fisPadHoldZRi; - _Z25fisPadHoldPressRightSticki; - _Z14fisPadHoldPlusi; - _Z15fisPadHoldMinusi; - _Z12fisPadHoldUpi; - _Z15fisPadHoldRighti; - _Z14fisPadHoldDowni; - _Z14fisPadHoldLefti; - _Z20fisPadHoldUiCursorUpi; - _Z22fisPadHoldUiCursorDowni; - _Z22fisPadHoldUiCursorLefti; - _Z23fisPadHoldUiCursorRighti; - - _Z14fisPadReleaseAi; - _Z14fisPadReleaseBi; - _Z14fisPadReleaseXi; - _Z14fisPadReleaseYi; - _Z14fisPadReleaseLi; - _Z14fisPadReleaseRi; - _Z15fisPadReleaseZLi; - _Z15fisPadReleaseZRi; - _Z28fisPadReleasePressRightSticki; - _Z17fisPadReleasePlusi; - _Z18fisPadReleaseMinusi; - _Z15fisPadReleaseUpi; - _Z18fisPadReleaseRighti; - _Z17fisPadReleaseDowni; - _Z17fisPadReleaseLefti; - _Z23fisPadReleaseUiCursorUpi; - _Z25fisPadReleaseUiCursorDowni; - _Z25fisPadReleaseUiCursorLefti; - _Z26fisPadReleaseUiCursorRighti; - + _Z12drawMainHookPN4sead8ViewportEPNS_11DrawContextEPNS_18LogicalFrameBufferEPN2al9LayoutKitE; + _Z16sequenceDrawHookPN2al8SequenceE; + _Z20nerveKeeperUpdateVarv; + _Z31setPlayerEnableToSeeOddSpaceVarPKN2al9LiveActorE; + _Z22executeDirectorDrawVarPKcS0_; + _Z26executeTableHolderDrawCtorPN2al22ExecuteTableHolderDrawE; + _Z29executeTableHolderDrawExecutePN2al22ExecuteTableHolderDrawE; + _Z9initActorPN2al9LiveActorERKNS_13ActorInitInfoEPN4sead14SafeStringBaseIcEES8_PKc; + _Z25shineListLayoutDecideHookP15ShineListLayout; + + _Z22fgetNpadStatesHandheldPN2nn3hid17NpadHandheldStateEiRKj; + _Z18fgetNpadStatesDualPN2nn3hid16NpadJoyDualStateEiRKj; + _Z21fgetNpadStatesFullKeyPN2nn3hid16NpadFullKeyStateEiRKj; + _Z21fgetNpadStatesJoyLeftPN2nn3hid16NpadJoyLeftStateEiRKj; + _Z22fgetNpadStatesJoyRightPN2nn3hid17NpadJoyRightStateEiRKj; _Z26fisModeDiverOrJungleGymRomv; _Z15fisModeDiverRomv; @@ -106,7 +48,15 @@ _Z28fgetPadAccelerationDeviceNumi; _Z12motionUpdatePN2al23JoyPadAccelPoseAnalyzerE; + _Z14tasDrawKitHookPKN2al5SceneEPKc; + + _Z22koopaHatRandomizerHookiiiPii; + _Z18koopaHatRandomHooki; + + _Z14pipeRandomnessi; + _Z17getMofumofuTargeti; _Z16isPatternReversev; + _Z17bgmStartSoundHookPN2nn3atk14SoundStartableEPNS0_11SoundHandleEPKcPKNS1_9StartInfoE; local: *; }; diff --git a/include/al/LiveActor/LiveActor.h b/include/al/LiveActor/LiveActor.h index c27e2b3..e9fee20 100644 --- a/include/al/LiveActor/LiveActor.h +++ b/include/al/LiveActor/LiveActor.h @@ -11,7 +11,8 @@ #include "al/pose/ActorPoseKeeper.h" #include "al/rail/RailKeeper.h" #include "al/rail/RailRider.h" -#include "al/scene/SceneObjHolder.h" +#include "al/iuse/IUseSceneObjHolder.h" +#include "al/iuse/IUseStageSwitch.h" #include "al/screen/ScreenPointKeeper.h" #include "al/sensor/HitSensorKeeper.h" #include "al/sensor/HitSensor.h" @@ -25,6 +26,8 @@ namespace al class SensorMsg; class ScreenPointer; class ScreenPointTarget; + class CollisionParts; + class ModelKeeper; class LiveActor : public al::IUseNerve, public al::IUseEffectKeeper, public al::IUseAudioKeeper, public al::IUseStageSwitch, public al::IUseSceneObjHolder, public al::IUseAreaObj, public al::IUseCamera, public al::IUseCollision, public al::IUseRail, public al::IUseHioNode { public: @@ -62,7 +65,9 @@ namespace al const char* mActorName; // _48 al::ActorPoseKeeperBase* mPoseKeeper; // _50 - char _58[0x90-0x58]; + char _58[0x80-0x58]; + al::CollisionParts* mCollisionParts; + al::ModelKeeper* mModelKeeper; al::NerveKeeper* mNerveKeeper; // _90 al::HitSensorKeeper* mHitSensorKeeper; // _98 al::ScreenPointKeeper* mScreenPointKeeper; // _A0 @@ -72,4 +77,4 @@ namespace al al::StageSwitchKeeper* mStageSwitchKeeper; // _C0 al::RailKeeper* mRailKeeper; // _C8 }; -}; \ No newline at end of file +}; diff --git a/include/al/LiveActor/LiveActorGroup.h b/include/al/LiveActor/LiveActorGroup.h index 26be814..6b7aba7 100644 --- a/include/al/LiveActor/LiveActorGroup.h +++ b/include/al/LiveActor/LiveActorGroup.h @@ -12,10 +12,9 @@ namespace al LiveActorGroup(const char *, int); virtual void registerActor(al::LiveActor *); + int calcAliveActorNum() const; - const char* mGroupName; // _8 - int mMaxActorCount; // _10 - int mActorCount; // _14 - al::LiveActor** mActors; // _18 + const char* mName; + sead::PtrArray mActors; }; -}; \ No newline at end of file +}; diff --git a/include/al/LiveActor/LiveActorKit.h b/include/al/LiveActor/LiveActorKit.h new file mode 100644 index 0000000..ab66739 --- /dev/null +++ b/include/al/LiveActor/LiveActorKit.h @@ -0,0 +1,70 @@ +#pragma once + +#include "al/hio/HioNode.h" + + +namespace al { +class ActorResourceHolder; +class GravityHolder; +class GraphicsSystemInfo; +class ModelDrawBufferCounter; +class ModelDrawBufferUpdater; +class ModelDisplayListController; +class ClippingDirector; +class ItemDirectorBase; +class HitSensorDirector; +class ScreenPointDirector; +class ShadowDirector; +class StageSwitchDirector; +class ProjectDemoDirector; +class GamePadSystem; +class PadRumbleDirector; +class ModelGroup; + +class AreaObjDirector; +class ExecuteDirector; +class EffectSystem; +class ExecuteAsyncExecutor; +class LiveActorGroup; +class CameraDirector; +class CollisionDirector; +class PlayerHolder; +class SwitchAreaDirector; +class LiveActorGroup; +class NatureDirector; + +class LiveActorKit : public al::HioNode { +public: + unsigned char gap1[0x8]; + int iVar1; + ActorResourceHolder* mActorResourceHolder; + AreaObjDirector* mAreaObjDirector; + ExecuteDirector* mExecuteDirector; + GravityHolder* mGravityHolder; + EffectSystem* mEffectSystem; + GraphicsSystemInfo* mGraphicsSystemInfo; + ModelDrawBufferCounter* mModelDrawBufferCounter; + ModelDrawBufferUpdater* mModelDrawBufferUpdater; + ExecuteAsyncExecutor* mExecuteAsyncExecutor1; + ExecuteAsyncExecutor* mExecuteAsyncExecutor2; + ModelDisplayListController* mModelDisplayListController; + void* unk1; // ExecuteSystemInitInfo + LiveActorGroup* mOriginalDrawingGroup; + CameraDirector* mCameraDirector; + ClippingDirector* mClippingDirector; + CollisionDirector* mCollisionDirector; + ItemDirectorBase* mItemDirector; + PlayerHolder* mPlayerHolder; + HitSensorDirector* mHitSensorDirector; + ScreenPointDirector* mScreenPointDirector; + ShadowDirector* mShadowDirector; + StageSwitchDirector* mStageSwitchDirector; + SwitchAreaDirector* mSwitchAreaDirector; + LiveActorGroup* mAllActors; + ProjectDemoDirector* unk3; + GamePadSystem* unk4; + PadRumbleDirector* mPadRumbleDirector; + NatureDirector* mNatureDirector; + ModelGroup* mModelGroup; +}; +} diff --git a/include/al/PlayerHolder/PlayerHolder.h b/include/al/PlayerHolder/PlayerHolder.h index 6cbb399..1c74706 100644 --- a/include/al/PlayerHolder/PlayerHolder.h +++ b/include/al/PlayerHolder/PlayerHolder.h @@ -16,8 +16,9 @@ namespace al { public: PlayerHolder(int); al::LiveActor *getPlayer(int); + al::LiveActor* tryGetPlayer(int) const; int *getPlayerNum() const; int *getBufferSize() const; void registerPlayer(al::LiveActor *, al::PadRumbleKeeper *); }; -} \ No newline at end of file +} diff --git a/include/al/actor/WaterSurfaceFinder.h b/include/al/actor/WaterSurfaceFinder.h new file mode 100644 index 0000000..4bd51c3 --- /dev/null +++ b/include/al/actor/WaterSurfaceFinder.h @@ -0,0 +1,18 @@ +#pragma once + +#include "al/LiveActor/LiveActor.h" +#include + +namespace al { +class WaterSurfaceFinder { +public: + bool isNearSurface(float) const; + + al::LiveActor* mActor; + bool mIsNearSurface; + float mDistBelowSurface; + sead::Vector3f mSurfacePoint; + sead::Vector3f vVar2; + sead::Vector3f vVar3; +}; +} diff --git a/include/al/area/AreaObj.h b/include/al/area/AreaObj.h new file mode 100644 index 0000000..f5694a4 --- /dev/null +++ b/include/al/area/AreaObj.h @@ -0,0 +1,37 @@ +#pragma once + +#include "al/iuse/IUseSceneObjHolder.h" +#include "al/iuse/IUseStageSwitch.h" +#include "al/hio/HioNode.h" +#include + +namespace al { +class PlacementInfo; +class AreaShape; +class StageSwitchKeeper; +class SceneObjHolder; + +class AreaObj : al::IUseStageSwitch, al::IUseSceneObjHolder, al::HioNode { +public: + AreaObj(char const *); + const char* getName() const; + al::SceneObjHolder* getSceneObjHolder() const; + al::StageSwitchKeeper* getStageSwitchKeeper() const; + //void init(al::AreaInitInfo const &); + void initStageSwitchKeeper(); + void invalidate(); + bool isInVolume(sead::Vector3f const &) const; + bool isInVolumeOffset(sead::Vector3f const &, float) const; + void validate(); + + const char* mName; + al::AreaShape* mAreaShape; + al::StageSwitchKeeper* mStageSwitchKeeper; + al::SceneObjHolder* mSceneObjHolder; + sead::Matrix34f mAreaMtx; + al::PlacementInfo* mPlacementInfo; + int mPriority; + bool mIsValid; +}; + +} diff --git a/include/al/area/AreaObjDirector.h b/include/al/area/AreaObjDirector.h index 233b5e5..a320359 100644 --- a/include/al/area/AreaObjDirector.h +++ b/include/al/area/AreaObjDirector.h @@ -1,12 +1,20 @@ #pragma once -namespace al -{ - class AreaObjDirector; - - class IUseAreaObj - { - public: - virtual al::AreaObjDirector* getAreaObjDirector() const = 0; - }; -}; \ No newline at end of file +#include "al/iuse/IUseAreaObj.h" + +namespace al { +class AreaObjFactory; +class AreaObjGroup; +class AreaObjMtxConnecterHolder; + +class AreaObjDirector { +public: + AreaObjGroup* getAreaObjGroup(const char*) const; + + AreaObjFactory* mFactory; + AreaObjMtxConnecterHolder* mMtxConnecterHolder; + AreaObjGroup** mAreaGroups; + int mAreaGroupCount; +}; + +} diff --git a/include/al/area/AreaObjGroup.h b/include/al/area/AreaObjGroup.h index 5070cdb..c781b91 100644 --- a/include/al/area/AreaObjGroup.h +++ b/include/al/area/AreaObjGroup.h @@ -1,10 +1,12 @@ #pragma once -namespace al -{ - class AreaObjGroup - { - public: - - }; -}; \ No newline at end of file +namespace al { +class AreaObj; +class AreaObjGroup { +public: + const char* mGroupName; + al::AreaObj** mAreas; + int mAreaCount; + int mBufferSize; +}; +} diff --git a/include/al/area/AreaShape.h b/include/al/area/AreaShape.h new file mode 100644 index 0000000..0ffbc5d --- /dev/null +++ b/include/al/area/AreaShape.h @@ -0,0 +1,85 @@ +#pragma once + +#include "al/hio/HioNode.h" +#include +#include +#include + +namespace al { + +class AreaShape : al::HioNode { +public: + AreaShape(); + + virtual bool isInVolume(sead::Vector3f const&) const; + virtual bool isInVolumeOffset(sead::Vector3f const&, float) const; + virtual bool calcNearestEdgePoint(sead::Vector3f*, sead::Vector3f const&) const; + virtual bool checkArrowCollision(sead::Vector3f*, sead::Vector3f*, sead::Vector3f const&, sead::Vector3f const&) const; + virtual bool calcLocalBoundingBox(sead::BoundBox3f*) const; + + bool calcLocalPos(sead::Vector3f*, sead::Vector3f const &) const; + bool calcTrans(sead::Vector3f*) const; + bool calcWorldDir(sead::Vector3f*, sead::Vector3f const &) const; + bool calcWorldPos(sead::Vector3f*, sead::Vector3f const &) const; + void setBaseMtxPtr(sead::Matrix34f const *); + void setScale(sead::Vector3f const &); + + sead::Matrix34f* mBaseMtx; + sead::Vector3f mScale; + +}; + +class AreaShapeCube : public AreaShape { +private: + enum OriginType { center, base, top }; +public: + AreaShapeCube(al::AreaShapeCube::OriginType); + bool isInVolume(sead::Vector3f const &) const override; + bool isInVolumeOffset(sead::Vector3f const &, float) const override; + bool calcNearestEdgePoint(sead::Vector3f*, sead::Vector3f const &) const override; + bool checkArrowCollision(sead::Vector3f*, sead::Vector3f*, sead::Vector3f const &, sead::Vector3f const &) const override; + bool calcLocalBoundingBox(sead::BoundBox3f*) const override; + bool isInLocalVolume(sead::Vector3f const &) const; + + OriginType mOriginType; +}; + +class AreaShapeCylinder : public AreaShape { +private: + enum OriginType { center, base, top }; +public: + AreaShapeCylinder(al::AreaShapeCylinder::OriginType); + bool isInVolume(sead::Vector3f const &) const override; + bool isInVolumeOffset(sead::Vector3f const &, float) const override; + bool calcNearestEdgePoint(sead::Vector3f*, sead::Vector3f const &) const override; + bool checkArrowCollision(sead::Vector3f*, sead::Vector3f*, sead::Vector3f const &, sead::Vector3f const &) const override; + bool calcLocalBoundingBox(sead::BoundBox3f*) const override; + + OriginType mOriginType; +}; + +class AreaShapeInfinite : public AreaShape { +public: + AreaShapeInfinite(); + bool isInVolume(sead::Vector3f const &) const override; + bool isInVolumeOffset(sead::Vector3f const &, float) const override; + bool calcNearestEdgePoint(sead::Vector3f*, sead::Vector3f const &) const override; + bool checkArrowCollision(sead::Vector3f*, sead::Vector3f*, sead::Vector3f const &, sead::Vector3f const &) const override; + bool calcLocalBoundingBox(sead::BoundBox3f*) const override; + +}; + +class AreaShapeOval : public AreaShape { +public: + AreaShapeOval(); + bool isInVolume(sead::Vector3f const &) const override; + bool isInVolumeOffset(sead::Vector3f const &, float) const override; + bool calcNearestEdgePoint(sead::Vector3f*, sead::Vector3f const &) const override; + bool checkArrowCollision(sead::Vector3f*, sead::Vector3f*, sead::Vector3f const &, sead::Vector3f const &) const override; + bool calcLocalBoundingBox(sead::BoundBox3f*) const override; + + float fVar1; + float fVar2; +}; + +} diff --git a/include/al/audio/AudioKeeper.h b/include/al/audio/AudioKeeper.h index fec6f51..6b2c137 100644 --- a/include/al/audio/AudioKeeper.h +++ b/include/al/audio/AudioKeeper.h @@ -1,18 +1,12 @@ #pragma once +#include "al/iuse/IUseAudioKeeper.h" + namespace al { - class AudioKeeper; - - class IUseAudioKeeper - { - public: - virtual al::AudioKeeper* getAudioKeeper() const = 0; - }; - class AudioKeeper { public: }; -}; \ No newline at end of file +}; diff --git a/include/al/camera/CameraDirector.h b/include/al/camera/CameraDirector.h index 13dd205..2ccc2eb 100644 --- a/include/al/camera/CameraDirector.h +++ b/include/al/camera/CameraDirector.h @@ -7,7 +7,7 @@ namespace al class CameraDirector { public: void startSnapShotMode(bool); - al::CameraPoseUpdater *getPoseUpdater(void); + al::CameraPoseUpdater* getPoseUpdater(int) const; float getSceneFovyDegree(void) const; unsigned char padding[0x30-0x02]; @@ -21,4 +21,4 @@ namespace al public: virtual al::CameraDirector* getCameraDirector() const = 0; }; -}; \ No newline at end of file +}; diff --git a/include/al/camera/CameraPoseUpdater.h b/include/al/camera/CameraPoseUpdater.h index ec5d652..5c3ab86 100644 --- a/include/al/camera/CameraPoseUpdater.h +++ b/include/al/camera/CameraPoseUpdater.h @@ -1,9 +1,44 @@ #pragma once -namespace al -{ - class CameraPoseUpdater { - public: - - }; -}; \ No newline at end of file +#include "al/camera/CameraTicket.h" +#include "al/nerve/NerveExecutor.h" + +#include + +namespace al { +class SceneCameraInfo; +class CameraViewFlag; +class Projection; +class CameraSwitcher; +class CameraStartParamCtrl; +class CameraStopJudge; +class CameraParamTransfer; +class CameraInterpole; +class CameraShaker; + +class CameraPoseUpdater : public al::NerveExecutor { +public: + int mSnapShotOrientationRotate; + al::SceneCameraInfo* mSceneCameraInfo; + void* gap1; + al::CameraViewInfo* mCameraViewInfo; + al::CameraViewFlag* mCameraViewFlag; + bool bVar1; + int iVar1; + sead::LookAtCamera mLookAtCamera; + al::CameraTicket* mTicket; + al::Projection* mProjection; + void* gap2; + float mNearClipDistance; + float fVar1; + float fVar2; + float fVar3; + al::CameraSwitcher* mCameraSwitcher; + al::CameraStartParamCtrl* mCameraStartParamCtrl; + al::CameraStopJudge* mCameraStopJudge; + al::CameraParamTransfer* mCameraParamTransfer; + const char* sVar1; + al::CameraInterpole* mCameraInterpole; + al::CameraShaker* mCameraShaker; +}; +} diff --git a/include/al/camera/CameraPoser.h b/include/al/camera/CameraPoser.h index f35d23e..fd63549 100644 --- a/include/al/camera/CameraPoser.h +++ b/include/al/camera/CameraPoser.h @@ -1,9 +1,65 @@ #pragma once -namespace al -{ - class CameraPoser { - public: - - }; -}; \ No newline at end of file +#include "al/hio/HioNode.h" +#include "al/iuse/IUseAreaObj.h" +#include "al/iuse/IUseAudioKeeper.h" +#include "al/iuse/IUseCollision.h" +#include "al/iuse/IUseName.h" +#include "al/iuse/IUseNerve.h" +#include "al/iuse/IUseRail.h" + +#include +#include + +namespace al { +class CameraPoserSceneInfo; +class CameraViewInfo; +class CameraPoserFlag; +class CameraVerticalAbsorber; +class CameraAngleCtrlInfo; +class CameraAngleSwingInfo; +class CameraArrowCollider; +class CameraOffsetCtrlPreset; +class LocalInterpole; +class LookAtInterpole; +class CameraParamMoveLimit; +class CameraTargetAreaLimitter; +class GyroCameraCtrl; +class RailKeeper; +class OrthoProjectionParam; + +class SnapShotCameraCtrl; + +class CameraPoser : public al::HioNode, public al::IUseAreaObj, public al::IUseAudioKeeper, public al::IUseCollision, public al::IUseName, public al::IUseNerve, public al::IUseRail { +public: + const char* mName; + float fVar1; + sead::Vector3f mPosition; + sead::Vector3f mTargetTrans; + sead::Vector3f mCameraUp; + float mFovyDegree; + float mNearClipDistance; + sead::Matrix34f mViewMtx; + bool bVar1; + al::CameraPoserSceneInfo* mPoserSceneInfo; + al::CameraViewInfo* mViewInfo; + al::CameraPoserFlag* mFlag; + al::CameraVerticalAbsorber* mVerticalAbsorber; + al::CameraAngleCtrlInfo* mAngleCtrlInfo; + al::CameraAngleSwingInfo* mAngleSwingInfo; + al::CameraArrowCollider* mArrowCollider; + al::CameraOffsetCtrlPreset* mOffsetCtrlPreset; + al::LocalInterpole* mLocalInterpole; + al::LookAtInterpole* mLookAtInterpole; + al::CameraParamMoveLimit* mParamMoveLimit; + al::CameraTargetAreaLimitter* mTargetAreaLimitter; + al::GyroCameraCtrl* mGyroCameraCtrl; + al::SnapShotCameraCtrl* mSnapShotCameraCtrl; + al::AudioKeeper* mAudioKeeper; + al::NerveKeeper* mNerveKeeper; + al::RailKeeper* mRailKeeper; + void* gap1; + void* gap2; + al::OrthoProjectionParam* mOrthoProjectionParam; +}; +} diff --git a/include/al/camera/CameraTicket.h b/include/al/camera/CameraTicket.h new file mode 100644 index 0000000..d6ff369 --- /dev/null +++ b/include/al/camera/CameraTicket.h @@ -0,0 +1,15 @@ +#pragma once + +#include "al/camera/CameraPoser.h" + +namespace al { +class CameraTicketId; + +class CameraTicket { +public: + al::CameraPoser* mPoser; + al::CameraTicketId* mTicketId; + int mPriority; + bool bVar1; +}; +} diff --git a/include/al/camera/SnapShotCameraCtrl.h b/include/al/camera/SnapShotCameraCtrl.h new file mode 100644 index 0000000..1b4da1b --- /dev/null +++ b/include/al/camera/SnapShotCameraCtrl.h @@ -0,0 +1,35 @@ +#pragma once + +#include "al/iuse/IUseAudioKeeper.h" +#include "al/nerve/NerveExecutor.h" + +#include + +struct CameraParam { + bool bVar; + float fVar1; + float fVar2; +}; + +namespace al { +class SnapShotCameraSceneInfo; + +class SnapShotCameraCtrl : public al::NerveExecutor, public al::IUseAudioKeeper { +public: + al::SnapShotCameraSceneInfo* mCameraSceneInfo; + CameraParam* mParam; + bool mIsValidLookAtOffset; + sead::Vector3f mLookAtOffset; + sead::Vector3f vVar1; + bool mIsValidZoomFovy; + float fVar1; + float fVar2; + float fVar3; + float mMaxZoomOutFovyDegree; + bool mIsValidRoll; + float mRollDegree; + float mRollTarget; + unsigned int uVar2; + bool bVar1; +}; +} diff --git a/include/al/collision/CollisionDirector.h b/include/al/collision/CollisionDirector.h index ae8474d..c8b283d 100644 --- a/include/al/collision/CollisionDirector.h +++ b/include/al/collision/CollisionDirector.h @@ -1,12 +1,3 @@ #pragma once -namespace al -{ - class CollisionDirector; - - class IUseCollision - { - public: - virtual al::CollisionDirector* getCollisionDirector() const = 0; - }; -}; \ No newline at end of file +#include "al/iuse/IUseCollision.h" diff --git a/include/al/collision/CollisionParts.h b/include/al/collision/CollisionParts.h new file mode 100644 index 0000000..40d471b --- /dev/null +++ b/include/al/collision/CollisionParts.h @@ -0,0 +1,41 @@ +#pragma once + +#include "al/collision/KCollisionServer.h" +#include "al/sensor/HitSensor.h" +#include +#include + +namespace al { +class CollisionParts { +public: + unsigned char gap1[0x18]; + sead::TList* mPartsList; + sead::Matrix34f* mJointMtx; + sead::Matrix34f mVar1; + sead::Matrix34f mBaseMtx; + sead::Matrix34f mBaseInvMtx; + sead::Matrix34f mPrevBaseMtx; + sead::Matrix34f mVar2; + sead::Vector3f mMtxScaleVec; + float mMtxScale; + float mInvMtxScale; + int mPriority; + al::KCollisionServer* mKCollisionServer; + al::HitSensor* mConnectedSensor; + const char* mSpecialPurpose; + const char* mOptionalPurpose; + float fVar2; + float fVar3; + float fVar4; + unsigned char gap2[0x4]; + float mBoundingSphereRange; + float mBaseMtxScale; + bool bVar1; + bool bVar2; + bool bVar3; + bool bVar4; + bool bVar5; + bool mIsMoving; + bool bVar6; +}; +} diff --git a/include/al/collision/HitInfo.h b/include/al/collision/HitInfo.h new file mode 100644 index 0000000..9b890cc --- /dev/null +++ b/include/al/collision/HitInfo.h @@ -0,0 +1,25 @@ + +#pragma once + +#include "al/collision/Triangle.h" +#include + +namespace al { +class HitInfo { +public: + al::Triangle mTri; + float fVar1; + sead::Vector3f mCollisionHitPos; + sead::Vector3f vVar1; + sead::Vector3f mCollisionMovingReaction; + bool bVar1; +}; + +class SphereHitInfo : public al::HitInfo { + +}; + +class DiskHitInfo : public al::HitInfo { + +}; +} diff --git a/include/al/collision/KCPrism.h b/include/al/collision/KCPrism.h new file mode 100644 index 0000000..abcd30d --- /dev/null +++ b/include/al/collision/KCPrism.h @@ -0,0 +1,33 @@ +#pragma once + +#include +#include + +namespace al { +class KCPrismData { // triangle +public: + float mLength; + u16 mPosIndex; + u16 mFaceNormalIndex; + u16 mEdgeNormalIndex[3]; + u16 mCollisionType; + u32 mTriIndex; +}; + +class KCPrismHeader { // model +public: + u32 mPositionsOffset; + u32 mNormalsOffset; + u32 mTrianglesOffset; + u32 mOctreeOffset; + float mThickness; + sead::Vector3f mOctreeOrigin; + u32 mXMask; + u32 mYMask; + u32 mZMask; + u32 mCoordShift; + u32 mYShift; + u32 mZShift; + float mHitboxRadiusCap; +}; +} diff --git a/include/al/collision/KCollisionServer.h b/include/al/collision/KCollisionServer.h new file mode 100644 index 0000000..ae80379 --- /dev/null +++ b/include/al/collision/KCollisionServer.h @@ -0,0 +1,88 @@ +#pragma once + +#include "al/collision/KCPrism.h" +#include + +namespace sead { +template +class FixedRingBuffer; +} + +namespace al { +class ByamlIter; +class KCHitInfo; + +class KCollisionServer { +public: + KCollisionServer(); + void areaOffsetSpaceToObjectSpace(sead::Vector3f*, sead::Vector3u const&, al::KCPrismHeader const*) const; + int calcAreaBlockOffset(sead::Vector3u const&, al::KCPrismHeader const*) const; + static int calcChildBlockOffset(sead::Vector3u const&, int); + float calcFarthestVertexDistance(); + void calcPosLocal(sead::Vector3f*, al::KCPrismData const*, int, al::KCPrismHeader const*) const; + static void calXVec(sead::Vector3f const*, sead::Vector3f const*, sead::Vector3f*); + void checkArrow(sead::Vector3f const&, sead::Vector3f const&, sead::FixedRingBuffer*, unsigned int*, unsigned int) const; + // check* + void getAreaSpaceSize(sead::Vector3f*, al::KCPrismHeader const*) const; + void getAreaSpaceSize(int*, int*, int*, al::KCPrismHeader const*) const; + void getAreaSpaceSize(sead::Vector3u*, al::KCPrismHeader const*) const; + int getAttributeElementNum() const; + bool getAttributes(al::ByamlIter*, unsigned int, al::KCPrismHeader const*) const; + bool getAttributes(al::ByamlIter*, al::KCPrismData const*) const; + // getBlockData + sead::Vector3f* getEdgeNormal1(al::KCPrismData const*, al::KCPrismHeader const*) const; + sead::Vector3f* getEdgeNormal2(al::KCPrismData const*, al::KCPrismHeader const*) const; + sead::Vector3f* getEdgeNormal3(al::KCPrismData const*, al::KCPrismHeader const*) const; + sead::Vector3f* getFaceNormal(al::KCPrismData const*, al::KCPrismHeader const*) const; + void* getInnerKcl(int) const; + void getMinMax(sead::Vector3f*, sead::Vector3f*) const; + inline sead::Vector3f* getNormal(unsigned int, al::KCPrismHeader const*) const; + inline int getNormalNum(al::KCPrismHeader const*) const; + + inline int getNumInnerKcl() const { + return *(int*)(this->gap1 + 0xc); + } + + inline al::KCPrismData* getPrismData(unsigned int idx, al::KCPrismHeader const* prismHeader) const { + return (al::KCPrismData*)(&prismHeader->mPositionsOffset + prismHeader->mTrianglesOffset + idx * 0x14); + } + + inline int getTriangleNum(al::KCPrismHeader const* prismHeader) const { + return (prismHeader->mOctreeOffset - prismHeader->mTrianglesOffset) / 0x14; + } + + inline al::KCPrismHeader* getV1Header(int) const; + // getVertexData (0xc) + + inline int getVertexNum(al::KCPrismHeader const* prismHeader) const { + return ((prismHeader->mNormalsOffset - prismHeader->mPositionsOffset) >> 2) * -0x55555555; + } + + void initKCollisionServer(void*, void const*); + inline bool isInsideMinMaxInAreaOffsetSpace(sead::Vector3u const&, al::KCPrismHeader const*) const; + inline bool isNanPrism(al::KCPrismData const*, al::KCPrismHeader const*) const; + bool isNearParallelNormal(al::KCPrismData const*, al::KCPrismHeader const*) const; + bool isParallelNormal(al::KCPrismData const*, al::KCPrismHeader const*) const; + // KCHit* + void objectSpaceToAreaOffsetSpace(sead::Vector3u*, sead::Vector3f const&, al::KCPrismHeader const*) const; + void objectSpaceToAreaOffsetSpaceV3f(sead::Vector3f*, sead::Vector3f const&, al::KCPrismHeader const*) const; + bool outCheckAndCalcArea(sead::Vector3u*, sead::Vector3u*, sead::Vector3f const&, sead::Vector3f const&, al::KCPrismHeader const*) const; + // search* + void setData(void*); + inline int toIndex(al::KCPrismData const*, al::KCPrismHeader const*) const; + + + sead::PtrArray mPrismHeaders; + unsigned char* gap1; // al::Resource? contains binary contents of kcl file + al::ByamlIter* mAttributeByml; + int* piVar1; + unsigned long uVar1; + int iVar1; + int iVar2; + int iVar3; + int iVar4; + int iVar5; + int iVar6; + float mFarthestVertexDistance; +}; +} diff --git a/include/al/collision/Triangle.h b/include/al/collision/Triangle.h new file mode 100644 index 0000000..2a80638 --- /dev/null +++ b/include/al/collision/Triangle.h @@ -0,0 +1,49 @@ +#pragma once + +#include "al/byaml/ByamlIter.h" +#include "al/collision/KCPrism.h" +#include +#include +#include + +namespace al { +class CollisionParts; +class LiveActor; +class HitSensor; + +class Triangle { +public: + Triangle(); + Triangle(al::CollisionParts const&, al::KCPrismData const*, al::KCPrismHeader const*); + + sead::Vector3f* calcAndGetEdgeNormal(int); + sead::Vector3f* calcAndGetFaceNormal(); + sead::Vector3f* calcAndGetNormal(int); + sead::Vector3f* calcAndGetPos(int); + void calcCenterPos(sead::Vector3f*) const; + void calcForceMovePower(sead::Vector3f*, sead::Vector3f const&) const; + void calcForceRotatePower(sead::Quatf*) const; + void fill(sead::Vector3f const&, sead::Vector3f const&, sead::Vector3f const&); + void fillData(al::CollisionParts const&, al::KCPrismData const*, al::KCPrismHeader const*); + bool getAttributes(al::ByamlIter*) const; + sead::Matrix34f* getBaseInvMtx() const; + sead::Matrix34f* getBaseMtx() const; + sead::Vector3f* getEdgeNormal(int) const; + sead::Vector3f* getFaceNormal() const; + al::LiveActor* getHostActor() const; + void getLocalPos(sead::Vector3f*, int) const; + sead::Vector3f* getNormal(int) const; + sead::Vector3f* getPos(int) const; + sead::Matrix34f* getPrevBaseMtx() const; + al::HitSensor* getSensor() const; + bool isHostMoved() const; + bool isValid() const; + + al::CollisionParts* mCollisionParts; + al::KCPrismData* mKCPrismData; + al::KCPrismHeader* mKCPrismHeader; + sead::Vector3f mFaceNormal; + sead::Vector3f mEdgeNormals[3]; + sead::Vector3f mVerts[3]; +}; +} diff --git a/include/al/effect/EffectInfo.h b/include/al/effect/EffectInfo.h index f126bca..a3021b0 100644 --- a/include/al/effect/EffectInfo.h +++ b/include/al/effect/EffectInfo.h @@ -1,10 +1,60 @@ #pragma once -namespace al -{ - class EffectInfo - { - public: - - }; -} \ No newline at end of file +#include +#include + +namespace al { +class EffectResourceInfo; +class ActionEffectData; + +class EffectInfo { +public: + const char* mName; + int mResourceCount; + int iVar1; + al::EffectResourceInfo* mResourceInfo; + void* gap1; + const char* mJointName; + sead::Vector3f mPosOffset; + sead::Vector3f mRotate; + float mScale; + float mParticleScale; + float mEmitRatio; + float mFarClipDistance; + int mForceCalcFrame; + int mHandleNum; + sead::Color4f mColor; + bool mIsEmitBillboard; + bool mIsEmitYBillboard; + bool mIsEmitCamera; + bool mIsDeleteAtClipping; + bool mIsOneTimeFade; + bool mIsEmitIgnoreRotate; + bool mIsEmitIgnoreScale; + bool mIsFollowPos; + bool mIsFollowMtx; + bool mIsEmitTrans; + bool mIsEmitRotate; + bool mIsEmitScale; + bool mIsFollowTrans; + bool mIsFollowRotate; + bool mIsFollowScale; + bool mIsNeedProgramInfo; + bool bVar1; + bool mIsSetMtxPtr; + bool mIsDirectPos; + bool mIsNonZeroPosOffset; + bool mIsNonZeroRotate; + bool mIsWhite; + bool mIsBindWorldAxisX; + bool mIsBindWorldAxisY; + bool mIsBindWorldAxisZ; + bool mIsNoEmitAtNoCollide; + bool mIsFollowScaleByFovy; + unsigned char gap2[0x5]; + int mActionEffectDataCount; + int iVar2; + al::ActionEffectData* mActionEffectData; + int mHitReactionCount; +}; +} diff --git a/include/al/effect/EffectSystem.h b/include/al/effect/EffectSystem.h new file mode 100644 index 0000000..db84673 --- /dev/null +++ b/include/al/effect/EffectSystem.h @@ -0,0 +1,12 @@ +#pragma once + +#include "al/effect/EffectSystemInfo.h" +#include + +namespace al { +class EffectSystem { +public: + sead::Heap* mHeap; + al::EffectSystemInfo mEffectSystemInfo; +}; +} diff --git a/include/al/effect/EffectSystemInfo.h b/include/al/effect/EffectSystemInfo.h new file mode 100644 index 0000000..504e127 --- /dev/null +++ b/include/al/effect/EffectSystemInfo.h @@ -0,0 +1,15 @@ +#pragma once + +namespace al { +class PtclSystem; + +class EffectSystemInfo { +public: + int iVar1; + int iVar2; + al::PtclSystem* mPtclSystem; + void* gap1; + int iVar3; + int iVar4; +}; +} diff --git a/include/al/effect/EffectUserInfo.h b/include/al/effect/EffectUserInfo.h index f4735f2..84b4649 100644 --- a/include/al/effect/EffectUserInfo.h +++ b/include/al/effect/EffectUserInfo.h @@ -1,19 +1,19 @@ #pragma once -namespace al -{ - class EffectUserInfo - { - public: - EffectUserInfo(); +namespace al { +class EffectInfo; - unsigned long _0; - int _8; - int _C; - unsigned long _10; - int _18; - int _1C; - unsigned long _20; - unsigned long _28; - }; -}; \ No newline at end of file +class EffectUserInfo { +public: + EffectUserInfo(); + + const char* mName; + int mEffectCount; + int iVar1; + al::EffectInfo* mEffectInfo; + int _18; + int _1C; + unsigned long _20; + unsigned long _28; +}; +} diff --git a/include/al/event/EventFlowExecutor.h b/include/al/event/EventFlowExecutor.h new file mode 100644 index 0000000..6cd4b20 --- /dev/null +++ b/include/al/event/EventFlowExecutor.h @@ -0,0 +1,19 @@ +#pragma once + +#include "al/LiveActor/LiveActor.h" +#include "al/hio/HioNode.h" + +namespace al { + +class EventFlowDataHolder; + +class IUseEventFlowData { +public: + virtual EventFlowDataHolder* getEventFlowDataHolder() const = 0; +}; + +class EventFlowExecutor : public al::HioNode, public al::IUseEventFlowData { + +}; + +} diff --git a/include/al/event/IEventFlowEventReceiver.h b/include/al/event/IEventFlowEventReceiver.h deleted file mode 100644 index a374c13..0000000 --- a/include/al/event/IEventFlowEventReceiver.h +++ /dev/null @@ -1,8 +0,0 @@ -#pragma once - -namespace al -{ - class IEventFlowEventReceiver { - - }; -} // namespace al diff --git a/include/al/execute/ExecuteDirector.h b/include/al/execute/ExecuteDirector.h new file mode 100644 index 0000000..a9b701d --- /dev/null +++ b/include/al/execute/ExecuteDirector.h @@ -0,0 +1,76 @@ +#pragma once + +#include +#include "al/hio/HioNode.h" +#include "al/execute/ExecuteTableHolder.h" + +namespace al { +class ExecuteRequestKeeper; +class ExecuteDirector : public al::HioNode { +public: + virtual ~ExecuteDirector(); + + sead::PtrArray mTableUpdate; + sead::PtrArray mTableDraw; + al::ExecuteRequestKeeper* mRequestKeeper; +}; +} + + + +/* + * ExecuteTableHolderUpdate execute order: + * 1: update 更新 + * 2: view update (core 1) ビュー更新(コア1) + * 3: view update (core 2) ビュー更新(コア2) + * 4: snapshot スナップショット + */ + + +/* + * ExecuteTableHolderDraw execute order: + * 1: 3D (culling) ３D（カリング） + * 2: 3D (depth shadow) ３D（デプスシャドウ） + * 3: 3D (depth shadow player) ３D（デプスシャドウプレイヤー） + * 4: 3D (static depth shadow) ３D（スタティックデプスシャドウ） + * 5: 3D (world AO) ３D（ワールドAo） + * 6: 3D (ocean depth) ３D（海用デプス） + * 7: 3D (sky) ３D（空） + * 8: 3D (opaque Z prepass) ３D（不透明Zプリパス） + * 9: 3D (deferred terrain) ３D（ディファード地形） + * 10: 3D (no reflection on the deferred) ３D（ディファード竸映り込みなし） + * 11: 3D (deferred character) ３D（ディファードキャラター） + * 12: 3D (deferred different space) ３D（ディファード異空間） + * 13: 3D (deferred player) ３D（ディファードプレイヤー） + * 14: 3D (deferred middle view) ３D（ディファード中景） + * 15: 3D (deferred translucent) ３D（ディファード半透明） + * 16: 3D (depth clear player) ３D（デプスクリアプレイヤー） + * 17: 3D (forward distant view) ３D（フォワード遠景） + * 18: 3D (forward player) ３D（フォワードプレイヤー） + * 19: 3D (forward) ３D（フォワード） + * 20: 3D (indirect) ３D（インダイレクト） + * 21: 3D (forward after indirect) ３D（インダイレクト後フォワード） + * 22: 3D (distant view after indirect) ３D（インダイレクト後遠景） + * 23: 3D (indirect after fog) ３D（フォグ後インダイレクト） + * 24: 3D (distant view after fog) ３D（フォグ後遠景） + * 25: 3D (after fog) ３D（フォグ後） + * 26: 3D (chroma key Z prepass) ３D（クロマキーZプリパス） + * 27: 3D (chroma key player) ３D（クロマキープレイヤー） + * 28: 3D (chroma key character) ３D（クロマキーキャラクター） + * 29: 2D back (main screen) ２Dバック（メイン画面） + * 30: 2D base (main screen) ２Dベース（メイン画面） + * 31: 2D effect (main screen) ２Dエフェクト（メイン画面） + * 32: 2D over (main screen) ２Dオーバー（メイン画面） + * 33: 2D (demo screen) ２D（デモ画面） + * 34: post effect mask ポストエフェクトマスク + * 35: actor drawing (original render target) アクター描画（独自レンダーターゲット） + * 36: actor drawing (project specific) アクター描画（プロジェクト固有） + * 37: model drawing buffer update モデル描画バッファ更新 + * 38: 3D (world map deferred) ３D（ワールドマップディファード） + * 39: 3D (world map forward) ３D（ワールドマップフォワード） + * 40: 2D (world map drawing) ２D（ワールドマップ描画） + * 41: 2D (moon get drawing) ２D（ムーンゲット描画） + * 42: 2D (snapshot) ２D（スナップショット） + * 43: 2D (for shooting) ２D（撮影用） + * 44: 2D (miss) ２D（ミス） + */ diff --git a/include/al/execute/ExecuteOrder.h b/include/al/execute/ExecuteOrder.h new file mode 100644 index 0000000..14bcda4 --- /dev/null +++ b/include/al/execute/ExecuteOrder.h @@ -0,0 +1,16 @@ +#pragma once + +namespace al { +struct ExecuteOrder { + const char* sVar1; + const char* sVar2; + int iVar1; + const char* sVar3; +}; + +struct ExecuteTableOrder { + const char* sVar1; + al::ExecuteOrder* mExecuteOrder; + int iVar1; +}; +} diff --git a/include/al/execute/ExecuteSystemInitInfo.h b/include/al/execute/ExecuteSystemInitInfo.h new file mode 100644 index 0000000..ae81861 --- /dev/null +++ b/include/al/execute/ExecuteSystemInitInfo.h @@ -0,0 +1,10 @@ +#pragma once + +#include + +namespace al { +class ExecuteSystemInitInfo { +public: + agl::DrawContext* mDrawContext; +}; +} diff --git a/include/al/execute/ExecuteTableHolder.h b/include/al/execute/ExecuteTableHolder.h new file mode 100644 index 0000000..f3f0dcb --- /dev/null +++ b/include/al/execute/ExecuteTableHolder.h @@ -0,0 +1,48 @@ +#pragma once + +#include "al/execute/ExecuteOrder.h" +#include "al/execute/ExecutorListBase.h" +#include "al/execute/ExecutorListActor.h" +#include "al/execute/ExecutorListActorModelDraw.h" +#include "al/execute/ExecutorListFunctor.h" +#include "al/execute/ExecutorListIUseExecutor.h" +#include "al/execute/ExecutorListLayout.h" +#include "al/hio/HioNode.h" +#include +#include + +namespace al { + +class ExecuteTableHolderUpdate : public al::HioNode { +public: + +}; + +class ExecuteTableHolderDraw : public al::HioNode { +public: + virtual ~ExecuteTableHolderDraw(); + ExecuteTableHolderDraw() { + mName = nullptr; + memset(&arr1, 0, 0x70); + debug_Enabled = true; + debug_ExecuteOrder = nullptr; + __asm("MOV X0, #0"); + __asm("LDR X0, [X0]"); + } + + + void execute() const; + + const char* mName; + sead::PtrArray arr1; + sead::PtrArray mListAll; + sead::PtrArray mListActor; // useless? some entries have 8 buffer size but no items + sead::PtrArray mListActorModel; + sead::PtrArray mListLayout; + sead::PtrArray mListUser; + sead::PtrArray mListFunctor; + bool debug_Enabled; + al::ExecuteOrder* debug_ExecuteOrder; +}; + +} diff --git a/include/al/execute/ExecutorActor.h b/include/al/execute/ExecutorActor.h new file mode 100644 index 0000000..b5d1887 --- /dev/null +++ b/include/al/execute/ExecutorActor.h @@ -0,0 +1,20 @@ +#pragma once + +#include "al/hio/HioNode.h" +#include "al/LiveActor/LiveActor.h" +#include + +namespace al { +class ExecutorActorExecuteBase : public al::HioNode { +public: + virtual void execute() const = 0; + + const char* mName; + sead::PtrArray mActors; +}; + +class ExecutorActorDraw : public al::ExecutorActorExecuteBase { + +}; + +} diff --git a/include/al/execute/ExecutorListActor.h b/include/al/execute/ExecutorListActor.h new file mode 100644 index 0000000..ce4a5f6 --- /dev/null +++ b/include/al/execute/ExecutorListActor.h @@ -0,0 +1,18 @@ +#pragma once + +#include "al/execute/ExecutorActor.h" +#include "al/execute/ExecutorListBase.h" +#include + +namespace al { + +class ExecutorListActorExecuteBase : public al::ExecutorListBase { +public: + sead::PtrArray mActors; +}; + +class ExecutorListActorDraw : public al::ExecutorListActorExecuteBase { + +}; + +} diff --git a/include/al/execute/ExecutorListActorModelDraw.h b/include/al/execute/ExecutorListActorModelDraw.h new file mode 100644 index 0000000..c84003f --- /dev/null +++ b/include/al/execute/ExecutorListActorModelDraw.h @@ -0,0 +1,260 @@ +#pragma once + +#include +#include "al/execute/ExecutorActor.h" +#include "al/execute/ExecutorListBase.h" +#include "al/execute/ExecuteSystemInitInfo.h" +#include "al/model/ModelDrawer.h" +#include + +namespace al { +class ExecutorListActorModelDrawBase : public al::ExecutorListBase { +public: + ExecutorListActorModelDrawBase(const char*, int, al::ExecuteSystemInitInfo const&); + virtual ~ExecutorListActorModelDrawBase(); + virtual void executeList() const; + virtual bool isActive() const; + virtual al::ModelDrawerBase* createDrawer(const char*) const = 0; + + void createList(); + void registerActorModel(al::LiveActor*); + + sead::PtrArray mActors; + agl::DrawContext* mDrawContext; +}; + +class ExecutorListActorModelDrawCharacterChromakey : public al::ExecutorListActorModelDrawBase { +public: + ExecutorListActorModelDrawCharacterChromakey(const char*, int, al::ExecuteSystemInitInfo const&); + virtual ~ExecutorListActorModelDrawCharacterChromakey(); + al::ModelDrawerChromakey* createDrawer(const char*) const override; +}; + +class ExecutorListActorModelDrawCulling : public al::ExecutorListActorModelDrawBase { +public: + ExecutorListActorModelDrawCulling(const char*, int, al::ExecuteSystemInitInfo const&); + virtual ~ExecutorListActorModelDrawCulling(); + al::ModelDrawerPrepassCulling* createDrawer(const char*) const override; +}; + +class ExecutorListActorModelDrawDeferred : public al::ExecutorListActorModelDrawBase{ +public: + ExecutorListActorModelDrawDeferred(const char*, int, al::ExecuteSystemInitInfo const&); + virtual ~ExecutorListActorModelDrawDeferred(); + al::ModelDrawerDeferred* createDrawer(const char*) const override; +}; + +class ExecutorListActorModelDrawDeferredFootPrint : public al::ExecutorListActorModelDrawBase { +public: + ExecutorListActorModelDrawDeferredFootPrint(const char*, int, al::ExecuteSystemInitInfo const&); + virtual ~ExecutorListActorModelDrawDeferredFootPrint(); + al::ModelDrawerDeferredFootPrint* createDrawer(const char*) const override; +}; + +class ExecutorListActorModelDrawDeferredMarchingCube : public al::ExecutorListActorModelDrawBase { +public: + ExecutorListActorModelDrawDeferredMarchingCube(const char*, int, al::ExecuteSystemInitInfo const&); + virtual ~ExecutorListActorModelDrawDeferredMarchingCube(); + al::ModelDrawerDeferred* createDrawer(const char*) const override; +}; + +class ExecutorListActorModelDrawDeferredOnly : public al::ExecutorListActorModelDrawBase { +public: + ExecutorListActorModelDrawDeferredOnly(const char*, int, al::ExecuteSystemInitInfo const&); + virtual ~ExecutorListActorModelDrawDeferredOnly(); + al::ModelDrawerDeferred* createDrawer(const char*) const override; +}; + +class ExecutorListActorModelDrawDeferredOpa : public al::ExecutorListActorModelDrawBase { +public: + ExecutorListActorModelDrawDeferredOpa(const char*, int, al::ExecuteSystemInitInfo const&); + virtual ~ExecutorListActorModelDrawDeferredOpa(); + al::ModelDrawerDeferred* createDrawer(const char*) const override; +}; + +class ExecutorListActorModelDrawDeferredSilhouette : public al::ExecutorListActorModelDrawBase { +public: + ExecutorListActorModelDrawDeferredSilhouette(const char*, int, al::ExecuteSystemInitInfo const&); + virtual ~ExecutorListActorModelDrawDeferredSilhouette(); + al::ModelDrawerDeferredSilhouette* createDrawer(const char*) const override; +}; + +class ExecutorListActorModelDrawDeferredSilhouetteRide : public al::ExecutorListActorModelDrawBase { +public: + ExecutorListActorModelDrawDeferredSilhouetteRide(const char*, int, al::ExecuteSystemInitInfo const&); + virtual ~ExecutorListActorModelDrawDeferredSilhouetteRide(); + al::ModelDrawerDeferredSilhouette* createDrawer(const char*) const override; +}; + +class ExecutorListActorModelDrawDeferredSky : public al::ExecutorListActorModelDrawBase { +public: + ExecutorListActorModelDrawDeferredSky(const char*, int, al::ExecuteSystemInitInfo const&); + virtual ~ExecutorListActorModelDrawDeferredSky(); + al::ModelDrawerDeferredSky* createDrawer(const char*) const override; +}; + +class ExecutorListActorModelDrawDeferredXlu : public al::ExecutorListActorModelDrawBase { +public: + ExecutorListActorModelDrawDeferredXlu(const char*, int, al::ExecuteSystemInitInfo const&); + virtual ~ExecutorListActorModelDrawDeferredXlu(); + al::ModelDrawerDeferred* createDrawer(const char*) const override; +}; + +class ExecutorListActorModelDrawDepthChromakey : public al::ExecutorListActorModelDrawBase { +public: + ExecutorListActorModelDrawDepthChromakey(const char*, int, al::ExecuteSystemInitInfo const&); + virtual ~ExecutorListActorModelDrawDepthChromakey(); + al::ModelDrawerDepthOnly* createDrawer(const char*) const override; +}; + +class ExecutorListActorModelDrawDepthDither : public al::ExecutorListActorModelDrawBase { +public: + ExecutorListActorModelDrawDepthDither(const char*, int, al::ExecuteSystemInitInfo const&); + virtual ~ExecutorListActorModelDrawDepthDither(); + al::ModelDrawerDepthOnly* createDrawer(const char*) const override; +}; + +class ExecutorListActorModelDrawDepthDitherIndirect : public al::ExecutorListActorModelDrawBase { +public: + ExecutorListActorModelDrawDepthDitherIndirect(const char*, int, al::ExecuteSystemInitInfo const&); + virtual ~ExecutorListActorModelDrawDepthDitherIndirect(); + al::ModelDrawerDepthOnly* createDrawer(const char*) const override; +}; + +class ExecutorListActorModelDrawDepthForce : public al::ExecutorListActorModelDrawBase { +public: + ExecutorListActorModelDrawDepthForce(const char*, int, al::ExecuteSystemInitInfo const&); + virtual ~ExecutorListActorModelDrawDepthForce(); + al::ModelDrawerDepthOnly* createDrawer(const char*) const override; +}; + +class ExecutorListActorModelDrawDepthIndirect : public al::ExecutorListActorModelDrawBase { +public: + ExecutorListActorModelDrawDepthIndirect(const char*, int, al::ExecuteSystemInitInfo const&); + virtual ~ExecutorListActorModelDrawDepthIndirect(); + al::ModelDrawerDepthOnly* createDrawer(const char*) const override; +}; + +class ExecutorListActorModelDrawDepthOnly : public al::ExecutorListActorModelDrawBase { +public: + ExecutorListActorModelDrawDepthOnly(const char*, int, al::ExecuteSystemInitInfo const&); + virtual ~ExecutorListActorModelDrawDepthOnly(); + al::ModelDrawerDepthOnly* createDrawer(const char*) const override; +}; + +class ExecutorListActorModelDrawDepthShadow : public al::ExecutorListActorModelDrawBase { +public: + ExecutorListActorModelDrawDepthShadow(const char*, int, al::ExecuteSystemInitInfo const&); + virtual ~ExecutorListActorModelDrawDepthShadow(); + al::ModelDrawerDepthShadow* createDrawer(const char*) const override; +}; + +class ExecutorListActorModelDrawDepthShadowMarchingCube : public al::ExecutorListActorModelDrawBase { +public: + ExecutorListActorModelDrawDepthShadowMarchingCube(const char*, int, al::ExecuteSystemInitInfo const&); + virtual ~ExecutorListActorModelDrawDepthShadowMarchingCube(); + al::ModelDrawerDepthShadow* createDrawer(const char*) const override; +}; + +class ExecutorListActorModelDrawDepthXlu : public al::ExecutorListActorModelDrawBase { +public: + ExecutorListActorModelDrawDepthXlu(const char*, int, al::ExecuteSystemInitInfo const&); + virtual ~ExecutorListActorModelDrawDepthXlu(); + al::ModelDrawerDepthOnly* createDrawer(const char*) const override; +}; + +class ExecutorListActorModelDrawDitherChromakey : public al::ExecutorListActorModelDrawBase { +public: + ExecutorListActorModelDrawDitherChromakey(const char*, int, al::ExecuteSystemInitInfo const&); + virtual ~ExecutorListActorModelDrawDitherChromakey(); + al::ModelDrawerDepthOnly* createDrawer(const char*) const override; +}; + +class ExecutorListActorModelDrawForward : public al::ExecutorListActorModelDrawBase { +public: + ExecutorListActorModelDrawForward(const char*, int, al::ExecuteSystemInitInfo const&); + virtual ~ExecutorListActorModelDrawForward(); + al::ModelDrawerForward* createDrawer(const char*) const override; +}; + +class ExecutorListActorModelDrawForwardForce : public al::ExecutorListActorModelDrawBase { +public: + ExecutorListActorModelDrawForwardForce(const char*, int, al::ExecuteSystemInitInfo const&); + virtual ~ExecutorListActorModelDrawForwardForce(); + al::ModelDrawerForward* createDrawer(const char*) const override; +}; + +class ExecutorListActorModelDrawForwardOnly : public al::ExecutorListActorModelDrawBase { +public: + ExecutorListActorModelDrawForwardOnly(const char*, int, al::ExecuteSystemInitInfo const&); + virtual ~ExecutorListActorModelDrawForwardOnly(); + al::ModelDrawerForward* createDrawer(const char*) const override; +}; + +class ExecutorListActorModelDrawForwardPostEffectMask : public al::ExecutorListActorModelDrawBase { +public: + ExecutorListActorModelDrawForwardPostEffectMask(const char*, int, al::ExecuteSystemInitInfo const&); + virtual ~ExecutorListActorModelDrawForwardPostEffectMask(); + al::ModelDrawerForward* createDrawer(const char*) const override; +}; + +class ExecutorListActorModelDrawIndirect : public al::ExecutorListActorModelDrawBase { +public: + ExecutorListActorModelDrawIndirect(const char*, int, al::ExecuteSystemInitInfo const&); + virtual ~ExecutorListActorModelDrawIndirect(); + al::ModelDrawerForward* createDrawer(const char*) const override; +}; + +class ExecutorListActorModelDrawIndirectOnly : public al::ExecutorListActorModelDrawBase { +public: + ExecutorListActorModelDrawIndirectOnly(const char*, int, al::ExecuteSystemInitInfo const&); + virtual ~ExecutorListActorModelDrawIndirectOnly(); + al::ModelDrawerForward* createDrawer(const char*) const override; +}; + +class ExecutorListActorModelDrawPlayerChromakey : public al::ExecutorListActorModelDrawBase { +public: + ExecutorListActorModelDrawPlayerChromakey(const char*, int, al::ExecuteSystemInitInfo const&); + virtual ~ExecutorListActorModelDrawPlayerChromakey(); + al::ModelDrawerChromakey* createDrawer(const char*) const override; +}; + +class ExecutorListActorModelDrawPlayerChromakeyOpa : public al::ExecutorListActorModelDrawBase { +public: + ExecutorListActorModelDrawPlayerChromakeyOpa(const char*, int, al::ExecuteSystemInitInfo const&); + virtual ~ExecutorListActorModelDrawPlayerChromakeyOpa(); + al::ModelDrawerChromakey* createDrawer(const char*) const override; +}; + +class ExecutorListActorModelDrawPlayerChromakeyXlu : public al::ExecutorListActorModelDrawBase { +public: + ExecutorListActorModelDrawPlayerChromakeyXlu(const char*, int, al::ExecuteSystemInitInfo const&); + virtual ~ExecutorListActorModelDrawPlayerChromakeyXlu(); + al::ModelDrawerChromakey* createDrawer(const char*) const override; +}; + +class ExecutorListActorModelDrawStaticDepthShadow : public al::ExecutorListActorModelDrawBase { +public: + ExecutorListActorModelDrawStaticDepthShadow(const char*, int, al::ExecuteSystemInitInfo const&); + virtual ~ExecutorListActorModelDrawStaticDepthShadow(); + al::ModelDrawerStaticDepthShadow* createDrawer(const char*) const override; +}; + +class ExecutorListActorModelDrawUpdate : public al::ExecutorListActorModelDrawBase { +public: + ExecutorListActorModelDrawUpdate(const char*, int, al::ExecuteSystemInitInfo const&); + virtual ~ExecutorListActorModelDrawUpdate(); + al::ModelDrawerBufferUpdate* createDrawer(const char*) const override; +}; + +class ExecutorListActorModelDrawWorldAo : public al::ExecutorListActorModelDrawBase { +public: + ExecutorListActorModelDrawWorldAo(const char*, int, al::ExecuteSystemInitInfo const&); + virtual ~ExecutorListActorModelDrawWorldAo(); + al::ModelDrawerWorldAo* createDrawer(const char*) const override; +}; + + + + +} diff --git a/include/al/execute/ExecutorListBase.h b/include/al/execute/ExecutorListBase.h new file mode 100644 index 0000000..cdfd7a4 --- /dev/null +++ b/include/al/execute/ExecutorListBase.h @@ -0,0 +1,15 @@ +#pragma once + +#include "al/hio/HioNode.h" + +namespace al { +class ExecutorListBase : public al::HioNode { +public: + ExecutorListBase(const char*); + virtual ~ExecutorListBase(); + virtual void executeList() const = 0; + virtual bool isActive() const = 0; + + const char* mName; +}; +} diff --git a/include/al/execute/ExecutorListFunctor.h b/include/al/execute/ExecutorListFunctor.h new file mode 100644 index 0000000..c3e4d2f --- /dev/null +++ b/include/al/execute/ExecutorListFunctor.h @@ -0,0 +1,14 @@ +#pragma once + +#include "al/async/FunctorBase.h" +#include "al/execute/ExecutorListBase.h" +#include + +namespace al { + +class ExecutorListFunctor : public al::ExecutorListBase { +public: + sead::PtrArray mFunctors; +}; + +} diff --git a/include/al/execute/ExecutorListIUseExecutor.h b/include/al/execute/ExecutorListIUseExecutor.h new file mode 100644 index 0000000..0ea3634 --- /dev/null +++ b/include/al/execute/ExecutorListIUseExecutor.h @@ -0,0 +1,22 @@ +#pragma once + +#include "al/execute/ExecutorListBase.h" +#include "al/iuse/IUseExecutor.h" +#include + +namespace al { + +class ExecutorListIUseExecutorBase : public al::ExecutorListBase { +public: + sead::PtrArray mUsers; +}; + +class ExecutorListIUseExecutorDraw : public al::ExecutorListIUseExecutorBase { + +}; + +class ExecutorListIUseExecutorUpdate : public al::ExecutorListIUseExecutorBase { + +}; + +} diff --git a/include/al/execute/ExecutorListLayout.h b/include/al/execute/ExecutorListLayout.h new file mode 100644 index 0000000..0ae0be3 --- /dev/null +++ b/include/al/execute/ExecutorListLayout.h @@ -0,0 +1,26 @@ +#pragma once + +#include "al/execute/ExecutorListBase.h" +#include "al/layout/LayoutActor.h" +#include +#include + +namespace al { + +class ExecutorListLayoutDrawBase : public al::ExecutorListBase { +public: + sead::PtrArray mLytActors; + unsigned char gap1[0x8]; +}; + +class ExecutorListLayoutDrawNormal : public al::ExecutorListLayoutDrawBase { +public: + sead::DrawContext* mDrawContext; +}; + +class ExecutorListLayoutUpdate : public al::ExecutorListBase { +public: + sead::PtrArray mLytActors; +}; + +} diff --git a/include/al/input/JoyPadAccelPoseAnalyzer.h b/include/al/input/JoyPadAccelPoseAnalyzer.h index 2da6c67..5f19ad2 100644 --- a/include/al/input/JoyPadAccelPoseAnalyzer.h +++ b/include/al/input/JoyPadAccelPoseAnalyzer.h @@ -1,6 +1,7 @@ #pragma once #include +#include "fl/efun.h" namespace al { @@ -35,7 +36,11 @@ class JoyPadAccelPoseAnalyzer { bool isSwingLeftHand() const; bool isSwingRightHand() const; void setSwingBorder(float, float); + #if SMOVER == 100 void update(); + #elif SMOVER == 130 + VVCEFUN(JoyPadAccelPoseAnalyzer, 0x005D5590, update); + #endif sead::Vector2f getSwingDirDoubleHandSameDir() const; int mControllerPort; // 0x0 port of the controller diff --git a/include/al/iuse/IEventFlowEventReceiver.h b/include/al/iuse/IEventFlowEventReceiver.h new file mode 100644 index 0000000..46e958e --- /dev/null +++ b/include/al/iuse/IEventFlowEventReceiver.h @@ -0,0 +1,8 @@ +#pragma once + +namespace al { +class IEventFlowEventReceiver { +public: + unsigned char padding[0x8]; +}; +} diff --git a/include/al/iuse/ISceneObj.h b/include/al/iuse/ISceneObj.h new file mode 100644 index 0000000..ccae770 --- /dev/null +++ b/include/al/iuse/ISceneObj.h @@ -0,0 +1,15 @@ +#pragma once + +namespace al { + +class ActorInitInfo; + +class ISceneObj { +public: + virtual const char* getSceneObjName() const = 0; + virtual ~ISceneObj(); + virtual void initAfterPlacementSceneObj(ActorInitInfo const&) = 0; + virtual void initSceneObj() = 0; +}; + +} diff --git a/include/al/iuse/IUseAreaObj.h b/include/al/iuse/IUseAreaObj.h new file mode 100644 index 0000000..c28b702 --- /dev/null +++ b/include/al/iuse/IUseAreaObj.h @@ -0,0 +1,10 @@ +#pragma once + +namespace al { +class AreaObjDirector; + +class IUseAreaObj { +public: + virtual AreaObjDirector* getAreaObjDirector() const = 0; +}; +} // namespace al diff --git a/include/al/iuse/IUseAudioKeeper.h b/include/al/iuse/IUseAudioKeeper.h new file mode 100644 index 0000000..8fa5513 --- /dev/null +++ b/include/al/iuse/IUseAudioKeeper.h @@ -0,0 +1,10 @@ +#pragma once + +namespace al { +class AudioKeeper; + +class IUseAudioKeeper { +public: + virtual AudioKeeper* getAudioKeeper() const = 0; +}; +} // namespace al diff --git a/include/al/iuse/IUseCollision.h b/include/al/iuse/IUseCollision.h new file mode 100644 index 0000000..7958c0a --- /dev/null +++ b/include/al/iuse/IUseCollision.h @@ -0,0 +1,10 @@ +#pragma once + +namespace al { +class CollisionDirector; + +class IUseCollision { +public: + virtual al::CollisionDirector* getCollisionDirector() const = 0; +}; +} // namespace al diff --git a/include/al/iuse/IUseExecutor.h b/include/al/iuse/IUseExecutor.h new file mode 100644 index 0000000..45b6d4b --- /dev/null +++ b/include/al/iuse/IUseExecutor.h @@ -0,0 +1,9 @@ +#pragma once + +namespace al { +class IUseExecutor { +public: + virtual void execute() = 0; + virtual void draw() const; +}; +} diff --git a/include/al/iuse/IUseFluidSurface.h b/include/al/iuse/IUseFluidSurface.h new file mode 100644 index 0000000..8c3fb69 --- /dev/null +++ b/include/al/iuse/IUseFluidSurface.h @@ -0,0 +1,19 @@ +#pragma once + +#include + +namespace al { +class IUseFluidSurface { +public: + virtual bool calcIsInArea(sead::Vector3f const&) const = 0; + virtual void calcPos(sead::Vector3f*, sead::Vector3f const&) const = 0; + virtual void calcPosFlat(sead::Vector3f*, sead::Vector3f const&) const = 0; + virtual void calcDisplacementPos(sead::Vector3f*, sead::Vector3f const&) const = 0; + virtual void calcNormal(sead::Vector3f*, sead::Vector3f const&) const = 0; + virtual bool tryAddRipple(sead::Vector3f const&, float, float) = 0; + virtual bool tryAddRippleWithRange(sead::Vector3f const&, float, float, float, float) = 0; + virtual bool tryAddQuadRipple(sead::Vector3f const&, sead::Vector3f const&, sead::Vector3f const&, sead::Vector3f const&, float) = 0; + virtual const char* getTypeName() const = 0; + virtual void setFieldScale(float) = 0; +}; +} diff --git a/include/al/actor/IUseName.h b/include/al/iuse/IUseName.h similarity index 66% rename from include/al/actor/IUseName.h rename to include/al/iuse/IUseName.h index 655d917..38b8ee0 100644 --- a/include/al/actor/IUseName.h +++ b/include/al/iuse/IUseName.h @@ -1,10 +1,8 @@ #pragma once -namespace al -{ - class IUseName - { +namespace al { + class IUseName { public: virtual const char* getName() const = 0; }; -}; \ No newline at end of file +}; diff --git a/include/al/iuse/IUseNerve.h b/include/al/iuse/IUseNerve.h new file mode 100644 index 0000000..ad95be2 --- /dev/null +++ b/include/al/iuse/IUseNerve.h @@ -0,0 +1,11 @@ +#pragma once + +namespace al { +class NerveKeeper; + +class IUseNerve { +public: + inline IUseNerve() {} + virtual NerveKeeper* getNerveKeeper() const = 0; +}; +} diff --git a/include/al/iuse/IUseRail.h b/include/al/iuse/IUseRail.h new file mode 100644 index 0000000..a2a7302 --- /dev/null +++ b/include/al/iuse/IUseRail.h @@ -0,0 +1,10 @@ +#pragma once + +namespace al { +class RailRider; + +class IUseRail { +public: + virtual al::RailRider* getRailRider() const = 0; +}; +} // namespace al diff --git a/include/al/iuse/IUseSceneObj.h b/include/al/iuse/IUseSceneObj.h new file mode 100644 index 0000000..e69de29 diff --git a/include/al/iuse/IUseSceneObjHolder.h b/include/al/iuse/IUseSceneObjHolder.h new file mode 100644 index 0000000..c62d92b --- /dev/null +++ b/include/al/iuse/IUseSceneObjHolder.h @@ -0,0 +1,12 @@ +#pragma once + +namespace al { +class SceneObjHolder; + +class IUseSceneObjHolder { +public: + virtual al::SceneObjHolder* getSceneObjHolder() const = 0; + static const char* sSceneObjName; +}; + +} diff --git a/include/al/iuse/IUseStageSwitch.h b/include/al/iuse/IUseStageSwitch.h new file mode 100644 index 0000000..a788614 --- /dev/null +++ b/include/al/iuse/IUseStageSwitch.h @@ -0,0 +1,13 @@ +#pragma once + +#include "al/iuse/IUseName.h" + +namespace al { +class StageSwitchKeeper; + +class IUseStageSwitch : virtual public al::IUseName { +public: + virtual al::StageSwitchKeeper* getStageSwitchKeeper() const = 0; + virtual void initStageSwitchKeeper() = 0; +}; +} diff --git a/include/al/layout/IUseLayout.h b/include/al/layout/IUseLayout.h index aca473a..a8af7e3 100644 --- a/include/al/layout/IUseLayout.h +++ b/include/al/layout/IUseLayout.h @@ -5,10 +5,10 @@ #pragma once -#include "al/actor/IUseName.h" +#include "al/iuse/IUseName.h" namespace al { class IUseLayout : public al::IUseName { }; -} \ No newline at end of file +} diff --git a/include/al/layout/LayoutActor.h b/include/al/layout/LayoutActor.h index a53f003..65320a2 100644 --- a/include/al/layout/LayoutActor.h +++ b/include/al/layout/LayoutActor.h @@ -6,16 +6,51 @@ #include "al/camera/CameraDirector.h" #include "al/audio/AudioKeeper.h" #include "al/effect/EffectKeeper.h" -#include "al/scene/SceneObjHolder.h" +#include "al/iuse/IUseSceneObjHolder.h" #include "al/message/IUseMessageSystem.h" namespace al { + class LayoutActionKeeper; +class LayoutKeeper; +class LayoutTextPaneAnimator; +class LayoutExecuteInfo; +class HitReactionKeeper; +class LayoutSceneInfo; +class LayoutPartsActorKeeper; class IUseLayoutAction { - - }; +public: + virtual al::LayoutActionKeeper* getLayoutActionKeeper() const = 0; +}; class LayoutActor : public al::IUseHioNode, public al::IUseNerve, public al::IUseLayout, public al::IUseLayoutAction, public al::IUseMessageSystem, public al::IUseCamera, public al::IUseAudioKeeper, public al::IUseEffectKeeper, public al::IUseSceneObjHolder { - + public: + virtual al::NerveKeeper* getNerveKeeper() const override; + virtual void appear(); + virtual void kill(); + virtual void movement(); + virtual void calcAnim(bool); + virtual const char* getName() const override; + virtual al::EffectKeeper* getEffectKeeper() const override; + virtual al::AudioKeeper* getAudioKeeper() const override; + virtual al::LayoutActionKeeper* getLayoutActionKeeper() const override; + virtual al::LayoutKeeper* getLayoutKeeper() const; + virtual al::CameraDirector* getCameraDirector() const override; + virtual al::SceneObjHolder* getSceneObjHolder() const override; + virtual al::MessageSystem* getMessageSystem() const override; + virtual void control(); + + sead::FixedSafeString<128> mName; + al::NerveKeeper* mNerveKeeper; + al::LayoutKeeper* mLayoutKeeper; + al::LayoutActionKeeper* mLayoutActionKeeper; + al::LayoutTextPaneAnimator* mTextPaneAnimator; + al::EffectKeeper* mEffectKeeper; + al::AudioKeeper* mAudioKeeper; + al::LayoutExecuteInfo* mExecuteInfo; + al::HitReactionKeeper* mHitReactionKeeper; + al::LayoutSceneInfo* mSceneInfo; + al::LayoutPartsActorKeeper* mPartsActorKeeper; + bool mIsAlive; }; -} \ No newline at end of file +} diff --git a/include/al/layout/RollParts.h b/include/al/layout/RollParts.h new file mode 100644 index 0000000..b287469 --- /dev/null +++ b/include/al/layout/RollParts.h @@ -0,0 +1,42 @@ +#pragma once + +#include "al/layout/LayoutActor.h" + +namespace al { +class LayoutInitInfo; + +class RollParts : public al::LayoutActor { +public: + RollParts(al::LayoutActor*, al::LayoutInitInfo const&, const char*); + + void activate(); + void activate(int); + void calcCursorTrans(sead::Vector2f*) const; + void deactivate(); + bool isJustChangeRoll() const; + bool isRoll() const; + void rollLeft(); + void rollRight(); + void setData(char16_t const**, int, bool, int, const char*); + void setSelectedIdx(int); + void startLoopAction(const char*, const char*); + void updateHeaderText(); + + char16_t** mData; + int mDataCount; + int iVar1; + bool bVar1; + const char* sVar1; + const char* sVar2; + const char* mActionChange; + const char* mActionSelect; + const char* mActionWait; + const char* mActionRightIn; + const char* mActionLeftOut; + const char* mActionRightOut; + const char* mActionLeftIn; + int iVar2; + int iVar3; + bool bVar2; +}; +} diff --git a/include/al/message/IUseMessageSystem.h b/include/al/message/IUseMessageSystem.h index bebbc57..23a557a 100644 --- a/include/al/message/IUseMessageSystem.h +++ b/include/al/message/IUseMessageSystem.h @@ -1,7 +1,10 @@ #pragma once namespace al { - class IUseMessageSystem { +class MessageSystem; - }; -} \ No newline at end of file +class IUseMessageSystem { +public: + virtual al::MessageSystem* getMessageSystem() const = 0; +}; +} diff --git a/include/al/model/ModelDrawer.h b/include/al/model/ModelDrawer.h new file mode 100644 index 0000000..831a3ce --- /dev/null +++ b/include/al/model/ModelDrawer.h @@ -0,0 +1,217 @@ +#pragma once + +#include +#include "al/hio/HioNode.h" + +namespace al { +class ModelDrawBufferCounter; +class ModelDrawDisplayList; +class MeshDrawerTable; +class GraphicsSystemInfo; +class ModelKeeper; +class ModelCtrl; +class UniformBlock; + +class ModelDrawerBase : public al::HioNode { +public: + ModelDrawerBase(const char*); + virtual ~ModelDrawerBase(); + virtual void createTable() = 0; + virtual void draw() const = 0; + virtual void registerModel(al::ModelCtrl*); + virtual void addModel(al::ModelCtrl*); + virtual void removeModel(al::ModelCtrl*); + virtual void updateModel(al::ModelCtrl*); + + bool addModelToTable(al::ModelCtrl*); + void createModelDrawDisplayList(int); + int getDrawBufferIndex() const; + bool isDraw() const; + void setDrawInfo(agl::DrawContext*, al::GraphicsSystemInfo const*, al::ModelDrawBufferCounter const*, al::ModelKeeper const*); + + const char* mName; + agl::DrawContext* mDrawContext; + al::ModelKeeper* mModelKeeper; + al::GraphicsSystemInfo* mGraphicsSystemInfo; + al::ModelDrawBufferCounter* mDrawBufferCounter; + al::ModelDrawDisplayList* mDrawDisplayList; + sead::PtrArray mTable; + al::MeshDrawerTable* mMeshDrawerTable; +}; + +class ModelDrawerBufferUpdate : public al::ModelDrawerBase { +public: + ModelDrawerBufferUpdate(const char*); + virtual ~ModelDrawerBufferUpdate(); + void createTable() override; + void draw() const override; +}; + +class ModelDrawerChromakey : public al::ModelDrawerBase { +public: + ModelDrawerChromakey(const char*, bool, bool, bool, bool); + virtual ~ModelDrawerChromakey(); + void createTable() override; + void draw() const override; + void registerModel(al::ModelCtrl*) override; + + bool bVar1; + bool mIsCharacter; + bool mIsOpa; + bool mIsXlu; +}; + +class ModelDrawerDeferred : public al::ModelDrawerBase { +public: + ModelDrawerDeferred(const char*, bool, bool, bool, bool); + virtual ~ModelDrawerDeferred(); + void createTable() override; + void draw() const override; + void addModel(al::ModelCtrl*) override; + void removeModel(al::ModelCtrl*) override; + + bool mIsOnly; + bool mIsNotXlu; + bool mIsNotOpa; + bool mIsMarchingCube; +}; + +class ModelDrawerDeferredFootPrint : public al::ModelDrawerBase { +public: + ModelDrawerDeferredFootPrint(const char*); + virtual ~ModelDrawerDeferredFootPrint(); + void createTable() override; + void draw() const override; + + sead::GraphicsContextMRT mGraphicsContext; +}; + +enum SilhouetteDrawCategory { + Default = 0, + Ride +}; + +class ModelDrawerDeferredSilhouette : public al::ModelDrawerBase { +public: + ModelDrawerDeferredSilhouette(const char*, al::SilhouetteDrawCategory); + virtual ~ModelDrawerDeferredSilhouette(); + void createTable() override; + void draw() const override; + + al::SilhouetteDrawCategory mDrawCategory; + al::UniformBlock* mUniformBlock; +}; + +class ModelDrawerDeferredSky : public al::ModelDrawerBase { +public: + ModelDrawerDeferredSky(const char*); + virtual ~ModelDrawerDeferredSky(); + void createTable() override; + void draw() const override; + + sead::GraphicsContextMRT mGraphicsContext; +}; + +class ModelDrawerDepthOnly : public al::ModelDrawerBase { +public: + ModelDrawerDepthOnly(const char*, bool, bool, bool, bool, bool); + virtual ~ModelDrawerDepthOnly(); + void createTable() override; + void draw() const override; + void registerModel(al::ModelCtrl*) override; + void addModel(al::ModelCtrl*) override; + void removeModel(al::ModelCtrl*) override; + void updateModel(al::ModelCtrl*) override; + + void createTableCulling(); + + bool bVar1; + bool mIsForce; + bool mIsDither; + bool mIsXlu; + bool mIsIndirect; + bool mIsChromakey; + bool bVar2; + al::MeshDrawerTable* uVar1; +}; + +class ModelDrawerDepthShadow : public al::ModelDrawerBase { +public: + ModelDrawerDepthShadow(const char*, bool, bool); + virtual ~ModelDrawerDepthShadow(); + void createTable() override; + void draw() const override; + void registerModel(al::ModelCtrl*) override; + void addModel(al::ModelCtrl*) override; + void updateModel(al::ModelCtrl*) override; + + bool mIsMarchingCube; +}; + +class ModelDrawerDepthShadowMap : public al::ModelDrawerBase { +public: + ModelDrawerDepthShadowMap(const char*); + virtual ~ModelDrawerDepthShadowMap(); + void createTable() override; + void draw() const override; + void removeModel(al::ModelCtrl*) override; + void updateModel(al::ModelCtrl*) override; +}; + +class ModelDrawerForward : public al::ModelDrawerBase { +public: + ModelDrawerForward(const char*, bool, bool, bool, bool, bool, bool); + virtual ~ModelDrawerForward(); + void createTable() override; + void draw() const override; + void addModel(al::ModelCtrl*) override; + void removeModel(al::ModelCtrl*) override; + + bool mIsOnly; + bool mIsPostEffectMask; + bool mIsForce; + bool mIsIndirect; + bool bVar1; + bool bVar2; +}; + +class ModelDrawerMask : public al::ModelDrawerBase { +public: + ModelDrawerMask(const char*); + virtual ~ModelDrawerMask(); + void createTable() override; + void draw() const override; + void updateModel(al::ModelCtrl*) override; +}; + +class ModelDrawerPrepassCulling : public al::ModelDrawerBase { +public: + ModelDrawerPrepassCulling(const char*); + virtual ~ModelDrawerPrepassCulling(); + void createTable() override; + void draw() const override; + void registerModel(al::ModelCtrl*) override; + void addModel(al::ModelCtrl*) override; + void updateModel(al::ModelCtrl*) override; +}; + +class ModelDrawerStaticDepthShadow : public al::ModelDrawerBase { +public: + ModelDrawerStaticDepthShadow(const char*); + virtual ~ModelDrawerStaticDepthShadow(); + void createTable() override; + void draw() const override; + void addModel(al::ModelCtrl*) override; + void removeModel(al::ModelCtrl*) override; +}; + +class ModelDrawerWorldAo : public al::ModelDrawerBase { +public: + ModelDrawerWorldAo(const char*); + virtual ~ModelDrawerWorldAo(); + void createTable() override; + void draw() const override; + void addModel(al::ModelCtrl*) override; + void removeModel(al::ModelCtrl*) override; +}; +} diff --git a/include/al/model/ModelKeeper.h b/include/al/model/ModelKeeper.h new file mode 100644 index 0000000..df4809f --- /dev/null +++ b/include/al/model/ModelKeeper.h @@ -0,0 +1,38 @@ +#pragma once + +#include "al/hio/HioNode.h" +#include + +namespace al { +class AnimPlayerSkl; +class AnimPlayerMat; +class AnimPlayerVis; +class ActorResource; +class ModelCtrl; +class DitherAnimator; +class ModelLodCtrl; + +class ModelKeeper : public al::HioNode { +public: + void setDisplayRootJointMtxPtr(sead::Matrix34f const*); + void setModelLodCtrl(al::ModelLodCtrl*); + void setDitherAnimator(al::DitherAnimator*); + + unsigned char pad[0x8]; + const char* mName; + al::ModelCtrl* mModelCtrl; + al::ActorResource* mActorResource; + al::AnimPlayerSkl* mAnimPlayerSkl; + al::AnimPlayerMat* mAnimPlayerMat1; + al::AnimPlayerMat* mAnimPlayerMat2; + al::AnimPlayerMat* mAnimPlayerMat3; + al::AnimPlayerMat* mAnimPlayerMat4; + al::AnimPlayerVis* mAnimPlayerVis1; + al::AnimPlayerVis* mAnimPlayerVis2; + sead::Matrix34f* mVar1; // array + bool bVar1; + bool bVar2; + bool bVar3; + bool bVar4; +}; +} diff --git a/include/al/nature/FluidSurfaceHolder.h b/include/al/nature/FluidSurfaceHolder.h new file mode 100644 index 0000000..a3621d9 --- /dev/null +++ b/include/al/nature/FluidSurfaceHolder.h @@ -0,0 +1,15 @@ +#pragma once + +#include "al/iuse/IUseFluidSurface.h" +#include + +namespace al { +class FluidSurfaceHolder { +public: + bool calcIsInFluid(sead::Vector3f const&, const char*); + + sead::PtrArray mSurfaces; + al::IUseFluidSurface* uVar1; + float fVar1; +}; +} diff --git a/include/al/nature/NatureDirector.h b/include/al/nature/NatureDirector.h new file mode 100644 index 0000000..a8f198d --- /dev/null +++ b/include/al/nature/NatureDirector.h @@ -0,0 +1,11 @@ +#pragma once + +#include "al/nature/FluidSurfaceHolder.h" + +namespace al { +class NatureDirector { +public: + void* gap; + al::FluidSurfaceHolder* mSurfaceHolder; +}; +} diff --git a/include/al/nerve/Nerve.h b/include/al/nerve/Nerve.h index 73c228d..25f8b6b 100644 --- a/include/al/nerve/Nerve.h +++ b/include/al/nerve/Nerve.h @@ -1,25 +1,15 @@ #pragma once +#include "al/iuse/IUseNerve.h" + namespace al { class NerveKeeper; - class IUseNerve - { - public: - - inline IUseNerve() - { - - } - - virtual NerveKeeper* getNerveKeeper() const = 0; - }; - class Nerve { public: virtual void execute(NerveKeeper *) = 0; virtual void executeOnEnd(NerveKeeper *) const; }; -}; \ No newline at end of file +}; diff --git a/include/al/nerve/NerveStateBase.h b/include/al/nerve/NerveStateBase.h index e071e53..9c105bf 100644 --- a/include/al/nerve/NerveStateBase.h +++ b/include/al/nerve/NerveStateBase.h @@ -1,11 +1,10 @@ #pragma once #include "al/nerve/NerveExecutor.h" +#include "al/LiveActor/LiveActor.h" -namespace al -{ - class NerveStateBase : public NerveExecutor - { +namespace al { + class NerveStateBase : public NerveExecutor { public: NerveStateBase(const char *); @@ -16,6 +15,14 @@ namespace al virtual bool update(); virtual void control(); - bool mIsDead; // _10 + bool mIsDead = true; }; -}; \ No newline at end of file + + class ActorStateBase : public al::NerveStateBase { + public: + ActorStateBase(const char*, al::LiveActor*); + + private: + LiveActor* mLiveActor; +}; +}; diff --git a/include/al/rail/BezierCurve.h b/include/al/rail/BezierCurve.h new file mode 100644 index 0000000..01e07cd --- /dev/null +++ b/include/al/rail/BezierCurve.h @@ -0,0 +1,30 @@ +#pragma once + +#include + +namespace al { +class BezierCurve { +public: + BezierCurve(); + void set(sead::Vector3f const&, sead::Vector3f const&, sead::Vector3f const&, sead::Vector3f const&); + + float calcLength(float, float, int) const; + void calcPos(sead::Vector3f*, float) const; + void calcVelocity(sead::Vector3f*, float) const; + float calcDeltaLength(float) const; + float calcCurveParam(float) const; + float calcNearestParam(sead::Vector3f const&) const; + float calcNearestLength(float*, sead::Vector3f const&, float) const; + void calcNearestPos(sead::Vector3f*, sead::Vector3f const&) const; + void calcStartPos(sead::Vector3f*) const; + void calcCtrlPos1(sead::Vector3f*) const; + void calcCtrlPos2(sead::Vector3f*) const; + void calcEndPos(sead::Vector3f*) const; + + sead::Vector3f mStartPos; + sead::Vector3f vVar1; + sead::Vector3f vVar2; + sead::Vector3f vVar3; + float mLength; +}; +} diff --git a/include/al/rail/LinearCurve.h b/include/al/rail/LinearCurve.h new file mode 100644 index 0000000..a27e098 --- /dev/null +++ b/include/al/rail/LinearCurve.h @@ -0,0 +1,25 @@ +#pragma once + +#include + +namespace al { +class LinearCurve { +public: + LinearCurve(); + void set(sead::Vector3f const&, sead::Vector3f const&); + + void calcPos(sead::Vector3f*, float) const; + void calcVelocity(sead::Vector3f*, float) const; + float calcLength(float, float) const; + float calcCurveParam(float) const; + float calcNearestParam(sead::Vector3f const&) const; + float calcNearestLength(float*, sead::Vector3f const&, float) const; + void calcNearestPos(sead::Vector3f*, sead::Vector3f const&) const; + void calcStartPos(sead::Vector3f*) const; + void calcEndPos(sead::Vector3f*) const; + + sead::Vector3f mStartPos; + sead::Vector3f mVector; + float mLength; +}; +} diff --git a/include/al/rail/Rail.h b/include/al/rail/Rail.h new file mode 100644 index 0000000..7674961 --- /dev/null +++ b/include/al/rail/Rail.h @@ -0,0 +1,42 @@ +#pragma once + +#include "al/actor/Placement.h" +#include + +namespace al { +class RailPart; + +class Rail { +public: + Rail(); + void init(al::PlacementInfo const&); + + void calcPos(sead::Vector3f*, float) const; + int getIncludedSection(al::RailPart const**, float*, float) const; + void calcDirection(sead::Vector3f*, float); + void calcPosDir(sead::Vector3f*, sead::Vector3f*, float) const; + float getTotalLength() const; + float getPartLength(int) const; + float getLengthToPoint(int) const; + void calcRailPointPos(sead::Vector3f*, int) const; + void calcNearestRailPointPosFast(sead::Vector3f*, unsigned int*, sead::Vector3f const&) const; + void calcNearestRailPointNo(int*, sead::Vector3f const&) const; + void calcNearestRailPointPos(sead::Vector3f*, sead::Vector3f const&) const; + float normalizeLength(float) const; + float calcNearestRailPosCoord(sead::Vector3f const&, float) const; + float calcNearestRailPosCoord(sead::Vector3f const&, float, float*) const; + void calcNearestRailPos(sead::Vector3f*, sead::Vector3f const&, float) const; + bool isNearRailPoint(float, float) const; + int calcRailPointNum(float, float) const; + void getIncludedSectionLength(float*, float*, float) const; + int getIncludedSectionIndex(float) const; + bool isIncludeBezierRailPart() const; + bool isBezierRailPart(int) const; + + al::PlacementInfo** mPlacementInfos; + al::RailPart* mParts; + int mPartCount; + int mNumPoints; + bool mIsClosed; +}; +} diff --git a/include/al/rail/RailRider.h b/include/al/rail/RailRider.h index 150d17a..481cbb6 100644 --- a/include/al/rail/RailRider.h +++ b/include/al/rail/RailRider.h @@ -1,12 +1,3 @@ #pragma once -namespace al -{ - class RailRider; - - class IUseRail - { - public: - virtual al::RailRider* getRailRider() const = 0; - }; -}; \ No newline at end of file +#include "al/iuse/IUseRail.h" diff --git a/include/al/scene/Scene.h b/include/al/scene/Scene.h index c35eff8..7b43d7b 100644 --- a/include/al/scene/Scene.h +++ b/include/al/scene/Scene.h @@ -4,11 +4,21 @@ #include #include "al/audio/AudioKeeper.h" #include "al/camera/CameraDirector.h" -#include "al/scene/SceneObjHolder.h" +#include "al/iuse/IUseSceneObjHolder.h" #include "SceneInitInfo.h" namespace al { + class LiveActorKit; + class StageResourceKeeper; + class LayoutKit; + class SceneStopCtrl; + class SceneMsgCtrl; + class SceneCoverCtrl; + class SceneObjHolder; + class AudioDirector; + class AudioKeeper; + struct DrawSystemInfo; class Scene : public al::NerveExecutor, public al::IUseAudioKeeper, public al::IUseCamera, public al::IUseSceneObjHolder { @@ -27,6 +37,17 @@ namespace al virtual al::SceneObjHolder* getSceneObjHolder(); virtual al::CameraDirector* getCameraDirector(); - unsigned char _28[0xD8-0x28]; + bool mIsAlive; + sead::FixedSafeString<64> mName; + StageResourceKeeper* mStageResourceKeeper; + LiveActorKit* mLiveActorKit; + LayoutKit* mLayoutKit; + SceneObjHolder* mSceneObjHolder; + SceneStopCtrl* mSceneStopCtrl; + SceneMsgCtrl* mSceneMsgCtrl; + SceneCoverCtrl* mSceneCoverCtrl; + AudioDirector* mAudioDirector; + AudioKeeper* mAudioKeeper; + DrawSystemInfo* mDrawSystemInfo; }; -}; \ No newline at end of file +}; diff --git a/include/al/scene/SceneObjHolder.h b/include/al/scene/SceneObjHolder.h deleted file mode 100644 index 33631a6..0000000 --- a/include/al/scene/SceneObjHolder.h +++ /dev/null @@ -1,14 +0,0 @@ -#pragma once - -namespace al -{ - class SceneObjHolder; - - class IUseSceneObjHolder - { - public: - virtual al::SceneObjHolder* getSceneObjHolder() const = 0; - - static const char* sSceneObjName; - }; -}; \ No newline at end of file diff --git a/include/al/sensor/HitSensor.h b/include/al/sensor/HitSensor.h index 0b1b064..eb2926e 100644 --- a/include/al/sensor/HitSensor.h +++ b/include/al/sensor/HitSensor.h @@ -23,23 +23,20 @@ class HitSensor { void update(); void addHitSensor(al::HitSensor*); - const char* mName; // _0 - int _8; - float _C; - float _10; - float _14; - float _18; - unsigned short mMaxSensorCount; // _1C - unsigned short mSensorCount; // _1E - al::HitSensor** mSensors; // _20 + const char* mName; + unsigned int mType; + sead::Vector3f vVar1; + float mRadius; + unsigned short mMaxSensorCount; + unsigned short mSensorCount; + al::HitSensor** mSensors; unsigned long _28; - al::SensorHitGroup* mHitGroup; // _30 - bool mIsValidBySystem; // _38 - bool mIsValid; // _39 - bool _3A[4]; // unknown type - unsigned short _3E; - al::LiveActor* mParentActor; // _40 - const sead::Vector3* mFollowPos; // _48 - const sead::Matrix34* mFollowMtx; // _50 + al::SensorHitGroup* mHitGroup; + bool mIsValidBySystem; + bool mIsValid; + al::LiveActor* mHost; + const sead::Vector3* mFollowPos; + const sead::Matrix34* mFollowMtx; + sead::Vector3f vVar2; }; -}; // namespace al \ No newline at end of file +}; // namespace al diff --git a/include/al/sensor/HitSensorKeeper.h b/include/al/sensor/HitSensorKeeper.h index a367461..0d0b127 100644 --- a/include/al/sensor/HitSensorKeeper.h +++ b/include/al/sensor/HitSensorKeeper.h @@ -1,10 +1,12 @@ #pragma once -namespace al -{ - class HitSensorKeeper - { - public: - - }; -}; \ No newline at end of file +#include "sead/container/seadPtrArray.h" + +namespace al { +class HitSensor; + +class HitSensorKeeper { +public: + sead::PtrArray mSensors; +}; +} diff --git a/include/al/sequence/Sequence.h b/include/al/sequence/Sequence.h index f140ce0..7f5f883 100644 --- a/include/al/sequence/Sequence.h +++ b/include/al/sequence/Sequence.h @@ -8,5 +8,7 @@ namespace al { class Sequence : public al::NerveExecutor, public al::IUseAudioKeeper, public al::IUseSceneCreator { public: Sequence(const char *seqName); + + void drawMain() const; }; -} \ No newline at end of file +} diff --git a/include/al/switch/StageSwitchKeeper.h b/include/al/switch/StageSwitchKeeper.h index ca79dcc..dc61b36 100644 --- a/include/al/switch/StageSwitchKeeper.h +++ b/include/al/switch/StageSwitchKeeper.h @@ -1,21 +1,10 @@ #pragma once -#include "al/actor/IUseName.h" - namespace al { - class StageSwitchKeeper; - - class IUseStageSwitch : virtual public al::IUseName - { - public: - virtual al::StageSwitchKeeper* getStageSwitchKeeper() const = 0; - virtual void initStageSwitchKeeper() = 0; - }; - class StageSwitchKeeper { public: StageSwitchKeeper(); }; -}; \ No newline at end of file +}; diff --git a/include/al/util.hpp b/include/al/util.hpp index 2a2a864..e3de696 100644 --- a/include/al/util.hpp +++ b/include/al/util.hpp @@ -2,14 +2,20 @@ namespace al { class LiveActor; - -class AreaObj { -}; - +class AreaObj; +class HitInfo; +class ICollisionPartsKeeper; +class Triangle; +class CollisionPartsFilterBase; +class TriangleFilterBase; +struct EffectUserInfo; +struct EffectSystemInfo; } namespace sead { class LogicalFrameBuffer; +class LookAtCamera; +class Projection; } #include "sead/basis/seadNew.hpp" @@ -45,6 +51,8 @@ al::LiveActor* createActorFunction(const char* name); namespace al { +void drawKit(const Scene* scene, const char* kitName); + // General Input functions #if (SMOVER == 100) @@ -68,6 +76,7 @@ bool isPadTriggerUiCursorUp(int port); bool isPadTriggerUiCursorDown(int port); bool isPadTriggerUiCursorLeft(int port); bool isPadTriggerUiCursorRight(int port); +bool isPadHold(int port, int mask); bool isPadHoldA(int port); bool isPadHoldB(int port); bool isPadHoldX(int port); @@ -108,18 +117,31 @@ bool isPadReleaseUiCursorUp(int port); bool isPadReleaseUiCursorDown(int port); bool isPadReleaseUiCursorLeft(int port); bool isPadReleaseUiCursorRight(int port); + +sead::Vector2f* getLeftStick(int); +sead::Vector2f* getRightStick(int); #endif #if (SMOVER == 130) +EFUN(0x005CFBD0, bool, isPadTriggerA, EFUN_ARGS(int port)); +EFUN(0x005CFC80, bool, isPadTriggerB, EFUN_ARGS(int port)); +EFUN(0x005CFD30, bool, isPadTriggerX, EFUN_ARGS(int port)); +EFUN(0x005CFDE0, bool, isPadTriggerY, EFUN_ARGS(int port)); +EFUN(0x005CFE90, bool, isPadTriggerZL, EFUN_ARGS(int port)); +EFUN(0x005CFF40, bool, isPadTriggerZR, EFUN_ARGS(int port)); +EFUN(0x005CFFF0, bool, isPadTriggerL, EFUN_ARGS(int port)); +EFUN(0x005D00A0, bool, isPadTriggerR, EFUN_ARGS(int port)); + EFUN(0x005D0200, bool, isPadTriggerDown, EFUN_ARGS(int port)); EFUN(0x005D0150, bool, isPadTriggerUp, EFUN_ARGS(int port)); EFUN(0x005D02B0, bool, isPadTriggerLeft, EFUN_ARGS(int port)); EFUN(0x005D0360, bool, isPadTriggerRight, EFUN_ARGS(int port)); -EFUN(0x005CFBD0, bool, isPadTriggerA, EFUN_ARGS(int port)); + EFUN(0x005D0fD0, bool, isPadHoldL, EFUN_ARGS(int port)); -#endif +EFUN(0x005D0B00, bool, isPadHold, EFUN_ARGS(int port, int mask)); -sead::Vector2f* getLeftStick(int); -sead::Vector2f* getRightStick(int); +EFUN(0x005D1770, sead::Vector2f*, getLeftStick, EFUN_ARGS(int port)); +EFUN(0x005D1830, sead::Vector2f*, getRightStick, EFUN_ARGS(int port)); +#endif // getters @@ -156,8 +178,21 @@ PlayerActorHakoniwa* getPlayerActor(al::LiveActor const*, int); PlayerActorHakoniwa* tryGetPlayerActor(al::PlayerHolder const*, int); +#if (SMOVER == 100) int getMainControllerPort(); +int getPlayerControllerPort(int); +#endif +#if (SMOVER == 130) +EFUN(0x005CF910, int, getMainControllerPort, EFUN_ARGS(void)); +EFUN(0x005CF950, int, getPlayerControllerPort, EFUN_ARGS(int)); +#endif + +#if (SMOVER == 100) int getPadAccelerationDeviceNum(int); +#endif +#if (SMOVER == 130) +EFUN(0x005D25B0, int, getPadAccelerationDeviceNum, EFUN_ARGS(int)); +#endif #if (SMOVER == 100) sead::Heap* getCurrentHeap(void); @@ -166,9 +201,15 @@ sead::Heap* getCurrentHeap(void); EFUN(0x006A4550, sead::Heap*, getCurrentHeap, EFUN_ARGS(void)); #endif +#if (SMOVER == 100) int getRandom(int, int); int getRandom(int); bool isHalfProbability(); +#endif +#if (SMOVER == 130) +EFUN(0x00692F20, int, getRandom, EFUN_ARGS(int)); +EFUN(0x00693BB0, bool, isHalfProbability, EFUN_ARGS(void)); +#endif al::Projection* getProjection(al::IUseCamera const*, int); @@ -185,12 +226,12 @@ EFUN(0x006652C0, sead::Vector3f*, getVelocity, EFUN_ARGS(const al::LiveActor*)); EFUN(0x0066DFC0, sead::Quatf*, getQuat, EFUN_ARGS(const al::LiveActor*)); #endif -int getPlayerControllerPort(int); - char const* getActionName(al::LiveActor const*); char const* getActionFrame(al::LiveActor const*); +ISceneObj* getSceneObj(al::IUseSceneObjHolder const *, int); + // setters void setTransY(al::LiveActor*, float); @@ -280,11 +321,19 @@ f32 calcDistance(al::LiveActor const*, sead::Vector3f const&); // calculates dis void calcFrontDir(sead::Vector3f* result, al::LiveActor const* actor); +void rotateVectorQuat(sead::Vector3f*, sead::Quatf const&); + // velocity stuff void addVelocity(al::LiveActor*, sead::Vector3f const&); + +#if (SMOVER == 100) void setVelocity(al::LiveActor*, sead::Vector3f const&); +#endif +#if (SMOVER == 130) +EFUN(0x006653F0, void, setVelocity, EFUN_ARGS(al::LiveActor*, const sead::Vector3f&)); +#endif void scaleVelocityExceptDirection(al::LiveActor*, sead::Vector3f const&, float); @@ -340,6 +389,10 @@ bool isSensorPlayerAttack(al::HitSensor const* targetSensor); bool sendMsgPlayerHipDropKnockDown(al::HitSensor* target, al::HitSensor* source); +sead::Vector3f& getSensorPos(al::HitSensor const*); +float getSensorRadius(al::HitSensor const*); +bool isSensorValid(al::HitSensor const*); + // audio void tryPauseBgmIfLowPriority(al::IUseAudioKeeper const* keeper, const char* audioName, int unk); @@ -385,6 +438,8 @@ void tryGetAreaObjArg(bool*, al::AreaObj const*, const char*); void tryGetAreaObjStringArg(const char**, al::AreaObj const*, const char*); +bool calcNearestAreaObjEdgePos(sead::Vector3f*, al::AreaObj const*, sead::Vector3f const&); + #if (SMOVER == 100) void offCollide(al::LiveActor*); // 0x0065d650 void onCollide(al::LiveActor*); // 0x0065d630 @@ -395,6 +450,7 @@ EFUN(0x0065D630, void, onCollide, EFUN_ARGS(al::LiveActor*)); #endif void startAction(al::LiveActor*, char const*); +void startAction(al::IUseLayoutAction*, const char*, const char*); bool tryStartSe(al::IUseAudioKeeper const*, sead::SafeStringBase const&); @@ -449,4 +505,35 @@ void setDitherAnimMaxAlpha(al::LiveActor*, float); void setDitherAnimClippingJudgeLocalOffset(al::LiveActor*, sead::Vector3f const&); void setDitherAnimClippingJudgeParam(al::LiveActor*, const char*); +#if (SMOVER == 100) +sead::LookAtCamera* getLookAtCamera(const IUseCamera*, int); +#endif +#if (SMOVER == 130) +EFUN(0x005B3D60, sead::LookAtCamera*, getLookAtCamera, EFUN_ARGS(const IUseCamera*, int)); +#endif +sead::Projection* getProjectionSead(al::IUseCamera const*, int); + +void normalize(sead::Vector3f*); +float normalize(float, float, float); + +} + +namespace alCollisionUtil { + al::LiveActor* getCollisionHitActor(al::HitInfo const*); + al::HitSensor* getCollisionHitSensor(al::HitInfo const*); + sead::Vector3f* getCollisionHitNormal(al::HitInfo const*); + sead::Vector3f* getCollisionHitPos(al::HitInfo const*); + al::CollisionParts* getCollisionHitParts(al::HitInfo const*); + + al::ICollisionPartsKeeper* getCollisionPartsKeeper(al::IUseCollision const*); + + bool getFirstPolyOnArrow(al::IUseCollision const*, sead::Vector3f*, al::Triangle*, sead::Vector3f const&, al::CollisionPartsFilterBase const*, al::TriangleFilterBase const*); +} + +namespace alEffectFunction { + al::EffectUserInfo* tryFindEffectUser(al::EffectSystemInfo const*, const char*); +} + +namespace alSensorFunction { + unsigned int findSensorTypeByName(const char*); } diff --git a/include/constants.h b/include/constants.h new file mode 100644 index 0000000..c1baef6 --- /dev/null +++ b/include/constants.h @@ -0,0 +1,12 @@ +#pragma once + +namespace constants { + +// Fadeoff distances for the rendering +// It's done in drawer.cpp like this: +// (maxDist-al::calcDistance(player, pos))/maxDist * maxAlpha +constexpr float minDist = 15000; +constexpr float maxDist = 20000; +constexpr float maxAlpha = .2; + +} // namespace constants diff --git a/include/debugMenu.hpp b/include/debugMenu.hpp index 739a62a..de01a0d 100644 --- a/include/debugMenu.hpp +++ b/include/debugMenu.hpp @@ -1,5 +1,6 @@ #pragma once +#include "sead/FrameBuffer.h" #include "sead/devenv/seadDebugFontMgrNvn.h" #include "sead/textwriter.h" #include "sead/basis/seadNew.hpp" @@ -20,4 +21,4 @@ extern bool isInGame; bool setupDebugMenu(agl::DrawContext *context, sead::Viewport *viewport); void drawBackground(agl::DrawContext *context); -void drawMainHook(HakoniwaSequence *curSequence, sead::Viewport *viewport, sead::DrawContext *drawContext); \ No newline at end of file +void drawMainHook(sead::Viewport* viewport, sead::DrawContext* drawContext, sead::LogicalFrameBuffer* frameBuffer, al::LayoutKit* layoutKit); diff --git a/include/drawer.h b/include/drawer.h new file mode 100644 index 0000000..88d555c --- /dev/null +++ b/include/drawer.h @@ -0,0 +1,27 @@ +#pragma once + +#include "al/area/AreaObjGroup.h" +#include "al/collision/KCPrism.h" +#include "al/PlayerHolder/PlayerHolder.h" +#include "al/scene/Scene.h" +#include "al/util.hpp" +#include "game/StageScene/StageScene.h" + +#include +#include + +namespace al { + class AreaObj; + class Triangle; + class HitInfo; + class LiveActorKit; +} + + +float calcFadeoff(al::LiveActor const *actor, sead::Vector3f pos2); +// bool tryDrawAreaGroup(al::Scene *curScene, char const *area, bool isDrawSolid, sead::Color4f wire, sead::Color4f solid, sead::Color4f cyl); +void drawWireTriangle(sead::PrimitiveRenderer* renderer, al::Triangle const& tri, sead::Color4f wire, sead::Color4f colorNormal, bool drawNormal); +void drawAreaObjGroup(sead::PrimitiveRenderer* renderer, al::AreaObjGroup const* group, bool isDrawSolid = false, sead::Color4f wire = sead::Color4f(0.0f, 1.0f, 0.0f, 0.1f), sead::Color4f solid = sead::Color4f(0.0f, 1.0f, 0.0f, 0.1f), sead::Color4f cyl = sead::Color4f(0.0f, 1.0f, 0.0f, 0.1f)); +void drawAreaObj(sead::PrimitiveRenderer* renderer, al::AreaObj const* area, bool isDrawSolid = false, sead::Color4f wire = sead::Color4f(0.0f, 1.0f, 0.0f, 0.5f), sead::Color4f solid = sead::Color4f(0.0f, 1.0f, 0.0f, 0.1f), sead::Color4f cyl = sead::Color4f(0.0f, 1.0f, 0.0f, 0.1f)); +void drawHitInfo(sead::PrimitiveRenderer* renderer, al::HitInfo const* hitInfo, sead::Color4f wire = sead::Color4f(0.96f, 0.96f, 0.86f, 0.8f), sead::Color4f solid = sead::Color4f(1.0f, 0.1f, 0.1f, 0.3f)); +void drawAllCollision(sead::PrimitiveRenderer* renderer, al::LiveActorKit const& liveActorKit); diff --git a/include/fl/common.h b/include/fl/common.h index 79ad8c0..0e2977a 100644 --- a/include/fl/common.h +++ b/include/fl/common.h @@ -1,6 +1,12 @@ #pragma once -#define PRACTICE_VERSTR "1.2.3" -#define PRACTICE_VER 123 +#define PRACTICE_VERSTR "1.5.0" +#define PRACTICE_VER 150 +#if SMOVER == 100 +# define GAME_VERSION "1.0.0" +#endif +#if SMOVER == 130 +# define GAME_VERSION "1.3.0" +#endif -#define MSG_NO130 "Not supported on 1.3 (currently)\n" \ No newline at end of file +#define MSG_NO130 "Not supported on 1.3 (currently)\n" diff --git a/include/fl/efun.h b/include/fl/efun.h index 2a5d37c..af4a89c 100644 --- a/include/fl/efun.h +++ b/include/fl/efun.h @@ -15,6 +15,13 @@ inline RETURN_TYPE NAME(ARGS) {\ return t_##NAME(ARG_NAMES);\ } +// void WEFUN +#define VWEFUN(ADDR, NAME, ARGS, ARG_NAMES) \ +inline void NAME(ARGS) {\ + EFUN(ADDR, void, t_##NAME, EFUN_ARGS(ARGS));\ + t_##NAME(ARG_NAMES);\ +} + // class member function with arguments and return type #define CEFUN(CLASS, ADDR, RETURN_TYPE, NAME, ARGS, ARG_NAMES) \ inline RETURN_TYPE NAME(ARGS) {\ diff --git a/include/fl/input.h b/include/fl/input.h index 7bbf90b..69f3a80 100644 --- a/include/fl/input.h +++ b/include/fl/input.h @@ -1,67 +1,20 @@ #pragma once -#include "sead/math/seadVector.h" +extern long raw_input; +extern long raw_input_prev; +extern long ext_input; -sead::Vector2f* fgetLeftStick(int port); -sead::Vector2f* fgetRightStick(int port); - -bool fisPadTriggerA(int port); -bool fisPadTriggerB(int port); -bool fisPadTriggerX(int port); -bool fisPadTriggerY(int port); -bool fisPadTriggerL(int port); -bool fisPadTriggerR(int port); -bool fisPadTriggerZL(int port); -bool fisPadTriggerZR(int port); -bool fisPadTriggerPressLeftStick(int port); -bool fisPadTriggerPressRightStick(int port); -bool fisPadTriggerPlus(int port); -bool fisPadTriggerMinus(int port); -bool fisPadTriggerUp(int port); -bool fisPadTriggerRight(int port); -bool fisPadTriggerDown(int port); -bool fisPadTriggerLeft(int port); -bool fisPadTriggerUiCursorUp(int port); -bool fisPadTriggerUiCursorDown(int port); -bool fisPadTriggerUiCursorLeft(int port); -bool fisPadTriggerUiCursorRight(int port); -bool fisPadHoldA(int port); -bool fisPadHoldB(int port); -bool fisPadHoldX(int port); -bool fisPadHoldY(int port); -bool fisPadHoldL(int port); -bool fisPadHoldR(int port); -bool fisPadHoldZL(int port); -bool fisPadHoldZR(int port); -bool fisPadHoldPressLeftStick(int port); -bool fisPadHoldPressRightStick(int port); -bool fisPadHoldPlus(int port); -bool fisPadHoldMinus(int port); -bool fisPadHoldUp(int port); -bool fisPadHoldRight(int port); -bool fisPadHoldDown(int port); -bool fisPadHoldLeft(int port); -bool fisPadHoldUiCursorUp(int port); -bool fisPadHoldUiCursorDown(int port); -bool fisPadHoldUiCursorLeft(int port); -bool fisPadHoldUiCursorRight(int port); -bool fisPadReleaseA(int port); -bool fisPadReleaseB(int port); -bool fisPadReleaseX(int port); -bool fisPadReleaseY(int port); -bool fisPadReleaseL(int port); -bool fisPadReleaseR(int port); -bool fisPadReleaseZL(int port); -bool fisPadReleaseZR(int port); -bool fisPadReleasePressLeftStick(int port); -bool fisPadReleasePressRightStick(int port); -bool fisPadReleasePlus(int port); -bool fisPadReleaseMinus(int port); -bool fisPadReleaseUp(int port); -bool fisPadReleaseRight(int port); -bool fisPadReleaseDown(int port); -bool fisPadReleaseLeft(int port); -bool fisPadReleaseUiCursorUp(int port); -bool fisPadReleaseUiCursorDown(int port); -bool fisPadReleaseUiCursorLeft(int port); -bool fisPadReleaseUiCursorRight(int port); +bool isPressed(int button); +bool isPressedPrev(int button); +bool isTriggerLeft(); +bool isTriggerRight(); +bool isTriggerUp(); +bool isTriggerDown(); +bool isHoldLeft(); +bool isHoldRight(); +bool isHoldUp(); +bool isHoldDown(); +bool isHoldA(); +bool isHoldB(); +bool isL(); +bool isTriggerPressLeftStick(); diff --git a/include/fl/nerve.h b/include/fl/nerve.h new file mode 100644 index 0000000..8b4a1ce --- /dev/null +++ b/include/fl/nerve.h @@ -0,0 +1,16 @@ +#include "al/nerve/Nerve.h" + +namespace fl { + + const uintptr_t __module_start__ = ((uintptr_t)&malloc) - 0x724B94; + + inline const al::Nerve* getNerveAt(uintptr_t offset) + { + return (al::Nerve*) (__module_start__ + offset); + } + + inline const void setNerveAt(al::IUseNerve* to, uintptr_t offset) + { + al::setNerve(to, getNerveAt(offset)); + } +} diff --git a/include/fl/packet.h b/include/fl/packet.h index 73ef9b0..7158bf1 100644 --- a/include/fl/packet.h +++ b/include/fl/packet.h @@ -19,13 +19,13 @@ namespace smo class OutPacket { public: - virtual u32 calcLen() {return 0;} - virtual void construct(u8* dst) {} + virtual u32 calcLen() const {return 0;} + virtual void construct(u8* dst) const {} }; enum InPacketType : u8 { - PlayerScriptInfo = 1, PlayerScriptData = 2, PlayerTeleport = 3, PlayerGo = 4, ChangePage = 5 + PlayerScriptInfo = 1, PlayerScriptData = 2, PlayerTeleport = 3, PlayerGo = 4, Select = 5, UINavigation = 6, PlayerScriptState = 7, }; class InPacket @@ -42,10 +42,11 @@ namespace smo { Log = 0, Warning = 1, Error = 2, Fatal = 3 }; + OutPacketLog(const char* msg) : message(msg), type(Log) {} LogType type; - char* message; - u32 calcLen(); - void construct(u8* dst); + const char* message; + u32 calcLen() const; + void construct(u8* dst) const; }; class InPacketPlayerScriptInfo : public InPacket @@ -82,11 +83,27 @@ namespace smo void on(Server& server); }; - class InPacketChangePage : public InPacket + class InPacketSelect : public InPacket { - u8 page; + u8 option; public: void parse(const u8* data, u32 len); void on(Server& server); }; -} \ No newline at end of file + + class InPacketUINavigation : public InPacket + { + long inputMask; + public: + void parse(const u8* data, u32 len); + void on(Server& server); + }; + + class InPacketPlayerScriptState : public InPacket + { + u8 state; + public: + void parse(const u8* data, u32 len); + void on(Server& server); + }; +} diff --git a/include/fl/rtti.hpp b/include/fl/rtti.hpp new file mode 100644 index 0000000..73ee530 --- /dev/null +++ b/include/fl/rtti.hpp @@ -0,0 +1,18 @@ +#pragma once + +#include +#include "al/nerve/NerveKeeper.h" + +struct RttiStl { + uintptr_t example; + const char* name; +}; + +#define RTTI_WRAP(out, in) \ +union { \ + decltype(in) underlying; \ + uintptr_t vtbl; \ + \ + inline auto GetRtti() { return *reinterpret_cast(vtbl - 8); } \ + inline bool HasRtti() { return GetRtti() != NULL; } \ +}* out = reinterpret_cast(in); diff --git a/include/fl/server.h b/include/fl/server.h index eb7f708..870f060 100644 --- a/include/fl/server.h +++ b/include/fl/server.h @@ -1,9 +1,12 @@ #pragma once #include "nn/os.hpp" +#include "packet.h" #include #include #include +#include +#include #define SERVER_PORT 7902 #define CLIENT_PORT 7901 @@ -24,9 +27,10 @@ class Server { void start(); void connect(const char* ip); void disconnect(); - void sendPacket(OutPacket& packet, OutPacketType type); + void sendPacket(const OutPacket& packet, OutPacketType type); bool isConnected(); void handlePacket(u8* buf, size_t bufSize); + void log(const char* fmt, ...); static Server& instance() { static Server s; @@ -35,4 +39,4 @@ class Server { s32 socket = -1; sockaddr server = { 0 }; }; -} \ No newline at end of file +} diff --git a/include/fl/tas.h b/include/fl/tas.h index fef66c0..1c549e2 100644 --- a/include/fl/tas.h +++ b/include/fl/tas.h @@ -22,7 +22,7 @@ namespace fl bool isRunning = false; bool startPending = false; - u64 curFrame = 0; + s64 curFrame = 0; u64 frameCount = 0; bool oldMotion = false; @@ -33,5 +33,6 @@ namespace fl void start(); void stop(); void setScriptName(char* name); + void onStageKill(); }; -} \ No newline at end of file +} diff --git a/include/fl/ui/page.h b/include/fl/ui/page.h deleted file mode 100644 index 30a0024..0000000 --- a/include/fl/ui/page.h +++ /dev/null @@ -1,26 +0,0 @@ -#pragma once - -#include - -namespace fl { -namespace ui { - - class PracticeUI; - - class Page { - public: - Page(const char* name) - : mPageName(name) - { - } - virtual ~Page() = default; - - virtual void update(PracticeUI& ui) = 0; - inline const char* getName() const { return mPageName; }; - - private: - const char* mPageName; - }; - -} // namespace ui -} // namespace fl \ No newline at end of file diff --git a/include/fl/ui/pages.h b/include/fl/ui/pages.h deleted file mode 100644 index 3555595..0000000 --- a/include/fl/ui/pages.h +++ /dev/null @@ -1,28 +0,0 @@ -#pragma once - -namespace fl { -namespace ui { - - class PracticeUI; - -#define _PAGE(N) \ - namespace N { \ - void update(fl::ui::PracticeUI&); \ - } - - _PAGE(about); - _PAGE(debug); - _PAGE(info); - _PAGE(misc); - _PAGE(modes); - _PAGE(mooninfo); - _PAGE(options); - _PAGE(stages); - _PAGE(tas); - -#undef _PAGE - -} // namespace ui -} // namespace fl - -#include "fl/ui/ui.h" \ No newline at end of file diff --git a/include/fl/ui/ui.h b/include/fl/ui/ui.h index 10fb3e7..066d8f3 100644 --- a/include/fl/ui/ui.h +++ b/include/fl/ui/ui.h @@ -1,8 +1,9 @@ #pragma once +#include "al/collision/Triangle.h" +#include "al/rail/BezierCurve.h" +#include "al/rail/LinearCurve.h" #include "debugMenu.hpp" -#include "fl/ui/page.h" -#include "fl/ui/pages.h" #include "fl/ui/ui.h" #include #include @@ -10,8 +11,19 @@ #include #include #include +#include + +#define NUMSAVES 16 +#define MAXDEPTH 16 namespace fl { + +struct SaveState { + bool mSaved = false; + sead::Vector3f mTrans = { 0, 0, 0 }; + sead::Quatf mQuat = { 0, 0, 0, 0 }; +}; + namespace ui { class Page; @@ -31,58 +43,93 @@ namespace ui { #if (SMOVER == 130) void menu(); #endif + void kill(); inline StageScene* getStageScene() { - return mStageScene; + return stageScene; } template void printf(const char* format, Args... args) { printPos += sprintf(textBuffer + printPos, format, args...); } - void toggle(const char* name, bool& value); - inline void cursor(int line) - { - if (curLine == line) - printf(">"); - } - template - void trigger(const char* name, F func) - { - cursor(curMaxLine); - printf("%s\n", name); - if (inputEnabled && !nextFrameNoRightInput && curLine == curMaxLine && al::isPadTriggerRight(CONTROLLER_AUTO)) - func(); - curMaxLine++; - } - inline void addLine() { curMaxLine++; } - - bool teleportEnabled = false; - bool shineRefresh = false; - bool gotShineRefresh = false; - bool alwaysWarp = false; - bool disableAutoSave = false; - bool skipBowser = false; - bool disablePuppet = false; - - bool isModeDiverOrJungleGymRom = false; - bool isModeDiverRom = false; - bool isModeE3LiveRom = false; - bool isModeE3MovieRom = false; - bool isModeEpdMovieRom = false; - bool isModeJungleGymRom = false; - - enum class Page : u8 { - About = 0, - Options = 1, - Stage = 2, - Misc = 3, - Info = 4, - Tas = 5, - MoonInfo = 6, - Modes = 7, - Debug = 8 + + struct { + bool teleportEnabled = false; + bool noclipEnabled = false; + bool shineRefresh = false; + bool gotShineRefresh = false; + bool alwaysWarp = false; + bool disableAutoSave = false; + bool skipBowser = false; + bool buttonMotionRoll = false; + bool moonJump = false; + bool loadCurrentFile = false; + bool loadFileConfirm = false; + bool repeatCapBounce = false; + bool repeatRainbowSpin = false; + bool wallJumpCapBounce = false; + bool disableCameraVertical = false; + bool disableCameraStop = false; + bool noDamageLife = false; + bool lockHack = false; + bool lockCarry = false; + bool disableShineNumUnlock = false; + bool showOddSpace = false; + + bool disablePuppet = false; + bool overrideBowserHat0 = false; + bool reloadDUP = false; + bool shouldRender = true; + bool muteBgm = false; + + bool pipeMazeOverride = false; + int pipeMazeConfig[3] = { 0, 0, 0 }; // 2 pipes ; 3 pipes ; 5 pipes + } options; + + struct { + bool showPlayer = false; + bool showAxis = false; + bool showArea = false; + bool showAreaPoint = false; + bool showAreaGroup = false; + bool showHitInfoFloor = false; + bool showHitInfoWall = false; + bool showHitInfoCeil = false; + bool showHitInfoArray = false; + bool showCRC = false; + al::AreaObjGroup* curAreaGroup = nullptr; + al::AreaObj* curArea = nullptr; + sead::Vector3f nearestEdgePoint = sead::Vector3f::zero; + sead::Vector3f actorTrans = sead::Vector3f::zero; +#if SMOVER == 100 + al::Triangle kclTri = al::Triangle(); +#endif + bool showHitSensors = false; + } renderer; + + struct { + bool isModeDiverOrJungleGymRom = false; + bool isModeDiverRom = false; + bool isModeE3LiveRom = false; + bool isModeE3MovieRom = false; + bool isModeEpdMovieRom = false; + bool isModeJungleGymRom = false; + } modes; + + enum Page : u8 { + Menu, About, + Options, OptionsMvmt, OptionsMoon, OptionsSave, OptionsCamera, OptionsTeleport, OptionsRenderer, OptionsPipeMaze, + Stage, Misc, + Info, InfoPlayer, InfoMoon, InfoHack, InfoCappy, InfoStatistics, InfoCamera, InfoMighty1, InfoMighty2, + Tas, Modes, Debug, + Test, TestWallAction, TestCapActionHistory, + TestLiveActorKit, TestObjectList, TestAreaList, + TestExecute, TestExecuteDraw, + TestNatureDirector, TestCollisionDirector, + TestGameDataHolder, TestGameDataFile, TestGameDataShine, + TestTalkatoo, TestOther, TestLoadingZones }; enum MofumofuPattern : s8 { @@ -123,44 +170,67 @@ namespace ui { { "Siblings", 5, false }, { "Snake", 5, true }, { "8", 6, false }, { "Mushroom", 6, true }, { "Z", 7, false }, { "Tetris", 7, true }, { "Ear", 8, false }, { "Bomb", 8, true }, { "Bird", 9, false }, { "L", 9, true }, { "O", 10, false }, { "Star", 10, true } }; - Page curPage = Page::About; - u8 curLine = 0; + Page curPage = Page::Menu; + s8 curLine = 0; + u8 maxLine = 0; bool inputEnabled = true; bool hideShineCounter = false; bool nextFrameNoLeftInput = false; bool nextFrameNoRightInput = false; + s32 actorIndex = 0; + s32 areaGroupIndex = 0; + s32 areaIndex = 0; + s32 dataShineIdx = 0; + s8 executeTableDrawIdx = 0; + s32 executeListIdx = 0; + s32 executeItemIdx = 0; + s32 itemIdx = 0; + u8 wallAction = 0; + s8 otherPageIdx = 0; + int talkatooIndex = 0; + int curWorldId = 0; + int curScenarioNo = 1; + s8 changeStageNum = 0; + s8 curDepth = 0; + s8 cursorHistory[MAXDEPTH] = { 0 }; + bool movingPage = false; + bool quatRot = false; + al::LinearCurve* linearCurve = nullptr; + al::BezierCurve* bezierCurve = nullptr; + al::LiveActor* currentActor; + s8 numDigits = 3; + + bool testDrawCube = false; + bool testDrawCylinder = false; + bool testDrawSphere = false; + private: - StageScene* mStageScene { nullptr }; + StageScene* stageScene { nullptr }; u8 curMaxLine = 0; - sead::Vector3f savedTrans; - sead::Quatf savedQuat; - bool saved = false; + SaveState savestates[NUMSAVES]; + s8 savestateIndex = 0; + bool noclipping; s8 reloadStageForPos = -1; - sead::Vector3f reloadStagePos; + sead::Vector3f reloadStageTrans; sead::Quatf reloadStageQuat; + float moonJumpVel = 50.0f; + char* demangleBuffer = static_cast(malloc(64)); + size_t demangledSize; + int cxaStatus; + al::LiveActor* currentHack; + al::HitSensor* currentCarry; + int heldDirFrames = 0; + char textBuffer[4096]; u32 printPos; - const struct { - void (*const update)(PracticeUI&) { nullptr }; - const char* const name { nullptr }; - } mPages[9] { - { fl::ui::about::update, "About" }, - { fl::ui::options::update, "Options" }, - { fl::ui::stages::update, "Stages" }, - { fl::ui::misc::update, "Miscellaneous" }, - { fl::ui::info::update, "Info" }, - { fl::ui::tas::update, "TAS" }, - { fl::ui::mooninfo::update, "Moon Info" }, - { fl::ui::modes::update, "Modes" }, - { fl::ui::debug::update, "Debug" } - }; - - void savePosition(PlayerActorHakoniwa& player); - void loadPosition(PlayerActorHakoniwa& player); + void savePosition(PlayerActorHakoniwa& player, s8 idx); + void loadPositionPlayer(PlayerActorHakoniwa& player, s8 idx); + void loadPosition(al::LiveActor* actor, s8 idx); + void toggleNoclip(PlayerActorHakoniwa& player); }; } // namespace ui -} // namespace fl \ No newline at end of file +} // namespace fl diff --git a/include/fl/util.h b/include/fl/util.h index b6bd035..42f75bd 100644 --- a/include/fl/util.h +++ b/include/fl/util.h @@ -3,6 +3,7 @@ #include "nn/init.h" #include "sead/math/seadQuat.h" #include "sead/math/seadVector.h" +#include "al/collision/Triangle.h" #define RAD(deg) (deg * (M_PI / 180)) #define DEG(rad) (rad * (180 / M_PI)) @@ -11,5 +12,6 @@ namespace fl { sead::Vector3f QuatToEuler(sead::Quatf* quat); void* memset(void* dest, int val, size_t len); void* memcpy(void* dest, const void* src, size_t len); +void fillTri(al::Triangle* tri, al::CollisionParts const& collisionParts, al::KCPrismData const* prismData, al::KCPrismHeader const* prismHeader); -} \ No newline at end of file +} diff --git a/include/game/Actors/Fastener.h b/include/game/Actors/Fastener.h new file mode 100644 index 0000000..0c19581 --- /dev/null +++ b/include/game/Actors/Fastener.h @@ -0,0 +1,38 @@ +#include "al/LiveActor/LiveActor.h" +#include "al/camera/CameraTicket.h" +#include "al/rail/Rail.h" +#include "al/rail/RailRider.h" +#include + +class CapTargetInfo; +class FixMapParts; + +class FastenerRailKeeper : public al::LiveActor { +public: + al::LiveActor* mFastener; + al::Rail* mRail; + al::RailRider* mRailRider; + float fVar1; + bool mIsShowLine; + sead::PtrArray mCameraTickets; + bool mIsFastener; + bool mIsMesh; + bool mIsInvalid; + bool mIsUncutable; + bool mIsLimitY; + bool mIsFixXZ; + bool mIsMeshInvisible; + bool mIsSplit; + int mSplitLevel; + FixMapParts* mMeshModel; + char gap1[0xb0]; +}; + + +class Fastener : public al::LiveActor { +public: + CapTargetInfo* mCapTargetInfo; + sead::PtrArray mRailKeeperArray; + FastenerRailKeeper* mRailKeepers[0x80]; + sead::PtrArrayImpl mArray2; +}; diff --git a/include/game/Actors/GrowPlantSeed.h b/include/game/Actors/GrowPlantSeed.h new file mode 100644 index 0000000..9daf670 --- /dev/null +++ b/include/game/Actors/GrowPlantSeed.h @@ -0,0 +1,69 @@ +#pragma once + +#include "al/LiveActor/LiveActor.h" +#include "al/actor/Placement.h" +#include "al/nerve/NerveStateBase.h" +#include "al/sensor/HitSensor.h" +#include "game/RouteGuide/RouteGuidePoint.h" + +#include +#include + +namespace al { +class CollisionPartsConnector; +class FlashingCtrl; +} +class SaveObjInfo; +class PlayerHoldObjTutorialController; +class MapObjStatePlayerHold; +class GrowSeedStateRevival; + +class GrowSeedStateWait : public al::ActorStateBase { +public: + class Param { + public: + float fVar1; + float fVar2; + float fVar3; + float fVar4; + float fVar5; + }; + + al::CollisionPartsConnector* mCollisionPartsConnector; + sead::Vector3f vVar1; + al::FlashingCtrl* mFlashingCtrl; + GrowSeedStateWait::Param* mParam; + sead::Quatf* qVar1; + int iVar1; + al::HitSensor* mSensor; + bool bVar1; + bool bVar2; + bool bVar3; + sead::Vector3f vVar2; +}; + +class GrowPlantSeed : public al::LiveActor, public RouteGuidePoint { +public: + al::PlacementId* mPlacementId; + SaveObjInfo* mSaveObjInfo; + unsigned char gap1[0x30]; + MapObjStatePlayerHold* mStatePlayerHold; + GrowSeedStateWait* mStateWait; + GrowSeedStateWait* mStateWaitWater; + GrowSeedStateRevival* mStateRevival; + sead::Quatf qVar1; + int iVar1; + int iVar2; + bool mIsSave; + bool bVar1; + bool bVar2; + sead::Vector3f vVar1; + int iVar3; + bool bVar3; + bool bVar4; + bool bVar5; + int iVar4; + bool bVar6; + PlayerHoldObjTutorialController* mHoldObjTutorialController; + bool bVar7; +}; diff --git a/include/game/Actors/JugemFishing.h b/include/game/Actors/JugemFishing.h new file mode 100644 index 0000000..82b0d82 --- /dev/null +++ b/include/game/Actors/JugemFishing.h @@ -0,0 +1,84 @@ +#pragma once + +#include "al/LiveActor/LiveActor.h" +#include "game/Interfaces/IUsePlayerHack.h" +#include "al/iuse/IEventFlowEventReceiver.h" +#include "al/event/EventFlowExecutor.h" +#include +#include +#include +#include "al/iuse/IUseNerve.h" +#include "al/nerve/NerveKeeper.h" + +class CapTargetInfo; +class EnemyStateHackStart; +class PlayerPushReceiver; + +namespace al { + +class ActorCameraTarget; +class CameraTicket; + +class JointControllerBase : public al::HioNode { +public: + unsigned char padding[0x8]; + sead::PtrArrayImpl mArray; + void* gap1; + void* gap2; +}; + +} + +class JugemFishingSurfaceCheckInfo { + +}; + +class JugemFishingFloatOffsetCtrl : public al::JointControllerBase, public al::IUseNerve { +public: + al::LiveActor* mActor; + JugemFishingSurfaceCheckInfo* mSurfaceCheckInfo; + al::NerveKeeper* mNerveKeeper; + sead::Matrix34f* mMat1; + sead::Matrix34f mMat2; + float fVar1; + float fVar2; +}; + +class JugemFishingHookOffsetCtrl : public al::JointControllerBase, public al::IUseNerve { +public: + al::NerveKeeper* mNerveKeeper; + JugemFishingSurfaceCheckInfo* mSurfaceCheckInfo; +}; + + +class JugemFishing : public al::LiveActor, public al::IEventFlowEventReceiver, public IUsePlayerHack { +public: + CapTargetInfo* mCapTargetInfo; + al::EventFlowExecutor* mEventFlowExecutor; + unsigned char padding[0x8]; + EnemyStateHackStart* mStateHackStart; + void* gap1; + JugemFishingFloatOffsetCtrl* mFloatOffsetCtrl; + JugemFishingHookOffsetCtrl* mHookOffsetCtrl; + void* gap2; + void* gap3; + JugemFishingSurfaceCheckInfo* mSurfaceCheckInfo; + void* gap4; + PlayerPushReceiver* mPlayerPushReceiver; + unsigned char padding1[0xc]; + sead::Vector3f vVar1; + sead::Vector3f vVar2; + unsigned char padding2[0x4]; + bool bVar1; + bool bVar2; + bool bVar3; + bool bVar4; + int iVar1; + int iVar2; + int iVar3; + al::CameraTicket* mTicket1; + al::CameraTicket* mTicket2; + al::ActorCameraTarget* mCameraTarget; + + +}; diff --git a/include/game/Actors/Killer.h b/include/game/Actors/Killer.h new file mode 100644 index 0000000..13e449e --- /dev/null +++ b/include/game/Actors/Killer.h @@ -0,0 +1,28 @@ +#pragma once + +#include "al/LiveActor/LiveActor.h" +#include "al/nerve/NerveStateBase.h" +#include "al/sensor/SensorMsg.h" +#include + +class KillerStateHack : public al::ActorStateBase { + +}; + +class Killer : public al::LiveActor { +public: + unsigned char padding[0x8]; + KillerStateHack* mStateHack; + int iVar1; + float mAliveCount; + int mHackCooldown; + sead::Vector3f mFacing; + float mTurnVel; + bool bVar1; + bool bVar2; + bool mIsMagnum; + bool bVar4; + bool bVar5; + bool bVar6; + int iVar3; +}; diff --git a/include/game/Actors/KuriboHack.h b/include/game/Actors/KuriboHack.h index 3e00007..cddf4fb 100644 --- a/include/game/Actors/KuriboHack.h +++ b/include/game/Actors/KuriboHack.h @@ -1,7 +1,77 @@ #pragma once +#include "al/actor/WaterSurfaceFinder.h" #include "al/LiveActor/LiveActor.h" +#include + +class CapTargetInfo; +class EnemyStateSwoon; +class EnemyStateReset; +class EnemyStateWander; +class ActorStateSandGeyser; +class EnemyStateBlowDown; +class JointSpringControllerHolder; +class EnemyCap; +class CollisionPartsFilterBase; +class PlayerPushReceiver; +class CollisionMultiShape; +class CollisionShapeKeeper; +class PlayerCeilingCheck; +class DisregardReceiver; + +class KuriboStateHack { + +}; class KuriboHack : public al::LiveActor { +public: + CapTargetInfo* mCapTargetInfo; + EnemyStateSwoon* mStateSwoon; + EnemyStateReset* mStateReset; + EnemyStateWander* mStateWander; + ActorStateSandGeyser* mStateSandGeyser; + KuriboStateHack* mStateHack; + EnemyStateBlowDown* mStateBlowDown; + JointSpringControllerHolder* mJointSpringControllerHolder; + bool bVar1; + EnemyCap* mEnemyCap; + bool bVar2; + KuriboHack* mChild; + bool mIsGold; + int iVar1; + CollisionPartsFilterBase* mCollisionPartsFilter; + sead::Vector3f vVar1; + float fVar1; + PlayerPushReceiver* mPushReceiver; + CollisionMultiShape* mCollisionMultiShape; + CollisionShapeKeeper* mCollisionShapeKeeper; + unsigned char padding[0x4]; + int iVar2; + int iVar3; + int iVar4; + unsigned int uVar1; + int iVar5; + int iVar6; + float fVar2; + PlayerCeilingCheck* mCeilingCheck; + bool bVar3; + sead::Vector3f mEndHackTargetPos; + int iVar7; + const char* mJointName; + sead::Matrix34f mVar1; + sead::Matrix34f mVar2; + unsigned char padding1[0x14]; + int iVar8; + al::HitSensor* mSensor1; + sead::Vector3f vVar2; + int iVar9; + al::WaterSurfaceFinder* mWaterSurfaceFinder; + sead::Matrix34f mVar3; + sead::Matrix34f mVar4; + bool bVar4; + sead::ListImpl mKuriboList; + unsigned char padding2[0x10]; + DisregardReceiver* mDisregardReceiver; + unsigned char padding3[0x8]; -}; \ No newline at end of file +}; diff --git a/include/game/Actors/Megane.h b/include/game/Actors/Megane.h new file mode 100644 index 0000000..227877a --- /dev/null +++ b/include/game/Actors/Megane.h @@ -0,0 +1,8 @@ +#pragma once + +#include "al/LiveActor/LiveActor.h" + +class Megane : public al::LiveActor { +public: + bool isWearingGlasses() const; +}; diff --git a/include/game/GameData/GameDataFile.h b/include/game/GameData/GameDataFile.h index 9f4d0b3..d8dcaf5 100644 --- a/include/game/GameData/GameDataFile.h +++ b/include/game/GameData/GameDataFile.h @@ -9,40 +9,269 @@ #include "types.h" #include "game/StageScene/ChangeStageInfo.h" #include "GameProgressData.h" +#include +#include class ChangeStageInfo; class ShineInfo; +class UniqObjInfo; +class SphinxQuizData; +class TimeBalloonSaveData; +class WorldWarpTalkData; +class VisitStageData; +class MoonRockData; +class BossSaveData; +class AchievementSaveData; +class SearchAmiiboDataTable; +class NetworkUploadFlag; +class SequenceDemoSkipData; +class HintPhotoData; +class ShopTalkData; +class RaceRecord; +class GameDataHolder; + class GameDataFile { + + public: + class HintInfo { public: + sead::FixedSafeString<128> mStageName; + sead::FixedSafeString<128> mObjId; + const char* sVar2; + sead::FixedSafeString<64> mObjectName; + sead::Vector3f mHintTrans; + sead::Vector3f mTrans; + unsigned char gap4[0x20]; + int mMainScenarioNo; + int mWorldId; + bool mIsMoonRock; + bool mIsGet; + bool mIsAchievementShine; + bool mIsGrand; + bool mIsShopShine; + int iVar2; + int mHintStatus; + int mStatus; + sead::DateTime mGetTime; + int mUniqueId; + sead::FixedSafeString<32> mOptionalId; + unsigned int mProgressBitFlag; + bool mDisableHintById; + bool bVar3; + }; + void wearCostume(char const *); void wearCap(char const *); void changeNextStage(ChangeStageInfo const*, int); + void calcShineIndexTableNameUnlockable(int* table, int* count, int worldId); #if(SMOVER==100) PlayerHitPointData* getPlayerHitPointData() const; bool isGotShine(const ShineInfo*) const; void setGotShine(const ShineInfo*); + void addCoin(int amount); #endif #if(SMOVER==130) CEFUN(GameDataFile, 0x004C65F0, s32, getScenarioNo, EFUN_ARGS(int worldId), EFUN_ARGS(worldId)); CVEFUN(GameDataFile, 0x004C8530, PlayerHitPointData*, getPlayerHitPointData); CEFUN(GameDataFile, 0x004C9700, bool, isGotShine, EFUN_ARGS(const ShineInfo* shineInfo), EFUN_ARGS(shineInfo)); VCEFUN(GameDataFile, 0x004C9880, setGotShine, EFUN_ARGS(const ShineInfo* info), EFUN_ARGS(info)); + VCEFUN(GameDataFile, 0x004CC1C0, addCoin, EFUN_ARGS(int amount), EFUN_ARGS(amount)); #endif #if SMOVER==100 - unsigned char padding_6A8[0x6A8]; + /*unsigned char padding_30[0x30]; + sead::FixedSafeString<128> mStartId; + unsigned char padding_6A8[0x6A8-0xC8]; GameProgressData *mGameProgressData; // 0x6A8 spad(gap, 0x340); - int curWorldId; + int curWorldId;*/ + + ShineInfo* mShineInfo1; + void* gap1; + ShineInfo* mLatestGetShineInfo; + int* mShopShine; + int* mQuest; + int iVar2; + sead::FixedSafeString<128> sVar1; + sead::FixedSafeString<128> sVar2; + sead::FixedSafeString<128> sVar3; + sead::FixedSafeString<128> mCheckpointName; + sead::FixedSafeString<128> mWorldStageName; + sead::FixedSafeString<128> mStageNameCurrent; + sead::FixedSafeString<128> mStageNamePrevious; + bool bVar1; + bool bVar2; + bool* mWorldWarpHoleThrough; + sead::DateTime mLastUpdateTime; + sead::DateTime mSaveTime; + unsigned char gap9[0x10]; + UniqObjInfo** uVar1; + sead::FixedSafeString<128> sVar6; + unsigned char gap10[0x18]; + void* gap11; + unsigned char gap12[0x60]; + int* mPayShineNum; + bool mIsPayShineAllInAllWorld; + int mKeyNum; + int mOpenDoorLockNum; + UniqObjInfo** uVar2; + UniqObjInfo** uVar3; + sead::FixedSafeString<128>* mPlantedSeeds; + int mCoinNum; + int mTotalCoinNum; + int mPlayerJumpCount; + int mPlayerThrowCapCount; + int* mUseCoinCollectNum; + int* gap13; + bool mIsPlayDemoOpening; + bool mIsEnableCap; + bool bVar3; + bool* mSessionMemberNum; + int mSessionEventProgress; + bool mIsPayCoinToSphinx; // jaxi + SphinxQuizData* mSphinxQuizData; + bool* mTalkLocalLanguage; + bool mIsHintNpcFirstTalk; + bool mIsKinopioBrigadeNpcFirstTalk; + int mCapStatusForJango; + int iVar9; + int mJangoCount; + TimeBalloonSaveData* mTimeBalloonSaveData; + sead::FixedSafeString<64> mWorldTravelingStatus; + bool mIsStartWorldTravelingPeach; + bool mIsPlayAlreadyWorldWarp; + bool mIsTalkFirstAmiiboNpc; + bool mIsUnlockAchievement; + WorldWarpTalkData* mWorldWarpTalkData; + VisitStageData* mVisitStageData; + GameProgressData *mGameProgressData; + MoonRockData* mMoonRockData; + BossSaveData* mBossSaveData; + AchievementSaveData* mAchievementSaveData; + SearchAmiiboDataTable* mSearchAmiiboDataTable; + NetworkUploadFlag* mNetworkUploadFlag; + SequenceDemoSkipData* mSequenceDemoSkipData; + HintPhotoData* mHintPhotoData; + ulong mPlayTimeTotal; + sead::SafeString* psVar1; // bought outfits/caps + sead::SafeString* psVar2; // bought caps/outfits + sead::SafeString* mBoughtStickers; + sead::SafeString* mBoughtSouvenirs; + sead::FixedSafeString<64> mCurrentClothName; + sead::FixedSafeString<64> mCurrentCapName; + bool mIsCostumeRandom; + bool mIsCapRandom; + void* gap17; + bool mIsRideSphinx; + bool mIsRideMotorcycle; + int* mScenarioNo; + sead::PtrArray mRaceRecords; + int iVar3; + int iVar4; + int mJumpingRopeBestCount; + int iVar1; + bool mIsExistRecordJumpingRope; + int mVolleyballBestCount; + int mVolleyballDayCount; + bool mIsExistRecordVolleyball; + bool bVar28; + int mNextWorldId; + int mPrevWorldId; + bool mIsPlayDemoPlayerDownForBattleKoopaAfter; + void* gap19; + bool mIsKidsMode; + unsigned char gap20[0x7]; + sead::PtrArrayImpl arr4; + bool mIsTalkKakku; + bool mIsTalkWorldTravelingPeach; + bool mIsTalkCollectBgmNpc; + int mTokimekiMayorNpcFavorabilityRating; + bool mFirstNetwork; + GameDataHolder* mDataHolder; + int* mShineNum; + PlayerHitPointData* mHitPointData; + sead::FixedSafeString<128> mStageNameNext; + bool mIsStageHakoniwa; + bool bVar5; + int iVar10; + sead::FixedSafeString<128> sVar9; + HintInfo* mShineList; // contains 1024 entries + sead::PtrArrayImpl arr2; + int iVar5; + int** ppiVar1; + sead::PtrArrayImpl arr3; + int iVar6; + int iVar7; + sead::SafeString sVar10; + int mWorldId; + int mWorldId2; // maybe wrong + int iVar8; + bool bVar6; + bool bVar7; + bool bVar23; + void* gap24; + bool bVar8; + bool bVar9; + bool bVar10; + int* mShinesPreMoonRock; + int* mShinesPostMoonRock; + int mAchievementShines; + unsigned char gap25[0x8]; + bool bVar11; + ChangeStageInfo* uVar4; + ChangeStageInfo* uVar5; + bool bVar12; + bool bVar13; + unsigned char gap26[0x6]; + int mWonRace; + int mRaceRivalLevel; + int mLastRaceRanking; + void* gap27; + ShopTalkData* mShopTalkData; + void* gap28; + bool mShowExplainCheckpointFlag; + unsigned char gap29[0x8]; + sead::Vector3f mHomeTrans; + bool mIsExistHome; + sead::Vector3f mRaceStartNpcTrans; + bool mIsExistRaceStartNpc; + sead::Vector3f mRaceStartTrans; + bool mIsExistRaceStart; + sead::Vector3f mRaceGoalTrans; + bool mIsExistRaceGoal; + sead::Vector3f mHintNpcTrans; + bool mIsExistHintNpc; + sead::Vector3f vVar6; + bool bVar19; + sead::Vector3f mJangoTrans; + bool mIsExistJango; + sead::Vector3f mAmiiboNpcTrans; + bool mIsExistAmiiboNpc; + sead::Vector3f mTimeBalloonNpcTrans; + bool mIsExistTimeBalloonNpc; + sead::Vector3f mPoetterTrans; + bool mIsExistPoetter; + sead::Vector3f mMoonRockTrans; + bool mIsExistMoonRock; + sead::Vector3f vVar11; + bool bVar25; + void* gap30; + unsigned char gap31[0x8]; + void* gap32; + unsigned char gap33[0xc]; + bool bVar26; + bool bVar27; #endif #if SMOVER==130 - unsigned char padding_6A8[0x6A8]; + unsigned char padding_30[0x30]; + sead::FixedSafeString<128> mStartId; + unsigned char padding_6A8[0x6A8-0xC8]; GameProgressData *mGameProgressData; // 0x6A8 undefined padding_9F0[0x1F0]; PlayerHitPointData* mPlayerHitPointData; spad(gap, 0x148); int curWorldId; #endif -}; \ No newline at end of file +}; diff --git a/include/game/GameData/GameDataFunction.h b/include/game/GameData/GameDataFunction.h index c170e71..84bd3f9 100644 --- a/include/game/GameData/GameDataFunction.h +++ b/include/game/GameData/GameDataFunction.h @@ -14,19 +14,23 @@ #include +namespace al { + class LayoutActor; +} + class GameDataFunction { public: // Gets the required number of moons required to leave a kingdom #if(SMOVER==100) - static s32 findUnlockShineNumByWorldId(bool*, GameDataHolderAccessor, int); // 0x004d53c0 - static s32 getCurrentShineNum(GameDataHolderAccessor); // 0x004d3C60 - static s32 getTotalShineNum(GameDataHolderAccessor, int); // 0x004d4490 + static s32 getCurrentShineNum(GameDataHolderAccessor); + static s32 getTotalShineNum(GameDataHolderAccessor, int); + static s32 findUnlockShineNumByWorldId(bool *, GameDataHolderAccessor, int); #endif #if(SMOVER==130) - static WEFUN(0x004D53C0, s32, findUnlockShineNumByWorldId, EFUN_ARGS(bool* something, GameDataHolderAccessor accessor, int something2), EFUN_ARGS(something, accessor, something2)); - static WEFUN(0x004D3C60, s32, getCurrentShineNum, EFUN_ARGS(GameDataHolderAccessor accessor), EFUN_ARGS(accessor)); - static WEFUN(0x004D4490, s32, getTotalShineNum, EFUN_ARGS(GameDataHolderAccessor accessor, int something), EFUN_ARGS(accessor, something)); + static WEFUN(0x004D3C60, s32, getCurrentShineNum, EFUN_ARGS(GameDataHolderAccessor *accessor), EFUN_ARGS(accessor)); + static WEFUN(0x004D4490, s32, getTotalShineNum, EFUN_ARGS(GameDataHolderAccessor *accessor, int something), EFUN_ARGS(accessor, something)); + static WEFUN(0x004D53C0, s32, findUnlockShineNumByWorldId, EFUN_ARGS(bool *something, GameDataHolderAccessor *accessor, int something2), EFUN_ARGS(something, accessor, something2)); #endif // gets prev save file's current world id static s32 getPrevWorldId(GameDataHolderAccessor); @@ -126,5 +130,14 @@ class GameDataFunction static void tryChangeNextStageWithDemoWorldWarp(GameDataHolderWriter, char const*); static void changeNextStageWithCloset(GameDataHolderWriter); - static void addCoin(GameDataHolderWriter, int); -}; \ No newline at end of file + #if(SMOVER==100) + static int getPlayTimeTotal(GameDataHolderAccessor); + static int getPlayTimeAcrossFile(GameDataHolderAccessor); + #endif + #if(SMOVER==130) + static WEFUN(0x004D2C10, int, getPlayTimeTotal, EFUN_ARGS(GameDataHolderAccessor accessor), EFUN_ARGS(accessor)); + static WEFUN(0x004D2C20, int, getPlayTimeAcrossFile, EFUN_ARGS(GameDataHolderAccessor accessor), EFUN_ARGS(accessor)); + #endif + + static const char16_t* tryFindShineMessage(al::LayoutActor const*, int, int); +}; diff --git a/include/game/GameData/GameDataHolder.h b/include/game/GameData/GameDataHolder.h index 1d42541..2c0209d 100644 --- a/include/game/GameData/GameDataHolder.h +++ b/include/game/GameData/GameDataHolder.h @@ -11,13 +11,29 @@ #include "game/StageScene/ChangeStageInfo.h" #include "game/WorldList/WorldList.h" #include "sead/prim/seadSafeString.h" +#include #include class ChangeStageInfo; class GameDataFile; -class GameDataHolder // : public GameDataHolderBase +class TempSaveData; +class CapMessageBossData; +class TemporaryScenarioCameraHolder; +class AchievementInfoReader; +class AchievementHolder; +class MapDataHolder; +class QuestInfoHolder; +class GameSequenceInfo; +class GameConfigData; +class UniqObjInfo; + +namespace al { +class ActorInitInfo; +} + +class GameDataHolder : public al::ISceneObj, public al::IUseMessageSystem // : public GameDataHolderBase { public: GameDataHolder(al::MessageSystem const *); @@ -35,6 +51,11 @@ class GameDataHolder // : public GameDataHolderBase void initializeDataId(s32); void readByamlData(s32, char const *); s32 tryFindEmptyFileId() const; + al::MessageSystem* getMessageSystem() const override; + + virtual const char* getSceneObjName() const override; + virtual void initAfterPlacementSceneObj(al::ActorInitInfo const&) override; + virtual void initSceneObj() override; bool isRequireSave() const; void setRequireSave(); @@ -55,7 +76,12 @@ class GameDataHolder // : public GameDataHolderBase VCEFUN(GameDataHolder, 0x004DB060, changeNextStage, EFUN_ARGS(const ChangeStageInfo* info, int something), EFUN_ARGS(info, something)); #endif bool tryChangeNextStageWithWorldWarpHole(char const *); + #if(SMOVER==100) void returnPrevStage(); + #endif + #if(SMOVER==130) + VVCEFUN(GameDataHolder, 0x004DB150, returnPrevStage); + #endif char* getNextStageName() const; char* getNextStageName(s32 idx) const; GameDataFile* getGameDataFile(s32 idx) const; @@ -100,11 +126,71 @@ class GameDataHolder // : public GameDataHolderBase void readFromSaveDataBufferCommonFileOnlyLanguage(); - u64* _8; - undefined8 padding; - undefined8 _padding; - GameDataFile* mDataFileArr; // 0x18 - GameDataFile* mGameDataFile; // 0x20 - unsigned char padding_190[0x168]; - WorldList *mWorldList; // 0x190 -}; \ No newline at end of file + + al::MessageSystem* mMessageSystem; + GameDataFile** mFiles; + GameDataFile* mPlayingFile; + GameDataFile* uVar1; + int mPlayingFileId; + unsigned char gap1[0x4]; + void* gap2; + bool mIsRequireSave; + int mRequireSaveFrame; + bool mIsInvalidSaveForMoonGet; + bool bVar1; + bool bVar2; + sead::BufferedSafeString mLanguage; + unsigned char gap3[0x20]; + ulong mPlayTimeAcrossFile; + sead::Heap* mHeap; + void* gap8; + GameConfigData* mGameConfigData; + TempSaveData* uVar2; + TempSaveData* uVar3; + CapMessageBossData* mCapMessageBossData; + unsigned char gap9[0x8]; + unsigned char gap10[0x4]; + unsigned char gap11[0x4]; + TemporaryScenarioCameraHolder* mTemporaryScenarioCameraHolder; + bool* mIsPlayAlreadyScenarioStartCamera; + sead::PtrArrayImpl mStageLockList; + sead::PtrArrayImpl arr1; + sead::PtrArrayImpl mItemListE3; + sead::PtrArrayImpl mItemCloth; + sead::PtrArrayImpl mItemCap; + sead::PtrArrayImpl mItemGift; + sead::PtrArrayImpl mItemSticker; + sead::PtrArray mHackObj; + sead::PtrArrayImpl arr2; + void* gap12; + int iVar1; + AchievementInfoReader* mAchievementInfoReader; + AchievementHolder* mAchievementHolder; + WorldList* mWorldList; + sead::PtrArrayImpl mChangeStageList; + sead::PtrArrayImpl mExStageList; + sead::PtrArrayImpl mInvalidOpenMapList; + sead::PtrArray mShowHackTutorialList; + bool* mIsShowBindTutorial; + MapDataHolder* mMapDataHolder; + int iVar2; + void** gap13; + int* mCoinCollectNumMax; + int* piVar1; + void* gap14; + int iVar3; + UniqObjInfo* mLocationName; + bool bVar3; + unsigned char gap15[0x7]; + bool mIsEnableCheckpointWarp; + sead::Vector3f mStageMapPlayerPos; + sead::Vector3f (*mCoinTransForDeadPlayer)[8]; + unsigned char gap17[0x4]; + bool bVar5; + bool mIsSeparatePlay; + bool bVar6; + QuestInfoHolder* mQuestInfoHolder; + bool bVar7; + GameSequenceInfo* mGameSequenceInfo; + void* gap18; +}; diff --git a/include/game/GameData/GameDataHolderBase.h b/include/game/GameData/GameDataHolderBase.h index 43e74d5..c20906e 100644 --- a/include/game/GameData/GameDataHolderBase.h +++ b/include/game/GameData/GameDataHolderBase.h @@ -1,17 +1,10 @@ #pragma once -namespace al -{ - class ISceneObj { - - }; -}; - - #include "al/hio/HioNode.h" +#include "al/iuse/ISceneObj.h" #include "al/message/IUseMessageSystem.h" class GameDataHolderBase : public al::ISceneObj, public al::IUseMessageSystem, public al::HioNode { public: -}; \ No newline at end of file +}; diff --git a/include/game/GameDataHolderAccessor.h b/include/game/GameDataHolderAccessor.h deleted file mode 100644 index 77c0129..0000000 --- a/include/game/GameDataHolderAccessor.h +++ /dev/null @@ -1,19 +0,0 @@ -/** - * @file GameDataHolderAccessor.h - * @brief Wrapper class for GameDataHolder. - */ - -#pragma once - -#include "../al/scene/Scene.h" -#include "../types.h" -#include "GameDataHolder.h" - -class GameDataHolderAccessor -{ - public: - GameDataHolderAccessor(al::IUseSceneObjHolder const *); - GameDataHolderAccessor(al::SceneObjHolder const *); - - GameDataHolder *holder; -}; \ No newline at end of file diff --git a/include/game/Interfaces/IJudge.h b/include/game/Interfaces/IJudge.h new file mode 100644 index 0000000..22c49b3 --- /dev/null +++ b/include/game/Interfaces/IJudge.h @@ -0,0 +1,8 @@ +#pragma once + +class IJudge { +public: + virtual void reset() = 0; + virtual void update() = 0; + virtual bool judge() const = 0; +}; diff --git a/include/game/Interfaces/IUsePlayerCollision.h b/include/game/Interfaces/IUsePlayerCollision.h new file mode 100644 index 0000000..49d49e9 --- /dev/null +++ b/include/game/Interfaces/IUsePlayerCollision.h @@ -0,0 +1,17 @@ +#pragma once + +class PlayerCollider; + +class IUsePlayerCollision { +public: + virtual PlayerCollider* getPlayerCollider() const; + virtual bool isEnableStandUp() const; + virtual bool isEnableHoldUp() const; + virtual bool isPressedCeil() const; + virtual float getSafetyCeilSpace() const; + virtual float getCeilCheckHeight() const; + virtual bool isAboveGround() const; + virtual float getGroundHeight() const; + virtual float getShadowDropHeight() const; + virtual float getFallDistance() const; +}; diff --git a/include/game/Layouts/CommonVerticalList.h b/include/game/Layouts/CommonVerticalList.h new file mode 100644 index 0000000..6f3fe82 --- /dev/null +++ b/include/game/Layouts/CommonVerticalList.h @@ -0,0 +1,105 @@ +#pragma once + +#include "al/layout/LayoutActor.h" +#include "al/layout/RollParts.h" +#include "al/nerve/NerveExecutor.h" +#include "nn/ui2d/Texture.h" +#include +#include + +namespace al { +class LayoutInitInfo; +} +class CursorParts; +class RollPartsData; +class ScrollBarParts; + +class CommonVerticalList : public al::NerveExecutor { +public: + CommonVerticalList(al::LayoutActor*, al::LayoutInitInfo const&); + ~CommonVerticalList(); + void initData(int); + void initDataNoResetSelected(int); + void initDataWithIdx(int, int, int); + + void appearCursor(); + void hideCursor(); + void endCursor(); + + void up(); + void pageUp(); + void jumpTop(); + void down(); + void pageDown(); + void jumpBottom(); + void rollRight(); + void rollLeft(); + void decide(); + void reject(); + + void addGroupAnimData(sead::FixedSafeString<64> const*, const char*); + void addStringData(sead::WFixedSafeString<512> const*, const char*); + float calcAnimRate(); + void calcCursorPos(sead::Vector2f*) const; + int getListPartsNum() const; + al::RollParts* getParts(int) const; + int getRollPartsSelected(int) const; + al::RollParts* getSelectedParts() const; + void setEnableData(bool const*); + void setImageData(nn::ui2d::TextureInfo**, const char*); + void setRollPartsData(RollPartsData*); + void setRollPartsSelected(int, int); + void setSelectedIdx(int, int); + void update(); + void updateCursorPos(); + void updateParts(); + + bool isActive() const; + bool isDeactive() const; + bool isDecideEnd() const; + bool isRejectEnd() const; + + void activate(); + void deactivate(); + void hideAll(); + void startLoopActionAll(const char*, const char*); + + void exeActive(); + void exeDeactive(); + void exeDecide(); + void exeDecideEnd(); + void exeReject(); + void exeRejectEnd(); + + al::LayoutActor* mLyt; + sead::PtrArray mRollParts; + CursorParts* mParCursor; + ScrollBarParts* mParScroll; + int iVar1; + int mCursorIdx; + int mTopIdx; + int mPrevCursorIdx; + int mPrevTopIdx; + float fVar1; + int mDelayFrame; + int iVar7; + float fVar2; + sead::Vector2f mCursorPos; + bool bVar1; + bool bVar2; + int iVar8; + sead::WFixedSafeString<512>** mStringData; + sead::FixedSafeString<128>* uVar1; + nn::ui2d::TextureInfo** uVar2; + nn::ui2d::TextureInfo* uVar3; + bool* mEnableData; + int mStringDataCount; + int mItemCount; + char* sVar1; + void* mGroupAnimData; + int mGroupAnimDataCount; + RollPartsData* mRollPartsData; + int* mRollPartsSelected; + float fVar3; + bool bVar3; +}; diff --git a/include/game/Layouts/ShineListLayout.h b/include/game/Layouts/ShineListLayout.h new file mode 100644 index 0000000..d02280e --- /dev/null +++ b/include/game/Layouts/ShineListLayout.h @@ -0,0 +1,97 @@ +#pragma once + +#include "al/layout/LayoutActor.h" +//#include "al/layout/SimpleLayoutAppearWaitEnd.h" +#include +#include + +class MapTerrainLayout; +class CommonVerticalList; +namespace al { +class LayoutInitInfo; +class RollParts; +class SimpleLayoutAppearWaitEnd; +} + +class ShineListLayout : public al::LayoutActor { +public: + ShineListLayout(al::LayoutInitInfo const&); + void appear() override; + void control() override; + void appearPosLayout(); + void endPosLayout(); + + void up(); // 1 + void upTrigger(); // 2 + void down(); // 3 + void downTrigger(); // 4 + void right(); // 5 + void rightTrigger(); // 6 + void left(); // 7 + void leftTrigger(); // 8 + void decide(); // 9 + void pageDownTrigger(); // 10 + void pageUpTrigger(); // 11 + + void calcCursorPos(sead::Vector2f*) const; + void calcTransOnMap(sead::Vector2f*, sead::Vector3f const&, sead::Matrix44f const&); + int getSelectedWorldId() const; + int getWorldShineNum(al::LayoutActor const*, int) const; + void setSelectedWorld(int); + void updatePosLayout(bool); + void updateWorldInfo(); + + bool isClosing() const; + bool isCompleteCollectCoin() const; + bool isCompleteShine() const; + bool isEnableChangePage() const; + bool isEnableInput() const; + + void cancel(); + void changeIn(bool); + void changeOut(bool); + void deactivate(); + void jumpAchievement(); + + // nerves + void exeAppear(); + void exeChangeIn(); + void exeChangeOut(); + void exeDeactive(); + void exeEnd(); + void exeList(); + void exeWorldRoll(); + + + CommonVerticalList* mVerticalList; + sead::WFixedSafeString<512>* mTxtContent; + sead::WFixedSafeString<512>* mTxtNumber00; + sead::WFixedSafeString<512>* mTxtNumber01; + sead::WFixedSafeString<512>* mTxtValue; + sead::WFixedSafeString<512>* mTxtIcon; + sead::FixedSafeString<64>* mOnOff; + sead::FixedSafeString<64>* mState; + char16_t** mWorldNames; + sead::PtrArray mShineListPos; + sead::PtrArray mShineListPosSelect; + al::RollParts* mRollParts; + al::SimpleLayoutAppearWaitEnd* mShineListAchieve; + int mWorldTotalShineNum; + int mWorldIdx; + int mWorldCount; + int* mTopIndices; + int* mCursorIndices; + unsigned char gap1[0x8]; + int mInput; + int iVar2; + MapTerrainLayout* mMapTerrainLayout; + bool bVar1; + bool bVar2; + al::LayoutActor* mParCounter00; + al::LayoutActor* mParCounter01; + al::LayoutActor* mParFooter; + int iVar3; + int mCursorIdx; + int iVar5; + int iVar6; +}; diff --git a/include/game/Player/HackCap.h b/include/game/Player/HackCap.h index f8aa404..0edd763 100644 --- a/include/game/Player/HackCap.h +++ b/include/game/Player/HackCap.h @@ -7,6 +7,27 @@ #include "al/LiveActor/LiveActor.h" +namespace al { +class PadRumbleKeeper; +class WaterSurfaceFinder; +class ActorDitherAnimator; +} +class IUsePlayerCollision; +class PlayerAreaChecker; +class PlayerSeparateCapFlag; +class IUsePlayerHeightCheck; +class PlayerWetControl; +class PlayerJointControlKeeper; +class PlayerColliderHackCap; +class HackCapTrigger; +class HackCapAboveGroundChecker; +class HackCapThrowParam; +class CapTargetInfo; +class PlayerEyeSensorHitHolder; +class HackCapJointControlKeeper; +class PlayerWallActionHistory; +class PlayerCapActionHistory; + #define HACKSIZE sizeof(al::LiveActor) class HackCap : public al::LiveActor { @@ -22,8 +43,90 @@ class HackCap : public al::LiveActor { bool isFlying(void) const; - unsigned char padding_118[0x118 - HACKSIZE]; - al::LiveActor *mActorA; // 0x118 - unsigned char padding_08[0x08]; - al::LiveActor *mPlayerActor; // 0x128 -}; \ No newline at end of file + unsigned char padding_108[0x108 - HACKSIZE]; + al::LiveActor* mActorDisplayHat; + al::LiveActor* mActorDepthShadow; + al::LiveActor* mActorEyes; + al::LiveActor* mActorThrownEyes; + al::LiveActor* mPlayerActor; + IUsePlayerCollision* mPlayerCollision; + char* mCapModelName; + PlayerAreaChecker* mJudgeInWater; + PlayerSeparateCapFlag* mSeparateCapFlag; + IUsePlayerHeightCheck* mPlayerHeightCheck; + PlayerWetControl* mPlayerWetControl; + PlayerJointControlKeeper* mPlayerJointControlKeeper; + PlayerColliderHackCap* mPlayerColliderHackCap; + al::WaterSurfaceFinder* mWaterSurfaceFinder; + al::PadRumbleKeeper* mPadRumbleKeeper; + PlayerWetControl* mHackCapWetControl; + HackCapTrigger* mHackCapTrigger; + al::ActorDitherAnimator* mDitherAnimator; + HackCapAboveGroundChecker* mAboveGroundChecker; + al::LiveActor** uVar1; + int iVar1; + int iVar2; + int iVar3; + al::LiveActor** uVar2; + int iVar4; + int iVar5; + int iVar6; + al::HitSensor* uVar3; + al::HitSensor* mSensorAttack; + sead::Vector3f mSensorTail1; + sead::Vector3f mSensorTail2; + sead::Vector3f mSensorTail3; + sead::Vector3f mSensorTail4; + sead::Vector3f mSensorTail5; + HackCapThrowParam* mThrowParam; + CapTargetInfo* gap3; + CapTargetInfo* mCapTargetInfo; + void* uVar4; + sead::Vector3f vVar1; + sead::Vector3f vVar2; + sead::Vector3f vVar3; + float fVar1; + float fVar2; + float fVar3; + float fVar4; + float fVar5; + int iVar7; + int iVar8; + float fVar6; + int iVar9; + int iVar10; + int iVar11; + int iVar12; + int iVar13; + bool bVar1; + bool bVar2; + bool bVar3; + bool bVar4; + bool bVar5; + bool bVar6; + bool bVar7; + bool bVar8; + bool bVar9; + bool bVar10; + bool bVar11; + bool bVar12; + bool bVar13; + bool bVar14; + bool bVar15; + bool bVar16; + bool bVar17; + bool bVar18; + PlayerWallActionHistory* mWallActionHistory; + PlayerCapActionHistory* mCapActionHistory; + PlayerInput* mPlayerInput; + PlayerEyeSensorHitHolder* mPlayerEyeSensorHitHolder1; + PlayerEyeSensorHitHolder* mPlayerEyeSensorHitHolder2; + sead::Vector3f mPos1; + sead::Vector3f mPos2; + sead::Vector3f mPos3; + sead::Vector3f mPos4; + bool bVar19; + bool bVar20; + bool bVar21; + HackCapJointControlKeeper* mJointControlKeeper; +}; diff --git a/include/game/Player/PlayerAction.h b/include/game/Player/PlayerAction.h new file mode 100644 index 0000000..9cfc07c --- /dev/null +++ b/include/game/Player/PlayerAction.h @@ -0,0 +1,45 @@ +#pragma once + +#include +#include "al/LiveActor/LiveActor.h" +#include "game/Player/PlayerConst.h" +#include "game/Player/PlayerInput.h" +#include "game/Interfaces/IUsePlayerCollision.h" +#include "game/Interfaces/IUsePlayerHack.h" + +class PlayerActionDiveInWater; +class PlayerActionTurnControl; + +class PlayerActionAirMoveControl { +public: + al::LiveActor* mActor; + PlayerConst* mPlayerConst; + PlayerInput* mPlayerInput; + IUsePlayerCollision* mCollider; + IUsePlayerHack* mHackKeeper; + PlayerActionTurnControl* mActionTurnControl; + bool bVar1; + bool bVar2; + bool bVar3; + bool bVar4; + int mExtendFrame; + int iVar1; + int iVar2; + bool bVar5; + bool bVar6; + bool bVar7; + float fVar1; + float fVar2; + sead::Vector3f vVar1; + sead::Vector3f vVar2; + float fVar3; + float fVar4; + float mFallSpeedMax; + bool bVar8; + sead::Vector3f vVar3; + float fVar5; + sead::Vector3f vVar4; +}; + +class PlayerActionGroundMoveControl; +class PlayerActionCollisionSnap; diff --git a/include/game/Player/PlayerActorBase.h b/include/game/Player/PlayerActorBase.h index b7eebd6..95efcf0 100644 --- a/include/game/Player/PlayerActorBase.h +++ b/include/game/Player/PlayerActorBase.h @@ -11,5 +11,5 @@ class PlayerActorBase : public al::LiveActor , public IUsePlayerHack { public: - PlayerHackKeeper getPlayerHackKeeper(); -}; \ No newline at end of file + PlayerHackKeeper* getPlayerHackKeeper() const; +}; diff --git a/include/game/Player/PlayerActorHakoniwa.h b/include/game/Player/PlayerActorHakoniwa.h index 08fac09..260ef39 100644 --- a/include/game/Player/PlayerActorHakoniwa.h +++ b/include/game/Player/PlayerActorHakoniwa.h @@ -20,6 +20,128 @@ #define PACTORSIZE 0xC8 +namespace al { + class WaterSurfaceFinder; + class FootPrintHolder; +} + +class PlayerStainControl; +class PlayerColliderHakoniwa; +class PlayerInfo; +class PlayerConst; + +class PlayerTrigger; + class HackCap; + class ActorDimensionKeeper; + class PlayerModelKeeper; + class PlayerModelChangerHakoniwa; + class PlayerAnimator; + class PlayerColliderHakoniwa; + class PlayerPuppet; + class PlayerAreaChecker; + class PlayerDamageKeeper; + class PlayerDemoActionFlag; + class PlayerCapActionHistory; + class PlayerCapManHeroEyesControl; + class PlayerContinuousJump; + class PlayerContinuousLongJump; + class PlayerCounterAfterUpperPunch; + class PlayerCounterForceRun; + class PlayerCounterIceWater; + class PlayerCounterQuickTurnJump; + class PlayerWallActionHistory; + class PlayerBindKeeper; + class PlayerCarryKeeper; + class PlayerEquipmentUser; + class PlayerHackKeeper; + class PlayerFormSensorCollisionArranger; + class PlayerJumpMessageRequest; + class PlayerSandSinkAffect; + class PlayerSpinCapAttack; + class PlayerActionDiveInWater; + class PlayerEffect; + class PlayerEyeSensorHitHolder; + class PlayerPushReceiver; + class PlayerHitPush; + class PlayerJointControlKeeper; + class PlayerPainPartsKeeper; + class PlayerRecoverySafetyPoint; + class PlayerRippleGenerator; + class PlayerSeparateCapFlag; + class PlayerWetControl; + class PlayerStainControl; + class GaugeAir; + class WaterSurfaceShadow; + class WorldEndBorderKeeper; + class PlayerSeCtrl; + class PlayerStateWait; + class PlayerStateSquat; + class PlayerStateRunHakoniwa2D3D; + class PlayerStateSlope; + class PlayerStateRolling; + class PlayerStateSpinCap; + class PlayerStateJump; + class PlayerStateCapCatchPop; + class PlayerStateWallAir; + class PlayerStateGrabCeil; + class PlayerStatePoleClimb; + class PlayerStateHipDrop; + class PlayerStateHeadSliding; + class PlayerStateLongJump; + class PlayerStateFallHakoniwa; + class PlayerStateSandSink; + class ActorStateSandGeyser; + class PlayerStateRise; + class PlayerStateSwim; + class PlayerStateDamageLife; + class PlayerStateDamageSwim; + class PlayerStateDamageFire; + class PlayerStatePress; + class PlayerStateBind; + class PlayerStateHack; + class PlayerStateEndHack; + class PlayerStateCameraSubjective; + class PlayerStateAbyss; + class PlayerJudgeAirForceCount; + class PlayerJudgeCameraSubjective; + class PlayerJudgeCapCatchPop; + class PlayerJudgeDeadWipeStart; + class PlayerJudgeDirectRolling; + class PlayerJudgeForceLand; + class PlayerJudgeForceSlopeSlide; + class PlayerJudgeForceRolling; + class PlayerJudgeGrabCeil; + class PlayerJudgeInWater; + class PlayerJudgeInWater; + class PlayerJudgeInWater; + class PlayerJudgeInWater; + class PlayerJudgeInvalidateInputFall; + class PlayerJudgeLongFall; + class PlayerJudgeOutInWater; + class PlayerJudgeRecoveryLifeFast; + class PlayerJudgeSandSink; + class PlayerJudgeSpeedCheckFall; + class PlayerJudgeStartHipDrop; + class PlayerJudgeStartRise; + class PlayerJudgeStartRolling; + class PlayerJudgeStartRun; + class PlayerJudgeStartSquat; + class PlayerJudgeStartWaterSurfaceRun; + class PlayerJudgeSlopeSlide; + class PlayerJudgePoleClimb; + class PlayerJudgePreInputJump; + class PlayerJudgePreInputCapThrow; + class PlayerJudgePreInputHackAction; + class HackCapJudgePreInputHoveringJump; + class HackCapJudgePreInputSeparateThrow; + class HackCapJudgePreInputSeparateJump; + class PlayerJudgeWallCatch; + class PlayerJudgeWallCatchInputDir; + class PlayerJudgeWallHitDown; + class PlayerJudgeWallHitDownForceRun; + class PlayerJudgeWallHitDownRolling; + class PlayerJudgeWallKeep; + class PlayerActorHakoniwa : public PlayerActorBase , public IUseDimension { public: int *getPortNo(void) const; @@ -37,18 +159,128 @@ class PlayerActorHakoniwa : public PlayerActorBase , public IUseDimension { void tryActionStartSpinAttack(); unsigned char padding_E8[0xE8 - PACTORSIZE]; int portNo; // 0xE8 - unsigned char padding_138[0x48]; + unsigned char padding_138[0x38]; + PlayerInfo* mPlayerInfo; + PlayerConst* mPlayerConst; PlayerInput *mPlayerInput; //0x138 - unsigned char padding_148[0x08]; - HackCap *mHackCap; // 0x148 - unsigned char padding_158[0x06]; - PlayerModelKeeper *mPlayerModelKeeper; // 0x158 - unsigned char padding_168[0x08]; - PlayerAnimator *mPlayerAnimator; // 0x168 - undefined padding_270[0x28]; + PlayerTrigger* mPlayerTrigger; + HackCap* mHackCap; + ActorDimensionKeeper* mActorDimensionKeeper; + PlayerModelKeeper* mModelKeeper; + PlayerModelChangerHakoniwa* mModelChangerHakoniwa; + PlayerAnimator* mAnimator; + PlayerColliderHakoniwa* mColliderHakoniwa; + PlayerPuppet* mPuppet; + PlayerAreaChecker* mAreaChecker; + al::WaterSurfaceFinder* mWaterSurfaceFinder; + void* gap1; PlayerDamageKeeper* mDamageKeeper; - spad(gap, 0x68); + PlayerDemoActionFlag* mDemoActionFlag; + PlayerCapActionHistory* mCapActionHistory; + PlayerCapManHeroEyesControl* mCapManHeroEyesControl; + PlayerContinuousJump* mContinuousJump; + PlayerContinuousLongJump* mContinuousLongJump; + PlayerCounterAfterUpperPunch* mCounterAfterUpperPunch; + PlayerCounterForceRun* mCounterForceRun; + PlayerCounterIceWater* mCounterIceWater; + PlayerCounterQuickTurnJump* mCounterQuickTurnJump; + PlayerWallActionHistory* mWallActionHistory; + PlayerBindKeeper* mBindKeeper; + PlayerCarryKeeper* mCarryKeeper; + PlayerEquipmentUser* mEquipmentUser; PlayerHackKeeper* mHackKeeper; - spad(gap2, 0x5F); - PlayerRecoverySafetyPoint *mPlayerRecoverPoint; // 0x270 -}; \ No newline at end of file + PlayerFormSensorCollisionArranger* mFormSensorCollisionArranger; + PlayerJumpMessageRequest* mJumpMessageRequest; + PlayerSandSinkAffect* mSandSinkAffect; + PlayerSpinCapAttack* mSpinCapAttack; + PlayerActionDiveInWater* mActionDiveInWater; + PlayerEffect* mPlayerEffect; + PlayerEyeSensorHitHolder* mEyeSensorHitHolder; + PlayerPushReceiver* mPushReceiver; + PlayerHitPush* mHitPush; + void* gap2; + PlayerJointControlKeeper* mJointControlKeeper; + PlayerPainPartsKeeper* mPainPartsKeeper; + PlayerRecoverySafetyPoint* mRecoverPoint; + PlayerRippleGenerator* mRippleGenerator; + PlayerSeparateCapFlag* mSeparateCapFlag; + PlayerWetControl* mWetControl; + PlayerStainControl* mStainControl; + al::FootPrintHolder* mFootPrintHolder; + GaugeAir* mGaugeAir; + WaterSurfaceShadow* mWaterSurfaceShadow; + WorldEndBorderKeeper* mWorldEndBorderKeeper; + void* gap3; + PlayerSeCtrl* mSeCtrl; + al::HitSensor* mHitSensorBody; + bool* mIsLongShadow; + PlayerStateWait* mStateWait; + PlayerStateSquat* mStateSquat; + PlayerStateRunHakoniwa2D3D* mStateRunHakoniwa2D3D; + PlayerStateSlope* mStateSlope; + PlayerStateRolling* mStateRolling; + PlayerStateSpinCap* mStateSpinCap; + PlayerStateJump* mStateJump; + PlayerStateCapCatchPop* mStateCapCatchPop; + PlayerStateWallAir* mStateWallAir; + void* gap4; + PlayerStateGrabCeil* mStateGrabCeil; + PlayerStatePoleClimb* mStatePoleClimb; + PlayerStateHipDrop* mStateHipDrop; + PlayerStateHeadSliding* mStateHeadSliding; + PlayerStateLongJump* mStateLongJump; + PlayerStateFallHakoniwa* mStateFallHakoniwa; + PlayerStateSandSink* mStateSandSink; + ActorStateSandGeyser* mStateSandGeyser; + PlayerStateRise* mStateRise; + PlayerStateSwim* mStateSwim; + PlayerStateDamageLife* mStateDamageLife; + PlayerStateDamageSwim* mStateDamageSwim; + PlayerStateDamageFire* mStateDamageFire; + PlayerStatePress* mStatePress; + PlayerStateBind* mStateBind; + PlayerStateHack* mStateHack; + PlayerStateEndHack* mStateEndHack; + PlayerStateCameraSubjective* mStateCameraSubjective; + PlayerStateAbyss* mStateAbyss; + PlayerJudgeAirForceCount* mJudgeAirForceCount; + PlayerJudgeCameraSubjective* mJudgeCameraSubjective; + PlayerJudgeCapCatchPop* mJudgeCapCatchPop; + PlayerJudgeDeadWipeStart* mJudgeDeadWipeStart; + PlayerJudgeDirectRolling* mJudgeDirectRolling; + void* gap5; + PlayerJudgeForceLand* mJudgeForceLand; + PlayerJudgeForceSlopeSlide* mJudgeForceSlopeSlide; + PlayerJudgeForceRolling* mJudgeForceRolling; + PlayerJudgeGrabCeil* mJudgeGrabCeil; + PlayerJudgeInWater* mJudgeInWater1; + PlayerJudgeInWater* mJudgeInWater2; + PlayerJudgeInWater* mJudgeInWater3; + PlayerJudgeInWater* mJudgeInWater4; + PlayerJudgeInvalidateInputFall* mJudgeInvalidateInputFall; + PlayerJudgeLongFall* mJudgeLongFall; + PlayerJudgeOutInWater* mJudgeOutInWater; + PlayerJudgeRecoveryLifeFast* mJudgeRecoveryLifeFast; + PlayerJudgeSandSink* mJudgeSandSink; + PlayerJudgeSpeedCheckFall* mJudgeSpeedCheckFall; + PlayerJudgeStartHipDrop* mJudgeStartHipDrop; + PlayerJudgeStartRise* mJudgeStartRise; + PlayerJudgeStartRolling* mJudgeStartRolling; + PlayerJudgeStartRun* mJudgeStartRun; + PlayerJudgeStartSquat* mJudgeStartSquat; + PlayerJudgeStartWaterSurfaceRun* mJudgeStartWaterSurfaceRun; + PlayerJudgeSlopeSlide* mJudgeSlopeSlide; + PlayerJudgePoleClimb* mJudgePoleClimb; + PlayerJudgePreInputJump* mJudgePreInputJump; + PlayerJudgePreInputCapThrow* mJudgePreInputCapThrow; + PlayerJudgePreInputHackAction* mJudgePreInputHackAction; + HackCapJudgePreInputHoveringJump* mHackCapJudgePreInputHoveringJump; + HackCapJudgePreInputSeparateThrow* mHackCapJudgePreInputSeparateThrow; + HackCapJudgePreInputSeparateJump* mHackCapJudgePreInputSeparateJump; + PlayerJudgeWallCatch* mJudgeWallCatch; + PlayerJudgeWallCatchInputDir* mJudgeWallCatchInputDir; + PlayerJudgeWallHitDown* mJudgeWallHitDown; + PlayerJudgeWallHitDownForceRun* mJudgeWallHitDownForceRun; + PlayerJudgeWallHitDownRolling* mJudgeWallHitDownRolling; + PlayerJudgeWallKeep* mJudgeWallKeep; +}; diff --git a/include/game/Player/PlayerCapActionHistory.h b/include/game/Player/PlayerCapActionHistory.h new file mode 100644 index 0000000..2794636 --- /dev/null +++ b/include/game/Player/PlayerCapActionHistory.h @@ -0,0 +1,41 @@ +#pragma once + +#include "al/LiveActor/LiveActor.h" +#include "game/Player/PlayerConst.h" +#include "game/Player/PlayerTrigger.h" + + +class IUsePlayerCollision; + + +class PlayerCounterAfterCapCatch { +public: + bool isCapCatch(void); + void update(PlayerTrigger *); + + PlayerConst* mPlayerConst; + PlayerTrigger* mPlayerTrigger; + int mCapCatch; +}; + +class PlayerCapActionHistory { +public: + void clearCapJump(void); + void clearLandLimit(void); + void clearLandLimitStandAngle(void); + void clearLimitHeight(void); + void clearWallAirLimit(void); + bool isOverLimitHeight(void); + void recordLimitHeight(void); + void update(void); + + al::LiveActor* mPlayer; + PlayerConst* mPlayerConst; + PlayerTrigger* mPlayerTrigger; + IUsePlayerCollision* mPlayerCollider; + PlayerCounterAfterCapCatch* mCounterCapCatch; + bool mLimitHeight = false; + sead::Vector3f mCapThrowPos; + bool mCapJump = true; + bool mRainbowSpin = true; +}; diff --git a/include/game/Player/PlayerCarryKeeper.h b/include/game/Player/PlayerCarryKeeper.h new file mode 100644 index 0000000..7f13d2f --- /dev/null +++ b/include/game/Player/PlayerCarryKeeper.h @@ -0,0 +1,68 @@ +#pragma once + +#include "al/nerve/NerveExecutor.h" +#include "al/LiveActor/LiveActor.h" +#include "al/sensor/HitSensor.h" +#include "game/Player/PlayerAnimator.h" + +class IPlayerModelChanger; +class IUsePlayerCeilingCheck; +class PlayerJointParamHandLegAngle; +class IUsePlayerCollision; +class PlayerPushReceiver; +class PlayerActorHakoniwa; + +class PlayerCarryKeeper : public al::NerveExecutor { +public: + PlayerCarryKeeper(al::LiveActor const*, al::HitSensor*, PlayerAnimator*, IPlayerModelChanger const*, IUsePlayerCeilingCheck const*, PlayerJointParamHandLegAngle*); + ~PlayerCarryKeeper(); + + bool endCameraSubjective(); + void endDemoShineGet(); + void exeCarry(); + void exeRelease(); + void exeStart(); + void exeThrow(); + void exeWait(); + const char* getCarryAnimName() const; + const char* getCarryStartAnimName() const; + const char* getCarryThrowAnimName() const; + const char* getThrowReleaseFrame() const; + bool isCarry() const; + bool isCarryFront() const; + bool isCarryUp() const; + bool isCarryWallKeep() const; + bool isThrow() const; + bool isThrowHandR() const; + bool isThrowHold() const; + bool isThrowRelease() const; + bool sendPlayerWarp(); + bool startCameraSubjective(); + void startCancelAndRelease(); + bool startCarry(al::HitSensor*); + bool startDemoKeepCarry(); + void startDemoShineGet(); + void startRelease(); + void startReleaseDamage(); + void startReleaseDead(); + void startReleaseDemo(); + bool startThrow(bool); + void update(); + bool updateCollideLockUp(IUsePlayerCollision const*, PlayerPushReceiver const*); + void updateHandJointAngle(); + + PlayerActorHakoniwa* mPlayer; + PlayerAnimator* mAnimator; + al::HitSensor* mSensorPlayer; + al::HitSensor* mSensorHeld; + IPlayerModelChanger* mModelChanger; + IUsePlayerCeilingCheck* mCeilingCheck; + PlayerJointParamHandLegAngle* mJointParamHandLegAngle; + int iVar1; + bool mIsCarryUp; + bool bVar1; + sead::Vector3f vVar1; + float fVar1; + sead::Vector3f vVar2; + +}; diff --git a/include/game/Player/PlayerCollider.h b/include/game/Player/PlayerCollider.h new file mode 100644 index 0000000..2f0fe65 --- /dev/null +++ b/include/game/Player/PlayerCollider.h @@ -0,0 +1,119 @@ +#pragma once + +#include "al/collision/CollisionDirector.h" +#include "al/LiveActor/LiveActor.h" +#include "game/Interfaces/IUsePlayerCollision.h" +#include +#include +#include + +namespace al { + class HitInfo; +} + + +class PlayerCeilingCheck; +class CollisionShapeKeeper; +class CollisionPartsFilterOnlySpecialPurpose; +class CollisionMultiShape; +class CollisionPartsFilterBase; + +class IUsePlayerCeilingCheck { +public: + virtual bool isEnableStandUp() const; + virtual bool isEnableHoldUp() const; + virtual bool isPressedCeil() const; + virtual float getSafetyCeilSpace() const; + virtual float getCeilCheckHeight() const; +}; + +class IUsePlayerHeightCheck { +public: + virtual bool isAboveGround() const; + virtual float getGroundHeight() const; + virtual float getShadowDropHeight() const; +}; + +class IUsePlayerFallDistanceCheck { +public: + virtual float getFallDistance() const; +}; + + +class PlayerCollider { +public: + virtual al::CollisionDirector* getCollisionDirector() const; + + enum WallBorderCheckType { + cNone, cNoFace, cAll + }; + + al::CollisionDirector* mCollisionDirector; + sead::Matrix34f* mVar1; + sead::Vector3f* vVar1; + sead::Vector3f* vVar2; + sead::Vector3f vVar3; + float fVar1; + sead::Matrix34f mVar2; + al::HitInfo* mHitFloor; + float fVar2; + al::HitInfo* mHitWall; + float fVar3; + al::HitInfo* mHitCeil; + float fVar4; + void* gap1; + bool bVar1; + bool bVar2; + sead::Vector3f vVar4; + sead::Vector3f vVar5; + unsigned char gap2[0x4]; + sead::Matrix34f mVar3; + CollisionShapeKeeper* mCollisionShapeKeeper; + float mCollisionShapeScale; + CollisionMultiShape* uVar2; + unsigned char gap3[0x4]; + bool mIsFastMoveCollisionArea; + bool bVar3; + bool bVar4; + sead::Vector3f vVar6; + WallBorderCheckType mWallBorderCheckType; + CollisionPartsFilterBase* mCollisionPartsFilter; + sead::PtrArrayImpl arr1; + sead::PtrArrayImpl arr2; + sead::PtrArrayImpl arr3; + al::HitInfo (*uVar3)[64]; + unsigned int uVar4; + sead::PtrArray arr4; + sead::PtrArrayImpl arr5; + sead::PtrArrayImpl arr6; + sead::Vector3f vVar7; + sead::Vector3f vVar8; + float fVar5; +}; + +class PlayerConst; + +class PlayerColliderHakoniwa : public IUsePlayerCollision, public IUsePlayerCeilingCheck, public IUsePlayerHeightCheck, public IUsePlayerFallDistanceCheck { +public: + al::LiveActor* mPlayer; + PlayerConst* mPlayerConst; + PlayerCollider* mCollider; + PlayerCeilingCheck* mCeilingCheck; + bool mIsAboveGround; + float mGroundHeight; + float mShadowDropHeight; + sead::Vector3f vVar1; + sead::Vector3f vVar2; + float mFallDistance; + int iVar1; + al::HitSensor* uVar1; + CollisionShapeKeeper* uVar2; + CollisionShapeKeeper* uVar3; + CollisionShapeKeeper* uVar4; + CollisionShapeKeeper* uVar5; + CollisionShapeKeeper* uVar6; + CollisionShapeKeeper* uVar7; + CollisionShapeKeeper* uVar8; + CollisionShapeKeeper* uVar9; + CollisionPartsFilterOnlySpecialPurpose* mFilter2DOnly; +}; diff --git a/include/game/Player/PlayerConst.h b/include/game/Player/PlayerConst.h new file mode 100644 index 0000000..223c25e --- /dev/null +++ b/include/game/Player/PlayerConst.h @@ -0,0 +1,17 @@ +#pragma once + +#include "al/hio/HioNode.h" +#include "types.h" + +class PlayerConst : al::HioNode { +public: + int getWallInhibitAfterPunch() const; + float getWallHeightLowLimit() const; + float getWallKeepDegree() const; + float getWallCatchDegree() const; + float getWallCatchHeightEdgeTop() const; + float getWallCatchHeightBottom() const; + float getCollisionRadius() const; + float getCollisionRadiusStand() const; + +}; diff --git a/include/game/Player/PlayerCounter.h b/include/game/Player/PlayerCounter.h new file mode 100644 index 0000000..5a99692 --- /dev/null +++ b/include/game/Player/PlayerCounter.h @@ -0,0 +1,19 @@ +#pragma once + +#include "types.h" + +class PlayerCounterAfterCapCatch; +class PlayerCounterGetCoin; +class PlayerCounterIceWater; +class PlayerCounterQuickTurnJump; + +class PlayerCounterAfterUpperPunch { +public: + unsigned int uVar1; +}; + +class PlayerCounterForceRun { +public: + int iVar1; + float fVar1; +}; diff --git a/include/game/Player/PlayerDamageKeeper.h b/include/game/Player/PlayerDamageKeeper.h index b256085..9ccc067 100644 --- a/include/game/Player/PlayerDamageKeeper.h +++ b/include/game/Player/PlayerDamageKeeper.h @@ -9,10 +9,11 @@ class PlayerDamageKeeper void activatePreventDamage(); void dead(); void damage(int level); + void damageForce(int level); #endif #if(SMOVER==130) VVCEFUN(PlayerDamageKeeper, 0x003E2850, dead); VVCEFUN(PlayerDamageKeeper, 0x003E28B0, activatePreventDamage); VCEFUN(PlayerDamageKeeper, 0x003E25B0, damage, EFUN_ARGS(int amount), EFUN_ARGS(amount)); #endif -}; \ No newline at end of file +}; diff --git a/include/game/Player/PlayerExternalVelocity.h b/include/game/Player/PlayerExternalVelocity.h new file mode 100644 index 0000000..c728d97 --- /dev/null +++ b/include/game/Player/PlayerExternalVelocity.h @@ -0,0 +1,5 @@ +#pragma once + +class PlayerExternalVelocity { + +}; diff --git a/include/game/Player/PlayerHackKeeper.h b/include/game/Player/PlayerHackKeeper.h index a55d1ab..f53fdf4 100644 --- a/include/game/Player/PlayerHackKeeper.h +++ b/include/game/Player/PlayerHackKeeper.h @@ -5,11 +5,13 @@ #pragma once -#include "al/LiveActor/LiveActor.h" +#include class PlayerHackKeeper { public: + const char* getCurrentHackName() const; + char padding[0x68]; - al::LiveActor *currentHackActor; -}; \ No newline at end of file + al::LiveActor *mCurrentHackActor; +}; diff --git a/include/game/Player/PlayerHitPointData.h b/include/game/Player/PlayerHitPointData.h index 485c978..ba786c9 100644 --- a/include/game/Player/PlayerHitPointData.h +++ b/include/game/Player/PlayerHitPointData.h @@ -9,9 +9,11 @@ class PlayerHitPointData void getMaxUpItem(); void recover(); void recoverForDebug(); + void damage(); #endif #if(SMOVER==130) VVCEFUN(PlayerHitPointData, 0x004E49E0, getMaxUpItem); - VVCEFUN(PlayerHitPointData, 0x004E49E0, recover); + VVCEFUN(PlayerHitPointData, 0x004E4A20, recover); + VVCEFUN(PlayerHitPointData, 0x004D3A70, damage); #endif -}; \ No newline at end of file +}; diff --git a/include/game/Player/PlayerInput.h b/include/game/Player/PlayerInput.h index ca825c9..aa24ad5 100644 --- a/include/game/Player/PlayerInput.h +++ b/include/game/Player/PlayerInput.h @@ -4,5 +4,6 @@ class PlayerInput { public: + bool isTriggerRollingRestartSwing() const; -}; \ No newline at end of file +}; diff --git a/include/game/Player/PlayerJointControlKeeper.h b/include/game/Player/PlayerJointControlKeeper.h new file mode 100644 index 0000000..49b8e29 --- /dev/null +++ b/include/game/Player/PlayerJointControlKeeper.h @@ -0,0 +1,8 @@ +#pragma once + + + +class PlayerJointControlKeeper { +public: + void update(); +}; diff --git a/include/game/Player/PlayerJudge.h b/include/game/Player/PlayerJudge.h new file mode 100644 index 0000000..442e60b --- /dev/null +++ b/include/game/Player/PlayerJudge.h @@ -0,0 +1,152 @@ +#pragma once + +#include "al/LiveActor/LiveActor.h" +#include "al/actor/WaterSurfaceFinder.h" +#include "game/Interfaces/IJudge.h" +#include "game/Player/PlayerCollider.h" +#include "game/Player/PlayerConst.h" +#include "game/Player/PlayerCounter.h" +#include "game/Player/PlayerExternalVelocity.h" +#include "game/Player/PlayerInput.h" +#include "game/Player/PlayerTrigger.h" +#include + +class IPlayerModelChanger; +class PlayerCarryKeeper; +class PlayerAreaChecker; + +class PlayerJudgeAbyssDeadStatus; +class PlayerJudgeActiveCameraSubjective; +class PlayerJudgeAirForceCount; +class PlayerJudgeCameraInWater; +class PlayerJudgeCameraSubjective; +class PlayerJudgeCapCatch; +class PlayerJudgeCapCatchPop; +class PlayerJudgeCollideWall; +class PlayerJudgeDead; +class PlayerJudgeDeadSceneEnd; +class PlayerJudgeDeadWipeStart; +class PlayerJudgeDirectRolling; +class PlayerJudgeDiveInWater; +class PlayerJudgeDrawForward; +class PlayerJudgeEnableGuideArrow; +class PlayerJudgeEnablePeachAmiibo; +class PlayerJudgeEnableStandUp; +class PlayerJudgeFailureCameraSubjective; +class PlayerJudgeForceRolling; +class PlayerJudgeForceSlopeSlide; +class PlayerJudgeGrabCeil; +class PlayerJudgeInvalidateInputFall; + +class PlayerJudgeInWater : public IJudge { +public: + al::LiveActor* mActor; + PlayerConst* mPlayerConst; + IUsePlayerCollision* mCollider; + PlayerAreaChecker* mAreaChecker; + al::WaterSurfaceFinder* mWaterSurfaceFinder; + IUsePlayerHeightCheck* mHeightCheck; + PlayerCounterForceRun* mCounterForceRun; + bool bVar1; + bool bVar2; + bool bVar3; +}; + +class PlayerJudgeIsNerve; +class PlayerJudgeNormalFall; +class PlayerJudgeOr; +class PlayerJudgeOutInWater; +class PlayerJudgePlaySwitchOnAreaWaitAnim; + +class PlayerJudgePoleClimb : public IJudge { +public: + al::LiveActor* mActor; + PlayerConst* mPlayerConst; + IUsePlayerCollision* mCollider; + IPlayerModelChanger* mModelChanger; + PlayerCarryKeeper* mCarryKeeper; + PlayerExternalVelocity* mExternalVelocity; + PlayerInput* mPlayerInput; + PlayerTrigger* mPlayerTrigger; + bool mIsClimbing; + al::CollisionParts* uVar1; + sead::Vector3f vVar1; + sead::Vector3f vVar2; + sead::Vector3f vVar3; + float fVar1; + float fVar2; + char* mMaterialName; +}; + +class PlayerJudgePreInputCapThrow; +class PlayerJudgePreInputHackAction; +class PlayerJudgePreInputJump; + +class PlayerJudgePreInputPoleClimbSwing : public IJudge { +public: + PlayerConst* mPlayerConst; + PlayerInput* mPlayerInput; + int mSwingDelay; +}; + +class PlayerJudgeRecoveryLifeFast; +class PlayerJudgeReduceOxygen; +class PlayerJudgeSafetyPointRecovery; +class PlayerJudgeSameNerve; +class PlayerJudgeSandSink; +class PlayerJudgeSleep; +class PlayerJudgeSlopeSlide; +class PlayerJudgeSlopeSlideRun; +class PlayerJudgeSpeedCheckFall; +class PlayerJudgeStartDash; +class PlayerJudgeStartGroundSpin; +class PlayerJudgeStartHipDrop; +class PlayerJudgeStartJumpHakoniwa; +class PlayerJudgeStartRise; +class PlayerJudgeStartRolling; +class PlayerJudgeStartRun; +class PlayerJudgeStartRunOld; +class PlayerJudgeStartSquat; +class PlayerJudgeStartSwimJump; +class PlayerJudgeStartWaterSurfaceRun; +class PlayerJudgeStatusPoleClimb; +class PlayerJudgeTalkGround; +class PlayerJudgeTalkSwim; +class PlayerJudgeTouchMove; +class PlayerJudgeWallHitDown; +class PlayerJudgeWallHitDownForceRun; +class PlayerJudgeWallHitDownRolling; +class PlayerJudgeWallPush; +class PlayerJudgeWaterSurfaceRun; + +class PlayerJudgeForceLand : public IJudge {}; + +class PlayerJudgeLongFall : public IJudge {}; + +class PlayerJudgeWallKeep : public IJudge { +public: + unsigned char padding[0x58]; + bool bVar1; +}; + +class PlayerJudgeWallCatch : public IJudge { +public: + al::LiveActor* mActor; + PlayerConst* mPlayerConst; + IUsePlayerCollision* mCollider; + IPlayerModelChanger* mModelChanger; + PlayerCarryKeeper* mCarryKeeper; + PlayerExternalVelocity* mExternalVelocity; + PlayerInput* mPlayerInput; + PlayerTrigger* mPlayerTrigger; + PlayerCounterForceRun* mCounterForceRun; + bool bVar1; + unsigned char padding1[0xf]; + sead::Vector3f vVar1; + sead::Vector3f vVar2; + sead::Vector3f vVar3; +}; + +class PlayerJudgeWallCatchInputDir : public IJudge { + +}; diff --git a/include/game/Player/PlayerStainControl.h b/include/game/Player/PlayerStainControl.h new file mode 100644 index 0000000..4e2dcf9 --- /dev/null +++ b/include/game/Player/PlayerStainControl.h @@ -0,0 +1,87 @@ +#pragma once + +#include "al/LiveActor/LiveActor.h" +#include "game/Player/HackCap.h" +#include +#include + +class PlayerModelChangerHakoniwa; +class PlayerEffect; + +class PlayerStainControl { +private: + enum StainType { + Poison = 1, Fire, Ice, SandDesert, SandSea, SandMoon + }; + + struct unkstruct { + int iVar1; + float fVar1; + float fVar2; + float fVar3; + float fVar4; + float fVar5; + unsigned char pad[0x4]; + float fVar6; + int iVar2; + int iVar3; + }; + +public: + PlayerStainControl(al::LiveActor const*, al::LiveActor*, PlayerModelChangerHakoniwa const*, HackCap const*, PlayerEffect*); + + void clearCurrentStain(bool); + void clearStain(); + void clearStainRequest(); + int getSandType(const char*) const; + bool isEnableInvalidateStain() const; + bool isEnableLowPriorityStain() const; + bool isEnableValidateStain() const; + void noticeEndHack(); + void noticeMainShineGet(); + void noticeStartHack(); + void recordBlackSmoke(); + void recordBlizzard(); + void recordDamageFire(); + void recordDamageFireDead(); + void recordExplosion(); + void recordIceWater(); + void recordInWater(); + void recordInWet(); + void recordPoison(); + void recordSandHeavyLand(const char*); + void recordSandMoonBySensor(); + void recordSandMove(const char*); + void recordSnowBySensor(); + void recordSnowMove(const char*); + void tryDeleteStainEffect(PlayerStainControl::StainType, float); + void tryEmitClearStainEffect(PlayerStainControl::StainType, float); + void tryEmitStainEffect(PlayerStainControl::StainType); + void update(); + + al::LiveActor* mPlayer; + al::LiveActor* mPlayerModel; + PlayerModelChangerHakoniwa* mModelChanger; + HackCap* mHackCap; + PlayerEffect* mPlayerEffect; + sead::PtrArray arr1; + int iVar1; + sead::PtrArray arr2; + StainType mStainType; + bool bVar1; + bool bVar2; + bool bVar3; + bool bVar4; + int iVar2; + int iVar3; + int iVar4; + float fVar1; + float fVar2; + float fVar3; + float fVar4; + float fVar5; + int iVar5; + int iVar6; + bool bVar5; + bool bVar6; +}; diff --git a/include/game/Player/PlayerState.h b/include/game/Player/PlayerState.h new file mode 100644 index 0000000..7447e07 --- /dev/null +++ b/include/game/Player/PlayerState.h @@ -0,0 +1,226 @@ +#pragma once + +#include "al/actor/WaterSurfaceFinder.h" +#include "al/nerve/NerveStateBase.h" +#include "al/sensor/HitSensor.h" +#include "game/Interfaces/IUseDimension.h" +#include "game/Player/PlayerAction.h" +#include "game/Player/PlayerAnimator.h" +#include "game/Player/PlayerConst.h" +#include "game/Player/PlayerInput.h" +#include "game/Player/PlayerJudge.h" +#include "game/Player/PlayerTrigger.h" +#include "game/Player/PlayerWallActionHistory.h" +#include + +class IUsePlayerCeilingCheck; +class IUsePlayerCollision; +class PlayerSpinCapAttack; +class PlayerJointControlKeeper;; +class PlayerJointParamCapThrow; +class PlayerJointParamGrab; +class PlayerJointParamHandLegAngle; +class PlayerModelHolder; +class PlayerContinuousJump; +class HackCap; +class HackCapJudgeHoldHoveringJump; + +class PlayerStateAbyss; +class PlayerStateAutoDash; +class PlayerStateBind; +class PlayerStateCameraSubjective; +class PlayerStateCapCatchPop; +class PlayerStateCeilingKeep; +class PlayerStateDamageFire; + +class PlayerStateDamageLife : public al::ActorStateBase { +public: + PlayerConst* mPlayerConst; + IUsePlayerCollision* mPlayerCollider; + IUsePlayerCeilingCheck* mCeilingCheck; + +}; + +class PlayerStateDamageSwim; +class PlayerStateEndHack; +class PlayerStateFallHakoniwa; +class PlayerStateFreeRun; + +class PlayerStateGrabCeil : public al::ActorStateBase { +public: + PlayerConst* mPlayerConst; + PlayerInput* mPlayerInput; + PlayerModelHolder* mModelHolder; + PlayerTrigger* mPlayerTrigger; + IUsePlayerCollision* mCollider; + PlayerAnimator* mAnimator; + PlayerJudgePreInputJump* mJudgePreInputJump; + al::HitSensor* mSensor; + PlayerJointParamGrab* mJointParamGrab; + PlayerActionAirMoveControl* mActionAirMoveControl; + PlayerActionCollisionSnap* mActionCollisionSnap; + bool bVar1; + bool bVar2; + int iVar1; + bool bVar3; + float fVar1; + float fVar2; + float fVar3; + float fVar4; + sead::Vector3f vVar1; + sead::Vector3f vVar2; + int iVar2; + float fVar5; + int iVar3; + float fVar6; + int iVar4; + float fVar7; +}; + +class PlayerStateGroundSpin; +class PlayerStateHack; +class PlayerStateHeadSliding; +class PlayerStateHipDrop; + +class PlayerStateJump : public al::ActorStateBase { +public: + PlayerConst* mPlayerConst; + IPlayerModelChanger* mModelChanger; + IUseDimension* mDimensionKeeper; + PlayerJumpMessageRequest* mJumpMessageRequest; + PlayerJudgeCapCatch* mJudgeCapCatch; + PlayerCounterForceRun* mCounterForceRun; + PlayerJointControlKeeper* mJointControlKeeper; + IUsePlayerCollision* mCollider; + PlayerAnimator* mAnimator; + PlayerContinuousJump* mContinuousJump; + PlayerTrigger* mPlayerTrigger; + PlayerActionDiveInWater* mActionDiveInWater; + PlayerActionAirMoveControl* mActionAirMoveControl; + HackCap* mHackCap; + HackCapJudgeHoldHoveringJump* mHackCapJudgeHoldHoveringJump; + bool bVar1; + int mExtendFrame; + float mJumpPower; + float mJumpMoveSpeedMax; + float mGravity; + int iVar1; + unsigned int mContinuousJumpCount; + bool bVar2; + bool bVar3; + bool bVar4; + bool bVar5; + bool bVar6; + bool bVar7; + bool mIsHoldCapSeparateJump; + sead::Vector3f vVar1; + const char* mJumpName; + const char* sVar1; + PlayerInput* mPlayerInput; + sead::Vector3f vVar2; + int iVar2; + bool bVar8; + + +}; + +class PlayerStateJump2D3D; +class PlayerStateLongJump; +class PlayerStateNormalFall; +class PlayerStateNormalJump; +class PlayerStateNormalWait; + +class PlayerStateNormalWallJump : public al::ActorStateBase { +public: + void appear(void); + void exeJump(void); + + PlayerConst* mPlayerConst; + IUsePlayerCollision* mPlayerCollider; + PlayerInput* mPlayerInput; + PlayerTrigger* mPlayerTrigger; + PlayerAnimator* mPlayerAnimator; + PlayerActionDiveInWater* mDiveInWater; + PlayerActionAirMoveControl* mAirMoveControl; + const char* mName; // value = "WallJump" + sead::Vector3f mPos; + bool gap1; // value = false +}; + +class PlayerStateNormalWallSlide; + +class PlayerStatePoleClimb : public al::ActorStateBase { +private: + enum ClimbType { + Climb, ClimbFast, ClimbSwing + }; + +public: + PlayerConst* mPlayerConst; + PlayerInput* mPlayerInput; + PlayerModelHolder* mModelHolder; + IUsePlayerCollision* mCollider; + PlayerAnimator* mAnimator; + PlayerJointParamHandLegAngle* mJointParamHandLegAngle; + PlayerJudgePreInputJump* mJudgePreInputJump; + PlayerStateNormalWallJump* mStateNormalWallJump1; + PlayerStateNormalWallJump* mStateNormalWallJump2; + PlayerWallActionHistory* mWallActionHistory; + PlayerActionCollisionSnap* mActionCollisionSnap; + PlayerJudgePreInputPoleClimbSwing* mJudgePreInputPoleClimbSwing; + char* mMaterialName; + float fVar1; + float fVar2; + float fVar3; + ClimbType mClimbType; + int mClimbDelay; + sead::Vector2f mPoleMoveInput; + bool mHasJustTurned; + bool mIsInputReverse; + sead::Vector2f mStickMoveRaw; + int mClimbDownKeepTime; + bool bVar3; + sead::Vector2f mLeftStickInit; +}; + +class PlayerStatePress; +class PlayerStateRecoveryDead; +class PlayerStateRise; +class PlayerStateRolling; +class PlayerStateRun; +class PlayerStateRun2D; +class PlayerStateRun2D3D; +class PlayerStateRunHakoniwa; +class PlayerStateRunHakoniwa2D3D; +class PlayerStateSandSink; +class PlayerStateSlope; + +class PlayerStateSpinCap : public al::ActorStateBase { +public: + PlayerConst* mPlayerConst; + PlayerInput* mPlayerInput; + PlayerCounterForceRun* mPlayerCounterForceRun; + al::WaterSurfaceFinder* mWaterSurfaceFinder; + IUsePlayerCollision* mPlayerCollider; + PlayerTrigger* mPlayerTrigger; + PlayerSpinCapAttack* mPlayerSpinCapAttack; + PlayerAnimator* mPlayerAnimator; + PlayerJointParamCapThrow* mPlayerJointParamCapThrow; + PlayerActionAirMoveControl* mPlayerActionAirMoveControl; + PlayerActionGroundMoveControl* mPlayerActionGroundMoveControl; + bool bVar1; + PlayerJudgeWaterSurfaceRun* mPlayerJudgeWaterSurfaceRun; + bool bVar2; + bool bVar3; + int iVar1; + int iVar2; +}; + +class PlayerStateSquat; +class PlayerStateSwim; +class PlayerStateSwordAttack; +class PlayerStateTargetJump; +class PlayerStateTouchMove; +class PlayerStateWait; +class PlayerStateWallAir; +class PlayerStateWallCatch; diff --git a/include/game/Player/PlayerTrigger.h b/include/game/Player/PlayerTrigger.h new file mode 100644 index 0000000..152fd6f --- /dev/null +++ b/include/game/Player/PlayerTrigger.h @@ -0,0 +1,32 @@ +#pragma once + +class PlayerTrigger { +public: + enum ECollisionTrigger { + cUpperPunch = 0, + cPoison = 5 + }; + enum EAttackSensorTrigger {}; + enum EActionTrigger { var1 = 30 }; + enum EReceiveSensorTrigger {}; + enum EPreMovementTrigger {}; + enum EDemoEndTrigger {}; + enum EMaterialChangeTrigger {}; + + // bool isOn(ECollisionTrigger); + // bool isOn(EAttackSensorTrigger); + // bool isOn(EActionTrigger); + // bool isOn(EReceiveSensorTrigger); + // bool isOn(EPreMovementTrigger); + // bool isOn(EDemoEndTrigger); + // bool isOn(EMaterialChangeTrigger); + + unsigned int mCollisionTrigger; + unsigned int mAttackSensorTrigger; + unsigned long mActionTrigger; + unsigned int mReceiveSensorTrigger; + unsigned int mPreMovementTrigger; + unsigned int mDemoEndTrigger; + unsigned int mMaterialChangeTrigger; + const char* mRecMaterialTrigger; +}; diff --git a/include/game/Player/PlayerWallActionHistory.h b/include/game/Player/PlayerWallActionHistory.h new file mode 100644 index 0000000..f2ad33a --- /dev/null +++ b/include/game/Player/PlayerWallActionHistory.h @@ -0,0 +1,21 @@ +#pragma once + +#include + +class IUsePlayerCollision; + +class PlayerWallActionHistory { +public: + void recordWallJump(IUsePlayerCollision *, sead::Vector3f *); + void recordWallJump(sead::Vector3f *, sead::Vector3f *); + void recordWallLeave(sead::Vector3f *, sead::Vector3f *); + void reset(void); + void update(IUsePlayerCollision *); + + bool mHasJumped = false; + sead::Vector3f mWallJumpPos; + sead::Vector3f mWallJumpNormal; + bool mHasLeft = false; + sead::Vector3f mWallLeavePos; + sead::Vector3f mWallLeaveNormal; +}; diff --git a/include/game/PlayerActorBase.h b/include/game/PlayerActorBase.h deleted file mode 100644 index 064de6f..0000000 --- a/include/game/PlayerActorBase.h +++ /dev/null @@ -1,12 +0,0 @@ -/** - * @file PlayerActorBase.h - * @brief base class for PlayerActor -* Vtable loc: 1D774E8 -*/ - -#include "PlayerHackKeeper.h" - -class PlayerActorBase { - public: - PlayerHackKeeper getPlayerHackKeeper(); -}; \ No newline at end of file diff --git a/include/game/PlayerHackKeeper.h b/include/game/PlayerHackKeeper.h deleted file mode 100644 index e56227b..0000000 --- a/include/game/PlayerHackKeeper.h +++ /dev/null @@ -1,15 +0,0 @@ -/** - * @file PlayerHackKeeper.h - * @brief Contains info on the current hack (capture) - */ - -#pragma once - -#include - -class PlayerHackKeeper -{ - public: - char padding[0x68]; - al::LiveActor *currentHackActor; -}; \ No newline at end of file diff --git a/include/game/RouteGuide/RouteGuidePoint.h b/include/game/RouteGuide/RouteGuidePoint.h new file mode 100644 index 0000000..1e16c4e --- /dev/null +++ b/include/game/RouteGuide/RouteGuidePoint.h @@ -0,0 +1,9 @@ + +#pragma once + +class RouteGuidePoint { +public: + unsigned char gap1[0x8]; + bool mIsValidateGuide; + bool mIsHorizontalGuide; +}; diff --git a/include/game/SceneObjs/CapManHeroDemoDirector.h b/include/game/SceneObjs/CapManHeroDemoDirector.h new file mode 100644 index 0000000..203abf9 --- /dev/null +++ b/include/game/SceneObjs/CapManHeroDemoDirector.h @@ -0,0 +1,16 @@ +#pragma once + +#include "al/hio/HioNode.h" +#include "al/iuse/ISceneObj.h" + +class CapManHeroBase; +class StageTalkDemoNpcCap; + +class CapManHeroDemoDirector : public al::HioNode, public al::ISceneObj { +public: + CapManHeroBase* mCapManHero; + StageTalkDemoNpcCap* mTalkDemoCurrent; + StageTalkDemoNpcCap* mTalkDemoFirstMoonGet; + StageTalkDemoNpcCap* mTalkDemoStageStart; + StageTalkDemoNpcCap* mTalkDemoMoonRock; +}; diff --git a/include/game/StageScene/ChangeStageInfo.h b/include/game/StageScene/ChangeStageInfo.h index d7e091d..d0848a1 100644 --- a/include/game/StageScene/ChangeStageInfo.h +++ b/include/game/StageScene/ChangeStageInfo.h @@ -38,17 +38,16 @@ class ChangeStageInfo CVEFUN(ChangeStageInfo, 0x0021C5A0, bool, isSubScenarioTypeResetMiniGame); VCEFUN(ChangeStageInfo, 0x0021C5C0, setWipeType, EFUN_ARGS(const char* type), EFUN_ARGS(type)); #endif -private: + #if(SMOVER==100) - sead::FixedSafeString<128> mStageEntranceName; + sead::FixedSafeString<128> mStageId; sead::FixedSafeString<128> mStageName; - sead::FixedSafeString<128> mUnkStr; + sead::FixedSafeString<128> mObjId; bool mUnkBool; - spad(pad, 0x3); s32 mScenario; SubScenarioType mSubScenarioType; sead::FixedSafeString<128> mWipeType; - s32 mUnkInt; + s32 mHintPriority; spad(unk, 0x4); #endif #if(SMOVER==130) @@ -56,4 +55,4 @@ class ChangeStageInfo #endif }; -static_assert(sizeof(ChangeStageInfo) == 0x278); \ No newline at end of file +static_assert(sizeof(ChangeStageInfo) == 0x278); diff --git a/include/game/StageScene/StageScene.h b/include/game/StageScene/StageScene.h index 8201d4a..37c331a 100644 --- a/include/game/StageScene/StageScene.h +++ b/include/game/StageScene/StageScene.h @@ -4,6 +4,79 @@ #include "game/Amiibo/HelpAmiiboDirector.h" #include "game/StageScene/StageSceneLayout.h" +namespace al { +class LiveActorGroup; +class Projection; +class WipeHolder; +class WipeSimple { + public: + void startOpen(int); + void startClose(int); +}; +class WindowConfirm; +class HtmlViewer; +class SimpleLayoutAppearWaitEnd; +class SimpleAudioUser; +class CameraTicket; +class ParabolicPath; +class DemoSyncedEventKeeper; +class ChromakeyDrawer; +class NfpDirector; +class LayoutTextureRenderer; +class LiveActor; +} + +class StageSceneStateTimeBalloon; +class StageSceneStateWorldMap; +class StageSceneStateShop; +class StageSceneStateSnapShot; +class StageSceneStateGetShine; +class StageSceneStateGetShineMain; +class StageSceneStateGetShineGrand; +class StageSceneStateCollectBgm; +class StageSceneStateMiniGameRanking; +class StageSceneStatePauseMenu; +class StageSceneStateCloset; +class StageSceneStateCollectionList; +class StageSceneStateSkipDemo; +class StageSceneStateCheckpointWarp; +class StageSceneStateCarryMeat; +class TimeBalloonSequenceInfo; +class StageSceneStateTitleLogo; +class StageSceneStateMiss; +class StageSceneStateYukimaruRace; +class StageSceneStateYukimaruRaceTutorial; +class StageSceneStateRaceManRace; +class StageSceneStateRadicon; +class StageSceneStateScenarioCamera; +class StageSceneStateGetShineMainSandWorld; +class StageSceneStateRecoverLife; +class StageSceneStateTalk; +class StageSceneStateWarp; +class StageSceneStateWorldIntroCamera; +class ScenarioStartCameraHolder; +class CinemaCaption; +class MapLayout; +class CollectionList; +class TimeBalloonNpc; +class ProjectItemDirector; +class Pyramid; +class PlayGuideSkip; +class LocationNameCtrl; +class MiniGameMenu; +class NpcEventDirector; +class ControllerGuideSnapShotCtrl; +class InputSeparator; +class OpeningStageStartDemo; +class SceneAudioSystemPauseController; +class DemoSoundSynchronizer; +class ProjectSeNamedList; +class TimeBalloonDirector; +class KoopaHackFunction; +class CollectBgmRegister; +class BgmAnimeSyncDirector; +class HelpAmiiboDirector; + class StageScene : public al::Scene { public: @@ -26,17 +99,107 @@ class StageScene : public al::Scene CVEFUN(StageScene, 0x00473080, bool, isDefeatKoopaLv1); #endif #if(SMOVER==100) - spad(inherit, 0x2D0 - sizeof(al::Scene)); - GameDataHolderAccessor* mHolder; // 0x2D0 - spad(gap1, 0x20); - StageSceneLayout* stageSceneLayout; // 0x2F8 - spad(gap2, 0x1B8); - HelpAmiiboDirector* mHelpAmiiboDirector; // 0x4B8 + sead::FixedSafeString<64> mCurrentStageName; + unsigned int scenarioNo; + + // States - 0x138 to 0x208 + StageSceneStateWorldMap *mStateWorldMap; + StageSceneStateShop *mStateShop; + StageSceneStateSnapShot *mStateSnapShot; + StageSceneStateGetShine *mStateGetShine; + StageSceneStateGetShineMain *mStateGetShineMain; + StageSceneStateGetShineGrand *mStateGetShineGrand; + StageSceneStateCollectBgm *mStateCollectBgm; + StageSceneStateCollectionList *mStateCollectionList; + StageSceneStateMiniGameRanking *mStateMiniGameRanking; + StageSceneStatePauseMenu *mStatePauseMenu; + StageSceneStateCloset *mStateCloset; + StageSceneStateSkipDemo *mStateSkipDemo; + StageSceneStateCheckpointWarp *mStateCheckpointWarp; + StageSceneStateCarryMeat *mStateCarryMeat; + StageSceneStateTimeBalloon *mStateTimeBalloon; + StageSceneStateTitleLogo *mStateTitleLogo; + StageSceneStateMiss *mStateMiss; + StageSceneStateYukimaruRace *mStateYukimaruRace; + StageSceneStateYukimaruRaceTutorial *mStateYukimaruRaceTutorial; + StageSceneStateRaceManRace *mStateRaceManRace; + StageSceneStateRadicon *mStateRadicon; + StageSceneStateScenarioCamera *mStateScenarioCamera; + StageSceneStateRecoverLife *mStateRecoverLife; + StageSceneStateGetShineMainSandWorld *mStateGetShineMainSandWorld; + StageSceneStateTalk *mStateTalk; + StageSceneStateWarp *mStateWarp; + StageSceneStateWorldIntroCamera *mStateWorldIntroCamera; + + ScenarioStartCameraHolder *mScenarioStartCameraHolder; + sead::FixedSafeString<64> mCostumeName; + sead::FixedSafeString<64> mCapName; + unsigned char gap1[0x8]; + GameDataHolderAccessor *mDataHolder; + al::PlacementInfo *mPlacementInfo; + al::LayoutTextureRenderer *mLayoutTextureRenderer; + PlayGuideSkip *mPlayGuideSkip; + CinemaCaption *mCinemaCaption; + StageSceneLayout *mStageSceneLayout; + bool enableLayout; + al::SimpleLayoutAppearWaitEnd *mLayoutStartScenario; + al::SimpleLayoutAppearWaitEnd *mLayoutStartWorld; + al::SimpleLayoutAppearWaitEnd *mLayoutStartWorldRegion; + ControllerGuideSnapShotCtrl *mControllerGuideSnapShotCtrl; + InputSeparator *mInputSeparator; + al::WipeSimple *mWipeCircle; + al::WipeHolder *mWipeHolder; + LocationNameCtrl *mLocationNameCtrl; + al::WindowConfirm *mWindowConfirm; + MiniGameMenu *mMiniGameMenu; + bool *hasStartedStage; // probably wrong + unsigned char gap_360[0x10]; + MapLayout *mMapLayout; + al::SimpleLayoutAppearWaitEnd *mMenuLayout; + al::LiveActorGroup *mShoppingWatcher; + CollectionList *mCollectionList; + __int64_t unkNoIdea; + TimeBalloonNpc *mTimeBalloonNpc; // placement for this object 004C9844 + ProjectItemDirector *mProjectItemDirector; + Pyramid *mPyramid; + OpeningStageStartDemo *mOpeningStageStartDemo; // can also be DemoStartWorldWaterfallStage + __int64_t nerveExeDemoStageStart; + SceneAudioSystemPauseController *mSceneAudioSystemPauseController; + DemoSoundSynchronizer *mDemoSoundSynchronizer; + al::SimpleAudioUser *mAudioStageStartAtmosSe; + al::SimpleAudioUser *mAudioSePlayArea; + al::SimpleAudioUser *mAudioSnapShotCameraCtrl; + ProjectSeNamedList *mProjectSeNamedList; + unsigned char gap_3F0[0x8]; + TimeBalloonDirector *mTimeBalloonDirector; + TimeBalloonSequenceInfo *mTimeBalloonSequenceInfo; + __int64_t unkSomethingElse; + al::CameraTicket *mWarpCheckpointCamera; + sead::Vector3f *mWarpToCheckpointCamera; + sead::Vector3f *mWarpToCheckpointCameraPoint; + sead::Vector3f *mWarpToCheckpointPlayerPos; + sead::Vector3f mWarpToCheckpointDestPoint; + unsigned char padding_43C[0x4]; + al::LiveActor *mCheckpointFlagWarp; + al::ParabolicPath *mParabolicPath; + KoopaHackFunction *mKoopaHackFunction; + al::LiveActor *mShineDot; + unsigned char gap_460[0x10]; + CollectBgmRegister *mCollectBgmRegister; + BgmAnimeSyncDirector *mBgmAnimeSyncDirector; + al::DemoSyncedEventKeeper *mDemoSyncedEventKeeper; + char *activeDemoName; + char *activeDemoType; // maybe wrong + NpcEventDirector *mNpcEventDirector; + al::ChromakeyDrawer *mChromakeyDrawer; + al::HtmlViewer *mHtmlViewer; + al::NfpDirector *mNfpDirector; + HelpAmiiboDirector *mHelpAmiiboDirector; #endif #if(SMOVER==130) spad(inherit, 0x2E0 - sizeof(al::Scene)); - GameDataHolderAccessor* mHolder; // 0x2E0 + GameDataHolderAccessor* mDataHolder; // 0x2E0 spad(gap1, 0x20); - StageSceneLayout* stageSceneLayout; // 0x308 + StageSceneLayout* mStageSceneLayout; // 0x308 #endif }; diff --git a/include/game/StageScene/StageSceneState.h b/include/game/StageScene/StageSceneState.h new file mode 100644 index 0000000..802d058 --- /dev/null +++ b/include/game/StageScene/StageSceneState.h @@ -0,0 +1,37 @@ +#pragma once + +#include "al/nerve/NerveStateBase.h" +#include "al/scene/Scene.h" +#include "game/Layouts/ShineListLayout.h" + +class HackListLayout; +class SouvenirListLayout; +class StageSceneStateStageMap; +class StageSceneStateCollectBgm; +class InputSeparator; +class CursorParts; +class FooterParts; +class RollParts; +class SceneAudioSystemPauseController; +namespace al { +class SimpleLayoutAppearWaitEnd; +} + +class StageSceneStateCollectionList : public al::NerveStateBase { +public: + al::Scene* mScene; + ShineListLayout* mShineList; + HackListLayout* mHackList; + SouvenirListLayout* mSouvenirList; + StageSceneStateStageMap* mStateStageMap; + StageSceneStateCollectBgm* mStateCollectBgm; + InputSeparator* mInputSeparator; + al::SimpleLayoutAppearWaitEnd* uVar1; + CursorParts* mCursorParts; + al::SimpleLayoutAppearWaitEnd* uVar2; + FooterParts* mFooterParts; + RollParts* mRollParts; + void* uVar3; + unsigned char padding[0x18]; + SceneAudioSystemPauseController* mSceneAudioSystemPauseController; +}; diff --git a/include/game/System/Application.h b/include/game/System/Application.h new file mode 100644 index 0000000..794cd8c --- /dev/null +++ b/include/game/System/Application.h @@ -0,0 +1,21 @@ +#pragma once + +#include + +namespace al { + class SystemKit; + class GameFrameworkNx; + class DrawSystemInfo; + class AccountHolder; +} + +class Application : public sead::IDisposer { +public: + static const Application* sInstance; + + al::SystemKit* mSystemKit; + al::GameFrameworkNx *mFramework; + al::DrawSystemInfo* mDrawSystemInfo; + al::AccountHolder* mAccountHolder; +}; +// const Application *Application::sInstance; diff --git a/include/game/System/GameFrameWorkNx.h b/include/game/System/GameFrameWorkNx.h index 43b71b0..ff58658 100644 --- a/include/game/System/GameFrameWorkNx.h +++ b/include/game/System/GameFrameWorkNx.h @@ -1,9 +1,17 @@ #pragma once -namespace al -{ - class GameFrameworkNx { - public: - // 0x210 agl::DrawContext - }; +#include +#include +#include +#include +#include +#include +#include +#include + +namespace al { +class GpuPerf; + +class GameFrameworkNx : public sead::GameFrameworkNx { +}; } // namespace al diff --git a/include/game/WorldEndBorderKeeper.h b/include/game/WorldEndBorderKeeper.h new file mode 100644 index 0000000..01992c8 --- /dev/null +++ b/include/game/WorldEndBorderKeeper.h @@ -0,0 +1,26 @@ +#pragma once + +#include "al/LiveActor/LiveActor.h" +#include "al/nerve/NerveExecutor.h" +#include +#include "al/area/AreaObj.h" + +class WorldEndBorderKeeper : public al::NerveExecutor { +public: + void exeInside(void); + void exeOutside(void); + void exePullBack(void); + void exeWaitBorder(void); + void reset(void); + void update(sead::Vector3f const&, sead::Vector3f const&, bool); + + al::LiveActor* mPlayer; + sead::Vector3f mPlayerTrans; + sead::Vector3f mPlayerVel; + bool mIsAirborne; + al::AreaObj* uVar1; + sead::Vector3f mBorderPoint; // closest point to the player that's inside the border + float mOscillateFrame; // goes to 240, only while the player is airborne + float mDistIntoBorder; // distance travelled into border before it starts to pull you back + sead::Vector3f mPullVel; // varies sinusoidally by 300 as oscillation does +}; diff --git a/include/mem.h b/include/mem.h index 05f19b2..13a824b 100644 --- a/include/mem.h +++ b/include/mem.h @@ -5,7 +5,11 @@ #include void* aligned_alloc(size_t alignment, size_t size); +extern "C" void free(void*); -#define alloc(SIZE) nn::init::GetAllocator()->Allocate(SIZE) -#define dealloc(PTR) nn::init::GetAllocator()->Free(PTR) -#define realloc(PTR, SIZE) nn::init::GetAllocator()->Reallocate(PTR, SIZE); \ No newline at end of file +//#define alloc(SIZE) nn::init::GetAllocator()->Allocate(SIZE) +//#define dealloc(PTR) nn::init::GetAllocator()->Free(PTR) +//#define realloc(PTR, SIZE) nn::init::GetAllocator()->Reallocate(PTR, SIZE); + +#define alloc(SIZE) aligned_alloc(0x10, SIZE) +#define dealloc(PTR) free(PTR) diff --git a/include/nn/atk/SoundStartable.h b/include/nn/atk/SoundStartable.h new file mode 100644 index 0000000..4503b69 --- /dev/null +++ b/include/nn/atk/SoundStartable.h @@ -0,0 +1,22 @@ +/** + * @file SoundPlayer.h + * @brief Sound player. + */ + +#pragma once + +#include "types.h" + +namespace nn +{ + namespace atk + { + class SoundHandle; + class SoundStartable { + public: + struct StartInfo; + + bool StartSound(SoundHandle*, const char*, const StartInfo*); + }; + }; +}; diff --git a/include/nn/hid.h b/include/nn/hid.h index 051f76d..bf6ff11 100644 --- a/include/nn/hid.h +++ b/include/nn/hid.h @@ -19,6 +19,5 @@ namespace nn void SetSupportedNpadIdType(u32 const* , u64); void SetSupportedNpadStyleSet(nn::util::BitFlagSet<32, nn::hid::NpadStyleTag>); void GetNpadStyleSet(u32 const &); - void GetNpadStates(nn::hid::NpadHandheldState *, s32, u32 const &); }; -}; \ No newline at end of file +}; diff --git a/include/nn/util.h b/include/nn/util.h index 9f88a91..647c91f 100644 --- a/include/nn/util.h +++ b/include/nn/util.h @@ -2,9 +2,35 @@ #include "../types.h" -namespace nn { namespace util { +namespace nn { +namespace util { -s32 SNPrintf(char* s, ulong n, const char* format, ...); -s32 VSNPrintf(char* s, ulong n, const char* format, va_list arg); +s32 SNPrintf(char *s, ulong n, const char *format, ...); +s32 VSNPrintf(char *s, ulong n, const char *format, va_list arg); -} } +} // namespace util + +namespace hid { +struct NpadBaseState { + long mSamplingNumber; + long mButtons; + long mAnalogStickL; + long mAnalogStickR; + int mAttributes; + int RESERVED; +}; + +struct NpadHandheldState : NpadBaseState{}; +struct NpadJoyDualState : NpadBaseState{}; +struct NpadFullKeyState : NpadBaseState{}; +struct NpadJoyLeftState : NpadBaseState{}; +struct NpadJoyRightState : NpadBaseState{}; + +void GetNpadStates(NpadHandheldState *, int, const unsigned int &); +void GetNpadStates(NpadJoyDualState *, int, const unsigned int &); +void GetNpadStates(NpadFullKeyState *, int, const unsigned int &); +void GetNpadStates(NpadJoyLeftState *, int, const unsigned int &); +void GetNpadStates(NpadJoyRightState *, int, const unsigned int &); +} // namespace hid + +} // namespace nn diff --git a/include/rs/util.hpp b/include/rs/util.hpp index 82f9cd2..63a6a5e 100644 --- a/include/rs/util.hpp +++ b/include/rs/util.hpp @@ -1,6 +1,6 @@ #pragma once #include "al/scene/Scene.h" -#include "al/scene/SceneObjHolder.h" +#include "al/iuse/IUseSceneObjHolder.h" #include "game/Player/PlayerActorHakoniwa.h" #include "sead/math/seadVector.h" #include @@ -37,4 +37,15 @@ int getActiveQuestNo(al::IUseSceneObjHolder const*); const char* getActiveQuestLabel(al::IUseSceneObjHolder const*); void requestShowHtmlViewer(al::IUseSceneObjHolder const*); -} \ No newline at end of file +#if (SMOVER == 100) +int getPlayerJumpCount(GameDataHolder const*); +int getPlayerThrowCapCount(GameDataHolder const*); +int getTotalCoinNum(GameDataHolder const*); +#endif +#if (SMOVER == 130) +EFUN(0x004ED610, int, getPlayerJumpCount, EFUN_ARGS(const GameDataHolder*)); +EFUN(0x004ED640, int, getPlayerThrowCapCount, EFUN_ARGS(const GameDataHolder*)); +EFUN(0x004ED410, int, getTotalCoinNum, EFUN_ARGS(const GameDataHolder*)); +#endif + +} diff --git a/include/sead/FrameBuffer.h b/include/sead/FrameBuffer.h new file mode 100644 index 0000000..d1ae4d6 --- /dev/null +++ b/include/sead/FrameBuffer.h @@ -0,0 +1,14 @@ +#pragma once + +namespace sead { + +struct DrawContext; + +class LogicalFrameBuffer; + +class FrameBuffer { +public: + void bind(DrawContext* context) const; +}; + +} diff --git a/include/sead/controller/nin/seadNinJoyNpadDevice.h b/include/sead/controller/nin/seadNinJoyNpadDevice.h new file mode 100644 index 0000000..dd929a5 --- /dev/null +++ b/include/sead/controller/nin/seadNinJoyNpadDevice.h @@ -0,0 +1,29 @@ +#pragma once + +#include "controller/seadControlDevice.h" +#include "controller/seadController.h" +#include "heap/seadHeap.h" + +namespace nn::hid { + +typedef int NpadJoyHoldType; + +} + +namespace sead +{ +// stubbed and only added methods for seadControllerMgr +class NinJoyNpadDevice : public ControlDevice +{ +public: + NinJoyNpadDevice(ControllerMgr* mgr, Heap* heap); + + void calc() override; + +//private: + int mNpadIdUpdateNum; + nn::hid::NpadJoyHoldType mNpadJoyHoldType; + void *SEAD_NINJOYNPADDEVICE[4261]; +}; + +} // namespace sead diff --git a/include/sead/controller/seadAccelerometerAddon.h b/include/sead/controller/seadAccelerometerAddon.h new file mode 100644 index 0000000..f3970f6 --- /dev/null +++ b/include/sead/controller/seadAccelerometerAddon.h @@ -0,0 +1,34 @@ +#pragma once + +#include "controller/seadControllerAddon.h" +#include "math/seadVector.h" + +namespace sead +{ +class Controller; + +class AccelerometerAddon : public ControllerAddon +{ + SEAD_RTTI_OVERRIDE(AccelerometerAddon, ControllerAddon) + +public: + explicit AccelerometerAddon(Controller* controller) + : ControllerAddon(controller), mIsEnable(false), mAcceleration(0.0f, 0.0f, 0.0f) + { + mId = ControllerDefine::cAddon_Accelerometer; + } + + ~AccelerometerAddon() override = default; + + bool isEnable() const { return mIsEnable; } + const Vector3f& getAcceleration() const { return mAcceleration; } + +protected: + bool mIsEnable; + Vector3f mAcceleration; +}; +#ifdef cafe +static_assert(sizeof(AccelerometerAddon) == 0x24, "sead::AccelerometerAddon size mismatch"); +#endif // cafe + +} // namespace sead diff --git a/include/sead/controller/seadControlDevice.h b/include/sead/controller/seadControlDevice.h new file mode 100644 index 0000000..c09507c --- /dev/null +++ b/include/sead/controller/seadControlDevice.h @@ -0,0 +1,35 @@ +#pragma once + +#include "container/seadListImpl.h" +#include "controller/seadControllerDefine.h" +#include "prim/seadRuntimeTypeInfo.h" + +namespace sead +{ +class ControllerMgr; + +class ControlDevice +{ + SEAD_RTTI_BASE(ControlDevice) + +public: + explicit ControlDevice(ControllerMgr* mgr) : mId(ControllerDefine::cDevice_Null), mMgr(mgr) {} + + virtual ~ControlDevice() = default; + + virtual void calc() = 0; + + ControllerDefine::DeviceId getId() const { return mId; } + +//protected: + ListNode mListNode; + ControllerDefine::DeviceId mId; + ControllerMgr* mMgr; + + friend class ControllerMgr; +}; +#ifdef cafe +static_assert(sizeof(ControlDevice) == 0x14, "sead::ControlDevice size mismatch"); +#endif // cafe + +} // namespace sead diff --git a/include/sead/controller/seadController.h b/include/sead/controller/seadController.h new file mode 100644 index 0000000..32d1ace --- /dev/null +++ b/include/sead/controller/seadController.h @@ -0,0 +1,95 @@ +#pragma once + +#include "container/seadOffsetList.h" +#include "controller/seadControllerBase.h" +#include "controller/seadControllerDefine.h" + +namespace sead +{ +class ControllerAddon; +class ControllerMgr; +class ControllerWrapperBase; + +class Controller : public ControllerBase +{ + SEAD_RTTI_OVERRIDE(Controller, ControllerBase) +public: + enum PadIdx + { + cPadIdx_A = 0, + cPadIdx_B = 1, + cPadIdx_C = 2, + cPadIdx_X = 3, + cPadIdx_Y = 4, + cPadIdx_Z = 5, + cPadIdx_2 = 6, // Also Right-Stick Click + cPadIdx_1 = 7, // Also Left-Stick Click + cPadIdx_Home = 8, + cPadIdx_Minus = 9, + cPadIdx_Plus = 10, + cPadIdx_Start = 11, + cPadIdx_Select = 12, + cPadIdx_ZL = cPadIdx_C, + cPadIdx_ZR = cPadIdx_Z, + cPadIdx_L = 13, + cPadIdx_R = 14, + cPadIdx_Touch = 15, + cPadIdx_Up = 16, + cPadIdx_Down = 17, + cPadIdx_Left = 18, + cPadIdx_Right = 19, + cPadIdx_LeftStickUp = 20, + cPadIdx_LeftStickDown = 21, + cPadIdx_LeftStickLeft = 22, + cPadIdx_LeftStickRight = 23, + cPadIdx_RightStickUp = 24, + cPadIdx_RightStickDown = 25, + cPadIdx_RightStickLeft = 26, + cPadIdx_RightStickRight = 27, + cPadIdx_Max = 28 + }; + + explicit Controller(ControllerMgr* mgr); + virtual ~Controller(); + + virtual void calc(); + virtual bool isConnected() const; + ControllerAddon* getAddonByOrder(ControllerDefine::AddonId id, int index) const; + ControllerAddon* getAddon(ControllerDefine::AddonId id) const; + + template + T getAddonAs() const; + +protected: + virtual void calcImpl_() = 0; + virtual bool isIdle_(); + virtual void setIdle_(); + +public: +//private: + ControllerDefine::ControllerId mId; + ControllerMgr* mMgr; + OffsetList mAddons; + OffsetList mWrappers; + + friend class ControllerWrapperBase; + friend class ControllerMgr; +}; +#ifdef cafe +static_assert(sizeof(Controller) == 0x15C, "sead::Controller size mismatch"); +#endif // cafe + +template +T Controller::getAddonAs() const +{ + for (auto& addon : mAddons) + { + T result = DynamicCast>(addon); + if (result) + return result; + } + + return nullptr; +} + +} // namespace sead diff --git a/include/sead/controller/seadControllerAddon.h b/include/sead/controller/seadControllerAddon.h new file mode 100644 index 0000000..f8dc3b6 --- /dev/null +++ b/include/sead/controller/seadControllerAddon.h @@ -0,0 +1,36 @@ +#pragma once + +#include "container/seadListImpl.h" +#include "controller/seadControllerDefine.h" +#include "prim/seadRuntimeTypeInfo.h" + +namespace sead +{ +class Controller; + +class ControllerAddon +{ + SEAD_RTTI_BASE(ControllerAddon) + +public: + explicit ControllerAddon(Controller* controller) + : mId(ControllerDefine::cAddon_Null), mController(controller) + { + } + + virtual ~ControllerAddon() = default; + + virtual bool calc() = 0; + +//protected: + ListNode mListNode; + ControllerDefine::AddonId mId; + Controller* mController; + + friend class Controller; +}; +#ifdef cafe +static_assert(sizeof(ControllerAddon) == 0x14, "sead::ControllerAddon size mismatch"); +#endif // cafe + +} // namespace sead diff --git a/include/sead/controller/seadControllerBase.h b/include/sead/controller/seadControllerBase.h new file mode 100644 index 0000000..c16d51e --- /dev/null +++ b/include/sead/controller/seadControllerBase.h @@ -0,0 +1,129 @@ +#pragma once + +#include "math/seadBoundBox.h" +#include "math/seadVector.h" +#include "prim/seadBitFlag.h" +#include "prim/seadRuntimeTypeInfo.h" + +namespace sead +{ +class Vector2i { + int x, y; +}; + +class ControllerBase +{ + SEAD_RTTI_BASE(ControllerBase) +public: + static const f32 cStickHoldThresholdDefault; + static const f32 cStickReleaseThresholdDefault; + static const Vector2f cInvalidPointer; + static const Vector2i cInvalidPointerS32; + + ControllerBase(s32 padBitMax, s32 leftStickCrossStartBit, s32 rightStickCrossStartBit, + s32 touchKeyBit); + + u32 getHoldMask() const { return mPadHold.getDirect(); } + u32 getTrigMask() const { return mPadTrig.getDirect(); } + u32 getReleaseMask() const { return mPadRelease.getDirect(); } + u32 getRepeatMask() const { return mPadRepeat.getDirect(); } + + u32 getPadHoldCount(s32 bit) const; + + const Vector2f& getLeftStick() const { return mLeftStick; } + const Vector2f& getRightStick() const { return mRightStick; } + f32 getLeftAnalogTrigger() const { return mLeftAnalogTrigger; } + f32 getRightAnalogTrigger() const { return mRightAnalogTrigger; } + const Vector2f& getPointer() const { return mPointer; } + const Vector2i& getPointerPrev() const { return mPointerS32; } + bool isPointerOn() const { return mPointerFlag.isOn(cPointerOn); } + bool isPointerOnNow() const { return mPointerFlag.isOn(cPointerOnNow); } + bool isPointerOffNow() const { return mPointerFlag.isOn(cPointerOffNow); } + bool isPointerUnkFlag3() const { return mPointerFlag.isOn(cPointerUnkFlag3); } + + bool isHold(u32 mask) const { return mask & getHoldMask(); } + bool isTrig(u32 mask) const { return mask & getTrigMask(); } + bool isHoldAll(u32 mask) const { return (mask & getHoldMask()) == mask; } + bool isRelease(u32 mask) const { return mask & getReleaseMask(); } + bool isRepeat(u32 mask) const { return mask & getRepeatMask(); } + + bool isTrigWithRepeat(u32 mask) const + { + u32 trig = getTrigMask(); + u32 repeat = getRepeatMask(); + return (repeat | trig) & mask; + } + + void setPadRepeat(u32 mask, u8 delay_frame, u8 pulse_frame); + + void setLeftStickCrossThreshold(f32 hold, f32 release); + void setRightStickCrossThreshold(f32 hold, f32 release); + + void setPointerBound(const BoundBox2f& bound); + const BoundBox2f& getPointerBound() const { return mPointerBound; } + +protected: + bool isIdleBase_(); + void setIdleBase_(); + void setPointerWithBound_(bool is_on, bool touchkey_hold, const Vector2f& pos); + void updateDerivativeParams_(u32 prev_hold, bool prev_pointer_on); + u32 getStickHold_(u32 prev_hold, const Vector2f& stick, f32 hold_threshold, + f32 release_threshold, s32 start_bit); + u32 createStickCrossMask_(); + +private: + enum + { + cPadIdx_MaxBase = 32 + }; + + enum PointerFlagMask + { + cPointerOn = 1 << 0, + cPointerOnNow = 1 << 1, + cPointerOffNow = 1 << 2, + cPointerUnkFlag3 = 1 << 3 + }; + + enum + { + cCrossUp, + cCrossDown, + cCrossLeft, + cCrossRight + }; + + BitFlag32 mPadTrig; + BitFlag32 mPadRelease; + BitFlag32 mPadRepeat; + BitFlag32 mPointerFlag; + Vector2i mPointerS32; + BoundBox2f mPointerBound; + u32 mPadHoldCounts[cPadIdx_MaxBase]; + u8 mPadRepeatDelays[cPadIdx_MaxBase]; + u8 mPadRepeatPulses[cPadIdx_MaxBase]; + f32 mLeftStickHoldThreshold; + f32 mRightStickHoldThreshold; + f32 mLeftStickReleaseThreshold; + f32 mRightStickReleaseThreshold; + s32 mPadBitMax; + s32 mLeftStickCrossStartBit; + s32 mRightStickCrossStartBit; + s32 mTouchKeyBit; + s32 mIdleFrame; + BitFlag32 mPadHold; + Vector2f mPointer; + Vector2f mLeftStick; + Vector2f mRightStick; + f32 mLeftAnalogTrigger; + f32 mRightAnalogTrigger; + + friend class Controller; + friend class ControllerWrapper; + friend class ControllerWrapperBase; +}; +#ifdef cafe +static_assert(sizeof(ControllerBase) == 0x130, "sead::ControllerBase size mismatch"); +#endif // cafe + +} // namespace sead diff --git a/include/sead/controller/seadControllerDefine.h b/include/sead/controller/seadControllerDefine.h new file mode 100644 index 0000000..3145fc4 --- /dev/null +++ b/include/sead/controller/seadControllerDefine.h @@ -0,0 +1,54 @@ +#pragma once + +#include "basis/seadTypes.h" + +namespace sead +{ +// from Wii U-decomp, not adjusted to switch +class ControllerDefine +{ +public: + enum ControllerId + { + cController_Null = 0, + cController_Win = 1, + cController_Ctr = 2, + cController_CtrDebug = 3, + cController_WiiRemote = 4, + cController_CafeDebug = 5, + cController_WinDRC = 6, + cController_CafeRemote = 7, + cController_CafeDRC = 8, + cController_Merge = 9, + cController_UserDefine = 10, + + _15 = 15, + _16 = 16 + }; + + enum DeviceId + { + cDevice_Null = 0, + cDevice_KeyboardMouse = 1, + cDevice_CtrHid = 2, + cDevice_WinJoyPad = 3, + cDevice_RvlWPad = 4, + cDevice_WinWPad = 5, + cDevice_CafeDebugPad = 6, + cDevice_CafeWPad = 7, + cDevice_CafeVPad = 8, + cDevice_UserDefine = 9, + + _13 = 13 + }; + + enum AddonId + { + cAddon_Null = 0, + cAddon_Accelerometer = 1, + cAddon_PatternRumble = 2, + cAddon_UserDefine = 3 + }; +}; + +} // namespace sead diff --git a/include/sead/controller/seadControllerMgr.h b/include/sead/controller/seadControllerMgr.h index fe07cd3..492621b 100644 --- a/include/sead/controller/seadControllerMgr.h +++ b/include/sead/controller/seadControllerMgr.h @@ -1,29 +1,128 @@ #pragma once -#include "sead/heap/seadDisposer.h" +#include "container/seadOffsetList.h" +#include "container/seadPtrArray.h" +#include "controller/seadController.h" +#include "framework/seadCalculateTask.h" +#include "framework/seadTaskMgr.h" +#include "framework/seadTaskParameter.h" +#include "heap/seadDisposer.h" +#include "prim/seadRuntimeTypeInfo.h" namespace sead { +class ControlDevice; +class Controller; +class ControllerAddon; - namespace ControllerDefine +class ControllerMgr : public CalculateTask +{ + SEAD_TASK_SINGLETON(ControllerMgr) + SEAD_RTTI_OVERRIDE(ControllerMgr, CalculateTask) + +private: + class ConstructArg : public TaskConstructArg { - typedef unsigned int ControllerId; + public: + //ConstructArg() : TaskConstructArg(), mHeapArray() { heap_array = &mHeapArray; } + + private: + HeapArray mHeapArray; }; - class Controller +public: + struct Parameter : public TaskParameter { - + SEAD_RTTI_OVERRIDE(Parameter, TaskParameter) + + public: + s32 controllerMax; + IDelegate1* proc; }; - class ControllerMgr + +public: + ControllerMgr(); + explicit ControllerMgr(const TaskConstructArg& arg); + ~ControllerMgr() override; + + void prepare() override; + void calc() override; + + void initialize(s32 controller_max, Heap* heap); + void finalize(); + + void initializeDefault(Heap* heap); + void finalizeDefault(); + + // TODO: Add/remove devices & controllers + + Controller* getControllerByOrder(ControllerDefine::ControllerId id, s32 index) const; + ControlDevice* getControlDevice(ControllerDefine::DeviceId id) const; + ControllerAddon* getControllerAddon(s32 index, ControllerDefine::AddonId id) const; + ControllerAddon* getControllerAddonByOrder(s32 controller_index, + ControllerDefine::AddonId addon_id, + int addon_index) const; + + template + T getControllerByOrderAs(s32 index) const; + template + T getControlDeviceAs() const; + template + T getControllerAddonAs(s32 index) const; + + s32 findControllerPort(const Controller* controller) const; + + DelegateThread* getFramework() const; + + Controller* getController(int port) { return mControllers[port]; } + +//private: + OffsetList mDevices; + PtrArray mControllers; +}; +#ifdef cafe +static_assert(sizeof(ControllerMgr) == 0xE8, "sead::ControllerMgr size mismatch"); +#endif // cafe + +template +T ControllerMgr::getControllerByOrderAs(s32 index) const +{ + for (PtrArray::iterator it = mControllers.begin(); it != mControllers.end(); ++it) { - SEAD_SINGLETON_DISPOSER(ControllerMgr) - public: - int findControllerPort(Controller*); - Controller* getControllerByOrder(ControllerDefine::ControllerId id, int); + T controller = DynamicCast::type>(&(*it)); + if (controller) + { + if (index == 0) + return controller; - /*unsigned char padding1[0x188]; - unsigned int controllerAmount; // idk how right this is - int padding2;*/ + index--; + } + } - }; -} \ No newline at end of file + return nullptr; +} + +template +T ControllerMgr::getControlDeviceAs() const +{ + for (OffsetList::iterator it = mDevices.begin(); it != mDevices.end(); ++it) + { + T device = DynamicCast::type>(&(*it)); + if (device) + return device; + } + + return nullptr; +} + +template +T ControllerMgr::getControllerAddonAs(s32 index) const +{ + Controller* controller = mControllers.at(index); + if (controller) + return controller->getAddonAs(); + + return nullptr; +} + +} // namespace sead diff --git a/include/sead/controller/seadControllerWrapper.h b/include/sead/controller/seadControllerWrapper.h new file mode 100644 index 0000000..a3f28a8 --- /dev/null +++ b/include/sead/controller/seadControllerWrapper.h @@ -0,0 +1,29 @@ +#pragma once + +#include "controller/seadControllerWrapperBase.h" + +namespace sead +{ +class ControllerWrapper : public ControllerWrapperBase +{ + SEAD_RTTI_OVERRIDE(ControllerWrapper, ControllerWrapperBase) + +public: + static const u8 cPadConfigDefault[Controller::cPadIdx_Max]; + + ControllerWrapper(); + ~ControllerWrapper() override = default; + + void calc(u32 prev_hold, bool prev_pointer_on) override; + + u32 createPadMaskFromControllerPadMask_(u32 controller_mask) const; + void setPadConfig(s32 padbit_max, const u8* pad_config, bool enable_stickcross_emulation); + +protected: + u8 mPadConfig[cPadIdx_MaxBase]; +}; +#ifdef cafe +static_assert(sizeof(ControllerWrapper) == 0x194, "sead::ControllerWrapper size mismatch"); +#endif // cafe + +} // namespace sead diff --git a/include/sead/controller/seadControllerWrapperBase.h b/include/sead/controller/seadControllerWrapperBase.h new file mode 100644 index 0000000..5fa5de7 --- /dev/null +++ b/include/sead/controller/seadControllerWrapperBase.h @@ -0,0 +1,44 @@ +#pragma once + +#include "controller/seadController.h" +#include "heap/seadDisposer.h" +#include "prim/seadRuntimeTypeInfo.h" + +namespace sead +{ +class Controller; + +class ControllerWrapperBase : public ControllerBase, public IDisposer +{ + SEAD_RTTI_OVERRIDE(ControllerWrapperBase, ControllerBase) + +public: + ControllerWrapperBase(); + virtual ~ControllerWrapperBase(); + + virtual void calc(u32 prev_hold, bool prev_pointer_on) = 0; + virtual void setIdle(); + +protected: + virtual bool isIdle_(); + +public: + void registerWith(Controller* controller, bool copy_repeat_setting); + void unregister(); + void copyRepeatSetting(const Controller* controller); + void setEnable(bool enable); + void setEnableOtherWrappers(bool enable) const; + +protected: + Controller* mController; + bool mIsEnable; + ListNode mListNode; + u8 mPadConfig[cPadIdx_MaxBase]; + + friend class Controller; +}; +#ifdef cafe +static_assert(sizeof(ControllerWrapperBase) == 0x174, "sead::ControllerWrapperBase size mismatch"); +#endif // cafe + +} // namespace sead diff --git a/include/sead/controller/seadPatternRumbleAddon.h b/include/sead/controller/seadPatternRumbleAddon.h new file mode 100644 index 0000000..d29c25e --- /dev/null +++ b/include/sead/controller/seadPatternRumbleAddon.h @@ -0,0 +1,35 @@ +#pragma once + +#include "controller/seadControllerAddon.h" + +namespace sead +{ +class PatternRumbleAddon : public ControllerAddon +{ + SEAD_RTTI_OVERRIDE(PatternRumbleAddon, ControllerAddon) + +public: + explicit PatternRumbleAddon(Controller* controller); + ~PatternRumbleAddon() override = default; + + bool calc() override; + +protected: + virtual void startRumbleImpl_() = 0; + virtual void stopRumbleImpl_() = 0; + +public: + bool isPatternEnable() const; + void startPattern(const char* pattern, u32 duration); + void stopPattern(); + +protected: + const char* mPattern; + u32 mPatternIdx; + u32 mPatternDuration; +}; +#ifdef cafe +static_assert(sizeof(PatternRumbleAddon) == 0x20, "sead::PatternRumbleAddon size mismatch"); +#endif // cafe + +} // namespace sead diff --git a/include/sead/devenv/seadDebugFontMgrNvn.h b/include/sead/devenv/seadDebugFontMgrNvn.h index d5ed619..81567ba 100644 --- a/include/sead/devenv/seadDebugFontMgrNvn.h +++ b/include/sead/devenv/seadDebugFontMgrNvn.h @@ -12,6 +12,7 @@ namespace sead { class DebugFontMgrNvn : public FontBase { public: DebugFontMgrNvn(void); + virtual ~DebugFontMgrNvn(); static DebugFontMgrNvn *sInstance; @@ -19,24 +20,25 @@ namespace sead { void initializeFromBinary(sead::Heap *, void *, unsigned long, void *, unsigned long, unsigned int); static sead::DebugFontMgrNvn *createInstance(sead::Heap *); void swapUniformBlockBuffer(void); - void begin(sead::DrawContext *) const; - void end(sead::DrawContext *) const; - float getHeight(void) const { + virtual float getHeight(void) const { return 16.f; }; - float getWidth(void) const { + virtual float getWidth(void) const { return 8.f; }; - float getCharWidth(char16_t) const { + virtual float getCharWidth(char16_t) const { return 8.f; }; - int getMaxDrawNum(void) const { - return 0x80; - }; - int getEncoding(void) const { + virtual int getEncoding(void) const { return 2; }; + virtual int getMaxDrawNum(void) const { + return 0x80; + }; + virtual void begin(sead::DrawContext *) const; + virtual void end(sead::DrawContext *) const; + //print }; @@ -50,24 +52,25 @@ namespace sead { void initializeFromBinary(sead::Heap* heap, void* shader, ulong shaderLength, void* font, ulong fontLength, void const* table, unsigned int); static sead::DebugFontMgrJis1Nvn *createInstance(sead::Heap *); void swapUniformBlockBuffer(void); - void begin(sead::DrawContext *) const; - void end(sead::DrawContext *) const; - - float getHeight(void) const { + + virtual float getHeight(void) const { return 16.f; }; - float getWidth(void) const { + virtual float getWidth(void) const { return 8.f; }; - - float getCharWidth(char16_t) const; - - int getMaxDrawNum(void) const { - return 0x80; + virtual float getCharWidth(char16_t) const { + return 8.f; }; - int getEncoding(void) const { + virtual int getEncoding(void) const { return 2; }; + virtual int getMaxDrawNum(void) const { + return 0x80; + }; + virtual void begin(sead::DrawContext *) const; + virtual void end(sead::DrawContext *) const; + //print }; -} \ No newline at end of file +} diff --git a/include/sead/framework/seadFramework.h b/include/sead/framework/seadFramework.h index 37344ff..e5749b6 100644 --- a/include/sead/framework/seadFramework.h +++ b/include/sead/framework/seadFramework.h @@ -22,7 +22,7 @@ class LogicalFrameBuffer; class MethodTreeMgr; class TaskMgr; -class Framework +class Framework : public sead::hostio::Node { SEAD_RTTI_BASE(Framework) @@ -70,6 +70,7 @@ class Framework virtual bool setProcessPriority(ProcessPriority); virtual void reserveReset(void*); virtual void initRun_(Heap*); + virtual void quitRun_(Heap*); virtual void runImpl_(); virtual MethodTreeMgr* createMethodTreeMgr_(Heap*) = 0; virtual void procReset_(); diff --git a/include/sead/framework/seadGameFramework.h b/include/sead/framework/seadGameFramework.h new file mode 100644 index 0000000..5b21713 --- /dev/null +++ b/include/sead/framework/seadGameFramework.h @@ -0,0 +1,31 @@ +#pragma once + +#include + +namespace sead { +class GameFramework : public sead::Framework { +public: + GameFramework(); + virtual ~GameFramework(); + + virtual void createSystemTasks(TaskBase*, const CreateSystemTaskArg&) override; + virtual void quitRun_(Heap*) override; + virtual void createControllerMgr(TaskBase*); + virtual void createHostIOMgr(TaskBase*, HostIOMgr::Parameter*, Heap*); + virtual void createProcessMeter(TaskBase*); + virtual void createSeadMenuMgr(TaskBase*); + virtual void createInfLoopChecker(TaskBase*, TickSpan const&, int); + virtual void createCuckooClock(TaskBase*); + virtual float calcFps() = 0; + virtual void saveScreenShot(SafeString const&); + virtual bool isScreenShotBusy() const; + virtual void waitStartDisplayLoop_(); + virtual void initHostIO_(); +}; + + +class GameFrameworkNx : public sead::GameFramework { +public: + virtual float calcFps() override; +}; +} // namespace sead diff --git a/include/sead/gfx/seadCamera.h b/include/sead/gfx/seadCamera.h index 5f16bb5..f543b42 100644 --- a/include/sead/gfx/seadCamera.h +++ b/include/sead/gfx/seadCamera.h @@ -2,6 +2,7 @@ #define SEAD_CAMERA_H_ #include +#include #include namespace sead @@ -16,7 +17,28 @@ class Camera virtual void doUpdateMatrix(Matrix34f* mtx) const = 0; - Matrix34f mMatrix; + Matrix34f mMatrix = Matrix34f::ident; +}; + +class LookAtCamera : public Camera +{ + SEAD_RTTI_OVERRIDE(LookAtCamera, Camera) +public: + LookAtCamera(const Vector3f& pos, const Vector3f& at, const Vector3f& up); + + Vector3f& getPos() { return mPos; } + Vector3f& getAt() { return mAt; } + Vector3f& getUp() { return mUp; } + const Vector3f& getPos() const { return mPos; } + const Vector3f& getAt() const { return mAt; } + const Vector3f& getUp() const { return mUp; } + + void doUpdateMatrix(Matrix34f* mtx) const override; + +//private: + Vector3f mPos; + Vector3f mAt; + Vector3f mUp; }; } // namespace sead diff --git a/include/sead/gfx/seadContext.h b/include/sead/gfx/seadContext.h index 5366937..e0f2b53 100644 --- a/include/sead/gfx/seadContext.h +++ b/include/sead/gfx/seadContext.h @@ -8,6 +8,7 @@ #include #include #include +#include #include "types.h" namespace sead @@ -44,4 +45,81 @@ namespace sead u32 DrawLockContext_xC; sead::CriticalSection mContextSection; // _10 }; -}; \ No newline at end of file + + class GraphicsContextMRT { +public: + virtual ~GraphicsContextMRT(); + + bool mDepthTestEnable; + bool mDepthWriteEnable; + int mDepthFunc; + int mCullFace; + int iVar1; + int iVar2; + int iVar3; + int iVar4; + int iVar5; + int iVar6; + int iVar7; + int iVar8; + int iVar9; + int iVar10; + int iVar11; + int iVar12; + int iVar13; + int iVar14; + int iVar15; + int iVar16; + int iVar17; + int iVar18; + int iVar19; + int iVar20; + int iVar21; + int iVar22; + int iVar23; + int iVar24; + int iVar25; + int iVar26; + int iVar27; + int iVar28; + int iVar29; + int iVar30; + int iVar31; + int iVar32; + int iVar33; + int iVar34; + int iVar35; + int iVar36; + int iVar37; + int iVar38; + int iVar39; + int iVar40; + int iVar41; + int iVar42; + int iVar43; + int iVar44; + int iVar45; + int iVar46; + int iVar47; + int iVar48; + int iVar49; + sead::Color4f mBlendColor; + bool bVar1; + int iVar50; + int iVar51; + int iVar52; + bool mStencilTestEnable; + int mStencilFunc; + int mStencilRef; + int mStencilValueMask; + int iVar53; + int iVar54; + int iVar55; + int iVar56; + int mPolygonMode; + int iVar57; + bool bVar2; + bool bVar3; + bool bVar4; +}; +}; diff --git a/include/sead/gfx/seadPrimitiveRenderer.h b/include/sead/gfx/seadPrimitiveRenderer.h index 39dc026..69603ed 100644 --- a/include/sead/gfx/seadPrimitiveRenderer.h +++ b/include/sead/gfx/seadPrimitiveRenderer.h @@ -1,73 +1,79 @@ -#ifndef SEAD_PRIMITIVE_RENDERER_H_ -#define SEAD_PRIMITIVE_RENDERER_H_ +#pragma once -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include +#include +#include -namespace sead -{ +class NVNbuffer; +class NVNmemoryPool; + +class unk { +public: + s64 size; +}; + +namespace sead { class Heap; class Camera; class Projection; class Texture; +class DrawContext; + +class PrimitiveDrawMgrBase {}; + +class PrimitiveDrawMgrNvn : public PrimitiveDrawMgrBase, public IDisposer { + SEAD_SINGLETON_DISPOSER(PrimitiveDrawMgrNvn) -class PrimitiveRendererBase -{ public: - virtual void prepareFromBinaryImpl(Heap* heap, const void* bin_data, u32 bin_size) = 0; - virtual void prepareImpl(Heap* heap, const SafeString& path) = 0; - virtual void setCameraImpl(const Camera& camera) = 0; - virtual void setProjectionImpl(const Projection& projection) = 0; - virtual void beginImpl() = 0; - virtual void endImpl() = 0; - virtual void drawQuadImpl(const Matrix34f& model_mtx, const Color4f& colorL, - const Color4f& colorR) = 0; - virtual void drawQuadImpl(const Matrix34f& model_mtx, const Texture& texture, - const Color4f& colorL, const Color4f& colorR, const Vector2f& uv_src, - const Vector2f& uv_size) = 0; - virtual void drawBoxImpl(const Matrix34f& model_mtx, const Color4f& colorL, - const Color4f& colorR) = 0; - virtual void drawCubeImpl(const Matrix34f& model_mtx, const Color4f& c0, const Color4f& c1) = 0; - virtual void drawWireCubeImpl(const Matrix34f& model_mtx, const Color4f& c0, - const Color4f& c1) = 0; - virtual void drawLineImpl(const Matrix34f& model_mtx, const Color4f& c0, const Color4f& c1) = 0; - virtual void drawSphere4x8Impl(const Matrix34f& model_mtx, const Color4f& north, - const Color4f& south) = 0; - virtual void drawSphere8x16Impl(const Matrix34f& model_mtx, const Color4f& north, - const Color4f& south) = 0; - virtual void drawDisk16Impl(const Matrix34f& model_mtx, const Color4f& center, - const Color4f& edge) = 0; - virtual void drawDisk32Impl(const Matrix34f& model_mtx, const Color4f& center, - const Color4f& edge) = 0; - virtual void drawCircle16Impl(const Matrix34f& model_mtx, const Color4f& edge) = 0; - virtual void drawCircle32Impl(const Matrix34f& model_mtx, const Color4f& edge) = 0; - virtual void drawCylinder16Impl(const Matrix34f& model_mtx, const Color4f& top, - const Color4f& btm) = 0; - virtual void drawCylinder32Impl(const Matrix34f& model_mtx, const Color4f& top, - const Color4f& btm) = 0; + virtual void prepareFromBinaryImpl(sead::Heap*, void const*, unsigned int); + virtual void prepareImpl(sead::Heap*, sead::SafeString const&); + virtual void beginImpl(sead::DrawContext*, sead::Matrix34f const&, sead::Matrix44f const&); + virtual void endImpl(sead::DrawContext*); + virtual void drawQuadImpl(sead::DrawContext*, sead::Matrix34f const&, sead::Color4f const&, sead::Color4f const&); + virtual void drawQuadImpl(sead::DrawContext*, sead::Matrix34f const&, sead::Texture const&, sead::Color4f const&, sead::Color4f const&, sead::Vector2f const&, sead::Vector2f const&); + virtual void drawBoxImpl(sead::DrawContext*, sead::Matrix34f const&, sead::Color4f const&, sead::Color4f const&); + virtual void drawCubeImpl(sead::DrawContext*, sead::Matrix34f const&, sead::Color4f const&, sead::Color4f const&); + virtual void drawWireCubeImpl(sead::DrawContext*, sead::Matrix34f const&, sead::Color4f const&, sead::Color4f const&); + virtual void drawLineImpl(sead::DrawContext*, sead::Matrix34f const&, sead::Color4f const&, sead::Color4f const&); + virtual void drawSphere4x8Impl(sead::DrawContext*, sead::Matrix34f const&, sead::Color4f const&, sead::Color4f const&); + virtual void drawSphere8x16Impl(sead::DrawContext*, sead::Matrix34f const&, sead::Color4f const&, sead::Color4f const&); + virtual void drawDisk16Impl(sead::DrawContext*, sead::Matrix34f const&, sead::Color4f const&, sead::Color4f const&); + virtual void drawDisk32Impl(sead::DrawContext*, sead::Matrix34f const&, sead::Color4f const&, sead::Color4f const&); + virtual void drawCircle16Impl(sead::DrawContext*, sead::Matrix34f const&, sead::Color4f const&); + virtual void drawCircle32Impl(sead::DrawContext*, sead::Matrix34f const&, sead::Color4f const&); + virtual void drawCylinder16Impl(sead::DrawContext*, sead::Matrix34f const&, sead::Color4f const&, sead::Color4f const&); + virtual void drawCylinder32Impl(sead::DrawContext*, sead::Matrix34f const&, sead::Color4f const&, sead::Color4f const&); + virtual ~PrimitiveDrawMgrNvn(); + + PrimitiveDrawMgrNvn(); + void setupNVNBuffer_(NVNbuffer*, NVNmemoryPool*, unsigned long*, unsigned long); + void swapUniformBlockBuffer(); + }; -class PrimitiveRenderer : public IDisposer -{ - SEAD_SINGLETON_DISPOSER(PrimitiveRenderer) +class PrimitiveDrawer { + SEAD_SINGLETON_DISPOSER(PrimitiveDrawer) public: - class QuadArg - { + class QuadArg { public: - QuadArg() - : mCenter(Vector3f::zero), mSize(Vector2f::zero), mColor0(Color4f::cWhite), - mColor1(Color4f::cWhite), mHorizontal(false) - { - } - - void setCornerAndSize(const Vector3f&, const Vector2f&); - // void setBoundBox(const BoundBox2f&, float); - void setColor(const Color4f&, const Color4f&); - void setColorHorizontal(const Color4f&, const Color4f&); + inline QuadArg(Vector3f pos, Vector2f size, Color4f color = Color4f(255, 255, 255, 1), Color4f color2 = Color4f(255, 255, 255, 1), bool isHorizontal = false) { + mCenter = pos; + mSize = size; + mColor0 = color; + mColor1 = color; + mHorizontal = isHorizontal; + }; + QuadArg() : mCenter(Vector3f::zero), mSize(Vector2f::zero), mColor0(Color4f::cWhite), mColor1(Color4f::cWhite), mHorizontal(false) {} + + void setCornerAndSize(const Vector3f &, const Vector2f &); + void setBoundBox(const BoundBox2f&, float); + void setColor(const Color4f &, const Color4f &); + void setColorHorizontal(const Color4f &, const Color4f &); Vector3f mCenter; Vector2f mSize; @@ -75,74 +81,132 @@ class PrimitiveRenderer : public IDisposer Color4f mColor1; bool mHorizontal; }; - - class CubeArg - { + class CubeArg { public: - void setCornerAndSize(const Vector3f&, const Vector3f&); - // void setBoundBox(const BoundBox3f&); + inline CubeArg(BoundBox3f const &box, Color4f const &color) { + mPos = box.getCenter(); + mSize = {box.getSizeX(), box.getSizeY(), box.getSizeZ()}; + mColor1 = color; + mColor2 = color; + }; + inline CubeArg(Vector3f const &pos, Vector3f const &size, Color4f const &color) { + mPos = pos; + mSize = size; + mColor1 = color; + mColor2 = color; + }; + Vector3f mPos; + Vector3f mSize; + Color4f mColor1; + Color4f mColor2; }; + PrimitiveDrawer(sead::DrawContext *); + virtual ~PrimitiveDrawer(); + void begin(); + + void setDrawContext(sead::DrawContext *); + + + const sead::Matrix34f* mModelMatrix; + sead::Matrix34f* mCamMatrix; + sead::Matrix44f* mProjMatrix; + sead::DrawContext* mDrawCtx; +}; + +class PrimitiveRendererBase { +public: + virtual void prepareFromBinaryImpl(Heap *heap, const void *bin_data, u32 bin_size) = 0; + virtual void prepareImpl(Heap *heap, const SafeString &path) = 0; + virtual void setCameraImpl(const Camera &camera) = 0; + virtual void setProjectionImpl(const Projection &projection) = 0; + virtual void beginImpl() = 0; + virtual void endImpl() = 0; + virtual void drawQuadImpl(const Matrix34f &model_mtx, const Color4f &colorL, const Color4f &colorR) = 0; + virtual void drawQuadImpl(const Matrix34f &model_mtx, const Texture &texture, const Color4f &colorL, const Color4f &colorR, const Vector2f &uv_src, const Vector2f &uv_size) = 0; + virtual void drawBoxImpl(const Matrix34f &model_mtx, const Color4f &colorL, const Color4f &colorR) = 0; + virtual void drawCubeImpl(const Matrix34f &model_mtx, const Color4f &c0, const Color4f &c1) = 0; + virtual void drawWireCubeImpl(const Matrix34f &model_mtx, const Color4f &c0, const Color4f &c1) = 0; + virtual void drawLineImpl(const Matrix34f &model_mtx, const Color4f &c0, const Color4f &c1) = 0; + virtual void drawSphere4x8Impl(const Matrix34f &model_mtx, const Color4f &north, const Color4f &south) = 0; + virtual void drawSphere8x16Impl(const Matrix34f &model_mtx, const Color4f &north, const Color4f &south) = 0; + virtual void drawDisk16Impl(const Matrix34f &model_mtx, const Color4f ¢er, const Color4f &edge) = 0; + virtual void drawDisk32Impl(const Matrix34f &model_mtx, const Color4f ¢er, const Color4f &edge) = 0; + virtual void drawCircle16Impl(const Matrix34f &model_mtx, const Color4f &edge) = 0; + virtual void drawCircle32Impl(const Matrix34f &model_mtx, const Color4f &edge) = 0; + virtual void drawCylinder16Impl(const Matrix34f &model_mtx, const Color4f &top, const Color4f &btm) = 0; + virtual void drawCylinder32Impl(const Matrix34f &model_mtx, const Color4f &top, const Color4f &btm) = 0; +}; + +class PrimitiveRenderer : public IDisposer, public unk, public PrimitiveDrawer { + SEAD_SINGLETON_DISPOSER(PrimitiveRenderer) + +public: + struct UVArg; public: PrimitiveRenderer(); virtual ~PrimitiveRenderer() {} - void prepareFromBinary(Heap* heap, const void* bin_data, u32 bin_size); - void prepare(Heap* heap, const SafeString& path); - void setCamera(const Camera& camera); - void setProjection(const Projection& projection); - void setModelMatrix(const Matrix34f& model_mtx); + void prepareFromBinary(Heap *heap, const void *bin_data, u32 bin_size); + void prepare(Heap *heap, const SafeString &path); + void setCamera(const Camera &camera); + void setProjection(const Projection &projection); + void setModelMatrix(const Matrix34f &model_mtx); void begin(); void end(); - void drawQuad(const Color4f&, const Color4f&); - void drawQuad(const Texture&, const Color4f&, const Color4f&, const Vector2f&, const Vector2f&); - void drawBox(const Color4f&, const Color4f&); - void drawCube(const Color4f&, const Color4f&); - void drawWireCube(const Color4f&, const Color4f&); - void drawLine(const Color4f&, const Color4f&); - void drawSphere4x8(const Color4f&, const Color4f&); - void drawSphere8x16(const Color4f&, const Color4f&); - void drawDisk16(const Color4f&, const Color4f&); - void drawDisk32(const Color4f&, const Color4f&); - void drawCircle16(const Color4f&); - void drawCircle32(const Color4f&); - void drawCylinder16(const Color4f&, const Color4f&); - void drawCylinder32(const Color4f&, const Color4f&); - - void drawQuad(const QuadArg&); - void drawQuad(const Texture&, const QuadArg&, const UVArg&); - void drawBox(const QuadArg&); - void drawCube(const CubeArg&); - void drawWireCube(const CubeArg&); - void drawLine(const Vector3f&, const Vector3f&, const Color4f&, const Color4f&); - void drawLine(const Vector3f&, const Vector3f&, const Color4f&); - void drawSphere4x8(const Vector3f&, float, const Color4f&, const Color4f&); - void drawSphere4x8(const Vector3f&, float, const Color4f&); - void drawSphere8x16(const Vector3f&, float, const Color4f&, const Color4f&); - void drawSphere8x16(const Vector3f&, float, const Color4f&); - void drawDisk16(const Vector3f&, float, const Color4f&, const Color4f&); - void drawDisk16(const Vector3f&, float, const Color4f&); - void drawDisk32(const Vector3f&, float, const Color4f&, const Color4f&); - void drawDisk32(const Vector3f&, float, const Color4f&); - void drawCircle16(const Vector3f&, float, const Color4f&); - void drawCircle32(const Vector3f&, float, const Color4f&); - void drawCylinder16(const Vector3f&, float, float, const Color4f&, const Color4f&); - void drawCylinder16(const Vector3f&, float, float, const Color4f&); - void drawCylinder32(const Vector3f&, float, float, const Color4f&, const Color4f&); - void drawCylinder32(const Vector3f&, float, float, const Color4f&); - - void drawAxis(const Vector3f&, float); + void drawQuad(const Color4f &, const Color4f &); + void drawQuad(const Texture &, const Color4f &, const Color4f &, const Vector2f &, const Vector2f &); + void drawBox(const Color4f &, const Color4f &); + void drawCube(const Color4f &, const Color4f &); + void drawWireCube(const Color4f &, const Color4f &); + void drawLine(const Color4f &, const Color4f &); + void drawSphere4x8(const Color4f &, const Color4f &); + void drawSphere8x16(const Color4f &, const Color4f &); + void drawDisk16(const Color4f &, const Color4f &); + void drawDisk32(const Color4f &, const Color4f &); + void drawCircle16(const Color4f &); + void drawCircle32(const Color4f &); + void drawCylinder16(const Color4f &, const Color4f &); + void drawCylinder32(const Color4f &, const Color4f &); + + void drawQuad(const QuadArg &); + void drawQuad(const Texture &, const QuadArg &, const UVArg &); + void drawBox(const QuadArg &); + void drawCube(const CubeArg &); + void drawWireCube(const CubeArg &); + void drawLine(const Vector3f &, const Vector3f &, const Color4f &, const Color4f &); + void drawLine(const Vector3f &, const Vector3f &, const Color4f &); + void drawSphere4x8(const Vector3f &, float, const Color4f &, const Color4f &); + void drawSphere4x8(const Vector3f &, float, const Color4f &); + void drawSphere8x16(const Vector3f &, float, const Color4f &, const Color4f &); + void drawSphere8x16(const Vector3f &, float, const Color4f &); + void drawDisk16(const Vector3f &, float, const Color4f &, const Color4f &); + void drawDisk16(const Vector3f &, float, const Color4f &); + void drawDisk32(const Vector3f &, float, const Color4f &, const Color4f &); + void drawDisk32(const Vector3f &, float, const Color4f &); + void drawCircle16(const Vector3f &, float, const Color4f &); + void drawCircle32(const Vector3f &, float, const Color4f &); + void drawCylinder16(const Vector3f &, float, float, const Color4f &, const Color4f &); + void drawCylinder16(const Vector3f &, float, float, const Color4f &); + void drawCylinder32(const Vector3f &, float, float, const Color4f &, const Color4f &); + void drawCylinder32(const Vector3f &, float, float, const Color4f &); + + void drawAxis(const Vector3f &, float); + + sead::Matrix34f mCameraMatrix; + sead::Matrix44f mProjection; + sead::Matrix34f mModelMatrix; private: - void doPrepare_(Heap* heap); + void doPrepare_(Heap *heap); - PrimitiveRendererBase* mRendererImpl; - Matrix34f mModelMtx; + // PrimitiveRendererBase* mRendererImpl; + // Matrix34f mModelMtx; }; -} // namespace sead +} // namespace sead + -#endif // SEAD_PRIMITIVE_RENDERER_H_ diff --git a/include/sead/gfx/seadViewport.h b/include/sead/gfx/seadViewport.h index 9401fd8..471673b 100644 --- a/include/sead/gfx/seadViewport.h +++ b/include/sead/gfx/seadViewport.h @@ -17,6 +17,7 @@ namespace sead Viewport(f32, f32, f32, f32); void project(sead::Vector2 *, sead::Vector3 const &) const; + void apply(sead::DrawContext*, sead::LogicalFrameBuffer const&) const; // void project(sead::Vector2 *, sead::Vector3 const &) const; f32 _8; @@ -24,4 +25,4 @@ namespace sead f32 _10; f32 _14; }; -}; \ No newline at end of file +}; diff --git a/include/sead/math/seadBoundBox.h b/include/sead/math/seadBoundBox.h index 8c52aff..123decc 100644 --- a/include/sead/math/seadBoundBox.h +++ b/include/sead/math/seadBoundBox.h @@ -1,14 +1,57 @@ #pragma once +#include "sead/math/seadMathCalcCommon.h" #include -namespace sead -{ +namespace sead { template struct BoundBox2 { - Vector2 mMin; - Vector2 mMax; + using Vector2 = sead::Vector2; + + BoundBox2() { setUndef(); } + BoundBox2(T x0, T y0, T x1, T y1) { set(x0, y0, x1, y1); } + BoundBox2(const Vector2& min, const Vector2& max) : mMin(min), mMax(max) {} + + T getSizeX() const { return mMax.x - mMin.x; } + T getSizeY() const { return mMax.y - mMin.y; } + + T getHalfSizeX() const { return (mMax.x - mMin.x) / 2.0f; } + T getHalfSizeY() const { return (mMax.y - mMin.y) / 2.0f; } + + const Vector2& getMin() const { return mMin; } + const Vector2& getMax() const { return mMax; } + + Vector2 getTL() const { return mMin; } + Vector2 getTR() const { return Vector2(mMax.x, mMin.y); } + Vector2 getBL() const { return Vector2(mMin.x, mMax.y); } + Vector2 getBR() const { return mMax; } + + Vector2 getCenter() const; + void getCenter(Vector2* p) const; + bool isUndef() const; + bool isInside(const Vector2& p) const; + + void setUndef(); + void set(T x0, T y0, T x1, T y1); + void set(const Vector2& min, const Vector2& max); + void setMin(const Vector2& min); + void setMax(const Vector2& max); + void setFromCenterAndXY(T centerX, T centerY, T sizeX, T sizeY); + void setFromCornerAndXY(T cornerX, T cornerY, T sizeX, T sizeY); + void setFromCenterAndXY(const Vector2& center, T sizeX, T sizeY) + { + setFromCenterAndXY(center.x, center.y, sizeX, sizeY); + } + void setFromCornerAndXY(const Vector2& corner, T sizeX, T sizeY); + void offset(T dx, T dy); + void offset(const Vector2& dv); + void scaleX(T sx); + void scaleY(T sy); + +private: + Vector2 mMin; + Vector2 mMax; static const BoundBox2 cUndefined; }; @@ -16,12 +59,48 @@ struct BoundBox2 template struct BoundBox3 { - Vector3 mMin; - Vector3 mMax; + using Vector3 = sead::Vector3; + + BoundBox3() { setUndef(); } + BoundBox3(T x0, T y0, T z0, T x1, T y1, T z1) { set(x0, y0, z0, x1, y1, z1); } + BoundBox3(const Vector3& min, const Vector3& max) { set(min, max); } + + T getSizeX() const { return mMax.x - mMin.x; } + T getSizeY() const { return mMax.y - mMin.y; } + T getSizeZ() const { return mMax.z - mMin.z; } + + T getHalfSizeX() const { return (mMax.x - mMin.x) / 2.0f; } + T getHalfSizeY() const { return (mMax.y - mMin.y) / 2.0f; } + T getHalfSizeZ() const { return (mMax.z - mMin.z) / 2.0f; } + + const Vector3& getMin() const { return mMin; } + const Vector3& getMax() const { return mMax; } + + Vector3 getCenter() const; + void getCenter(Vector3* p) const; + bool isUndef() const; + bool isInside(const Vector3& p) const; + + inline void setUndef() { + mMin = {Mathf::maxNumber(), Mathf::maxNumber(), Mathf::maxNumber()}; + mMax = {Mathf::minNumber(), Mathf::minNumber(), Mathf::minNumber()}; + } + void set(T x0, T y0, T z0, T x1, T y1, T z1); + void set(const Vector3& min, const Vector3& max); + void setMin(const Vector3& min); + void setMax(const Vector3& max); + void offset(T dx, T dy, T dz); + void offset(const Vector3& dv); + void scaleX(T sx); + void scaleY(T sy); + void scaleZ(T sz); + +private: + Vector3 mMin; + Vector3 mMax; static const BoundBox3 cUndefined; }; - typedef BoundBox2 BoundBox2f; typedef BoundBox3 BoundBox3f; diff --git a/include/sead/math/seadMathCalcCommon.h b/include/sead/math/seadMathCalcCommon.h index cf5086b..9abe098 100644 --- a/include/sead/math/seadMathCalcCommon.h +++ b/include/sead/math/seadMathCalcCommon.h @@ -28,6 +28,8 @@ class MathCalcCommon static T fitSign(T value, T sign_value) { return value * sign(sign_value); } + static T minNumber(); + static T maxNumber(); static T epsilon() { return std::numeric_limits::epsilon(); } static bool equalsEpsilon(T lhs, T rhs, T eps = epsilon()) diff --git a/include/sead/math/seadMathCalcCommon.hpp b/include/sead/math/seadMathCalcCommon.hpp index 8c68ca4..e36a5c0 100644 --- a/include/sead/math/seadMathCalcCommon.hpp +++ b/include/sead/math/seadMathCalcCommon.hpp @@ -117,4 +117,46 @@ inline T clamp(T value, T low, T high) value = high; return value; } + +template +inline T MathCalcCommon::maxNumber() +{ + return std::numeric_limits::max(); +} + +template <> +inline float MathCalcCommon::minNumber() +{ + return -std::numeric_limits::max(); +} + +template <> +inline float MathCalcCommon::maxNumber() +{ + return std::numeric_limits::max(); +} + +template <> +inline double MathCalcCommon::minNumber() +{ + return -std::numeric_limits::max(); +} + +template <> +inline double MathCalcCommon::maxNumber() +{ + return std::numeric_limits::max(); +} + +template <> +inline long double MathCalcCommon::minNumber() +{ + return -std::numeric_limits::max(); +} + +template <> +inline long double MathCalcCommon::maxNumber() +{ + return std::numeric_limits::max(); +} } // namespace sead diff --git a/include/sead/math/seadMatrix.h b/include/sead/math/seadMatrix.h index 85179c3..407889f 100644 --- a/include/sead/math/seadMatrix.h +++ b/include/sead/math/seadMatrix.h @@ -2,6 +2,7 @@ #define SEAD_MATRIX34_H_ #include +#include #include namespace sead @@ -29,6 +30,12 @@ struct Matrix34 : public Policies::Mtx34Base this->m[2][3] = _23; } + void setBase(s32 axis, const Vector3f& v) { + this->m[0][axis] = v.x; + this->m[1][axis] = v.y; + this->m[2][axis] = v.z; + } + static const Matrix34 zero; static const Matrix34 ident; }; diff --git a/include/sead/math/seadVector.h b/include/sead/math/seadVector.h index abff749..d4fd259 100644 --- a/include/sead/math/seadVector.h +++ b/include/sead/math/seadVector.h @@ -267,6 +267,7 @@ struct Vector4 : public Policies::Vec4Base typedef Vector2 Vector2f; typedef Vector3 Vector3f; +typedef Vector3 Vector3u; typedef Vector4 Vector4f; template <> diff --git a/include/sead/textwriter.h b/include/sead/textwriter.h index 5590a02..c336771 100644 --- a/include/sead/textwriter.h +++ b/include/sead/textwriter.h @@ -6,6 +6,7 @@ #pragma once #include "../types.h" +#include "FrameBuffer.h" #include #include #include @@ -32,6 +33,7 @@ namespace sead void setCursorFromTopLeft(sead::Vector2 const &); void beginDraw(); void endDraw(); + void setDrawContext(sead::DrawContext*); sead::DebugFontMgrNvn *getDefaultFont(); static void setDefaultFont(sead::FontBase *); static void setupGraphics(sead::DrawContext*); @@ -40,8 +42,7 @@ namespace sead sead::Viewport *mViewport; sead::Projection *mProjection; sead::Camera *mCamera; - int TextWriter_x20; - int TextWriter_x24; + sead::FontBase* mFont; int TextWriter_x28; int TextWriter_x2C; sead::Vector2 mScale; @@ -55,5 +56,7 @@ namespace sead int mFormatBufferSize; int TextWriter_x6C; sead::DrawContext *mDrawContext; + + static sead::FontBase* sDefaultFont; }; -}; \ No newline at end of file +}; diff --git a/include/sead/thread/seadEvent.h b/include/sead/thread/seadEvent.h index 9aaabd2..047a12c 100644 --- a/include/sead/thread/seadEvent.h +++ b/include/sead/thread/seadEvent.h @@ -42,7 +42,7 @@ class Event : public IDisposer #ifdef NNSDK nn::os::LightEventType mEventInner; #else -#error "Unknown platform" +//#error "Unknown platform" #endif #ifdef SEAD_DEBUG diff --git a/patches/100.slpatch b/patches/100.slpatch index d42b90c..565d7e4 100644 --- a/patches/100.slpatch +++ b/patches/100.slpatch @@ -1,4 +1,242 @@ [version=100, target=main] +004cc788: // StageScene::kill+19: + bl stageSceneKillHook + +// disable DokanMaze randomness +0025AB5C: + bl pipeRandomness +0025AE10: + bl pipeRandomness +0025AF58: + bl pipeRandomness +0025B0C4: + bl pipeRandomness +0025B164: // exeInLevel => randomness value unused + mov w0, #0 + +00a4667c: + bl bgmStartSoundHook +00a46694: + bl bgmStartSoundHook + +// resize StageScene +//004c1c10: +// mov w0, #0x4c8 + +//004c8dd8: +// bl storeActorInitInfo + +//004c8440: +// bl stageSceneCtorHook + +// set Shine->mIsNoRotate to true +//001cd904: +// mov w0, #1 +// str w0, [x19, #0x2fc] +// nop +// nop + +// disable GameDataFile::setGrowFlowerTime +//005203f0: +// ret + +//00520d48: +// mov x0, #1 +// ret + +// cancel al::addVelocity in PlayerActionAirMoveControl::update (doesn't disable gravity, just moving midair) +//00414fc0: +// nop +//00415020: +// nop + +// set GameDataFile::isGotCheckpointInWorld to true +//00521300: +// mov w0, #1 +// ret + +// change SkyWorldKoopaFrame::receiveMsg to only respond to TsukkunThrustCollide +//0031cd74: +// mov x1, xzr +// bl #0x26fd68 // rs::isMsgTsukkunCollideThrust +// tbz w0, #0, #0x54 +// nop +// nop +// nop +// nop +// nop + +// add bounds checking to NerveKeeper::update +//009596a4: +// bl nerveKeeperUpdateVar +// nop +// nop + +// al::ExecuteTableHolderDraw::execute const +//0089308c: +// ret + +// al::Effect::tryEmitEmitters +//00a59574: +// ret + +// al::BloomDirector::draw +//008bc960: +// ret + +// al::ResourceSystem::createResource +//00a7d390: +// mov w0, #0 + +// initActor +//008dc12c: +// b initActor + +// al::createTextureInfo +//008b48cc: +// ret + +// PlayerActionAirMoveControl::update +//00415030: +// nop +//00415040: +// nop + +//0043d58c: +// mov w0, #5 + +// rs::registerFruit +001d88bc: + mov w0, #0 + + + +// al::ExecuteDirector::init+44 +// increase al::ExecuteTableHolderDraw size +00891364: + mov w0, #0x90 + +// al::ExecuteTableHolderDraw::ExecuteTableHolderDraw+7 +0089215c: + bl executeTableHolderDrawCtor + +// al::ExecuteDirector::draw+33 +00891aac: + b executeTableHolderDrawExecute + + +// ShineTowerRocket::init +//00309904: +// mov w0, #1 + +// StageSceneStateTitleLogo::kill +//004fed3c: +// svc #0x26 + +// ControllerGuideSnapShotCtrl::exeShow (hide frame) +//001e4bd8: +// nop + +// ShineListLayout::exeList +//00205d4c: +// b shineListLayoutDecideHook + +// motion mod for tasing thing +//00862f2c: +// mov w0, #2 +// ret + +// crash on Senobi::init +/0017e430: +// svc #0x26 + +// crash on Senobi::initAfterPlacement +//0017e918: +// svc #0x26 + +// toggle updating joints if gravity changed +0041e764: + bl setPlayerJointUpdate + +// toggle x/y motion rolls +0045b75c: + b isTriggerRollingRestartSwingVar + +// toggle loading current file +004e7f84: + bl setLoadDataSelectingCurrentVar + nop + +// toggle load file confirmation +004e804c: + bl setLoadDataSelectingConfirmVar + +// toggle infinite cap bounces +004083ac: + bl setRepeatCapBounceVar + +// toggle infinite rainbow spins +00458cb8: + bl setRepeatRainbowSpinVar + +// toggle cap bounce after wall jump +00407f2c: + bl setWallJumpCapBounceVar + +// toggle taking damage +00528824: + b setDamageVar + +// toggle kingdom moon requirements +0052639c: + b findUnlockShineNumVar +0052a0c4: + b findUnlockShineNumVar +005336e8: + bl findUnlockShineNumVar +00533770: + bl findUnlockShineNumVar +00533928: + bl findUnlockShineNumVar +00533c0c: + bl findUnlockShineNumVar +00533ca0: + bl findUnlockShineNumVar + +// toggle rs::isPlayerEnableToSeeOddSpace +00570908: + b setPlayerEnableToSeeOddSpaceVar + + +// musiclist.pchtxt +//004d9e04: +// mov x0, #1 + +// seed.pchtxt +//005203f0: +// ret + +// some fix for motion stuff +00862f2c: + mov w0, #2 + ret + +00509c44: + bl tasDrawKitHook +004A6CC8: + bl tasDrawKitHook + +// override return value of sub_71000A34E4, which calculates the "real hat" index +// currently disabled, as it should already be consistent with just overriding al::getRandom below +//000A3F50: +// bl koopaHatRandomizerHook +//000A3320: +// bl koopaHatRandomizerHook + +// replacing call to al::getRandom +000A2DBC: + bl koopaHatRandomHook + StageScene::control+18: bl stageSceneControlHook @@ -6,13 +244,25 @@ StageScene::control+18: 005359dc: // GameSystem::init+18C mov x0, x19 // move GameSystem to arg register bl setupDebugMenu + +// override al::Sequence::drawMain to toggle rendering off if necessary +0050F1F0: + bl sequenceDrawHook -// replaces an execute draw call with custom hook that handles execute draw itself after running draw code -0050f258: // HakoniwaSequence::drawMain+84 - mov x0, x19 // HakoniwaSequence - mov x1, sp // viewport - mov x2, x20 // drawContext +// replaces all of the 2D-drawing methods with a hook to draw the menu on top +0050F258: + mov x0, sp // viewport + mov x1, x20 // drawContext + mov x2, x21 // sead::LogicalFrameBuffer + ldr x3, [x19, #0xf8] // al::LayoutKit bl drawMainHook + nop + nop + nop + nop + nop + nop + nop // disable snapshot mode if needed 005539b0: @@ -64,588 +314,6 @@ StageScene::control+18: 0050fa10: bl isDefeatKoopaLv1Var -// TAS - -// Left Stick -// Trigger -0041401c: - bl fgetLeftStick -00447dfc: - bl fgetLeftStick -0044c108: - bl fgetLeftStick -0045034c: - bl fgetLeftStick -004504d8: - bl fgetLeftStick -004508e0: - bl fgetLeftStick -004508fc: - bl fgetLeftStick -0056e270: - bl fgetLeftStick -0057313c: - bl fgetLeftStick -00576b50: - bl fgetLeftStick -00576bdc: - bl fgetLeftStick -00576c50: - bl fgetLeftStick -00576cc8: - bl fgetLeftStick -0097a6d0: - bl fgetLeftStick -009a37b4: - bl fgetLeftStick -009a3a2c: - bl fgetLeftStick - -// Right Stick -// Trigger -0044c144: - bl fgetRightStick -00450430: - bl fgetRightStick -004508a4: - bl fgetRightStick -0056e288: - bl fgetRightStick -005730e0: - bl fgetRightStick -00576c7c: - bl fgetRightStick -00576cd4: - bl fgetRightStick -00576cf0: - bl fgetRightStick -00840010: - bl fgetRightStick - -// A -// Trigger -0045022c: - b fisPadTriggerA -00450234: - b fisPadTriggerA -0056e260: - b fisPadTriggerA -00575be4: - b fisPadTriggerA -00575bf4: - b fisPadTriggerA -00575c2c: - b fisPadTriggerA -00575c3c: - b fisPadTriggerA -00576ae8: - b fisPadTriggerA -00576af8: - b fisPadTriggerA -00414000: - bl fisPadTriggerA -004140f8: - bl fisPadTriggerA -004142c4: - bl fisPadTriggerA -0044fe94: - bl fisPadTriggerA -004fd988: - bl fisPadTriggerA -0050bcf0: - bl fisPadTriggerA -0050bd8c: - bl fisPadTriggerA -0050c218: - bl fisPadTriggerA -0050c620: - bl fisPadTriggerA -00575bc8: - bl fisPadTriggerA -00575c10: - bl fisPadTriggerA -00576acc: - bl fisPadTriggerA -// Hold -00450790: - b fisPadHoldA -00573594: - b fisPadHoldA -005765a4: - b fisPadHoldA -0044fed0: - bl fisPadHoldA -00450448: - bl fisPadHoldA -00576554: - bl fisPadHoldA -// Release -0044ff0c: - bl fisPadReleaseA - -// B -// Trigger -0044feb8: - b fisPadTriggerB -0056e23c: - b fisPadTriggerB -00575cb8: - b fisPadTriggerB -00450250: - bl fisPadTriggerB -0050bcb8: - bl fisPadTriggerB -00575c68: - bl fisPadTriggerB -// Hold -0044fef4: - b fisPadHoldB -00576620: - b fisPadHoldB -005765d0: - bl fisPadHoldB -// Release -0044ff30: - b fisPadReleaseB - -// X -// Trigger -004502b0: - b fisPadTriggerX -00450594: - b fisPadTriggerX -0056e1ac: - b fisPadTriggerX -00576240: - b fisPadTriggerX -0044ff68: - bl fisPadTriggerX -004fd9b0: - bl fisPadTriggerX -0050bd5c: - bl fisPadTriggerX -0050be1c: - bl fisPadTriggerX -005761f0: - bl fisPadTriggerX -// Hold -00450740: - b fisPadHoldX -0056e1f4: - b fisPadHoldX -00573558: - b fisPadHoldX -0044ffc4: - bl fisPadHoldX -0045030c: - bl fisPadHoldX -004503a8: - bl fisPadHoldX -00450534: - bl fisPadHoldX -00450890: - bl fisPadHoldX -00576b38: - bl fisPadHoldX -00576ba8: - bl fisPadHoldX -00576c44: - bl fisPadHoldX -00576cbc: - bl fisPadHoldX -// Release -00450608: - b fisPadReleaseX -00450020: - bl fisPadReleaseX - -// Y -// Trigger -0044ff8c: - b fisPadTriggerY -0056e1d0: - b fisPadTriggerY -005762bc: - b fisPadTriggerY -00576e78: - b fisPadTriggerY -00577134: - b fisPadTriggerY -00450264: - bl fisPadTriggerY -004fd9dc: - bl fisPadTriggerY -0050bd28: - bl fisPadTriggerY -0050bdd4: - bl fisPadTriggerY -0057626c: - bl fisPadTriggerY -00576e2c: - bl fisPadTriggerY -00576ebc: - bl fisPadTriggerY -00576ec8: - bl fisPadTriggerY -00576f00: - bl fisPadTriggerY -// Hold -0044ffe8: - b fisPadHoldY -0056e218: - b fisPadHoldY -00576808: - b fisPadHoldY -0045041c: - bl fisPadHoldY -005767b8: - bl fisPadHoldY -// Release -00450044: - b fisPadReleaseY - -// L -// Trigger -005760cc: - b fisPadTriggerL -004143d8: - bl fisPadTriggerL -0045007c: - bl fisPadTriggerL - -00573454: - bl fisPadTriggerL -0057607c: - bl fisPadTriggerL -0084003c: - bl fisPadTriggerL -// Hold -0056e2b4: - b fisPadHoldL -00576710: - b fisPadHoldL -004500f4: - bl fisPadHoldL -004501e4: - bl fisPadHoldL -00450334: - bl fisPadHoldL -004503c0: - bl fisPadHoldL -004508c8: - bl fisPadHoldL -005766c0: - bl fisPadHoldL -// Release -0045016c: - bl fisPadReleaseL - -// R -// Trigger -00450090: - b fisPadTriggerR -004505c0: - b fisPadTriggerR -0045062c: - b fisPadTriggerR -0056e2d8: - b fisPadTriggerR -00573478: - b fisPadTriggerR -00576050: - b fisPadTriggerR -00840060: - b fisPadTriggerR -0050bd74: - bl fisPadTriggerR -0050bdbc: - bl fisPadTriggerR -0050be04: - bl fisPadTriggerR -00576000: - bl fisPadTriggerR -// Hold -00450108: - b fisPadHoldR -004501f8: - b fisPadHoldR -004503e4: - b fisPadHoldR -0057678c: - b fisPadHoldR -00450340: - bl fisPadHoldR -004508d4: - bl fisPadHoldR -0050bd80: - bl fisPadHoldR -0050bdc8: - bl fisPadHoldR -0050be10: - bl fisPadHoldR -0050c224: - bl fisPadHoldR -0050c644: - bl fisPadHoldR -0057673c: - bl fisPadHoldR -// Release -00450180: - b fisPadReleaseR - -// ZL -// Trigger -0056e57c: - b fisPadTriggerZL -005761c4: - b fisPadTriggerZL -0044d89c: - bl fisPadTriggerZL -0044d8ec: - bl fisPadTriggerZL -00450098: - bl fisPadTriggerZL -00576174: - bl fisPadTriggerZL -// Hold -004507e0: - b fisPadHoldZL -005735d0: - b fisPadHoldZL -008400a4: - b fisPadHoldZL -00450110: - bl fisPadHoldZL -00450200: - bl fisPadHoldZL -004506cc: - bl fisPadHoldZL -005734f8: - bl fisPadHoldZL -00840078: - bl fisPadHoldZL -// Release -00450188: - bl fisPadReleaseZL - -// ZR -// Trigger -0044d8c0: - b fisPadTriggerZR -0044d910: - b fisPadTriggerZR -004500bc: - b fisPadTriggerZR -0056e5c4: - b fisPadTriggerZR -00576148: - b fisPadTriggerZR -0050bca0: - bl fisPadTriggerZR -0050bcd8: - bl fisPadTriggerZR -0050bd10: - bl fisPadTriggerZR -0050bd44: - bl fisPadTriggerZR -0050be34: - bl fisPadTriggerZR -005760f8: - bl fisPadTriggerZR -// Hold -00450134: - b fisPadHoldZR -00450214: - b fisPadHoldZR -004506f0: - b fisPadHoldZR -00450830: - b fisPadHoldZR -0057351c: - b fisPadHoldZR -0057360c: - b fisPadHoldZR -0084009c: - b fisPadHoldZR -008400ac: - b fisPadHoldZR -0050bc48: - bl fisPadHoldZR -0050bcac: - bl fisPadHoldZR -0050bd1c: - bl fisPadHoldZR -0050bd50: - bl fisPadHoldZR -0050be40: - bl fisPadHoldZR -0050c230: - bl fisPadHoldZR -0050c650: - bl fisPadHoldZR -// Release -004501ac: - b fisPadReleaseZR - -// Press Right Stick -// Trigger -0045068c: - b fisPadTriggerPressRightStick -0056e2fc: - b fisPadTriggerPressRightStick -005734b4: - b fisPadTriggerPressRightStick -004d648c: - bl fisPadTriggerPressRightStick -004d7420: - bl fisPadTriggerPressRightStick - -// Plus -// Trigger -00575d14: - b fisPadTriggerPlus -00575de4: - b fisPadTriggerPlus -00576678: - b fisPadTriggerPlus -00576d88: - b fisPadTriggerPlus -0050be4c: - bl fisPadTriggerPlus -00575db8: - bl fisPadTriggerPlus -// Hold -0050bc54: - bl fisPadHoldPlus - -// Minus -// Trigger -00575d04: - b fisPadTriggerMinus -00576694: - b fisPadTriggerMinus -00576db4: - b fisPadTriggerMinus -00575d84: - bl fisPadTriggerMinus -00576a94: - bl fisPadTriggerMinus -00576d74: - bl fisPadTriggerMinus -00576d90: - bl fisPadTriggerMinus -00576f2c: - bl fisPadTriggerMinus - -// Dpad up -// Trigger -0050c360: - bl fisPadTriggerUp -00576a68: - bl fisPadTriggerUp -// Hold -009a38a8: - bl fisPadHoldUp -009a390c: - bl fisPadHoldUp - -// Dpad right -// Trigger -00577074: - b fisPadTriggerRight -00577200: - b fisPadTriggerRight -0057720c: - b fisPadTriggerRight -// Hold -005770d4: - b fisPadHoldRight -009a38cc: - bl fisPadHoldRight -009a38fc: - bl fisPadHoldRight - -// Dpad down -// Trigger -00577014: - b fisPadTriggerDown -0050c4b8: - bl fisPadTriggerDown -// Hold -009a38b4: - bl fisPadHoldDown -009a3928: - bl fisPadHoldDown - -// Dpad left -// Trigger -00577234: - b fisPadTriggerLeft -00577240: - b fisPadTriggerLeft -// Hold -009a38c0: - bl fisPadHoldLeft -009a38dc: - bl fisPadHoldLeft - -// UI-up -// Trigger -004fd878: - bl fisPadTriggerUiCursorUp -00575f08: - bl fisPadTriggerUiCursorUp -00575f58: - b fisPadTriggerUiCursorUp -// Hold -00576834: - bl fisPadHoldUiCursorUp -00576884: - b fisPadHoldUiCursorUp -// Release unused - -// UI-down -// Trigger -004fd8bc: - bl fisPadTriggerUiCursorDown -00575f84: - bl fisPadTriggerUiCursorDown -00575fd4: - b fisPadTriggerUiCursorDown -// Hold -005768b0: - bl fisPadHoldUiCursorDown -00576900: - b fisPadHoldUiCursorDown - -// UI-left -// Trigger -004fd900: - bl fisPadTriggerUiCursorLeft -00575e10: - bl fisPadTriggerUiCursorLeft -00575e60: - b fisPadTriggerUiCursorLeft -// Hold -0057692c: - bl fisPadHoldUiCursorLeft -0057697c: - b fisPadHoldUiCursorLeft - -// UI-right -// Trigger -004fd944: - bl fisPadTriggerUiCursorRight -00575e8c: - bl fisPadTriggerUiCursorRight -00575edc: - b fisPadTriggerUiCursorRight -// Hold -005769a8: - bl fisPadHoldUiCursorRight -005769f8: - b fisPadHoldUiCursorRight - // Motion // Camera Center off while TAS is running @@ -681,4 +349,16 @@ StageScene::control+18: 000b07f8: bl getMofumofuTarget 000b07a8: - bl isPatternReverse \ No newline at end of file + bl isPatternReverse + +// better input +0072EEDC: + bl fgetNpadStatesHandheld +0072EEF4: + bl fgetNpadStatesDual +0072EF0C: + bl fgetNpadStatesFullKey +0072EF24: + bl fgetNpadStatesJoyLeft +0072EF3C: + bl fgetNpadStatesJoyRight diff --git a/patches/130.slpatch b/patches/130.slpatch index 0c3d772..363b1ca 100644 --- a/patches/130.slpatch +++ b/patches/130.slpatch @@ -1,4 +1,7 @@ [version=130, target=main] +00472F2C: + bl stageSceneKillHook + StageScene::control+18: bl stageSceneControlHook @@ -47,4 +50,58 @@ StageScene::control+18: // toggle bowser skip 004B581C: - bl isDefeatKoopaLv1Var \ No newline at end of file + bl isDefeatKoopaLv1Var + +// Wiggler. +000A46EC: + bl getMofumofuTarget +000A4698: + bl isPatternReverse + +// Motion + +// weird motion fix thingy +005D25B0: + mov w0, #2 + ret + +// Camera Center off while TAS is running +003F3444: + bl fisPadTriggerLMotion +003F34BC: + bl fisPadTriggerLMotion + +// update +003EDA90: + bl motionUpdate +003EDA98: + bl motionUpdate + +003F15C0: + bl fgetPadAccelerationDeviceNum +005D55D8: + bl fgetPadAccelerationDeviceNum +005D564C: + bl fgetPadAccelerationDeviceNum +005D56F0: + bl fgetPadAccelerationDeviceNum +005D5794: + bl fgetPadAccelerationDeviceNum +005D58BC: + bl fgetPadAccelerationDeviceNum +005D5940: + bl fgetPadAccelerationDeviceNum +005D59C0: + bl fgetPadAccelerationDeviceNum + +// better input +0093FBF0: + bl fgetNpadStatesHandheld +0093FC08: + bl fgetNpadStatesDual +0093FC20: + bl fgetNpadStatesFullKey +0093FC38: + bl fgetNpadStatesJoyLeft +0093FC50: + bl fgetNpadStatesJoyRight diff --git a/source/debugMenu.cpp b/source/debugMenu.cpp index 54d81b3..8c93f18 100644 --- a/source/debugMenu.cpp +++ b/source/debugMenu.cpp @@ -1,7 +1,13 @@ #include "debugMenu.hpp" +#include "drawer.h" #include "fl/server.h" #include "fl/ui/ui.h" +#include "game/Player/PlayerActorHakoniwa.h" +#include "game/Player/PlayerCollider.h" +#include "game/System/Application.h" +#include #include +#include // These files must exist in your romfs! they are not there by default, and must be added in order for the debug font to work correctly. static const char* DBG_FONT_PATH = "DebugData/Font/nvn_font_jis1.ntx"; @@ -12,6 +18,7 @@ sead::TextWriter* gTextWriter; bool showMenu = true; bool isInGame = false; +bool inputEnabled = true; void setupDebugMenu(GameSystem* gSys) { @@ -94,49 +101,156 @@ void drawBackground(agl::DrawContext* context) agl::utl::DevTools::drawTriangleImm(context, p3, p4, p2, c); } -void drawMainHook(HakoniwaSequence* curSequence, sead::Viewport* viewport, sead::DrawContext* drawContext) +void drawMainHook(sead::Viewport* viewport, sead::DrawContext* drawContext, sead::LogicalFrameBuffer* frameBuffer, al::LayoutKit* layoutKit) { + al::executeDraw(layoutKit, "２Ｄバック（メイン画面）"); + al::executeDraw(layoutKit, "２Ｄベース（メイン画面）"); + al::executeDraw(layoutKit, "２Ｄオーバー（メイン画面）"); - if (!showMenu) { - al::executeDraw(curSequence->mLytKit, "２Ｄバック（メイン画面）"); - return; - } - - int dispWidth = al::getLayoutDisplayWidth(); - int dispHeight = al::getLayoutDisplayHeight(); - - gTextWriter->mViewport = viewport; + if (showMenu) { + int dispWidth = al::getLayoutDisplayWidth(); + int dispHeight = al::getLayoutDisplayHeight(); - gTextWriter->mColor = sead::Color4f( - 1.f, - 1.f, - 1.f, - 0.8f); + gTextWriter->setDrawContext(drawContext); + gTextWriter->setupGraphics(drawContext); + gTextWriter->mViewport = viewport; - al::Scene* curScene = curSequence->curScene; - - if (curScene && isInGame) { + gTextWriter->mColor = sead::Color4f( + 1.f, + 1.f, + 1.f, + 0.8f); drawBackground((agl::DrawContext*)drawContext); - al::PlayerHolder* pHolder = al::getScenePlayerHolder(curScene); - PlayerActorHakoniwa* player = al::tryGetPlayerActor(pHolder, 0); - sead::Vector3f* playerTrans = al::getTrans(player); - sead::Vector3f* playerVel = al::getVelocity(player); - sead::Quatf* playerQuat = al::getQuat(player); - sead::Vector3f* playerRecoveryPoint = player->mPlayerRecoverPoint->getSafetyPoint(); - gTextWriter->beginDraw(); + gTextWriter->setCursorFromTopLeft(sead::Vector2f(10.f, 10.f)); + gTextWriter->printf("FPS: %d\n", static_cast(round(Application::sInstance->mFramework->calcFps()))); gTextWriter->setCursorFromTopLeft(sead::Vector2f(10.f, (dispHeight / 2) + 30.f)); gTextWriter->setScaleFromFontHeight(20.f); #if (SMOVER == 100) - fl::ui::PracticeUI::instance().menu(*gTextWriter); + if(isInGame) + fl::ui::PracticeUI::instance().menu(*gTextWriter); #endif - isInGame = false; + gTextWriter->endDraw(); } + + fl::ui::PracticeUI& ui = fl::ui::PracticeUI::instance(); + al::Scene *curScene = ui.getStageScene(); +#if (SMOVER == 100) + if (curScene && isInGame) { + sead::LookAtCamera* cam = al::getLookAtCamera(curScene, 0); + sead::Projection* projection = al::getProjectionSead(curScene, 0); + + sead::PrimitiveRenderer* renderer = sead::PrimitiveRenderer::instance(); + renderer->setDrawContext(drawContext); + renderer->setCamera(*cam); + renderer->setProjection(*projection); + renderer->begin(); + + sead::Vector3f pos = sead::Vector3f::zero; + sead::Matrix34f mat = sead::Matrix34f::ident; + mat.setBase(3, pos); + renderer->setModelMatrix(mat); + + al::PlayerHolder* playerHolder = al::getScenePlayerHolder(curScene); + bool isExistPlayer = playerHolder->getPlayerNum() != 0; + al::LiveActor* playerActor = playerHolder->tryGetPlayer(0); + + PlayerActorHakoniwa* player; + if (isExistPlayer) + player = static_cast(playerActor); + + PlayerCollider* collider = player->mColliderHakoniwa->mCollider; + sead::Vector3f* playerTrans = al::getTrans(player); + sead::Quatf* playerQuat = al::getQuat(player); + sead::Vector3f playerFacing = sead::Vector3f::ez; + al::rotateVectorQuat(&playerFacing, *playerQuat); + + + HackCap* cappy = player->mHackCap; + sead::Vector3f* cappyTrans; + if (cappy) + cappyTrans = al::getTrans(cappy); + + // renderer->drawSphere8x16(ui.renderer.actorTrans, 30.0f, {1.0f, 0.0f, 0.0f, 0.8f}); + + if (ui.renderer.showPlayer) + renderer->drawSphere8x16(*playerTrans, 20.0f, {0.0f, 1.0f, 0.0f, 0.5f}); + + if (ui.renderer.showAxis) + renderer->drawAxis({0.0f, 0.0f, 0.0f}, 200.0f); + + if (ui.renderer.showHitInfoFloor) + drawHitInfo(renderer, collider->mHitFloor, {0.8, 1.0, 1.0, 0.8}); + + if (ui.renderer.showHitInfoWall) + drawHitInfo(renderer, collider->mHitWall, {1.0, 0.8, 1.0, 0.8}); - gTextWriter->endDraw(); + if (ui.renderer.showHitInfoCeil) + drawHitInfo(renderer, collider->mHitCeil, {1.0, 1.0, 0.8, 0.8}); - al::executeDraw(curSequence->mLytKit, "２Ｄバック（メイン画面）"); -} \ No newline at end of file + // drawWireTriangle(renderer, ui.renderer.kclTri, {1.0f, 1.0f, 1.0f, 1.0f}, {0.0f, 0.0f, 1.0f, 1.0f}, true); + + if (ui.renderer.showHitInfoArray) { + for (int i = 0; i < collider->arr4.capacity(); ++i) { + // for (int i = 0; i < 64; ++i) { + drawHitInfo(renderer, collider->arr4[i], {0.03f, 0.11f, 0.75f, 0.5f}); + } + } + + if (ui.renderer.showHitSensors && ui.currentActor) { + al::HitSensorKeeper* sensorKeeper = ui.currentActor->mHitSensorKeeper; + if (sensorKeeper) { + sead::PtrArray sensors = sensorKeeper->mSensors; + for (int i = 0; i < sensors.size(); ++i) { + al::HitSensor* sensor = sensors[i]; + if (!al::isSensorValid(sensor)) continue; + + sead::Vector3f pos = al::getSensorPos(sensor); + float radius = al::getSensorRadius(sensor); + renderer->drawSphere8x16(pos, radius, {1.0f, 0.8f, 1.0f, 0.7f}); + } + } + } + + if (ui.renderer.curArea && ui.renderer.showArea) { + al::calcNearestAreaObjEdgePos(&ui.renderer.nearestEdgePoint, ui.renderer.curArea, *playerTrans); + if (ui.renderer.showAreaPoint) + renderer->drawSphere8x16(ui.renderer.nearestEdgePoint, 15.0f, {0.0f, 1.0f, 0.0f, 1.0f}); + drawAreaObj(renderer, ui.renderer.curArea, false, {1.0f, 0.8f, 1.0f, 0.9f}, {1.0f, 0.8f, 1.0f, 0.6f}, {1.0f, 0.8f, 1.0f, 0.6f}); + } + + if (ui.renderer.curAreaGroup && ui.renderer.showAreaGroup) + drawAreaObjGroup(renderer, ui.renderer.curAreaGroup, false, {0.8f, 0.5f, 0.8f, 0.3f}, {0.8f, 0.5f, 0.8f, 0.3f}, {0.8f, 0.5f, 0.8f, 0.3f}); + + if (ui.renderer.showCRC && cappy) { + sead::Vector3f difference = *cappyTrans - *playerTrans; + sead::Vector3f crc = *playerTrans + sead::dot(difference, playerFacing) * playerFacing; + + renderer->drawLine(*playerTrans, *playerTrans + playerFacing * 50.0f, {0.25f, 0.25f, 1.0f, 1.0f}); + + renderer->drawSphere8x16(crc, 60.0f, {1.0f, 0.25f, 0.25, 0.4f}); + } + + + if (ui.testDrawCube) { + sead::PrimitiveRenderer::CubeArg shapeArea({20750, 250, 6750}, {500.0, 500.0, 500.0}, {1.0f, 0.0f, 0.0f, 1.0f}); + renderer->drawCube(shapeArea); + } + + if (ui.testDrawSphere) { + renderer->drawSphere8x16({20750, 250, 6750}, 250.0f, {0.0f, 1.0f, 0.0f, 1.0f}); + } + + if (ui.testDrawCylinder) { + renderer->drawCylinder32({20750, 250, 6750}, 250.0f, 500.0f, {0.0f, 0.0f, 1.0f, 1.0f}); + } + + renderer->end(); + } +#endif + + isInGame = false; +} diff --git a/source/drawer.cpp b/source/drawer.cpp new file mode 100644 index 0000000..7562e9b --- /dev/null +++ b/source/drawer.cpp @@ -0,0 +1,109 @@ +#include "drawer.h" +#include "al/area/AreaObj.h" +#include "al/area/AreaShape.h" +#include "al/collision/CollisionParts.h" +#include "al/collision/KCollisionServer.h" +#include "al/collision/Triangle.h" +#include "al/collision/HitInfo.h" +#include "al/LiveActor/LiveActorGroup.h" +#include "al/LiveActor/LiveActorKit.h" +#include "al/util.hpp" +#include "constants.h" + +bool enableFadeoff = true; + +float calcFadeoff(al::LiveActor const* actor, sead::Vector3f const& pos2) +{ + if (enableFadeoff == false) + return constants::maxAlpha; + return (constants::maxDist - al::calcDistance(actor, pos2)) / constants::maxDist * constants::maxAlpha; +} + +void drawAreaObjGroup(sead::PrimitiveRenderer* renderer, al::AreaObjGroup const* group, bool isDrawSolid, sead::Color4f wire, sead::Color4f solid, sead::Color4f cyl) { + for (int i = 0; i < group->mAreaCount; ++i) { + drawAreaObj(renderer, group->mAreas[i], isDrawSolid, wire, solid, cyl); + } +} + +void drawAreaObj(sead::PrimitiveRenderer* renderer, al::AreaObj const* area, bool isDrawSolid, sead::Color4f wire, sead::Color4f solid, sead::Color4f cyl) { + const char* shapeType; + al::tryGetAreaObjStringArg(&shapeType, area, "ModelName"); + + sead::Vector3f scale = area->mAreaShape->mScale; + sead::Vector3f pos; + area->mAreaShape->calcTrans(&pos); + renderer->setModelMatrix(area->mAreaMtx); + + if (al::isEqualString(shapeType, "AreaCubeBase")) { + sead::PrimitiveRenderer::CubeArg shapeArea(sead::Vector3f(0.0f, scale.y * 500.0f, 0.0f), scale * 1000.f, wire); + if (isDrawSolid) + renderer->drawCube(shapeArea); + renderer->drawWireCube(shapeArea); + } + else if (al::isEqualString(shapeType, "AreaCubeCenter")) { + sead::PrimitiveRenderer::CubeArg shapeArea(sead::Vector3f(0.0f, 0.0f, 0.0f), scale * 1000.0f, wire); + if (isDrawSolid) + renderer->drawCube(shapeArea); + renderer->drawWireCube(shapeArea); + } + else if (al::isEqualString(shapeType, "AreaCubeTop")) { + sead::PrimitiveRenderer::CubeArg shapeArea(sead::Vector3f(0.0f, -scale.y * 500.0f, 0.0f), scale * 1000.0f, wire); + if (isDrawSolid) + renderer->drawCube(shapeArea); + renderer->drawWireCube(shapeArea); + } + else if (al::isEqualString(shapeType, "AreaCylinder")) { + renderer->drawCylinder32(sead::Vector3f(0.0f, scale.y * 250.0f, 0.0f), scale.x * 500.0f, scale.y * 500.0f, cyl); + } + else if (al::isEqualString(shapeType, "AreaCylinderCenter")) { + renderer->drawCylinder32(sead::Vector3f(0.0f, 0.0f, 0.0f), scale.x * 500.0f, scale.y * 500.0f, cyl); + } + else if (al::isEqualString(shapeType, "AreaCylinderTop")) { + renderer->drawCylinder32(sead::Vector3f(0.0f, -scale.y * 250.0f, 0.0f), scale.x * 500.0f, scale.y * 500.0f, cyl); + } + else if (al::isEqualString(shapeType, "AreaSphere")) { + renderer->drawSphere8x16(sead::Vector3f(0.0f, 0.0f, 0.0f), scale.x * 1000.0f, cyl); + } +} + +void drawWireTriangle(sead::PrimitiveRenderer* renderer, al::Triangle const& tri, sead::Color4f wire, sead::Color4f colorNormal, bool drawNormal) { + sead::Vector3f v1 = tri.mVerts[0]; + sead::Vector3f v2 = tri.mVerts[1]; + sead::Vector3f v3 = tri.mVerts[2]; + + renderer->drawLine(v1, v2, wire); + renderer->drawLine(v2, v3, wire); + renderer->drawLine(v3, v1, wire); + + if (drawNormal) { + sead::Vector3f normal = tri.mFaceNormal * 50; + sead::Vector3f center = (v1 + v2 + v3) / 3; + renderer->drawLine(center, center + normal, colorNormal); + } +} + + +void drawHitInfo(sead::PrimitiveRenderer* renderer, al::HitInfo const* hitInfo, sead::Color4f wire, sead::Color4f solid) { + drawWireTriangle(renderer, hitInfo->mTri, wire, {1.0f, 0.5f, 0.0f, 0.8f}, true); + + renderer->drawSphere8x16(hitInfo->vVar1, 20.0f, {0.0f, 1.0f, 0.0f, 0.5f}); + renderer->drawSphere8x16(hitInfo->mCollisionHitPos, 15.0f, {1.0f, 0.0f, 0.0f, 0.5f}); + // renderer->drawSphere8x16(hitInfo->mCollisionMovingReaction, 15.0f, {0.0f, 0.0f, 1.0f, 0.5f}); +} + + +void drawAllCollision(sead::PrimitiveRenderer* renderer, al::LiveActorKit const& liveActorKit) { + sead::PtrArray actors = liveActorKit.mAllActors->mActors; + + for (int actorIdx = 0; actorIdx < actors.capacity(); actorIdx++) { + al::LiveActor* actor = actors[actorIdx]; + al::CollisionParts* collisionParts = actor->mCollisionParts; + if (!collisionParts) continue; + + // iterate through TList too? + + al::KCollisionServer* kCollisionServer = collisionParts->mKCollisionServer; + al::KCPrismHeader* prismHeader = kCollisionServer->mPrismHeaders[0]; + // prismHeader-> + } +} diff --git a/source/fl/game.cpp b/source/fl/game.cpp index 88ac118..dc95fab 100644 --- a/source/fl/game.cpp +++ b/source/fl/game.cpp @@ -25,7 +25,7 @@ void Game::damageMario(int amount) { void Game::lifeUpHeart() { #if SMOVER==100 - mStageScene->mHolder->mGameDataFile->getPlayerHitPointData()->getMaxUpItem(); + mStageScene->mDataHolder->mPlayingFile->getPlayerHitPointData()->getMaxUpItem(); #endif #if SMOVER==130 GameDataFunction::getLifeMaxUpItem(getPlayer()); @@ -34,7 +34,7 @@ void Game::lifeUpHeart() { void Game::healMario() { #if SMOVER==100 - mStageScene->mHolder->mGameDataFile->getPlayerHitPointData()->recover(); + mStageScene->mDataHolder->mPlayingFile->getPlayerHitPointData()->recover(); #endif #if SMOVER==130 GameDataFunction::recoveryPlayer(getPlayer()); diff --git a/source/fl/input.cpp b/source/fl/input.cpp index 57c01a2..52f5ce7 100644 --- a/source/fl/input.cpp +++ b/source/fl/input.cpp @@ -1,103 +1,140 @@ #include "sead/math/seadVector.h" +#include #include #include -#include - -#if(SMOVER==100) - -#define PADTRIGGER(BUTTON, PNAME) bool fisPadTrigger##BUTTON(int port) {\ - fl::TasHolder& h = fl::TasHolder::instance();\ - if (h.isRunning) {\ - if (h.curFrame == 0) return h.frames[0].PNAME;\ - return !h.frames[h.curFrame - 1].PNAME && h.frames[h.curFrame].PNAME;\ - } else return al::isPadTrigger##BUTTON(port);} +#include -#define PADHOLD(BUTTON, PNAME) bool fisPadHold##BUTTON(int port) {\ - fl::TasHolder& h = fl::TasHolder::instance();\ - if (h.isRunning) {\ - if (h.curFrame == 0) return h.frames[0].PNAME;\ - return h.frames[h.curFrame].PNAME;\ - } else return al::isPadHold##BUTTON(port);} +long raw_input; +long raw_input_prev; +long ext_input; -#define PADRELEASE(BUTTON, PNAME) bool fisPadRelease##BUTTON(int port) {\ - fl::TasHolder& h = fl::TasHolder::instance();\ - if (h.isRunning) {\ - if (h.curFrame == 0) return false;\ - return h.frames[h.curFrame - 1].PNAME && !h.frames[h.curFrame].PNAME;\ - } else return al::isPadRelease##BUTTON(port);} - -sead::Vector2f* fgetLeftStick(int port) -{ - fl::TasHolder& h = fl::TasHolder::instance(); - return h.isRunning ? &h.frames[h.curFrame].leftStick : al::getLeftStick(port); +bool isPressed(int button) { + return ((raw_input|ext_input) & (1 << button)) != 0; } -sead::Vector2f* fgetRightStick(int port) -{ - fl::TasHolder& h = fl::TasHolder::instance(); - return h.isRunning ? &h.frames[h.curFrame].rightStick : al::getRightStick(port); +bool isPressedPrev(int button) { + return (raw_input_prev & (1 << button)) != 0; +} +bool isTriggerLeft() { + return isPressed(12) && !isPressedPrev(12); +} +bool isTriggerUp() { + return isPressed(13) && !isPressedPrev(13); +} +bool isTriggerRight() { + return isPressed(14) && !isPressedPrev(14); +} +bool isTriggerDown() { + return isPressed(15) && !isPressedPrev(15); +} +bool isHoldLeft() { + return isPressed(12) && isPressedPrev(12); +} +bool isHoldUp() { + return isPressed(13) && isPressedPrev(13); +} +bool isHoldRight() { + return isPressed(14) && isPressedPrev(14); +} +bool isHoldDown() { + return isPressed(15) && isPressedPrev(15); +} +bool isHoldA() { + return isPressed(0) && isPressedPrev(0); +} +bool isHoldB() { + return isPressed(1) && isPressedPrev(1); +} +bool isL() { + return isPressed(6); +} +bool isTriggerPressLeftStick() { + return isPressed(4) && !isPressedPrev(4); } -PADTRIGGER(A, A); -PADTRIGGER(B, B); -PADTRIGGER(X, X); -PADTRIGGER(Y, Y); -PADTRIGGER(L, L); -PADTRIGGER(R, R); -PADTRIGGER(ZL, ZL); -PADTRIGGER(ZR, ZR); -PADTRIGGER(PressLeftStick, pressLeftStick); -PADTRIGGER(PressRightStick, pressRightStick); -PADTRIGGER(Plus, plus); -PADTRIGGER(Minus, minus); -PADTRIGGER(Up, dUp); -PADTRIGGER(Right, dRight); -PADTRIGGER(Down, dDown); -PADTRIGGER(Left, dLeft); -PADTRIGGER(UiCursorUp, dUp); -PADTRIGGER(UiCursorDown, dDown); -PADTRIGGER(UiCursorLeft, dLeft); -PADTRIGGER(UiCursorRight, dRight); +void controllerHook(nn::hid::NpadBaseState* state) { + fl::TasHolder& h = fl::TasHolder::instance(); + raw_input_prev = raw_input; + raw_input = state->mButtons; + if (!h.isRunning) { + return; + } -PADHOLD(A, A); -PADHOLD(B, B); -PADHOLD(X, X); -PADHOLD(Y, Y); -PADHOLD(L, L); -PADHOLD(R, R); -PADHOLD(ZL, ZL); -PADHOLD(ZR, ZR); -PADHOLD(PressLeftStick, pressLeftStick); -PADHOLD(PressRightStick, pressRightStick); -PADHOLD(Plus, plus); -PADHOLD(Minus, minus); -PADHOLD(Up, dUp); -PADHOLD(Right, dRight); -PADHOLD(Down, dDown); -PADHOLD(Left, dLeft); -PADHOLD(UiCursorUp, dUp); -PADHOLD(UiCursorDown, dDown); -PADHOLD(UiCursorLeft, dLeft); -PADHOLD(UiCursorRight, dRight); + state->mButtons = 0; + if(h.frames[h.curFrame].A) + state->mButtons |= (1 << 0); + if(h.frames[h.curFrame].B) + state->mButtons |= (1 << 1); + if(h.frames[h.curFrame].X) + state->mButtons |= (1 << 2); + if(h.frames[h.curFrame].Y) + state->mButtons |= (1 << 3); + if(h.frames[h.curFrame].pressLeftStick) + state->mButtons |= (1 << 4); + if(h.frames[h.curFrame].pressRightStick) + state->mButtons |= (1 << 5); + if(h.frames[h.curFrame].L) + state->mButtons |= (1 << 6); + if(h.frames[h.curFrame].R) + state->mButtons |= (1 << 7); + if(h.frames[h.curFrame].ZL) + state->mButtons |= (1 << 8); + if(h.frames[h.curFrame].ZR) + state->mButtons |= (1 << 9); + if(h.frames[h.curFrame].plus) + state->mButtons |= (1 << 10); + if(h.frames[h.curFrame].minus) + state->mButtons |= (1 << 11); + if(h.frames[h.curFrame].dLeft) + state->mButtons |= (1 << 12); + if(h.frames[h.curFrame].dUp) + state->mButtons |= (1 << 13); + if(h.frames[h.curFrame].dRight) + state->mButtons |= (1 << 14); + if(h.frames[h.curFrame].dDown) + state->mButtons |= (1 << 15); -PADRELEASE(A, A); -PADRELEASE(B, B); -PADRELEASE(X, X); -PADRELEASE(Y, Y); -PADRELEASE(L, L); -PADRELEASE(R, R); -PADRELEASE(ZL, ZL); -PADRELEASE(ZR, ZR); -PADRELEASE(PressLeftStick, pressLeftStick); -PADRELEASE(PressRightStick, pressRightStick); -PADRELEASE(Plus, plus); -PADRELEASE(Minus, minus); -PADRELEASE(Up, dUp); -PADRELEASE(Right, dRight); -PADRELEASE(Down, dDown); -PADRELEASE(Left, dLeft); -PADRELEASE(UiCursorUp, dUp); -PADRELEASE(UiCursorDown, dDown); -PADRELEASE(UiCursorLeft, dLeft); -PADRELEASE(UiCursorRight, dRight); + if(h.frames[h.curFrame].leftStick.x < -0.5f) + state->mButtons |= (1 << 16); + if(h.frames[h.curFrame].leftStick.y > 0.5f) + state->mButtons |= (1 << 17); + if(h.frames[h.curFrame].leftStick.x > 0.5f) + state->mButtons |= (1 << 18); + if(h.frames[h.curFrame].leftStick.y < -0.5f) + state->mButtons |= (1 << 19); + + if(h.frames[h.curFrame].rightStick.x < -0.5f) + state->mButtons |= (1 << 20); + if(h.frames[h.curFrame].rightStick.y > 0.5f) + state->mButtons |= (1 << 21); + if(h.frames[h.curFrame].rightStick.x > 0.5f) + state->mButtons |= (1 << 22); + if(h.frames[h.curFrame].rightStick.y < -0.5f) + state->mButtons |= (1 << 23); + + // all others unused -#endif \ No newline at end of file + //state->mAnalogStickL = (((long) h.frames[h.curFrame].leftStick.x) & 0xffffffff) | (((long) h.frames[h.curFrame].leftStick.y) << 32); + //state->mAnalogStickR = (((long) h.frames[h.curFrame].rightStick.x) & 0xffffffff) | (((long) h.frames[h.curFrame].rightStick.y) << 32); + state->mAnalogStickL = (((long) (h.frames[h.curFrame].leftStick.x * 32767)) & 0xffffffff) | (((long) (h.frames[h.curFrame].leftStick.y * 32767)) << 32); + state->mAnalogStickR = (((long) (h.frames[h.curFrame].rightStick.x * 32767)) & 0xffffffff) | (((long) (h.frames[h.curFrame].rightStick.y * 32767)) << 32); +} +void fgetNpadStatesHandheld(nn::hid::NpadHandheldState* state, int unk1, const unsigned int& unk2) { + nn::hid::GetNpadStates(state, unk1, unk2); + if(unk2 == 0) controllerHook(state); +} +void fgetNpadStatesDual(nn::hid::NpadJoyDualState* state, int unk1, const unsigned int& unk2) { + nn::hid::GetNpadStates(state, unk1, unk2); + if(unk2 == 0) controllerHook(state); +} +void fgetNpadStatesFullKey(nn::hid::NpadFullKeyState* state, int unk1, const unsigned int& unk2) { + nn::hid::GetNpadStates(state, unk1, unk2); + if(unk2 == 0) controllerHook(state); +} +void fgetNpadStatesJoyLeft(nn::hid::NpadJoyLeftState* state, int unk1, const unsigned int& unk2) { + nn::hid::GetNpadStates(state, unk1, unk2); + if(unk2 == 0) controllerHook(state); +} +void fgetNpadStatesJoyRight(nn::hid::NpadJoyRightState* state, int unk1, const unsigned int& unk2) { + nn::hid::GetNpadStates(state, unk1, unk2); + if(unk2 == 0) controllerHook(state); +} diff --git a/source/fl/packet.cpp b/source/fl/packet.cpp index f6764eb..e78df80 100644 --- a/source/fl/packet.cpp +++ b/source/fl/packet.cpp @@ -13,12 +13,12 @@ #include namespace smo { -u32 OutPacketLog::calcLen() +u32 OutPacketLog::calcLen() const { return strlen(message) + 1; } -void OutPacketLog::construct(u8* dst) +void OutPacketLog::construct(u8* dst) const { *dst = type; strcpy((char*)dst + 1, message); @@ -28,7 +28,7 @@ void InPacketPlayerScriptInfo::parse(const u8* data, u32 len) { fl::TasHolder& h = fl::TasHolder::instance(); if (h.isRunning) - return; + h.stop(); scriptName = (char*)alloc(len + 1); fl::memcpy(scriptName, data, len); scriptName[len] = '\0'; @@ -38,7 +38,7 @@ void InPacketPlayerScriptInfo::on(Server& server) { fl::TasHolder& h = fl::TasHolder::instance(); if (h.isRunning) - return; + h.stop(); h.setScriptName(scriptName); if (h.frames) { dealloc(h.frames); @@ -67,17 +67,15 @@ void InPacketPlayerTeleport::on(Server& server) void InPacketPlayerGo::parse(const u8* data, u32 len) { - nn::mem::StandardAllocator* m = nn::init::GetAllocator(); - scenario = *(signed char*)&data[0]; u8 stageLength = data[1]; u8 entranceLength = data[2]; - stageName = (char*)m->Allocate(stageLength + 1); + stageName = (char*)alloc(stageLength + 1); fl::memcpy(stageName, &data[3], stageLength); stageName[stageLength] = '\0'; - entrance = (char*)m->Allocate(entranceLength + 1); + entrance = (char*)alloc(entranceLength + 1); fl::memcpy(entrance, &data[3 + stageLength], entranceLength); entrance[entranceLength] = '\0'; @@ -86,22 +84,22 @@ void InPacketPlayerGo::parse(const u8* data, u32 len) void InPacketPlayerGo::on(Server& server) { - nn::mem::StandardAllocator* m = nn::init::GetAllocator(); StageScene* stageScene = fl::ui::PracticeUI::instance().getStageScene(); if (!stageScene) { if (entrance) - m->Free(entrance); + free(entrance); if (stageName) - m->Free(stageName); + free(stageName); + return; } - ChangeStageInfo info = ChangeStageInfo(stageScene->mHolder, entrance, stageName, false, scenario, { 0 }); - stageScene->mHolder->changeNextStage(&info, 0); + ChangeStageInfo info = ChangeStageInfo(stageScene->mDataHolder, entrance, stageName, false, scenario, { 0 }); + stageScene->mDataHolder->changeNextStage(&info, 0); if (entrance) - m->Free(entrance); + free(entrance); if (stageName) - m->Free(stageName); + free(stageName); if (startScript && fl::TasHolder::instance().frames) fl::TasHolder::instance().startPending = true; @@ -111,7 +109,7 @@ void InPacketPlayerScriptData::parse(const u8* data, u32 len) { fl::TasHolder& h = fl::TasHolder::instance(); if (h.isRunning) - return; + h.stop(); size_t cur = h.frameCount; if (h.frames) { h.frameCount += len / sizeof(fl::TasFrame); @@ -125,13 +123,41 @@ void InPacketPlayerScriptData::parse(const u8* data, u32 len) void InPacketPlayerScriptData::on(Server& server) { } -void InPacketChangePage::parse(const u8* data, u32 len) +void InPacketSelect::parse(const u8* data, u32 len) { - page = data[0]; + option = data[0]; } -void InPacketChangePage::on(Server& server) +void InPacketSelect::on(Server& server) { - fl::ui::PracticeUI::instance().curPage = (fl::ui::PracticeUI::Page)page; + auto& ui = fl::ui::PracticeUI::instance(); + ui.curLine = option; +} + +void InPacketUINavigation::parse(const u8* data, u32 len) +{ + inputMask = *((long*)data); +} + +void InPacketUINavigation::on(Server& server) +{ + auto& ui = fl::ui::PracticeUI::instance(); + ext_input |= inputMask; +} + +void InPacketPlayerScriptState::parse(const u8* data, u32 len) +{ + state = data[0]; +} + +void InPacketPlayerScriptState::on(Server& server) +{ + auto& tas = fl::TasHolder::instance(); + if(state == 1) { + if (tas.frames) + tas.start(); + } else if(state == 0) { + tas.stop(); + } +} } -} \ No newline at end of file diff --git a/source/fl/server.cpp b/source/fl/server.cpp index bc1ed5e..30fd39c 100644 --- a/source/fl/server.cpp +++ b/source/fl/server.cpp @@ -20,14 +20,13 @@ void threadFunc(void* args) { smo::Server* server = (smo::Server*) args; nn::TimeSpan w = nn::TimeSpan::FromNanoSeconds(1000000); - u8* buf = (u8*) nn::init::GetAllocator()->Allocate(30720); + u8* buf = (u8*) aligned_alloc(0x10, 30720); while (true) { server->handlePacket(buf, 30720); nn::os::YieldThread(); nn::os::SleepThread(w); } - nn::init::GetAllocator()->Free(buf); } namespace smo @@ -66,7 +65,7 @@ namespace smo if (!thread) { - thread = (nn::os::ThreadType*) nn::init::GetAllocator()->Allocate(sizeof(nn::os::ThreadType)); + thread = (nn::os::ThreadType*) aligned_alloc(0x10, sizeof(nn::os::ThreadType)); threadStack = aligned_alloc(0x1000, 0x15000); nn::os::CreateThread(thread, threadFunc, this, threadStack, 0x15000, 16, 0); nn::os::SetThreadName(thread, "UDP Thread"); @@ -103,7 +102,7 @@ namespace smo connected = false; } - void Server::sendPacket(OutPacket& packet, OutPacketType type) + void Server::sendPacket(const OutPacket& packet, OutPacketType type) { u32 len = packet.calcLen(); @@ -113,6 +112,16 @@ namespace smo nn::socket::SendTo(socket, data, len + 1, 0, (struct sockaddr*) &server, sizeof(server)); } + void Server::log(const char* fmt, ...) { + char buf[0x100]; + va_list args; + va_start(args, fmt); + vsnprintf(buf, sizeof(buf), fmt, args); + va_end(args); + const auto& packet = OutPacketLog(buf); + sendPacket(packet, OutPacketType::Log); + } + void Server::handlePacket(u8* buf, size_t bufSize) { if (!connected) return; @@ -120,6 +129,7 @@ namespace smo i++; u32 size = sizeof(server); u32 len = nn::socket::RecvFrom(socket, buf, bufSize, 0, &server, &size); + if(len == -1) return; switch ((InPacketType) buf[0]) { case 0: break; //timeout @@ -127,7 +137,9 @@ namespace smo IN_PACKET(PlayerTeleport); IN_PACKET(PlayerGo); IN_PACKET(PlayerScriptData); - IN_PACKET(ChangePage); + IN_PACKET(Select); + IN_PACKET(UINavigation); + IN_PACKET(PlayerScriptState); default: break; } } @@ -138,4 +150,4 @@ namespace smo } } -#undef IN_PACKET \ No newline at end of file +#undef IN_PACKET diff --git a/source/fl/tas.cpp b/source/fl/tas.cpp index a08d968..42f665e 100644 --- a/source/fl/tas.cpp +++ b/source/fl/tas.cpp @@ -3,27 +3,30 @@ void fl::TasHolder::update() { - if (!isRunning) - { - if (startPending) - { - isRunning = true; - curFrame = 0; - startPending = false; - } - return; - } - if (curFrame + 1 >= frameCount) stop(); + if(!isRunning) return; + + if (curFrame + 1 >= frameCount && curFrame >= 0) stop(); curFrame++; } +void fl::TasHolder::onStageKill() +{ + if(startPending) { + start(); + curFrame = -1; + } +} + void fl::TasHolder::start() { + startPending = false; + curFrame = 0; isRunning = true; } void fl::TasHolder::stop() { + startPending = false; curFrame = 0; isRunning = false; } @@ -32,4 +35,4 @@ void fl::TasHolder::setScriptName(char* name) { if (scriptName) dealloc(scriptName); scriptName = name; -} \ No newline at end of file +} diff --git a/source/fl/ui/p_about.cpp b/source/fl/ui/p_about.cpp deleted file mode 100644 index 5274b3b..0000000 --- a/source/fl/ui/p_about.cpp +++ /dev/null @@ -1,8 +0,0 @@ -#include "fl/ui/pages.h" - -void fl::ui::about::update(PracticeUI& ui) -{ - ui.printf("Welcome to the Practice Mod!\n"); - ui.printf("Made by Fruityloops#8500 and contributors\n"); - ui.printf("Big thanks to CraftyBoss, bryce_____ and Mars2030!\n"); -} \ No newline at end of file diff --git a/source/fl/ui/p_debug.cpp b/source/fl/ui/p_debug.cpp deleted file mode 100644 index f2691a4..0000000 --- a/source/fl/ui/p_debug.cpp +++ /dev/null @@ -1,21 +0,0 @@ -#include "fl/common.h" -#include "fl/ui/pages.h" -#include "game/GameData/GameDataFunction.h" - -void fl::ui::debug::update(PracticeUI& ui) -{ - StageScene* stageScene = ui.getStageScene(); -#if (SMOVER == 100) - ui.printf(" Current Scenario: %d\n", GameDataFunction::getWorldScenarioNo(*stageScene->mHolder, GameDataFunction::getCurrentWorldId(*stageScene->mHolder))); - ui.printf(" Current World ID: %d\n", GameDataFunction::getCurrentWorldId(*stageScene->mHolder)); - ui.printf(" Current Stage Name: %s\n", GameDataFunction::getCurrentStageName(*stageScene->mHolder)); -#endif -#if (SMOVER == 130) - ui.printf(" Current Scenario: %d\n", stageScene->mHolder->mGameDataFile->getScenarioNo(GameDataFunction::getCurrentWorldId(stageScene->mHolder))); - ui.printf(" Current World ID: %d\n", GameDataFunction::getCurrentWorldId(stageScene->mHolder)); - ui.printf(" Current Stage Name: %s\n", GameDataFunction::getCurrentStageName(stageScene->mHolder)); -#endif - ui.printf(" Language: %s\n", stageScene->mHolder->getLanguage()); - ui.printf("\n"); - ui.printf(" Practice Mod Version: %s\n", PRACTICE_VERSTR); -} \ No newline at end of file diff --git a/source/fl/ui/p_info.cpp b/source/fl/ui/p_info.cpp deleted file mode 100644 index ee7a2f8..0000000 --- a/source/fl/ui/p_info.cpp +++ /dev/null @@ -1,47 +0,0 @@ -#include "al/LiveActor/LiveActor.h" -#include "fl/ui/pages.h" -#include "fl/util.h" -#include "game/Player/PlayerActorHakoniwa.h" -#include "rs/util.hpp" - -void fl::ui::info::update(PracticeUI& ui) -{ - static bool quatRot = false; - - ui.toggle("Quaternion Rotation", quatRot); - - PlayerActorHakoniwa* player = rs::getPlayerActor(ui.getStageScene()); - al::LiveActor* cappy = player->mHackCap; - - sead::Vector3f* playerTrans = al::getTrans(player); - sead::Vector3f* playerVel = al::getVelocity(player); - sead::Quatf* playerQuat = al::getQuat(player); - sead::Vector3f playerEulerAngles = fl::QuatToEuler(playerQuat); - sead::Vector3f playerRot = sead::Vector3f(DEG(playerEulerAngles.x), DEG(playerEulerAngles.y), DEG(playerEulerAngles.z)); - sead::Vector3f* playerRecoveryPoint = player->mPlayerRecoverPoint->getSafetyPoint(); - sead::Vector3f* cappyPosition = al::getTrans(cappy); - sead::Vector3f* cappyVel = al::getVelocity(cappy); - sead::Quatf* cappyQuat = al::getQuat(cappy); - sead::Vector3f cappyEulerAngles = fl::QuatToEuler(cappyQuat); - sead::Vector3f cappyRot = sead::Vector3f(DEG(cappyEulerAngles.x), DEG(cappyEulerAngles.y), DEG(cappyEulerAngles.z)); - const char* anim = player->mPlayerAnimator->mCurrentAnim; - float hSpeed = al::calcSpeedH(player), vSpeed = al::calcSpeedV(player), speed = al::calcSpeed(player); - - ui.printf("Player Pos: (X: %.3f Y: %.3f Z: %.3f)\n", playerTrans->x, playerTrans->y, playerTrans->z); - ui.printf("Player Vel: (X: %.3f Y: %.3f Z: %.3f)\n", playerVel->x, playerVel->y, playerVel->z); - ui.printf("Player Speed: (H: %.3f V: %.3f S: %.3f)\n", hSpeed, vSpeed, speed); - if (quatRot) { - ui.printf("Player Rot: (W: %.3f X: %.3f Y: %.3f Z: %.3f)\n", playerQuat->w, playerQuat->x, playerQuat->y, playerQuat->z); - } else { - ui.printf("Player Rot: (X: %.3f Y: %.3f Z: %.3f)\n", playerRot.x, playerRot.y, playerRot.z); - } - ui.printf("Cappy Pos: (X: %.3f Y: %.3f Z: %.3f)\n", cappyPosition->x, cappyPosition->y, cappyPosition->z); - ui.printf("Cappy Vel: (X: %.3f Y: %.3f Z: %.3f)\n", cappyVel->x, cappyVel->y, cappyVel->z); - if (quatRot) { - ui.printf("Cappy Rot: (W: %.3f X: %.3f Y: %.3f Z: %.3f)\n", cappyQuat->w, cappyQuat->x, cappyQuat->y, cappyQuat->z); - } else { - ui.printf("Cappy Rot: (X: %.3f Y: %.3f Z: %.3f)\n", cappyRot.x, cappyRot.y, cappyRot.z); - } - ui.printf("Bubble Pos: (X: %.3f Y: %.3f Z: %.3f)\n", playerRecoveryPoint->x, playerRecoveryPoint->y, playerRecoveryPoint->z); - ui.printf("Current Animation: %s (%.0f/%.0f)\n", anim, player->mPlayerAnimator->getAnimFrame() - 1.0f, player->mPlayerAnimator->getAnimFrameMax()); -} \ No newline at end of file diff --git a/source/fl/ui/p_misc.cpp b/source/fl/ui/p_misc.cpp deleted file mode 100644 index 2f8f077..0000000 --- a/source/fl/ui/p_misc.cpp +++ /dev/null @@ -1,87 +0,0 @@ -#include "fl/ui/pages.h" -#include "game/GameData/GameDataFunction.h" -#include "game/Player/PlayerActorHakoniwa.h" -#include "rs/util.hpp" -#include - -void fl::ui::misc::update(PracticeUI& ui) -{ - StageScene* stageScene = ui.getStageScene(); - ui.trigger("Kill Mario", []() { - Game::instance().killMario(); - }); - ui.trigger("Damage Mario", []() { - Game::instance().damageMario(1); - }); - ui.trigger("Life Up Heart", []() { - Game::instance().lifeUpHeart(); - }); - ui.trigger("Heal Mario", []() { - Game::instance().healMario(); - }); - ui.trigger("Remove Cappy", []() { - Game::instance().removeCappy(); - }); - ui.trigger("Invincibility Star", []() { - Game::instance().invincibilityStar(); - }); - ui.trigger("Add 1000 coins", [stageScene]() { - GameDataFunction::addCoin(*stageScene->mHolder, 1000); - }); - - ui.addLine(); - - static u8 gravity = 0; - ui.cursor(8); - const char* gravityString = nullptr; - if (gravity == 0) - gravityString = "Down"; - else if (gravity == 1) - gravityString = "Up"; - else if (gravity == 2) - gravityString = "North"; - else if (gravity == 3) - gravityString = "South"; - else if (gravity == 4) - gravityString = "East"; - else if (gravity == 5) - gravityString = "West"; - - bool gravityChanged = false; - ui.printf("Gravity: %s\n", gravityString); - if (ui.curLine == 8 && ui.inputEnabled && !ui.nextFrameNoLeftInput && al::isPadTriggerLeft(CONTROLLER_AUTO)) { - gravity--; - gravityChanged = true; - } else if (ui.curLine == 8 && ui.inputEnabled && !ui.nextFrameNoRightInput && al::isPadTriggerRight(CONTROLLER_AUTO)) { - gravity++; - gravityChanged = true; - } - if (gravity == 255) - gravity = 5; - else if (gravity > 5) - gravity = 0; - PlayerActorHakoniwa* player = rs::getPlayerActor(stageScene); - al::LiveActor* o = player; - if (player->mHackKeeper->currentHackActor) - o = player->mHackKeeper->currentHackActor; - if (gravity == 0) - al::setGravity(o, { 0, -1, 0 }); - else if (gravity == 1) - al::setGravity(o, { 0, 1, 0 }); - else if (gravity == 2) - al::setGravity(o, { 1, 0, 0 }); - else if (gravity == 3) - al::setGravity(o, { -1, 0, 0 }); - else if (gravity == 4) - al::setGravity(o, { 0, 0, 1 }); - else if (gravity == 5) - al::setGravity(o, { 0, 0, -1 }); - ui.addLine(); - ui.printf("%sWiggler Pattern: %s\n", ui.curLine == 9 ? ">" : "", ui.curPattern == PracticeUI::MofumofuPattern::Random ? "Random" : ui.mPatternEntries[ui.curPattern].typeStr); - if (al::isPadTriggerRight(CONTROLLER_AUTO) && ui.curLine == 9) - (*(s8*)&ui.curPattern)++; - if (al::isPadTriggerLeft(CONTROLLER_AUTO) && ui.curLine == 9) - (*(s8*)&ui.curPattern)--; - if (*(s8*)&ui.curPattern > 21 || *(s8*)&ui.curPattern < -1) - ui.curPattern = PracticeUI::MofumofuPattern::Random; -} diff --git a/source/fl/ui/p_modes.cpp b/source/fl/ui/p_modes.cpp deleted file mode 100644 index eb8529b..0000000 --- a/source/fl/ui/p_modes.cpp +++ /dev/null @@ -1,13 +0,0 @@ -#include "fl/common.h" -#include "fl/ui/pages.h" -#include "game/GameData/GameDataFunction.h" - -void fl::ui::modes::update(PracticeUI& ui) -{ - ui.toggle("isModeDiverOrJungleGymRom", ui.isModeDiverOrJungleGymRom); - ui.toggle("isModeDiverRom", ui.isModeDiverRom); - ui.toggle("isModeJungleGymRom", ui.isModeJungleGymRom); - ui.toggle("isModeE3LiveRom", ui.isModeE3LiveRom); - ui.toggle("isModeE3MovieRom", ui.isModeE3MovieRom); - ui.toggle("isModeEpdMovieRom", ui.isModeEpdMovieRom); -} \ No newline at end of file diff --git a/source/fl/ui/p_mooninfo.cpp b/source/fl/ui/p_mooninfo.cpp deleted file mode 100644 index c85bc0e..0000000 --- a/source/fl/ui/p_mooninfo.cpp +++ /dev/null @@ -1,17 +0,0 @@ -#include "fl/ui/pages.h" -#include "game/GameData/GameDataFunction.h" - -void fl::ui::mooninfo::update(PracticeUI& ui) -{ - StageScene* stageScene = ui.getStageScene(); - ui.toggle("Hide Original Moon Counter", ui.hideShineCounter); - -#if (SMOVER == 100) - s32 currShine = GameDataFunction::getCurrentShineNum(*stageScene->mHolder); - s32 totalShine = GameDataFunction::getTotalShineNum(*stageScene->mHolder, -1); - s32 unlockShine = GameDataFunction::findUnlockShineNumByWorldId(0, *stageScene->mHolder, GameDataFunction::getCurrentWorldId(*stageScene->mHolder)); - ui.printf("Current Moons: %d\n", currShine); - ui.printf("Total Moons: %d\n", totalShine); - ui.printf("Required Moons: %d", unlockShine); -#endif -} \ No newline at end of file diff --git a/source/fl/ui/p_options.cpp b/source/fl/ui/p_options.cpp deleted file mode 100644 index 18ae6d9..0000000 --- a/source/fl/ui/p_options.cpp +++ /dev/null @@ -1,12 +0,0 @@ -#include "fl/ui/pages.h" - -void fl::ui::options::update(PracticeUI& ui) -{ - ui.toggle("Teleport", ui.teleportEnabled); - ui.toggle("Moon Refresh", ui.shineRefresh); - ui.toggle("Gray Moon Refresh", ui.gotShineRefresh); - ui.toggle("Always Enable Warps", ui.alwaysWarp); - ui.toggle("Disable Autosaving", ui.disableAutoSave); - ui.toggle("Cloud Kingdom Bowser Skip", ui.skipBowser); - ui.toggle("Disable teleport puppet", ui.disablePuppet); -} \ No newline at end of file diff --git a/source/fl/ui/p_stages.cpp b/source/fl/ui/p_stages.cpp deleted file mode 100644 index be06ab5..0000000 --- a/source/fl/ui/p_stages.cpp +++ /dev/null @@ -1,52 +0,0 @@ -#include "fl/ui/pages.h" -#include - -constexpr const char* stageNames[] = { "CapWorldHomeStage", "WaterfallWorldHomeStage", "SandWorldHomeStage", "LakeWorldHomeStage", "ForestWorldHomeStage", "CloudWorldHomeStage", "ClashWorldHomeStage", "CityWorldHomeStage", - "SnowWorldHomeStage", "SeaWorldHomeStage", "LavaWorldHomeStage", "BossRaidWorldHomeStage", "SkyWorldHomeStage", "MoonWorldHomeStage", "PeachWorldHomeStage", "Special1WorldHomeStage", "Special2WorldHomeStage", "MoonWorldBasementStage", "MoonWorldKoopa1Stage", "MoonWorldKoopa2Stage", "AnimalChaseExStage", "BikeSteelExStage", "BikeSteelNoCapExStage", "BullRunExStage", "ByugoPuzzleExStage", "CapAppearExStage", "CapAppearLavaLiftExStage", "CapRotatePackunExStage", "CapWorldTowerStage", "CityPeopleRoadStage", "CityWorldFactoryStage", "CityWorldMainTowerStage", "CityWorldSandSlotStage", "CityWorldShop01Stage", "ClashWorldShopStage", "CloudExStage", "Cube2DExStage", "DemoBossRaidAttackStage", "DemoChangeWorldBossRaidAttackStage", "DemoChangeWorldFindKoopaShipStage", "DemoChangeWorldStage", "DemoCrashHomeFallStage", "DemoCrashHomeStage", "DemoEndingStage", "DemoHackFirstStage", "DemoHackKoopaStage", "DemoLavaWorldScenario1EndStage", "DemoMeetCapNpcSubStage", "DemoOpeningStage", "DemoStartWorldWaterfallStage", "DemoTakeOffKoopaForMoonStage", "DemoWorldMoveBackwardArriveStage", "DemoWorldMoveBackwardStage", "DemoWorldMoveForwardArriveStage", "DemoWorldMoveForwardFirstStage", "DemoWorldMoveForwardStage", "DemoWorldMoveMoonBackwardStage", "DemoWorldMoveMoonForwardFirstStage", "DemoWorldMoveMoonForwardStage", "DemoWorldWarpHoleStage", "DonsukeExStage", "DotHardExStage", "DotTowerExStage", "ElectricWireExStage", "FastenerExStage", "FogMountainExStage", "ForestWorldBonusStage", "ForestWorldBossStage", "ForestWorldCloudBonusExStage", "ForestWorldTowerStage", "ForestWorldWaterExStage", "ForestWorldWoodsCostumeStage", "ForestWorldWoodsStage", "ForestWorldWoodsTreasureStage", "ForkExStage", "FrogPoisonExStage", "FrogSearchExStage", "FukuwaraiKuriboStage", "FukuwaraiMarioStage", "GabuzouClockExStage", "Galaxy2DExStage", "GotogotonExStage", "HomeShipInsideStage", "IceWalkerExStage", "IceWaterBlockExStage", "IceWaterDashExStage", "ImomuPoisonExStage", "JangoExStage", "JizoSwitchExStage", "KaronWingTowerStage", "KillerRailCollisionExStage", "KillerRoadExStage", "KillerRoadNoCapExStage", "LakeWorldShopStage", "LavaWorldBonus1Zone", "LavaWorldBubbleLaneExStage", "LavaWorldClockExStage", "LavaWorldCostumeStage", "LavaWorldExcavationExStage", "LavaWorldFenceLiftExStage", "LavaWorldShopStage", "LavaWorldTreasureStage", "LavaWorldUpDownExStage", "LavaWorldUpDownYoshiExStage", "Lift2DExStage", "MeganeLiftExStage", "MoonAthleticExStage", "MoonWorldCaptureParadeStage", "MoonWorldShopRoom", "MoonWorldSphinxRoom", "MoonWorldWeddingRoom2Stage", "MoonWorldWeddingRoomStage", "Note2D3DRoomExStage", "PackunPoisonExStage", "PackunPoisonNoCapExStage", "PeachWorldCastleStage", "PeachWorldCostumeStage", "PeachWorldPictureBossForestStage", "PeachWorldPictureBossKnuckleStage", "PeachWorldPictureBossMagmaStage", "PeachWorldPictureBossRaidStage", "PeachWorldPictureGiantWanderBossStage", "PeachWorldPictureMofumofuStage", "PeachWorldShopStage", "PoisonWaveExStage", "PoleGrabCeilExStage", "PoleKillerExStage", "PushBlockExStage", "RadioControlExStage", "RailCollisionExStage", "ReflectBombExStage", "RevengeBossKnuckleStage", "RevengeBossMagmaStage", "RevengeBossRaidStage", "RevengeForestBossStage", "RevengeGiantWanderBossStage", "RevengeMofumofuStage", "RocketFlowerExStage", "RollingExStage", "SandWorldCostumeStage", "SandWorldKillerExStage", "SandWorldMeganeExStage", "SandWorldPressExStage", "SandWorldPyramid000Stage", "SandWorldPyramid001Stage", "SandWorldRotateExStage", "SandWorldSecretStage", "SandWorldShopStage", "SandWorldSlotStage", "SandWorldSphinxExStage", "SandWorldUnderground000Stage", "SandWorldUnderground001Stage", "SandWorldVibrationStage", "SeaWorldCostumeStage", "SeaWorldSecretStage", "SeaWorldSneakingManStage", "SeaWorldUtsuboCaveStage", "SeaWorldVibrationStage", "SenobiTowerExStage", "SenobiTowerYoshiExStage", "ShootingCityExStage", "ShootingCityYoshiExStage", "ShootingElevatorExStage", "SkyWorldCloudBonusExStage", "SkyWorldCostumeStage", "SkyWorldShopStage", "SkyWorldTreasureStage", "SnowWorldCloudBonusExStage", "SnowWorldCostumeStage", "SnowWorldLobby000Stage", "SnowWorldLobby001Stage", "SnowWorldLobbyExStage", "SnowWorldRace000Stage", "SnowWorldRace001Stage", "SnowWorldRaceExStage", "SnowWorldRaceHardExStage", "SnowWorldRaceTutorialStage", "SnowWorldShopStage", "SnowWorldTownStage", "Special1WorldTowerBombTailStage", "Special1WorldTowerCapThrowerStage", "Special1WorldTowerFireBlowerStage", "Special1WorldTowerStackerStage", "Special2WorldCloudStage", "Special2WorldKoopaStage", "Special2WorldLavaStage", "StaffRollMoonRockDemo", "SwingSteelExStage", "Theater2DExStage", "TogezoRotateExStage", "TrampolineWallCatchExStage", "TrexBikeExStage", "TrexPoppunExStage", "TsukkunClimbExStage", "TsukkunRotateExStage", "WanwanClashExStage", "WaterTubeExStage", "WaterValleyExStage", "WindBlowExStage", "WorldStage", "YoshiCloudExStage" }; - -#define NUM_STAGES 201 - -void fl::ui::stages::update(PracticeUI& ui) -{ - static int currentStage = 0; - static int currentScenario = 1; - - ui.cursor(1); - if (ui.inputEnabled && ui.curLine == 1) { - if (al::isPadTriggerRight(CONTROLLER_AUTO) && !ui.nextFrameNoRightInput) - currentStage++; - if (al::isPadTriggerLeft(CONTROLLER_AUTO) && !ui.nextFrameNoLeftInput) { - if (currentStage == 0) - currentStage = NUM_STAGES - 1; - else - currentStage--; - } - } else if (ui.inputEnabled && ui.curLine == 2) { - if (al::isPadTriggerRight(CONTROLLER_AUTO) && !ui.nextFrameNoRightInput) - currentScenario = currentScenario == -1 ? 1 : currentScenario + 1; - if (al::isPadTriggerLeft(CONTROLLER_AUTO) && !ui.nextFrameNoLeftInput) { - if (currentScenario == -1) - currentScenario = 15; - else - currentScenario--; - } - } - if (currentScenario < -1 || currentScenario == 0 || currentScenario > 15) - currentScenario = -1; - if (currentStage + 1 > NUM_STAGES) - currentStage = 0; - ui.printf("Stage: %s\n", stageNames[currentStage]); - ui.addLine(); - ui.cursor(2); - if (currentScenario != -1) { - ui.printf("Scenario: %d\n", currentScenario); - } else - ui.printf("Scenario: Don't change\n"); - - ui.addLine(); - - ui.trigger("Go", [&ui]() { - ChangeStageInfo info = ChangeStageInfo(ui.getStageScene()->mHolder, "start", stageNames[currentStage], false, currentScenario, { 0 }); - ui.getStageScene()->mHolder->changeNextStage(&info, 0); - }); -} \ No newline at end of file diff --git a/source/fl/ui/p_tas.cpp b/source/fl/ui/p_tas.cpp deleted file mode 100644 index 7c0fcac..0000000 --- a/source/fl/ui/p_tas.cpp +++ /dev/null @@ -1,49 +0,0 @@ -#include "fl/common.h" -#include "fl/input.h" -#include "fl/server.h" -#include "fl/tas.h" -#include "fl/ui/pages.h" - -void fl::ui::tas::update(PracticeUI& ui) -{ -#if SMOVER == 130 - ui.printf(MSG_NO130); - return; -#endif - -#if SMOVER == 100 - ui.trigger("Connect to server", []() { - // smo::Server::instance().connect("someip"); - }); - ui.toggle("Old Motion Mod", fl::TasHolder::instance().oldMotion); - - fl::TasHolder& h = fl::TasHolder::instance(); - - if (h.isRunning) { - ui.trigger("Stop Script", [&h]() { - h.stop(); - }); - } else { - ui.trigger("Start Script", [&h]() { - if (h.frames) - h.start(); - }); - } - - ui.printf("\n"); - - if (h.scriptName) - ui.printf(" Script: %s (%lu frames)\n", h.scriptName, h.frameCount); - - if (h.isRunning) - ui.printf(" TAS Running %lu/%lu\n", h.curFrame, h.frameCount); - sead::Vector2f& left = *fgetLeftStick(CONTROLLER_AUTO); - sead::Vector2f& right = *fgetRightStick(CONTROLLER_AUTO); - ui.printf("Left Stick: (X: %.5f Y: %.5f)\n", left.x, left.y); - ui.printf("Right Stick: (X: %.5f Y: %.5f)\n", right.x, right.y); - ui.printf("Buttons:\n"); - // -1 = CONTROLLER_AUTO - ui.printf("%s %s %s %s %s %s %s %s\n", fisPadHoldA(-1) ? "A" : " ", fisPadHoldB(-1) ? "B" : " ", fisPadHoldX(-1) ? "X" : " ", fisPadHoldY(-1) ? "Y" : " ", fisPadHoldL(-1) ? "L" : " ", fisPadHoldR(-1) ? "R" : " ", fisPadHoldZL(-1) ? "ZL" : " ", fisPadHoldZR(-1) ? "ZR" : " "); - ui.printf("%s %s %s %s %s %s %s %s\n", fisPadHoldPlus(-1) ? "+" : " ", fisPadHoldMinus(-1) ? "-" : " ", fisPadHoldPressLeftStick(-1) ? "LS" : " ", fisPadHoldPressRightStick(-1) ? "RS" : " ", fisPadHoldUp(-1) ? "DUP" : " ", fisPadHoldRight(-1) ? "DRIGHT" : " ", fisPadHoldDown(-1) ? "DDOWN" : " ", fisPadHoldLeft(-1) ? "DLEFT" : " "); -#endif -} \ No newline at end of file diff --git a/source/fl/ui/ui.cpp b/source/fl/ui/ui.cpp index bf0c76d..9f39842 100644 --- a/source/fl/ui/ui.cpp +++ b/source/fl/ui/ui.cpp @@ -1,101 +1,405 @@ +#include "al/area/AreaObjDirector.h" +#include "al/area/AreaObj.h" +#include "al/area/AreaShape.h" +#include "al/camera/SnapShotCameraCtrl.h" +#include "al/camera/CameraPoser.h" +#include "al/collision/CollisionParts.h" +#include "al/collision/HitInfo.h" +#include "al/collision/KCPrism.h" +#include "al/collision/KCollisionServer.h" +#include "al/execute/ExecuteTableHolder.h" +#include "al/execute/ExecuteDirector.h" +#include "al/LiveActor/LiveActorGroup.h" +#include "al/LiveActor/LiveActorKit.h" +#include "al/model/ModelKeeper.h" +#include "al/nature/FluidSurfaceHolder.h" +#include "al/nature/NatureDirector.h" +#include "al/pose/ActorPoseKeeper.h" #include "al/util.hpp" -#include "fl/ui/page.h" -#include "fl/ui/pages.h" -#include "fl/util.h" -#include "nn/init.h" +#include "game/Actors/GrowPlantSeed.h" +#include "game/Actors/Fastener.h" +#include "game/Actors/Killer.h" +#include "game/Actors/JugemFishing.h" +#include "game/Actors/KuriboHack.h" +#include "game/Interfaces/IUsePlayerCollision.h" +#include "game/Player/PlayerCarryKeeper.h" +#include "game/Player/PlayerCollider.h" +#include "game/Player/PlayerCapActionHistory.h" +#include "game/Player/PlayerJudge.h" +#include "game/Player/PlayerState.h" +#include "game/Player/PlayerStainControl.h" +#include "game/Player/PlayerWallActionHistory.h" +#include "game/StageScene/StageSceneState.h" +#include "game/WorldEndBorderKeeper.h" +#include +#include "game/Layouts/CommonVerticalList.h" +#include "game/Layouts/ShineListLayout.h" +#include "game/GameData/GameDataFunction.h" +#include "types.h" +#include "al/effect/EffectSystem.h" +#include "al/effect/EffectUserInfo.h" +#include "al/effect/EffectInfo.h" +#include "game/SceneObjs/CapManHeroDemoDirector.h" #include "rs/util.hpp" +#include +#include "fl/common.h" +#include "fl/server.h" +#include "fl/input.h" +#include "fl/tas.h" +#include "fl/ui/ui.h" +#include "fl/util.h" +#include "fl/rtti.hpp" #include -#include -#include +#include +#include +#include -void fl::ui::PracticeUI::savePosition(PlayerActorHakoniwa& player) -{ - savedTrans = *al::getTrans(&player); - savedQuat = *al::getQuat(&player); - saved = true; +const char* stageNames[] = {"CapWorldHomeStage", "WaterfallWorldHomeStage", "SandWorldHomeStage", "LakeWorldHomeStage", "ForestWorldHomeStage", "CloudWorldHomeStage", "ClashWorldHomeStage", "CityWorldHomeStage", + "SnowWorldHomeStage", "SeaWorldHomeStage", "LavaWorldHomeStage", "BossRaidWorldHomeStage", "SkyWorldHomeStage", "MoonWorldHomeStage", "PeachWorldHomeStage", "Special1WorldHomeStage", "Special2WorldHomeStage", "MoonWorldBasementStage", "MoonWorldKoopa1Stage", "MoonWorldKoopa2Stage", "AnimalChaseExStage", "BikeSteelExStage", "BikeSteelNoCapExStage", "BullRunExStage", "ByugoPuzzleExStage", "CapAppearExStage", "CapAppearLavaLiftExStage", "CapRotatePackunExStage", "CapWorldTowerStage", "CityPeopleRoadStage", "CityWorldFactoryStage", "CityWorldMainTowerStage", "CityWorldSandSlotStage", "CityWorldShop01Stage", "ClashWorldShopStage", "CloudExStage", "Cube2DExStage", "DemoBossRaidAttackStage", "DemoChangeWorldBossRaidAttackStage", "DemoChangeWorldFindKoopaShipStage", "DemoChangeWorldStage", "DemoCrashHomeFallStage", "DemoCrashHomeStage", "DemoEndingStage", "DemoHackFirstStage", "DemoHackKoopaStage", "DemoLavaWorldScenario1EndStage", "DemoMeetCapNpcSubStage", "DemoOpeningStage", "DemoStartWorldWaterfallStage", "DemoTakeOffKoopaForMoonStage", "DemoWorldMoveBackwardArriveStage", "DemoWorldMoveBackwardStage", "DemoWorldMoveForwardArriveStage", "DemoWorldMoveForwardFirstStage", "DemoWorldMoveForwardStage", "DemoWorldMoveMoonBackwardStage", "DemoWorldMoveMoonForwardFirstStage", "DemoWorldMoveMoonForwardStage", "DemoWorldWarpHoleStage", "DonsukeExStage", "DotHardExStage", "DotTowerExStage", "ElectricWireExStage", "FastenerExStage", "FogMountainExStage", "ForestWorldBonusStage", "ForestWorldBossStage", "ForestWorldCloudBonusExStage", "ForestWorldTowerStage", "ForestWorldWaterExStage", "ForestWorldWoodsCostumeStage", "ForestWorldWoodsStage", "ForestWorldWoodsTreasureStage", "ForkExStage", "FrogPoisonExStage", "FrogSearchExStage", "FukuwaraiKuriboStage", "FukuwaraiMarioStage", "GabuzouClockExStage", "Galaxy2DExStage", "GotogotonExStage", "HomeShipInsideStage", "IceWalkerExStage", "IceWaterBlockExStage", "IceWaterDashExStage", "ImomuPoisonExStage", "JangoExStage", "JizoSwitchExStage", "KaronWingTowerStage", "KillerRailCollisionExStage", "KillerRoadExStage", "KillerRoadNoCapExStage", "LakeWorldShopStage", "LavaWorldBubbleLaneExStage", "LavaWorldClockExStage", "LavaWorldCostumeStage", "LavaWorldExcavationExStage", "LavaWorldFenceLiftExStage", "LavaWorldShopStage", "LavaWorldTreasureStage", "LavaWorldUpDownExStage", "LavaWorldUpDownYoshiExStage", "Lift2DExStage", "MeganeLiftExStage", "MoonAthleticExStage", "MoonWorldCaptureParadeStage", "MoonWorldShopRoom", "MoonWorldSphinxRoom", "MoonWorldWeddingRoom2Stage", "MoonWorldWeddingRoomStage", "Note2D3DRoomExStage", "PackunPoisonExStage", "PackunPoisonNoCapExStage", "PeachWorldCastleStage", "PeachWorldCostumeStage", "PeachWorldPictureBossForestStage", "PeachWorldPictureBossKnuckleStage", "PeachWorldPictureBossMagmaStage", "PeachWorldPictureBossRaidStage", "PeachWorldPictureGiantWanderBossStage", "PeachWorldPictureMofumofuStage", "PeachWorldShopStage", "PoisonWaveExStage", "PoleGrabCeilExStage", "PoleKillerExStage", "PushBlockExStage", "RadioControlExStage", "RailCollisionExStage", "ReflectBombExStage", "RevengeBossKnuckleStage", "RevengeBossMagmaStage", "RevengeBossRaidStage", "RevengeForestBossStage", "RevengeGiantWanderBossStage", "RevengeMofumofuStage", "RocketFlowerExStage", "RollingExStage", "SandWorldCostumeStage", "SandWorldKillerExStage", "SandWorldMeganeExStage", "SandWorldPressExStage", "SandWorldPyramid000Stage", "SandWorldPyramid001Stage", "SandWorldRotateExStage", "SandWorldSecretStage", "SandWorldShopStage", "SandWorldSlotStage", "SandWorldSphinxExStage", "SandWorldUnderground000Stage", "SandWorldUnderground001Stage", "SandWorldVibrationStage", "SeaWorldCostumeStage", "SeaWorldSecretStage", "SeaWorldSneakingManStage", "SeaWorldUtsuboCaveStage", "SeaWorldVibrationStage", "SenobiTowerExStage", "SenobiTowerYoshiExStage", "ShootingCityExStage", "ShootingCityYoshiExStage", "ShootingElevatorExStage", "SkyWorldCloudBonusExStage", "SkyWorldCostumeStage", "SkyWorldShopStage", "SkyWorldTreasureStage", "SnowWorldCloudBonusExStage", "SnowWorldCostumeStage", "SnowWorldLobby000Stage", "SnowWorldLobby001Stage", "SnowWorldLobbyExStage", "SnowWorldRace000Stage", "SnowWorldRace001Stage", "SnowWorldRaceExStage", "SnowWorldRaceHardExStage", "SnowWorldRaceTutorialStage", "SnowWorldShopStage", "SnowWorldTownStage", "Special1WorldTowerBombTailStage", "Special1WorldTowerCapThrowerStage", "Special1WorldTowerFireBlowerStage", "Special1WorldTowerStackerStage", "Special2WorldCloudStage", "Special2WorldKoopaStage", "Special2WorldLavaStage", "StaffRollMoonRockDemo", "SwingSteelExStage", "Theater2DExStage", "TogezoRotateExStage", "TrampolineWallCatchExStage", "TrexBikeExStage", "TrexPoppunExStage", "TsukkunClimbExStage", "TsukkunRotateExStage", "WanwanClashExStage", "WaterTubeExStage", "WaterValleyExStage", "WindBlowExStage", "WorldStage", "YoshiCloudExStage"}; + +const char* executeTableDrawNames[] = {"3D (culling)", "3D (depth shadow)", "3D (depth shadow player)", "3D (static depth shadow)", "3D (world AO)", "3D (ocean depth)", "3D (sky)", "3D (opaque Z prepass)", "3D (deferred terrain)", "3D (no reflection on the deferred)", "3D (deferred character)", "3D (deferred different space)", "3D (deferred player)", "3D (deferred middle view)", "3D (deferred translucent)", "3D (depth clear player)", "3D (forward distant view)", "3D (forward player)", "3D (forward)", "3D (indirect)", "3D (forward after indirect)", "3D (distant view after indirect)", "3D (indirect after fog)", "3D (distant view after fog)", "3D (after fog)", "3D (chroma key Z prepass)", "3D (chroma key player)", "3D (chroma key character)", "2D back (main screen)", "2D base (main screen)", "2D effect (main screen)", "2D over (main screen)", "2D (demo screen)", "post effect mask", "actor drawing (original render target)", "actor drawing (project specific)", "model drawing buffer update", "3D (world map deferred)", "3D (world map forward)", "2D (world map drawing)", "2D (moon get drawing)", "2D (snapshot)", "2D (for shooting)", "2D (miss)"}; + +constexpr const char *stageNameDescriptions[17][15] = { + {"first visit, spawn airborne", "plot complete", "post-game", "moon rock", "Luigi's Balloon World", "Koopa Freerunning", "trailer", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer"}, + {"first visit", "plot complete", "post-game", "moon rock", "Koopa Freerunning", "Luigi's Balloon World", "post-game, copy", "trailer", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer"}, + {"first visit", "night", "plot complete", "post-game", "moon rock", "Luigi's Balloon World", "Koopa Freerunning", "E3 demo", "trailer", "night, E3 demonstration", "crashes", "crashes", "crashes", "crashes", "crashes"}, + {"first visit", "plot complete", "post-game", "moon rock", "Koopa Freerunning", "Luigi's Balloon World", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer"}, + {"first visit", "night", "plot complete", "post-game", "moon rock", "Luigi's Balloon World", "Koopa Freerunning", "first visit, copy", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer"}, + {"first visit", "plot complete", "post-game", "moon rock", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer"}, + {"first visit", "plot complete", "post-game", "moon rock", "Luigi's Balloon World", "Koopa Freerunning", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer"}, + {"night", "day", "festival", "plot complete", "post-game", "Luigi's Balloon World", "festival, revisit", "moon rock", "Koopa Freerunning", "morning metro", "festival, 8-bit", "morning, missing wire", "day, trailer", "festival, trailer", "night, copy"}, + {"first visit", "plot complete", "post-game", "moon rock", "Luigi's Balloon World", "Koopa Freerunning", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer"}, + {"first visit", "plot complete", "post-game", "moon rock", "Koopa Freerunning", "Luigi's Balloon World", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer"}, + {"first visit", "evening", "plot complete", "Koopa Freerunning", "incomplete", "incomplete", "post-game", "moon rock", "Luigi's Balloon World", "bruncheon", "common layer", "common layer", "common layer", "common layer", "common layer"}, + {"first visit", "plot complete", "post-game", "moon rock", "crashes", "crashes", "crashes", "crashes", "crashes", "crashes", "crashes", "crashes", "crashes", "crashes", "crashes"}, + {"first visit", "plot complete", "post-game", "moon rock", "Luigi's Balloon World", "Koopa Freerunning", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer", "common layere"}, + {"first visit", "post-game", "moon rock", "Luigi's Balloon World", "Koopa Freerunning", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer"}, + {"rushroom", "first visit", "post-game", "Koopa Freerunning", "Luigi's Balloon World", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer"}, + {"first visit", "post-game", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer"}, + {"first visit", "post-game", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer", "common layer"}}; + + + + +//#define printf(FORMAT, ...) p.printf(FORMAT, ##__VA_ARGS__) + + +#define NUM_STAGES 200 +#define WALL_ACTIONS 4 +#define OTHER_PAGES 16 +#define HELD_THRESHOLD 20 + +#define CURSOR(LINE) charCursor = curLine == LINE ? ">" : " " +#define TITLE(NAME) printf(NAME "%s\n", inputEnabled ? "" : " [Menu disabled]") +#define TITLE_FMT(NAME, FMT...) printf(NAME "%s\n", FMT, inputEnabled ? "" : " [Menu disabled]") + +#define CHANGE_PAGE(NAME, PAGE, LINE) CURSOR(LINE);\ + printf("%s" NAME "\n", charCursor);\ + if (inputEnabled && !movingPage && curLine == LINE && !nextFrameNoRightInput && triggerRight) {movingPage = true; curPage = PAGE; cursorHistory[curDepth++] = curLine; curLine = 0;} + +#define BACK_PAGE(PAGE, LINE) CURSOR(LINE);\ + printf("%sBack\n", charCursor);\ + if (inputEnabled && !movingPage && curLine == LINE && ((!nextFrameNoRightInput && triggerRight) || (!nextFrameNoLeftInput && triggerLeft))) {movingPage = true; curPage = PAGE; curLine = cursorHistory[--curDepth];} + +// Sets max amount of lines for a page +#define MAX_LINE(LINE) maxLine = LINE; + +#define TOGGLES(BOOL, LINE) CURSOR(LINE);\ + if (inputEnabled && !movingPage && !nextFrameNoLeftInput && !nextFrameNoRightInput && curLine == LINE && (triggerLeft || triggerRight)) BOOL = !BOOL; + + +#define TOGGLE(NAME, BOOL, LINE) TOGGLES(BOOL, LINE);\ + printf("%s" NAME ": %s\n", charCursor, BOOL ? "Enabled" : "Disabled") + +#define TRIGGER(NAME, LINE, ACTION) CURSOR(LINE);\ + printf("%s" NAME "\n", charCursor);\ + if (inputEnabled && !movingPage && curLine == LINE && !nextFrameNoRightInput && triggerRight) {ACTION;} + +#define TRIGGER_FMT(NAME, LINE, ACTION, FMT...) CURSOR(LINE);\ + printf("%s" NAME "\n", charCursor, FMT);\ + if (inputEnabled && !movingPage && curLine == LINE && !nextFrameNoRightInput && triggerRight) {ACTION;} + +#define INDEX(INCDIR, DECDIR, VAR, MIN, MAX, LINE) CURSOR(LINE); \ + if (inputEnabled && !movingPage && curLine == LINE) { \ + if ((held##INCDIR && heldDirFrames > HELD_THRESHOLD) || trigger##INCDIR) VAR++; \ + if ((held##DECDIR && heldDirFrames > HELD_THRESHOLD) || trigger##DECDIR) VAR--; \ + } \ + if (VAR < MIN) VAR = MAX; \ + if (VAR > MAX) VAR = MIN + +#define INDEXRL(VAR, MIN, MAX, LINE) INDEX(Right, Left, VAR, MIN, MAX, LINE) +#define INDEXUD(VAR, MIN, MAX, LINE) INDEX(Up, Down, VAR, MIN, MAX, LINE) +#define INDEXDU(VAR, MIN, MAX, LINE) INDEX(Down, Up, VAR, MIN, MAX, LINE) + +// set SVAR to SVAL whenever VAR is changed +#define INDEXS(INCDIR, DECDIR, VAR, SVAR, SVAL, MIN, MAX, LINE) CURSOR(LINE); \ + if (inputEnabled && !movingPage && curLine == LINE) { \ + if ((held##INCDIR && heldDirFrames > HELD_THRESHOLD) || trigger##INCDIR) { \ + VAR++; \ + SVAR = SVAL; \ + } \ + if ((held##DECDIR && heldDirFrames > HELD_THRESHOLD) || trigger##DECDIR) { \ + VAR--; \ + SVAR = SVAL; \ + } \ + } \ + if (VAR < MIN-1) VAR = MAX; \ + if (VAR > MAX) VAR = MIN + +#define INDEXSRL(VAR, SVAR, SVAL, MIN, MAX, LINE) INDEXS(Right, Left, VAR, SVAR, SVAL, MIN, MAX, LINE) +#define INDEXZ(INCDIR, DECDIR, VAR, ZVAR, MIN, MAX, LINE) INDEXS(INCDIR, DECDIR, VAR, ZVAR, 0, MIN, MAX, LINE) +#define INDEXZRL(VAR, ZVAR, MIN, MAX, LINE) INDEXZ(Right, Left, VAR, ZVAR, MIN, MAX, LINE) + +#define DEMANGLE(MANGLED) abi::__cxa_demangle(MANGLED, demangleBuffer, &demangledSize, &cxaStatus) + +#define ACTOR_NAME(NAME, ACTOR) RTTI_WRAP(actorWrap, ACTOR); \ + const char* mangledName = actorWrap->GetRtti()->name; \ + char* NAME = DEMANGLE(mangledName) + +#define PRINT_NERVE(ACTOR) al::NerveKeeper* nerveKeeper = ACTOR->getNerveKeeper(); \ + if (nerveKeeper) { \ + int nerveStep = nerveKeeper->mStep; \ + al::Nerve* nerve = (al::Nerve*)nerveKeeper->getCurrentNerve(); \ + if (nerve) { \ + RTTI_WRAP(nerveWrap, nerve); \ + char mangledNerveName[64] = "_Z"; \ + strcat(mangledNerveName, nerveWrap->GetRtti()->name); \ + char* nerveName = DEMANGLE(mangledNerveName); \ + printf(" Nerve Name: %s\n", nerveName); \ + printf(" Nerve Step: %d\n", nerveStep); \ + } else { \ + printf(" Nerve Name: N/A\n"); \ + } \ + } else { \ + printf(" Nerve Name: N/A\n"); \ + printf(" Nerve Step: N/A\n"); \ + } + +const char* formatFLOAT[10] = { + " %s: %.0f\n", + " %s: %.1f\n", + " %s: %.2f\n", + " %s: %.3f\n", + " %s: %.4f\n", + " %s: %.5f\n", + " %s: %.6f\n", + " %s: %.7f\n", + " %s: %.8f\n", + " %s: %.9f\n" +}; +const char* format2FLOAT[10] = { + " %s: (%s: %.0f %s: %.0f)\n", + " %s: (%s: %.1f %s: %.1f)\n", + " %s: (%s: %.2f %s: %.2f)\n", + " %s: (%s: %.3f %s: %.3f)\n", + " %s: (%s: %.4f %s: %.4f)\n", + " %s: (%s: %.5f %s: %.5f)\n", + " %s: (%s: %.6f %s: %.6f)\n", + " %s: (%s: %.7f %s: %.7f)\n", + " %s: (%s: %.8f %s: %.8f)\n", + " %s: (%s: %.9f %s: %.9f)\n", +}; +const char* format3FLOAT[10] = { + " %s: (%s: %.0f %s: %.0f %s: %.0f)\n", + " %s: (%s: %.1f %s: %.1f %s: %.1f)\n", + " %s: (%s: %.2f %s: %.2f %s: %.2f)\n", + " %s: (%s: %.3f %s: %.3f %s: %.3f)\n", + " %s: (%s: %.4f %s: %.4f %s: %.4f)\n", + " %s: (%s: %.5f %s: %.5f %s: %.5f)\n", + " %s: (%s: %.6f %s: %.6f %s: %.6f)\n", + " %s: (%s: %.7f %s: %.7f %s: %.7f)\n", + " %s: (%s: %.8f %s: %.8f %s: %.8f)\n", + " %s: (%s: %.9f %s: %.9f %s: %.9f)\n", +}; +const char* format4FLOAT[10] = { + " %s: (%s: %.0f %s: %.0f %s: %.0f %s: %.0f)\n", + " %s: (%s: %.1f %s: %.1f %s: %.1f %s: %.1f)\n", + " %s: (%s: %.2f %s: %.2f %s: %.2f %s: %.2f)\n", + " %s: (%s: %.3f %s: %.3f %s: %.3f %s: %.3f)\n", + " %s: (%s: %.4f %s: %.4f %s: %.4f %s: %.4f)\n", + " %s: (%s: %.5f %s: %.5f %s: %.5f %s: %.5f)\n", + " %s: (%s: %.6f %s: %.6f %s: %.6f %s: %.6f)\n", + " %s: (%s: %.7f %s: %.7f %s: %.7f %s: %.7f)\n", + " %s: (%s: %.8f %s: %.8f %s: %.8f %s: %.8f)\n", + " %s: (%s: %.9f %s: %.9f %s: %.9f %s: %.9f)\n", +}; + +#define PRINT_FLOAT(NAME, VAL) printf(formatFLOAT[numDigits], NAME, VAL) +#define PRINT_2FLOAT(NAME, L1, V1, L2, V2) printf(format2FLOAT[numDigits], NAME, L1, V1, L2, V2) +#define PRINT_3FLOAT(NAME, L1, V1, L2, V2, L3, V3) printf(format3FLOAT[numDigits], NAME, L1, V1, L2, V2, L3, V3) +#define PRINT_4FLOAT(NAME, L1, V1, L2, V2, L3, V3, L4, V4) printf(format4FLOAT[numDigits], NAME, L1, V1, L2, V2, L3, V3, L4, V4) + +#define PRINT_VEC2(NAME, VECTOR) PRINT_2FLOAT(NAME, "X", VECTOR.x, "Y", VECTOR.y) +#define PRINT_VEC2PTR(NAME, VECTOR) PRINT_2FLOAT(NAME, "X", VECTOR->x, "Y", VECTOR->y) +#define PRINT_VEC3(NAME, VECTOR) PRINT_3FLOAT(NAME, "X", VECTOR.x, "Y", VECTOR.y, "Z", VECTOR.z) +#define PRINT_VEC3PTR(NAME, VECTOR) PRINT_3FLOAT(NAME, "X", VECTOR->x, "Y", VECTOR->y, "Z", VECTOR->z) +#define PRINT_QUAT(NAME, QUAT) PRINT_4FLOAT(NAME, "W", QUAT.w, "X", QUAT.x, "Y", QUAT.y, "Z", QUAT.z) +#define PRINT_QUATPTR(NAME, QUAT) PRINT_4FLOAT(NAME, "W", QUAT->w, "X", QUAT->x, "Y", QUAT->y, "Z", QUAT->z) +#define PRINT_SPEED(NAME, HORIZONTAL, VERTICAL, SPEED) PRINT_3FLOAT(NAME, "H", HORIZONTAL, "V", VERTICAL, "S", SPEED) + + +void fl::ui::PracticeUI::savePosition(PlayerActorHakoniwa& player, s8 idx) { + savestates[idx].mTrans = *al::getTrans(&player); + savestates[idx].mQuat = *al::getQuat(&player); + savestates[idx].mSaved = true; } -void fl::ui::PracticeUI::loadPosition(PlayerActorHakoniwa& player) -{ +void fl::ui::PracticeUI::loadPositionPlayer(PlayerActorHakoniwa& player, s8 idx) { al::LiveActor* move = &player; - al::LiveActor* hack = player.mHackKeeper->currentHackActor; - - if (hack) - move = hack; + al::LiveActor* hack = player.mHackKeeper->mCurrentHackActor; - if (disablePuppet && !hack) - al::offCollide(&player); - else if (!hack) - player.startDemoPuppetable(); - else + if (hack) { al::offCollide(hack); + al::setTrans(hack, savestates[idx].mTrans); + al::setVelocityZero(hack); + al::onCollide(hack); + } else { + if(options.disablePuppet) + al::offCollide(move); + else + player.startDemoPuppetable(); +#if SMOVER == 100 + player.mStainControl->clearStain(); // TODO on 1.3 +#endif + al::setTrans(move, savestates[idx].mTrans); + al::updatePoseQuat(move, savestates[idx].mQuat); + al::setVelocityZero(move); + if(options.disablePuppet) + al::onCollide(move); + else + player.endDemoPuppetable(); + } +} + +void fl::ui::PracticeUI::loadPosition(al::LiveActor* actor, s8 idx) { + al::offCollide(actor); + al::setTrans(actor, savestates[idx].mTrans); + al::updatePoseQuat(actor, savestates[idx].mQuat); + al::setVelocityZero(actor); + al::onCollide(actor); +} + +void fl::ui::PracticeUI::toggleNoclip(PlayerActorHakoniwa& player) { + al::LiveActor* move = &player; + al::LiveActor* hack = player.mHackKeeper->mCurrentHackActor; - al::setTrans(move, savedTrans); - if (!hack) - al::updatePoseQuat(move, savedQuat); - al::setVelocityZero(move); + if (hack) move = hack; - if (disablePuppet && !hack) - al::onCollide(&player); - else if (!hack) - player.endDemoPuppetable(); + if (!noclipping) + { + al::offCollide(move); + noclipping = true; + } else - al::onCollide(hack); + { + al::onCollide(move); + noclipping = false; + } } -void fl::ui::PracticeUI::update(StageScene* stageScene) -{ +void fl::ui::PracticeUI::kill() { + renderer.curArea = nullptr; + renderer.curAreaGroup = nullptr; + renderer.nearestEdgePoint = sead::Vector3f::zero; + + currentActor = nullptr; + actorIndex = 0; + areaGroupIndex = 0; + areaIndex = 0; +} + +void fl::ui::PracticeUI::update(StageScene* stageScene) { Game::instance().setStageScene(stageScene); - this->mStageScene = stageScene; + this->stageScene = stageScene; isInGame = true; PlayerActorHakoniwa* player = rs::getPlayerActor(stageScene); - bool holdL = al::isPadHoldL(CONTROLLER_AUTO); - -#if SMOVER == 100 + bool holdL = isL(); + fl::TasHolder::instance().update(); -#endif - if (holdL && al::isPadTriggerRight(CONTROLLER_AUTO)) { + bool triggerLeft = isTriggerLeft(); + bool triggerRight = isTriggerRight(); + + if (holdL && triggerRight) { inputEnabled = !inputEnabled; nextFrameNoRightInput = true; return; - } else if -#if SMOVER == 130 - (holdL && al::isPadTriggerLeft(CONTROLLER_AUTO)) -#endif -#if SMOVER == 100 - (al::isPadTriggerPressLeftStick(CONTROLLER_AUTO)) -#endif - { + } else if (holdL && isTriggerLeft()) { showMenu = !showMenu; -#if SMOVER == 130 nextFrameNoLeftInput = true; -#endif + } + + + if (hideShineCounter) + al::hidePane(stageScene->mStageSceneLayout->shineCounter, "TxtShine"); + else + al::showPane(stageScene->mStageSceneLayout->shineCounter, "TxtShine"); + + + if (!player) return; + + if (!showMenu || (!inputEnabled && !holdL)) + { + if (options.teleportEnabled) + { + // If holdL is true and the left D-pad is pressed, that means showMenu is only false + // because we just hid the menu. And hiding the menu shouldn't save Mario's position. + if (isTriggerLeft() && !holdL) + savePosition(*player, savestateIndex); + + if (triggerRight && savestates[savestateIndex].mSaved) + loadPositionPlayer(*player, savestateIndex); } - if (!showMenu || (!inputEnabled && !holdL)) { - if (teleportEnabled) { - if (al::isPadTriggerLeft(CONTROLLER_AUTO)) - savePosition(*player); + if (options.noclipEnabled) + { + if (isTriggerUp()) + toggleNoclip(*player); + } + +#if SMOVER == 100 + if (options.reloadDUP && isTriggerUp()) { + StageScene* stageScene = getStageScene(); + const char* entry = stageScene->mDataHolder->mPlayingFile->sVar1.cstr(); + ChangeStageInfo info = ChangeStageInfo(stageScene->mDataHolder, entry, stageScene->mDataHolder->getCurrentStageName(), false, -1, {0}); + stageScene->mDataHolder->changeNextStage(&info, 0); + } +#endif + } - if (al::isPadTriggerRight(CONTROLLER_AUTO) && saved) - loadPosition(*player); + if (reloadStageForPos != -1) + { + reloadStageForPos++; + if (reloadStageForPos == 11) + { + player->startDemoPuppetable(); + al::setTrans(player, reloadStageTrans); + al::updatePoseQuat(player, reloadStageQuat); + player->endDemoPuppetable(); + reloadStageForPos = -1; } } - if (hideShineCounter) - al::hidePane(stageScene->stageSceneLayout->shineCounter, "TxtShine"); - else - al::showPane(stageScene->stageSceneLayout->shineCounter, "TxtShine"); + if (options.moonJump) { + al::LiveActor* move = player; + al::LiveActor* hack = player->mHackKeeper->mCurrentHackActor; + + if (hack) move = hack; + + sead::Vector3f* moveVel = al::getVelocity(move); + if (isHoldA() || isHoldB()) { + al::setVelocity(move, { moveVel->x, moonJumpVel, moveVel->z }); + } + } #if SMOVER == 130 if (showMenu) menu(); else - al::setPaneStringFormat(stageScene->stageSceneLayout->coinCounter, "TxtDebug", " "); + al::setPaneStringFormat(stageScene->mStageSceneLayout->coinCounter, "TxtDebug", " "); #endif } @@ -106,51 +410,1775 @@ void fl::ui::PracticeUI::menu(sead::TextWriter& p) void fl::ui::PracticeUI::menu() #endif { - s32 sprintfRv = 0; printPos = 0; - if (!mStageScene) - return; if (showMenu) { - if (inputEnabled) { - if (al::isPadTriggerDown(CONTROLLER_AUTO) && curLine + 1 < curMaxLine) - curLine++; - if (al::isPadTriggerUp(CONTROLLER_AUTO) && curLine >= 1) - curLine--; - } + const char* charCursor = " "; + + PlayerActorHakoniwa* player = rs::getPlayerActor(stageScene); + bool isExistPlayer = player != nullptr; + + HackCap* cappy = player ? player->mHackCap : nullptr; + + bool triggerUp = isTriggerUp(); + bool triggerDown = isTriggerDown(); + bool triggerLeft = isTriggerLeft(); + bool triggerRight = isTriggerRight(); + bool heldUp = isHoldUp(); + bool heldDown = isHoldDown(); + bool heldLeft = isHoldLeft(); + bool heldRight = isHoldRight(); + + switch (curPage) { + case Menu: { + MAX_LINE(10); + TITLE("Welcome to the Practice Mod!"); + CHANGE_PAGE("About", About, 0) + CHANGE_PAGE("Options", Options, 1); + CHANGE_PAGE("Stages", Stage, 2); + CHANGE_PAGE("Miscellaneous", Misc, 3); + CHANGE_PAGE("Info", Info, 4); + CHANGE_PAGE("TAS", Tas, 5); + CHANGE_PAGE("Modes", Modes, 6); + CHANGE_PAGE("Debug", Debug, 7); + CHANGE_PAGE("Testing", Test, 8); + CHANGE_PAGE("Loading Zones", TestLoadingZones, 9); + break; + } + case About: { + TITLE("About"); + MAX_LINE(1); + BACK_PAGE(Menu, 0); +#if SMOVER == 100 + printf(" Welcome to the Practice Mod!\n\n"); +#endif + printf(" Press L + left D-pad to hide/unhide the menu.\n"); + printf(" Press L + right D-pad to disable/enable the menu.\n\n"); + printf(" Originally created by furitty\n"); + printf(" TAS-Tools implemented by Mars2030\n"); + printf(" Major rewrite by tetraxile\n"); + printf(" 1.3-improvements by Ontwikseltsaar\n"); + printf(" Further updates by MonsterDruide1\n"); + printf(" Big thanks to CraftyBoss and bryce_____!\n"); + printf(" Special thanks to the TAS community!\n"); + break; + } + case Options: { + TITLE("Options"); + BACK_PAGE(Menu, 0); +#if SMOVER == 100 + MAX_LINE(14); +#elif SMOVER == 130 + MAX_LINE(4); +#endif + + CHANGE_PAGE("Movement", OptionsMvmt, 1); + CHANGE_PAGE("Saving", OptionsSave, 2); +#if SMOVER == 100 + CHANGE_PAGE("Renderer", OptionsRenderer, 3); + TOGGLE("Disable Losing Health", options.noDamageLife, 4); + TOGGLE("Always Enable Warps", options.alwaysWarp, 5); + TOGGLE("Cloud Kingdom Bowser Skip", options.skipBowser, 6); + TOGGLE("Disable Moon Requirement", options.disableShineNumUnlock, 7); + TOGGLE("Enable Moe-Eye Vision", options.showOddSpace, 8); + TOGGLE("Override Bowser Hat Randomizer", options.overrideBowserHat0, 9); + + CURSOR(10); + printf("%sWiggler Pattern: %s\n", charCursor, curPattern == PracticeUI::MofumofuPattern::Random ? "Random" : mPatternEntries[curPattern].typeStr); + if (curLine == 10 && inputEnabled && !movingPage && !nextFrameNoLeftInput && triggerLeft) { + if ((*(s8 *)&curPattern) == (s8)PracticeUI::MofumofuPattern::Random) + (*(s8 *)&curPattern) = (s8)PracticeUI::MofumofuPattern::Star; + else + (*(s8 *)&curPattern)--; + } + else if (curLine == 10 && inputEnabled && !movingPage && !nextFrameNoRightInput && triggerRight) { + if ((*(s8 *)&curPattern) == (s8)PracticeUI::MofumofuPattern::Star) + (*(s8 *)&curPattern) = (s8)PracticeUI::MofumofuPattern::Random; + else + (*(s8 *)&curPattern)++; + } + TOGGLE("Disable music", options.muteBgm, 11); +#endif +#if SMOVER == 100 + CURSOR(12); + if (inputEnabled && !movingPage && curLine == 12) +#elif SMOVER == 130 + CURSOR(3); + if (inputEnabled && !movingPage && curLine == 3) +#endif + { + if (!nextFrameNoLeftInput && triggerLeft) numDigits--; + if (!nextFrameNoLeftInput && heldLeft && heldDirFrames > HELD_THRESHOLD) numDigits--; + if (!nextFrameNoRightInput && triggerRight) numDigits++; + if (!nextFrameNoRightInput && heldRight && heldDirFrames > HELD_THRESHOLD) numDigits++; + + if(numDigits < 0) numDigits = 0; + if(numDigits > 9) numDigits = 9; + } + printf("%sDigits for Info: %d\n", charCursor, numDigits); + + #if SMOVER == 100 + CHANGE_PAGE("PipeMaze Randomness", OptionsPipeMaze, 13); + #endif + + break; + } + case OptionsMvmt: { + TITLE("Options: Movement"); + BACK_PAGE(Options, 0); +#if SMOVER == 100 + MAX_LINE(8); +#elif SMOVER == 130 + MAX_LINE(3); +#endif + + CHANGE_PAGE("Teleport", OptionsTeleport, 1); + CHANGE_PAGE("Moon Jump", OptionsMoon, 2); +#if SMOVER == 100 + TOGGLE("Noclip", options.noclipEnabled, 3); + TOGGLE("X/Y Motion Rolls", options.buttonMotionRoll, 4); + TOGGLE("Infinite Cap Bounces", options.repeatCapBounce, 5); + TOGGLE("Infinite Rainbow Spins", options.repeatRainbowSpin, 6); + TOGGLE("Cap Bounce After Wall Jump", options.wallJumpCapBounce, 7); +#endif - if (inputEnabled && curLine == 0) { - if (al::isPadTriggerRight(CONTROLLER_AUTO) && !nextFrameNoRightInput) - (*(u8*)&curPage)++; - if (al::isPadTriggerLeft(CONTROLLER_AUTO) && !nextFrameNoLeftInput) - (*(u8*)&curPage)--; - if ((*(u8*)&curPage) > (u8)Page::Debug) - (*(u8*)&curPage) = (u8)Page::About; + break; + } + case OptionsTeleport: { + TITLE("Options: Teleport"); + MAX_LINE(6); + BACK_PAGE(OptionsMvmt, 0); + + TOGGLE("Teleport", options.teleportEnabled, 1); + + CURSOR(2); + if (inputEnabled && !movingPage && curLine == 2) { + if (!nextFrameNoLeftInput && triggerLeft) savestateIndex--; + else if (!nextFrameNoRightInput && triggerRight) savestateIndex++; + } + if (savestateIndex < 0) savestateIndex = NUMSAVES - 1; + if (savestateIndex >= NUMSAVES) savestateIndex = 0; + + printf("%sTeleport Index: %d/%d%s\n", charCursor, savestateIndex + 1, NUMSAVES, savestates[savestateIndex].mSaved ? "" : " (unsaved)"); + TRIGGER("Save Position", 3, { if (isExistPlayer) savePosition(*player, savestateIndex); }); + TRIGGER("Load Position", 4, { if (isExistPlayer) loadPositionPlayer(*player, savestateIndex); }); + + TOGGLE("Disable Teleport Puppet", options.disablePuppet, 5); + + sead::Vector3f curPos = savestates[savestateIndex].mTrans; + sead::Quatf curQuat = savestates[savestateIndex].mQuat; + PRINT_VEC3("Position", curPos); + PRINT_QUAT("Rotation", curQuat); + + break; + } + case OptionsMoon: { + TITLE("Options: Moon Jump"); + MAX_LINE(3); + BACK_PAGE(OptionsMvmt, 0); + + TOGGLE("Moon Jump", options.moonJump, 1); + CURSOR(2); + if (inputEnabled && !movingPage && curLine == 2) { + if (!nextFrameNoLeftInput && triggerLeft) moonJumpVel -= 1.0f; + if (!nextFrameNoLeftInput && heldLeft && heldDirFrames > HELD_THRESHOLD) moonJumpVel -= 1.0f; + if (!nextFrameNoRightInput && triggerRight) moonJumpVel += 1.0f; + if (!nextFrameNoRightInput && heldRight && heldDirFrames > HELD_THRESHOLD) moonJumpVel += 1.0f; + } + printf("%sVelocity: %.1f\n", charCursor, moonJumpVel); + + + break; + } + case OptionsSave: { + TITLE("Options: Saving"); +#if SMOVER == 100 + MAX_LINE(6); +#elif SMOVER == 130 + MAX_LINE(3); +#endif + BACK_PAGE(Options, 0); + + TOGGLE("Disable Saving Moons", options.shineRefresh, 1); + TOGGLE("Reactivate Moons", options.gotShineRefresh, 2); +#if SMOVER == 100 + TOGGLE("Disable Autosaving", options.disableAutoSave, 3); + TOGGLE("Allow Loading Current File", options.loadCurrentFile, 4); + TOGGLE("Disable Load File Confirmation", options.loadFileConfirm, 5); +#endif + + break; + } + case OptionsRenderer: { + TITLE("Options: Renderer"); + MAX_LINE(12); + BACK_PAGE(Options, 0); + + TOGGLE("Enable Game rendering", options.shouldRender, 1); + TOGGLE("Show Mario's position", renderer.showPlayer, 2); + TOGGLE("Show origin", renderer.showAxis, 3); + TOGGLE("Show current AreaObj", renderer.showArea, 4); + TOGGLE("Show closest area point", renderer.showAreaPoint, 5); + TOGGLE("Show current AreaObjGroup", renderer.showAreaGroup, 6); + TOGGLE("Show floor HitInfo", renderer.showHitInfoFloor, 7); + TOGGLE("Show wall HitInfo", renderer.showHitInfoWall, 8); + TOGGLE("Show ceiling HitInfo", renderer.showHitInfoCeil, 9); + TOGGLE("Show HitInfo array", renderer.showHitInfoArray, 10); + TOGGLE("Show CRC position", renderer.showCRC, 11); + + break; + } + case OptionsPipeMaze: { + TITLE("Options: PipeMaze Randomness"); + MAX_LINE(5); + BACK_PAGE(Options, 0); + + TOGGLE("Enable Override", options.pipeMazeOverride, 1); + + INDEX(Right, Left, options.pipeMazeConfig[0], 0, 1, 2); + printf("%s2 Pipes: %d\n", charCursor, options.pipeMazeConfig[0]); + + INDEX(Right, Left, options.pipeMazeConfig[1], 0, 2, 3); + printf("%s3 Pipes: %d\n", charCursor, options.pipeMazeConfig[1]); + + INDEX(Right, Left, options.pipeMazeConfig[2], 0, 4, 4); + printf("%s5 Pipes: %d\n", charCursor, options.pipeMazeConfig[2]); + + break; + } + case Stage: { + static s32 currentStage = 0; + static s8 currentScenario = 0; + + TITLE("Stages"); + MAX_LINE(4); + BACK_PAGE(Menu, 0); + + INDEXRL(currentStage, 0, NUM_STAGES - 1, 1); + printf("%sStage: %s\n", charCursor, stageNames[currentStage]); + + INDEXRL(currentScenario, 0, 15, 2); + if (currentScenario == 0) + printf("%sScenario: Don't change\n", charCursor); + else if (currentStage < 17) { + const char* description = stageNameDescriptions[currentStage][currentScenario-1]; + printf("%sScenario: %d (%s)\n", charCursor, currentScenario, description); + } + else + printf("%sScenario: %d\n", charCursor, currentScenario); + + TRIGGER("Go", 3, { + ChangeStageInfo info = ChangeStageInfo(stageScene->mDataHolder, "start", stageNames[currentStage], false, currentScenario==0 ? -1 : currentScenario, {0}); + stageScene->mDataHolder->changeNextStage(&info, 0); + curLine = 0; + }); + + break; + } + case Misc: { + TITLE("Miscellaneous"); + MAX_LINE(14); + BACK_PAGE(Menu, 0); + + if (!isInGame) { + printf(" Not in game!\n"); + return; + } + + TRIGGER("Kill Mario", 1, Game::instance().killMario()); + TRIGGER("Damage Mario", 2, { + if (isExistPlayer) { + bool tmpDamage = options.noDamageLife; + options.noDamageLife = false; + Game::instance().damageMario(1); + options.noDamageLife = tmpDamage; + } + }); + TRIGGER("Life Up Heart", 3, Game::instance().lifeUpHeart()); + TRIGGER("Heal Mario", 4, Game::instance().healMario()); + TRIGGER("Remove Cappy", 5, Game::instance().removeCappy()); + TRIGGER("Invincibility Star", 6, Game::instance().invincibilityStar()); + TRIGGER("Add 1000 coins", 7, stageScene->mDataHolder->mPlayingFile->addCoin(1000)); + TRIGGER("Add -1000 coins", 8, stageScene->mDataHolder->mPlayingFile->addCoin(-1000)); + + static u8 gravity = 0; + + CURSOR(9); + + const char* gravityString = nullptr; + + if (gravity == 0) gravityString = "Down"; + else if (gravity == 1) gravityString = "Up"; + else if (gravity == 2) gravityString = "North"; + else if (gravity == 3) gravityString = "South"; + else if (gravity == 4) gravityString = "East"; + else if (gravity == 5) gravityString = "West"; + + bool gravityChangedFrame = false; + + printf("%sGravity: %s\n", charCursor, gravityString); + if (curLine == 9 && inputEnabled && !movingPage && !nextFrameNoLeftInput && triggerLeft) {gravity--; gravityChangedFrame = true;} + else if (curLine == 9 && inputEnabled && !movingPage && !nextFrameNoRightInput && triggerRight) {gravity++; gravityChangedFrame = true;} + if (gravity == 255) gravity = 5; + else if (gravity > 5) gravity = 0; + + if (gravityChangedFrame && isExistPlayer) + { + if (gravity == 0) { + al::setGravity(player, {0, -1, 0}); + } + else { + if (gravity == 1) al::setGravity(player, {0, 1, 0}); + else if (gravity == 2) al::setGravity(player, {1, 0, 0}); + else if (gravity == 3) al::setGravity(player, {-1, 0, 0}); + else if (gravity == 4) al::setGravity(player, {0, 0, 1}); + else if (gravity == 5) al::setGravity(player, {0, 0, -1}); + } + } + +#if SMOVER == 130 + MAX_LINE(10); +#endif +#if SMOVER == 100 + TRIGGER("Reload Stage", 10, { + reloadStageForPos = 0; + if (isExistPlayer) { + reloadStageTrans = *al::getTrans(player); + reloadStageQuat = *al::getQuat(player); + } + ChangeStageInfo info = ChangeStageInfo(stageScene->mDataHolder, "start", stageScene->mDataHolder->getCurrentStageName(), false, CURRENT_SCENARIO, {0}); + stageScene->mDataHolder->changeNextStage(&info, 0); + }); + TRIGGER("Reload Scene", 11, { + const char* entry = stageScene->mDataHolder->mPlayingFile->sVar1.cstr(); + ChangeStageInfo info = ChangeStageInfo(stageScene->mDataHolder, entry, stageScene->mDataHolder->getCurrentStageName(), false, -1, {0}); + stageScene->mDataHolder->changeNextStage(&info, 0); + }); + TRIGGER("Previous scene", 12, stageScene->mDataHolder->returnPrevStage()); + + TOGGLE("Reload Scene (D-UP)", options.reloadDUP, 13); +#endif + + break; + } + case Info: { + TITLE("Info"); + BACK_PAGE(Menu, 0); + CHANGE_PAGE("Player Info", InfoPlayer, 1); + CHANGE_PAGE("Moon Info", InfoMoon, 2); + CHANGE_PAGE("Capture Info", InfoHack, 3); + CHANGE_PAGE("Cappy Info", InfoCappy, 4); + CHANGE_PAGE("Statistics Info", InfoStatistics, 5); + CHANGE_PAGE("Camera Info", InfoCamera, 6); + CHANGE_PAGE("Mighty Info 1", InfoMighty1, 7); + CHANGE_PAGE("Mighty Info 2", InfoMighty2, 8); + + MAX_LINE(9); + break; + } + case InfoPlayer: { + TITLE("Player Info"); + BACK_PAGE(Info, 0); + MAX_LINE(2); + + TOGGLE("Quaternion Rotation", quatRot, 1); + + if (!isInGame) { + printf(" Not in game!\n"); + + fl::TasHolder& h = fl::TasHolder::instance(); + if (h.isRunning) + printf(" TAS Running %lu/%lu\n", h.curFrame, h.frameCount); + return; + } + + sead::Vector3f* playerTrans = al::getTrans(player); + sead::Vector3f* playerVel = al::getVelocity(player); + sead::Quatf* playerQuat = al::getQuat(player); + sead::Vector3f playerEulerAngles = fl::QuatToEuler(playerQuat); + sead::Vector3f playerRot = sead::Vector3f(DEG(playerEulerAngles.x),DEG(playerEulerAngles.y),DEG(playerEulerAngles.z)); + sead::Vector3f* playerRecoveryPoint = player->mRecoverPoint->getSafetyPoint(); + const char* anim = player->mAnimator->mCurrentAnim; + float hSpeed = al::calcSpeedH(player), vSpeed = al::calcSpeedV(player), speed = al::calcSpeed(player); + float hSpeedAngle = atan2f(playerVel->z, playerVel->x); + if (hSpeedAngle < 0) + hSpeedAngle += M_PI * 2; + + static sead::Vector3f prevPlayerVel = { 0.0f, 0.0f, 0.0f }; + sead::Vector3f playerVelDelta = *playerVel - prevPlayerVel; + + PRINT_VEC3PTR("Player Pos", playerTrans); + PRINT_VEC3PTR("Player Vel", playerVel); + PRINT_VEC3("Player Vel Delta", playerVelDelta); + PRINT_FLOAT("Player Vel Angle", DEG(hSpeedAngle)); + prevPlayerVel = *playerVel; + PRINT_SPEED("Player Speed", hSpeed, vSpeed, speed); + if (quatRot) + PRINT_QUATPTR("Player Rot", playerQuat); + else + PRINT_VEC3("Player Rot", playerRot); + PRINT_VEC3PTR("Bubble Pos", playerRecoveryPoint); + printf(" Current Animation: %s (%.0f/%.0f)\n", anim, player->mAnimator->getAnimFrame() - 1.0f, player->mAnimator->getAnimFrameMax()); + +#if SMOVER == 100 + PRINT_NERVE(player); +#endif + + fl::TasHolder& h = fl::TasHolder::instance(); + if (h.isRunning) + printf(" TAS Running %lu/%lu\n", h.curFrame, h.frameCount); + break; + } + case InfoMoon: { + TITLE("Moon Info"); + MAX_LINE(2); + BACK_PAGE(Info, 0); + + TOGGLE("Hide Original Moon Counter", hideShineCounter, 1); + + if(!isInGame) { + printf(" Not in game!"); + break; + } + +#if SMOVER == 100 + s32 currShine = GameDataFunction::getCurrentShineNum(*stageScene->mDataHolder); + s32 totalShine = GameDataFunction::getTotalShineNum(*stageScene->mDataHolder, -1); + s32 unlockShine = GameDataFunction::findUnlockShineNumByWorldId(0, *stageScene->mDataHolder, GameDataFunction::getCurrentWorldId(*stageScene->mDataHolder)); +#endif +#if SMOVER == 130 + s32 currShine = GameDataFunction::getCurrentShineNum(stageScene->mDataHolder); + s32 totalShine = GameDataFunction::getTotalShineNum(stageScene->mDataHolder, -1); + s32 unlockShine = GameDataFunction::findUnlockShineNumByWorldId(0, stageScene->mDataHolder, GameDataFunction::getCurrentWorldId(stageScene->mDataHolder)); +#endif + + printf(" Current Moons: %d\n", currShine); + printf(" Total Moons: %d\n", totalShine); + printf(" Required Moons: %d", unlockShine); + break; + } + case InfoHack: { + TITLE("Capture Info"); + BACK_PAGE(Info, 0); + + if (!isExistPlayer) { + MAX_LINE(1); + printf(" No player actor!\n"); + break; + } + +#if SMOVER == 130 + MAX_LINE(1); + printf(MSG_NO130); + break; +#endif + + TOGGLE("Lock Current Capture", options.lockHack, 1); + + if (!options.lockHack) + currentHack = player->mHackKeeper->mCurrentHackActor; + + TRIGGER("Load position", 2, loadPosition(currentHack, savestateIndex)); + + if (currentHack) { + ACTOR_NAME(currentHackName, currentHack); + printf(" Capture Name: %s\n", currentHackName); + + sead::Vector3f* hackTrans = al::getTrans(currentHack); + sead::Vector3f* hackVel = al::getVelocity(currentHack); + float hSpeed = al::calcSpeedH(currentHack), vSpeed = al::calcSpeedV(currentHack), speed = al::calcSpeed(currentHack); + + PRINT_VEC3PTR("Capture Pos", hackTrans); + PRINT_VEC3PTR("Capture Vel", hackVel); + PRINT_SPEED("Capture Speed", hSpeed, vSpeed, speed); + printf(" Current Action: %s\n", al::getActionName(currentHack)); + + if (al::isEqualString(currentHackName, "Killer")) { + MAX_LINE(3); + static float prevAliveCount = 0.0f; + Killer* currentHackKiller = static_cast(currentHack); + printf(" Alive Counter: %f\n", currentHackKiller->mAliveCount); + printf(" Alive Counter Delta: %f\n", prevAliveCount - currentHackKiller->mAliveCount); + prevAliveCount = currentHackKiller->mAliveCount; + printf(" Capture Cooldown: %d\n", currentHackKiller->mHackCooldown); + PRINT_VEC3("Facing", currentHackKiller->mFacing); + printf(" Turning Speed: %f\n", currentHackKiller->mTurnVel); + printf(" %d %d %d\n", currentHackKiller->bVar1, currentHackKiller->bVar2, currentHackKiller->mIsMagnum); + printf(" %d %d %d\n", currentHackKiller->bVar4, currentHackKiller->bVar5, currentHackKiller->bVar6); + } + else if (al::isEqualString(currentHackName, "JugemFishing")) { + MAX_LINE(3); + JugemFishing* currentHackJugem = static_cast(currentHack); + printf(" %.3f %.3f\n", currentHackJugem->mFloatOffsetCtrl->fVar1, currentHackJugem->mFloatOffsetCtrl->fVar2); + + } + else if (al::isEqualString(currentHackName, "KuriboHack")) { + MAX_LINE(3); + KuriboHack* currentHackKuribo = static_cast(currentHack); + printf(" IsGold: %s\n", currentHackKuribo->mIsGold ? "True" : "False"); + printf(" %d %d %d %d\n", currentHackKuribo->iVar1, currentHackKuribo->iVar2, currentHackKuribo->iVar3, currentHackKuribo->iVar4); + printf(" %d %d %d %d\n", currentHackKuribo->iVar5, currentHackKuribo->iVar6, currentHackKuribo->iVar7, currentHackKuribo->iVar8); + printf(" %d %.3f %.3f\n", currentHackKuribo->iVar9, currentHackKuribo->fVar1, currentHackKuribo->fVar2); + printf(" %d %d %d %d\n", currentHackKuribo->bVar1, currentHackKuribo->bVar2, currentHackKuribo->bVar3, currentHackKuribo->bVar4); + PRINT_VEC3("", currentHackKuribo->vVar1); + PRINT_VEC3("", currentHackKuribo->vVar2); + printf(" JointName: %s\n", currentHackKuribo->mJointName); + } + else if (al::isEqualString(currentHackName, "Fastener")) { + MAX_LINE(4); + Fastener* currentHackFastener = static_cast(currentHack); + uintptr_t start = (uintptr_t)currentHackFastener; + + sead::PtrArray arr = currentHackFastener->mRailKeeperArray; + static int railKeeperIdx = 0; + INDEXRL(railKeeperIdx, 0, arr.size()-1, 3); + printf("%sRailKeeper: %d/%d (%d)\n", charCursor, railKeeperIdx+1, arr.size(), arr.capacity()); + FastenerRailKeeper* keeper = arr[railKeeperIdx]; + printf(" offset: 0x%x\n", (uintptr_t)keeper - start); + ACTOR_NAME(keeperName, keeper); + printf(" name: %s\n", keeperName); + } + } + else { + MAX_LINE(3); + printf(" Capture Name: Not captured\n"); + } + break; + } + case InfoCappy: { + TITLE("Cappy Info"); + BACK_PAGE(Info, 0); + + if (!isExistPlayer) { + MAX_LINE(1); + printf(" No player actor!\n"); + break; + } + MAX_LINE(2); + + TOGGLE("Quaternion Rotation", quatRot, 1); + + sead::Vector3f* cappyPosition = al::getTrans(cappy); + sead::Vector3f* cappyVel = al::getVelocity(cappy); + sead::Quatf* cappyQuat = al::getQuat(cappy); + sead::Vector3f cappyEulerAngles = fl::QuatToEuler(cappyQuat); + sead::Vector3f cappyRot = sead::Vector3f(DEG(cappyEulerAngles.x),DEG(cappyEulerAngles.y),DEG(cappyEulerAngles.z)); + + PRINT_VEC3PTR("Cappy Pos", cappyPosition); + PRINT_VEC3PTR("Cappy Vel", cappyVel); + if (quatRot) + PRINT_QUATPTR("Cappy Rot", cappyQuat); + else + PRINT_VEC3("Cappy Rot", cappyRot); + + break; + } + case InfoStatistics: { + TITLE("Statistics Info"); + BACK_PAGE(Info, 0); + MAX_LINE(1); + +#if SMOVER == 130 + printf(MSG_NO130); + break; +#endif + + if (!isInGame) { + printf(" Not in game!\n"); + break; + } + + int jumpCount = rs::getPlayerJumpCount(stageScene->mDataHolder); + int throwCapCount = rs::getPlayerThrowCapCount(stageScene->mDataHolder); + int playTimeTotal = GameDataFunction::getPlayTimeTotal(*stageScene->mDataHolder); + int playTimeAcrossFile = GameDataFunction::getPlayTimeAcrossFile(*stageScene->mDataHolder); + int totalCoinNum = rs::getTotalCoinNum(stageScene->mDataHolder); + + printf(" Jump Count: %d\n", jumpCount); + printf(" Throw Cap Count: %d\n", throwCapCount); + printf(" Play Time Total: %d\n", playTimeTotal); + printf(" Play Time Across File: %d\n", playTimeAcrossFile); + printf(" Total Coin Num: %d\n", totalCoinNum); + break; + } + case InfoCamera: { + TITLE("Camera Info"); + BACK_PAGE(Info, 0); + MAX_LINE(1); + + if (!isInGame) { + printf(" Not in game!\n"); + break; + } + + sead::LookAtCamera* camera = al::getLookAtCamera(stageScene, 0); + + sead::Vector3f cameraPos = camera->mPos; + sead::Vector3f cameraAt = camera->mAt; + sead::Vector3f cameraUp = camera->mUp; + + PRINT_VEC3("Camera Pos", cameraPos); + PRINT_VEC3("Camera At", cameraAt); + PRINT_VEC3("Camera Up", cameraUp); + + sead::Vector3f diff = cameraAt - cameraPos; + PRINT_FLOAT("Vertical angle", DEG(atan2f(diff.y, sqrtf(diff.x * diff.x + diff.z * diff.z)))); + PRINT_FLOAT("Horizontal angle", DEG(atan2f(diff.x, diff.z))); + break; + } + case InfoMighty1: { + TITLE("Mighty Info 1"); + BACK_PAGE(Info, 0); + MAX_LINE(1); + + if (!isInGame) { + printf(" Not in game!\n"); + + fl::TasHolder& h = fl::TasHolder::instance(); + if (h.isRunning) + printf(" TAS Running %lu/%lu\n", h.curFrame, h.frameCount); + break; + } + + PlayerActorHakoniwa* player = rs::getPlayerActor(stageScene); + al::LiveActor* cappy = player->mHackCap; + sead::LookAtCamera* camera = al::getLookAtCamera(stageScene, 0); + + sead::Vector3f* playerTrans = al::getTrans(player); + float hSpeed = al::calcSpeedH(player), vSpeed = al::calcSpeedV(player), speed = al::calcSpeed(player); + sead::Quatf* playerQuat = al::getQuat(player); + sead::Vector3f playerEulerAngles = fl::QuatToEuler(playerQuat); + sead::Vector3f playerRot = sead::Vector3f(DEG(playerEulerAngles.x), DEG(playerEulerAngles.y), DEG(playerEulerAngles.z)); + sead::Vector3f* cappyPosition = al::getTrans(cappy); + sead::Vector3f* playerVel = al::getVelocity(player); + float hSpeedAngle = atan2f(playerVel->z, playerVel->x); + if (hSpeedAngle < 0) + hSpeedAngle += M_PI * 2; + + sead::Vector3f cameraPos = camera->mPos; + sead::Vector3f cameraAt = camera->mAt; + sead::Vector3f cameraUp = camera->mUp; + sead::Vector3f cameraDiff = cameraAt - cameraPos; + float camVAngle = atan2f(cameraDiff.y, sqrtf(cameraDiff.x * cameraDiff.x + cameraDiff.z * cameraDiff.z)); + float camHAngle = atan2f(cameraDiff.z, cameraDiff.x); + if (camHAngle < 0) + camHAngle += M_PI * 2; + + float relAngleVel = hSpeedAngle - camHAngle - (M_PI / 2); // offset to move 0 to the right + if (relAngleVel < 0) + relAngleVel += M_PI * 2; + relAngleVel = -relAngleVel + M_PI*2; // invert to conform normal anti-clockwise angle system + + PRINT_VEC3PTR("Player Pos", playerTrans); + PRINT_SPEED("Player Speed", hSpeed, vSpeed, speed); + PRINT_FLOAT("Player Vel Angle", DEG(hSpeedAngle)); + PRINT_VEC3("Player Rot", playerRot); + PRINT_FLOAT("Rel. Vel Angle", DEG(relAngleVel)); + PRINT_VEC3PTR("Cappy Pos", cappyPosition); + PRINT_SPEED("Cappy Speed", al::calcSpeedH(cappy), al::calcSpeedV(cappy), al::calcSpeed(cappy)); + printf(" Current Animation: %s (%.0f/%.0f)\n", player->mAnimator->mCurrentAnim, player->mAnimator->getAnimFrame() - 1.0f, player->mAnimator->getAnimFrameMax()); + PRINT_FLOAT("Cam Vertical angle", DEG(camVAngle)); + PRINT_FLOAT("Cam Horizontal angle", DEG(camHAngle)); + + fl::TasHolder& h = fl::TasHolder::instance(); + if (h.isRunning) + printf(" TAS Running %lu/%lu\n", h.curFrame, h.frameCount); + + break; + } + case InfoMighty2: { + TITLE("Mighty Info 2"); + BACK_PAGE(Info, 0); + MAX_LINE(1); + + if (!isInGame) { + printf(" Not in game!\n"); + + fl::TasHolder& h = fl::TasHolder::instance(); + if (h.isRunning) + printf(" TAS Running %lu/%lu\n", h.curFrame, h.frameCount); + break; + } + + PlayerActorHakoniwa* player = rs::getPlayerActor(stageScene); + al::LiveActor* cappy = player->mHackCap; + sead::LookAtCamera* camera = al::getLookAtCamera(stageScene, 0); + + sead::Vector3f* playerVel = al::getVelocity(player); + sead::Vector3f* cappyVel = al::getVelocity(cappy); + sead::Vector3f* playerRecoveryPoint = player->mRecoverPoint->getSafetyPoint(); + + PRINT_VEC3PTR("Player Vel", playerVel); + PRINT_VEC3PTR("Cappy Vel", cappyVel); + PRINT_VEC3PTR("Bubble Pos", playerRecoveryPoint); + + sead::Vector3f cameraPos = camera->mPos; + sead::Vector3f cameraAt = camera->mAt; + sead::Vector3f cameraUp = camera->mUp; + sead::Vector3f diff = cameraAt - cameraPos; + + PRINT_VEC3("Camera Pos", cameraPos); + PRINT_VEC3("Camera At", cameraAt); + PRINT_VEC3("Camera Up", cameraUp); + + fl::TasHolder& h = fl::TasHolder::instance(); + if (h.isRunning) + printf(" TAS Running %lu/%lu\n", h.curFrame, h.frameCount); + + break; + } + case Tas: { + TITLE("TAS"); + BACK_PAGE(Menu, 0); + MAX_LINE(4); + + TRIGGER("Connect to server", 1, { + // smo::Server::instance().connect("someip"); + }); + TOGGLE("Old Motion Mod", fl::TasHolder::instance().oldMotion, 2); + + fl::TasHolder& h = fl::TasHolder::instance(); + + if (h.isRunning) {TRIGGER("Stop Script", 3, h.stop());} + else { TRIGGER("Start Script", 3, { + if (h.frames) h.start(); + }); + } + + printf("\n"); + + if (h.scriptName) + printf(" Script: %s (%lu frames)\n", h.scriptName, h.frameCount); + + if (h.isRunning) { + printf(" TAS Running %lu/%lu\n", h.curFrame, h.frameCount); + printf(" %lu Frames Remaining\n", h.frameCount - h.curFrame); + } + sead::Vector2f& left = *al::getLeftStick(CONTROLLER_AUTO); + sead::Vector2f& right = *al::getRightStick(CONTROLLER_AUTO); + printf(" Left Stick: (X: %.5f Y: %.5f)\n", left.x, left.y); + printf(" Right Stick: (X: %.5f Y: %.5f)\n", right.x, right.y); + printf(" Left Stick Cartesian: (X: %.0f Y: %.0f)\n", left.x * 32767, left.y * 32767); + printf(" Right Stick Cartesian: (X: %.0f Y: %.0f)\n", right.x * 32767, right.y * 32767); + printf(" Buttons:\n"); + // -1 = CONTROLLER_AUTO + printf(" %s %s %s %s %s %s %s %s\n", al::isPadHold(-1, 1) ? "A" : " ", al::isPadHold(-1, 1<<1) ? "B" : " ", al::isPadHold(-1, 1<<3) ? "X" : " ", al::isPadHold(-1, 1<<4) ? "Y" : " ", al::isPadHold(-1, 1<<13) ? "L" : " ", al::isPadHold(-1, 1<<14) ? "R" : " ", al::isPadHold(-1, 1<<2) ? "ZL" : " ", al::isPadHold(-1, 1<<5) ? "ZR" : " "); + printf(" %s %s %s %s %s %s %s %s\n", al::isPadHold(-1, 1<<10) ? "+" : " ", al::isPadHold(-1, 1<<9) ? "-" : " ", al::isPadHold(-1, 1<<7) ? "LS" : " ", al::isPadHold(-1, 1<<6) ? "RS" : " ", al::isPadHold(-1, 1<<16) ? "DUP" : " ", al::isPadHold(-1, 1<<19) ? "DRIGHT" : " ", al::isPadHold(-1, 1<<17) ? "DDOWN" : " ", al::isPadHold(-1, 1<<18) ? "DLEFT" : " "); + + break; + } + case Modes: { + TITLE("Modes"); + MAX_LINE(7); + BACK_PAGE(Menu, 0); + +#if SMOVER == 130 + MAX_LINE(1); + printf(MSG_NO130); + break; +#endif + + TOGGLE("isModeDiverOrJungleGymRom", modes.isModeDiverOrJungleGymRom, 1); + TOGGLE("isModeDiverRom", modes.isModeDiverRom, 2); + TOGGLE("isModeJungleGymRom", modes.isModeJungleGymRom, 3); + TOGGLE("isModeE3LiveRom", modes.isModeE3LiveRom, 4); + TOGGLE("isModeE3MovieRom", modes.isModeE3MovieRom, 5); + TOGGLE("isModeEpdMovieRom", modes.isModeEpdMovieRom, 6); + + break; + } + case Debug: { + TITLE("Debug"); + MAX_LINE(1); + BACK_PAGE(Menu, 0); + + StageScene* stageScene = getStageScene(); + if(isInGame) { +#if (SMOVER == 100) + printf(" Current Scenario: %d\n", GameDataFunction::getWorldScenarioNo(*stageScene->mDataHolder, GameDataFunction::getCurrentWorldId(*stageScene->mDataHolder))); + printf(" Current World ID: %d\n", GameDataFunction::getCurrentWorldId(*stageScene->mDataHolder)); + printf(" Current Stage Name: %s\n", GameDataFunction::getCurrentStageName(*stageScene->mDataHolder)); + printf(" Current Entry Name: %s\n", stageScene->mDataHolder->mPlayingFile->sVar1.cstr()); +#endif +#if (SMOVER == 130) + printf(" Current Scenario: %d\n", stageScene->mDataHolder->mPlayingFile->getScenarioNo(GameDataFunction::getCurrentWorldId(stageScene->mDataHolder))); + printf(" Current World ID: %d\n", GameDataFunction::getCurrentWorldId(stageScene->mDataHolder)); + printf(" Current Stage Name: %s\n", GameDataFunction::getCurrentStageName(stageScene->mDataHolder)); + printf(" Current Entry Name: %s\n", stageScene->mDataHolder->mPlayingFile->mStartId.cstr()); +#endif + printf(" Language: %s\n", stageScene->mDataHolder->getLanguage()); + } + else { + printf(" Current Scenario: --\n"); + printf(" Current World ID: --\n"); + printf(" Current Stage Name: --\n"); + printf(" Current Entry Name: --\n"); + } + printf("\n"); + printf(" Practice Mod Version: %s\n", PRACTICE_VERSTR); + printf(" Your Game Version: %s\n", GAME_VERSION); + break; + } + case Test: { + TITLE("Testing"); + MAX_LINE(7); + BACK_PAGE(Menu, 0); + +#if SMOVER == 130 + MAX_LINE(1); + printf(MSG_NO130); + break; +#endif + + CHANGE_PAGE("Wall Actions", TestWallAction, 1); + CHANGE_PAGE("Cap Action History", TestCapActionHistory, 2); + CHANGE_PAGE("LiveActorKit", TestLiveActorKit, 3); + CHANGE_PAGE("GameDataHolder", TestGameDataHolder, 4); + CHANGE_PAGE("Other", TestOther, 5); + CHANGE_PAGE("Talkatoo", TestTalkatoo, 6); + // printf(" NfpDirector: %p\n", stageScene->mNfpDirector); + // printf(" ActorInitInfo: %p\n", stageScene->mActorInitInfo); + // printf(" Group: %s\n", stageScene->mActorInitInfo->mGroup1->mGroupName); + // printf(" StageScene: %x\n", sizeof(*stageScene)); + + break; + } + case TestWallAction: { + TITLE("Wall Actions"); + BACK_PAGE(Test, 0); + + if (!isExistPlayer) { + MAX_LINE(1); + printf(" No player actor!\n"); + break; + } + + MAX_LINE(2); + + CURSOR(1); + if (inputEnabled && !movingPage && curLine == 1) { + if (!nextFrameNoLeftInput && triggerLeft) + wallAction--; + if (!nextFrameNoRightInput && triggerRight) + wallAction++; + } + + if (wallAction < 0) wallAction = WALL_ACTIONS - 1; + if (wallAction >= WALL_ACTIONS) wallAction = 0; + + switch (wallAction) { + case 0: { + printf("%sPlayerWallActionHistory\n", charCursor); + + PlayerWallActionHistory* wallActionHistory = player->mWallActionHistory; + printf(" Has Jumped: %s\n", wallActionHistory->mHasJumped ? "True" : "False"); + printf(" Has Left Wall: %s\n", wallActionHistory->mHasLeft ? "True" : "False"); + PRINT_VEC3("Wall Jump Pos", wallActionHistory->mWallJumpPos); + PRINT_VEC3("Wall Jump Normal", wallActionHistory->mWallJumpNormal); + PRINT_VEC3("Wall Leave Pos", wallActionHistory->mWallLeavePos); + PRINT_VEC3("Wall Leave Normal", wallActionHistory->mWallLeaveNormal); + + break; + } + case 1: { + printf("%sPlayerJudgeWallKeep\n", charCursor); + + bool bVar1 = player->mJudgeWallKeep->bVar1; + printf(" Judge: %s\n", bVar1 ? "True" : "False"); + + float groundHeight = player->mColliderHakoniwa->mGroundHeight; + // float lowlimit = player->mConst->getWallHeightLowLimit(); + printf(" Above Ground: %s\n", player->mColliderHakoniwa->mIsAboveGround ? "True" : "False"); + PRINT_FLOAT("Ground Height", groundHeight); + + break; + } + case 2: { + printf("%sPlayerJudgeWallCatch\n", charCursor); + + PlayerJudgeWallCatch* judge = player->mJudgeWallCatch; + bool bVar = judge->bVar1; + printf(" Judge: %s\n", bVar ? "True" : "False"); + + PRINT_VEC3("vVar1", judge->vVar1); + PRINT_VEC3("vVar2", judge->vVar2); + PRINT_VEC3("vVar3", judge->vVar3); + + bVar = judge->mPlayerTrigger->mActionTrigger & 1 << 30; + printf(" Trigger: %s\n", bVar ? "True" : "False"); + + int iVar = judge->mCounterForceRun->iVar1; + printf(" CounterForceRun: %d\n", iVar); + + PRINT_FLOAT("WallKeepDegree", judge->mPlayerConst->getWallKeepDegree()); + PRINT_FLOAT("WallCatchDegree", judge->mPlayerConst->getWallCatchDegree()); + PRINT_FLOAT("WallCatchHeightEdgeTop", judge->mPlayerConst->getWallCatchHeightEdgeTop()); + PRINT_FLOAT("WallCatchHeightBottom", judge->mPlayerConst->getWallCatchHeightBottom()); + PRINT_FLOAT("CollisionRadius", judge->mPlayerConst->getCollisionRadius()); + PRINT_FLOAT("CollisionRadiusStand", judge->mPlayerConst->getCollisionRadiusStand()); + + break; + } + case 3: { + printf("%sPlayerStateWallAir\n", charCursor); + + break; + } + default: { + wallAction = 0; + break; + } + } + + static_assert(WALL_ACTIONS == 4, "wrong number of wall actions"); + + break; + } + case TestCapActionHistory: { + TITLE("Cap Action History"); + MAX_LINE(1); + BACK_PAGE(Test, 0); + + if (!isExistPlayer) { + printf(" No player actor!\n"); + break; + } + + PlayerCapActionHistory* capActionHistory = player->mCapActionHistory; + PlayerCounterAfterCapCatch* counterCapCatch = capActionHistory->mCounterCapCatch; + printf(" Limit Height: %d\n", capActionHistory->mLimitHeight); + PRINT_VEC3("Pos", capActionHistory->mCapThrowPos); + printf(" Cap Bounce: %d\n", capActionHistory->mCapJump); + printf(" Rainbow Spin: %d\n", capActionHistory->mRainbowSpin); + printf(" Cap Catch: %d\n", counterCapCatch->mCapCatch); + // printf(" Is Cap Catch: %d\n", counterCapCatch->isCapCatch()); + + break; + } + case TestLiveActorKit: { + TITLE("LiveActorKit"); + MAX_LINE(6); + BACK_PAGE(Test, 0); + + CHANGE_PAGE("ObjectList", TestObjectList, 1); + CHANGE_PAGE("AreaList", TestAreaList, 2); + CHANGE_PAGE("ExecuteDirector", TestExecute, 3); + CHANGE_PAGE("NatureDirector", TestNatureDirector, 4); + CHANGE_PAGE("CollisionDirector", TestCollisionDirector, 5) + + break; + } + case TestObjectList: { + TITLE("ObjectList"); + MAX_LINE(4); + BACK_PAGE(TestLiveActorKit, 0); + + al::LiveActorKit* liveActorKit = stageScene->mLiveActorKit; + al::LiveActorGroup* actorGroup = liveActorKit->mAllActors; + sead::PtrArray allActors = actorGroup->mActors; + // al::ActorInitInfo* actorInitInfo = stageScene->mActorInitInfo; + // al::PlacementId* placementId; + + INDEXRL(actorIndex, 0, allActors.capacity() - 1, 1); + printf("%sActor Index: %d/%d\n", charCursor, actorIndex + 1, allActors.capacity()); + + currentActor = allActors[actorIndex]; + + TRIGGER("Load position", 2, loadPosition(currentActor, savestateIndex)); + TOGGLE("Show HitSensors", renderer.showHitSensors, 3); + + ACTOR_NAME(currentActorName, currentActor); + printf(" Actor Name: %s\n", currentActorName); + + if (currentActor->mModelKeeper) { + if (currentActor->mModelKeeper->mName) { + printf(" Model Name: %s\n", currentActor->mModelKeeper->mName); + } + } else { + printf(" Model Name: N/A\n"); + } + + if (currentActor->mPoseKeeper) { + sead::Vector3f actorPos = currentActor->mPoseKeeper->mTranslation; + PRINT_VEC3("Position", actorPos); + } else { + printf(" Position: N/A\n"); + } + + PRINT_NERVE(currentActor); + + printf("\n"); + + printf(" Group Name: %s\n", actorGroup->mName); + printf(" Alive Actors: %d/%d\n", actorGroup->calcAliveActorNum(), allActors.capacity()); + printf(" Max Actors: %d\n", allActors.size()); + + break; + } + case TestAreaList: { + TITLE("AreaList"); + BACK_PAGE(TestLiveActorKit, 0); + + al::LiveActorKit* liveActorKit = stageScene->mLiveActorKit; + al::AreaObjDirector* areaObjDirector = liveActorKit->mAreaObjDirector; + int groupCount = areaObjDirector->mAreaGroupCount; + + INDEXSRL(areaGroupIndex, areaIndex, 0, 0, groupCount - 1, 1); + printf("%sGroup Index: %d/%d\n", charCursor, areaGroupIndex + 1, groupCount); + + renderer.curAreaGroup = areaObjDirector->mAreaGroups[areaGroupIndex]; + + if (!renderer.curAreaGroup) { + MAX_LINE(2); + printf(" invalid group pointer"); + break; + } + MAX_LINE(3); + int areaCount = renderer.curAreaGroup->mAreaCount; + + CURSOR(2); + if (areaCount == 0) { + printf("%sArea Index: N/A\n", charCursor); + printf(" Group: %s (0)\n", renderer.curAreaGroup->mGroupName); + break; + } + printf("%sArea Index: %d/%d\n", charCursor, areaIndex + 1, areaCount); + if (inputEnabled && !movingPage && curLine == 2) { + if ((heldLeft && heldDirFrames > HELD_THRESHOLD) || triggerLeft) areaIndex--; + if ((heldRight && heldDirFrames > HELD_THRESHOLD) || triggerRight) areaIndex++; + } + if (areaIndex < 0) areaIndex = areaCount - 1; + if (areaIndex >= areaCount) areaIndex = 0; + + printf(" Group: %s (%d)\n", renderer.curAreaGroup->mGroupName, renderer.curAreaGroup->mBufferSize); + + renderer.curArea = renderer.curAreaGroup->mAreas[areaIndex]; + al::AreaShape* areaShape = renderer.curArea->mAreaShape; + sead::Vector3f areaTrans; + areaShape->calcTrans(&areaTrans); + sead::Vector3f areaScale = areaShape->mScale; + + const char* shapeType; + al::tryGetAreaObjStringArg(&shapeType, renderer.curArea, "ModelName"); + + printf(" Area Shape: %s\n", shapeType); + PRINT_VEC3("Area Pos", areaTrans); + PRINT_VEC3("Area Scale", areaScale); + // printf(" Obj ID: %s\n", renderer.curArea->mPlacementInfo->mPlacementIter) + + if (!isExistPlayer) break; + + sead::Vector3f* playerTrans = al::getTrans(player); + bool isInArea = renderer.curArea->isInVolume(*playerTrans); + float distToEdge = sead::norm2(*playerTrans - renderer.nearestEdgePoint); + + printf("\n"); + printf(" Is in Area: %s\n", isInArea ? "True" : "False"); + PRINT_FLOAT("Distance to Area", isInArea ? 0.0 : distToEdge); + PRINT_VEC3("Edge", renderer.nearestEdgePoint); + + break; + } + case TestExecute: { + TITLE("ExecuteDirector"); + MAX_LINE(6); + BACK_PAGE(TestLiveActorKit, 0); + + CHANGE_PAGE("ExecuteTableHolderDraw", TestExecuteDraw, 1); + + al::ExecuteDirector* director = stageScene->mLiveActorKit->mExecuteDirector; + sead::PtrArray arrTable = director->mTableDraw; + int arrSize = arrTable.size(); + + INDEXRL(executeTableDrawIdx, 0, arrSize - 1, 2); + printf("%sTableDraw Index: %d/%d\n", charCursor, executeTableDrawIdx + 1, arrSize); + + al::ExecuteTableHolderDraw* tableDraw = arrTable[executeTableDrawIdx]; + printf(" Name: %s\n", tableDraw->mName); + sead::PtrArray listActorModel = tableDraw->mListActorModel; + arrSize = listActorModel.capacity(); + + INDEXRL(executeListIdx, 0, arrSize - 1, 3); + printf("%sExecutorList Index: %d/%d (%d)\n", charCursor, executeListIdx + 1, arrSize, listActorModel.size()); + + al::ExecutorListActorModelDrawBase* executorList = listActorModel[executeListIdx]; + if (!executorList) { + // renderer.actorTrans = sead::Vector3f::zero; + break; + } + sead::PtrArray executorActors = executorList->mActors; + arrSize = listActorModel.capacity(); + + + INDEXRL(executeItemIdx, 0, arrSize - 1, 4); + printf("%sExecutorActor Index: %d/%d (%d)\n", charCursor, executeItemIdx + 1, arrSize, executorActors.size()); + + al::ExecutorActorExecuteBase* executorActor = executorActors[executeItemIdx]; + if (!executorActor) { + // renderer.actorTrans = sead::Vector3f::zero; + break; + } + printf(" ExecuteActor Name: %s\n", executorActor->mName); + sead::PtrArray actors = executorActor->mActors; + arrSize = actors.capacity(); + + INDEXRL(itemIdx, 0, arrSize - 1, 5); + al::LiveActor* actor = actors[itemIdx]; + printf( "Actor: %p\n", actor); + // renderer.actorTrans = *al::getTrans(actor); + + // printf(" Actor Pos: (X: %.3f Y: %.3f Z: %.3f)\n", renderer.actorTrans.x, renderer.actorTrans.y, renderer.actorTrans.z); + + break; + } + case TestExecuteDraw: { + TITLE("ExecuteTableHolderDraw"); + MAX_LINE(14); + BACK_PAGE(TestExecute, 0); + + static bool isJapanese = true; + static int drawTablePage = 0; + sead::PtrArray drawTables = stageScene->mLiveActorKit->mExecuteDirector->mTableDraw; + + TOGGLES(isJapanese, 1); + printf("%sLanguage: %s\n", charCursor, isJapanese ? "Japanese" : "English"); + + INDEXRL(drawTablePage, 0, 3, 2); + printf("%sShowing %d-%d out of 44\n", charCursor, drawTablePage*11+1, (drawTablePage+1)*11); + + for (int i = 0; i < 11; ++i) { + int idx = drawTablePage*11 + i; + al::ExecuteTableHolderDraw* drawTable = drawTables[idx]; + TOGGLES(drawTable->debug_Enabled, 3+i); + const char* name = isJapanese ? drawTable->mName : executeTableDrawNames[idx]; + printf("%s%s%s\n", charCursor, drawTable->debug_Enabled ? "On " : "Off ", name); + } + + break; + } + case TestNatureDirector: { + TITLE("NatureDirector"); + MAX_LINE(1); + BACK_PAGE(TestLiveActorKit, 0); + + al::NatureDirector* director = stageScene->mLiveActorKit->mNatureDirector; + // void* gap = director->gap; + al::FluidSurfaceHolder* surfaceHolder = director->mSurfaceHolder; + + sead::Vector3f& playerTrans = *al::getTrans(player); + + printf(" In Water: %s\n", surfaceHolder->calcIsInFluid(playerTrans, "Water") ? "True" : "False"); + + break; + } + case TestCollisionDirector: { + TITLE("CollisionDirector"); + MAX_LINE(3); + BACK_PAGE(TestLiveActorKit, 0); +#if SMOVER == 130 + MAX_LINE(1); + printf(MSG_NO130); + break; +#endif +#if SMOVER == 100 + PlayerCollider* collider = player->mColliderHakoniwa->mCollider; + al::Triangle floorTri = collider->mHitFloor->mTri; + al::CollisionParts* collisionParts = floorTri.mCollisionParts; + + al::KCollisionServer* collisionServer = collisionParts->mKCollisionServer; + sead::PtrArray prismHeaders = collisionServer->mPrismHeaders; + void* kcl = collisionServer->gap1; + + static int prismHeaderIdx = 0; + INDEXRL(prismHeaderIdx, 0, prismHeaders.capacity() - 1, 1); + printf("%sModel: %d/%d\n", charCursor, prismHeaderIdx+1, prismHeaders.capacity()); + al::KCPrismHeader* prismHeader = prismHeaders[prismHeaderIdx]; + + unsigned int triCount = collisionServer->getTriangleNum(prismHeader); + static unsigned int triIdx = 0; + INDEXRL(triIdx, 0, triCount - 1, 2); + printf("%sTriangle: %d/%d\n", charCursor, triIdx+1, triCount); + al::KCPrismData* prismData = (al::KCPrismData*)((long)&prismHeader->mPositionsOffset + prismHeader->mTrianglesOffset + triIdx * 0x14); + + + fillTri(&renderer.kclTri, *collisionParts, prismData, prismHeader); + al::Triangle tri = renderer.kclTri; + + PRINT_VEC3("A", tri.mVerts[0]); + PRINT_VEC3("B", tri.mVerts[1]); + PRINT_VEC3("C", tri.mVerts[2]); + + +// for (int triIdx = 0; triIdx < triCount; triIdx++); +// +// ACTOR_NAME(actorName, hostActor); +// +// printf(" Host Actor: %s\n", actorName); +// printf(" length: %f\n", prismData->mLength); +// printf(" position: %u\n", prismData->mPosIndex); +// printf(" face normal: %u\n", prismData->mFaceNormalIndex); +// printf(" edge normals: %u, %u, %u\n", prismData->mEdgeNormalIndex[0], prismData->mEdgeNormalIndex[1], prismData->mEdgeNormalIndex[2]); +// printf(" collision flags: %x\n", prismData->mCollisionFlags); +// printf(" tri index: %u\n", prismData->mTriIndex); + +#endif + break; + } + case TestGameDataHolder: { + TITLE("GameDataHolder"); + MAX_LINE(2); + BACK_PAGE(Test, 0); + + CHANGE_PAGE("GameDataFile", TestGameDataFile, 1); + + GameDataHolder* dataHolder = stageScene->mDataHolder; + + break; + } + case TestGameDataFile: { + TITLE("GameDataFile"); + MAX_LINE(2); + BACK_PAGE(TestGameDataHolder, 0); + + CHANGE_PAGE("Shine List", TestGameDataShine, 1); + + GameDataFile* curFile = stageScene->mDataHolder->mPlayingFile; + + printf(" File Index: %d/5\n", stageScene->mDataHolder->mPlayingFileId + 1); + + break; + } + case TestGameDataShine: { + TITLE("GameDataShine"); + MAX_LINE(4); + BACK_PAGE(TestGameDataFile, 0); +#if SMOVER == 130 + MAX_LINE(1); + printf(MSG_NO130); + break; +#endif +#if SMOVER == 100 + GameDataFile* curFile = stageScene->mDataHolder->mPlayingFile; + + INDEXRL(dataShineIdx, 0, 1023, 1); + printf("%sShine Index: %d/1024\n", charCursor, dataShineIdx+1); + GameDataFile::HintInfo& curShine = curFile->mShineList[dataShineIdx]; + + TRIGGER("Go to position", 2, { + if (isExistPlayer) { + al::offCollide(player); + player->startDemoPuppetable(); + player->mStainControl->clearStain(); + al::setTrans(player, curShine.mTrans); + al::setVelocityZero(player); + player->endDemoPuppetable(); + al::onCollide(player); + al::setTrans(player, curShine.mTrans); + } + }); + TRIGGER_FMT("Go to stage %s", 3, { + ChangeStageInfo info = ChangeStageInfo(stageScene->mDataHolder, "start", curShine.mStageName.cstr(), false, -1, {0}); + stageScene->mDataHolder->changeNextStage(&info, 0); + }, al::isEqualString(curShine.mStageName.cstr(), curFile->mStageNameCurrent.cstr()) ? "" : "!!!!!"); + + printf(" World ID: %d\n", curShine.mWorldId); + printf(" Is Got: %d\n", curShine.mIsGet); + printf(" Stage Name: %s\n", curShine.mStageName.cstr()); + printf(" Object ID: %s\n", curShine.mObjId.cstr() ?: "N/A"); + printf(" Achievement: %s\n", curShine.mOptionalId.cstr()); + PRINT_VEC3("Pos", curShine.mTrans); + PRINT_VEC3("Hint Trans", curShine.mHintTrans); + printf(" Unique ID: %d\n", curShine.mUniqueId); + printf(" Object Name: %s\n", curShine.mObjectName.cstr()); + + // printf(" %s\n", curShine.sVar3.cstr()); +#endif + break; + } + case TestOther: { + BACK_PAGE(Test, 0); + + if (!isExistPlayer) { + MAX_LINE(1); + printf(" No player actor!\n"); + break; + } + + INDEXRL(otherPageIdx, 0, OTHER_PAGES - 1, 1); + + switch (otherPageIdx) { + case 0: { + MAX_LINE(2); + printf("%sPlayerStatePoleClimb\n", charCursor); + + PlayerStatePoleClimb* statePoleClimb = player->mStatePoleClimb; + printf("%s\n", statePoleClimb->mMaterialName); + PRINT_FLOAT("fVar1", statePoleClimb->fVar1); + PRINT_FLOAT("fVar2", statePoleClimb->fVar2); + PRINT_FLOAT("fVar3", statePoleClimb->fVar3); + PRINT_VEC2("mPoleMoveInput", statePoleClimb->mPoleMoveInput); + printf("%d\n", statePoleClimb->mClimbType); + printf("%d\n", statePoleClimb->mClimbDelay); + printf("%d\n", statePoleClimb->mClimbDownKeepTime); + PRINT_VEC2("mStickMoveRaw", statePoleClimb->mStickMoveRaw); + PRINT_VEC2("mLeftStickInit", statePoleClimb->mLeftStickInit); + printf("%d %d %d\n", statePoleClimb->mHasJustTurned, statePoleClimb->mIsInputReverse, statePoleClimb->bVar3); + printf("%d\n", statePoleClimb->mJudgePreInputPoleClimbSwing->mSwingDelay); + + break; + } + case 1: { + MAX_LINE(2); + printf("%sPlayerJudgePoleClimb\n", charCursor); + + PlayerJudgePoleClimb* judgePoleClimb = player->mJudgePoleClimb; + printf("%s\n", judgePoleClimb->mMaterialName); + PRINT_VEC3("vVar1", judgePoleClimb->vVar1); + PRINT_VEC3("vVar2", judgePoleClimb->vVar2); + PRINT_VEC3("vVar3", judgePoleClimb->vVar3); + PRINT_FLOAT("fVar1", judgePoleClimb->fVar1); + PRINT_FLOAT("fVar2", judgePoleClimb->fVar2); + printf("%d\n", judgePoleClimb->mIsClimbing); + + break; + } + case 2: { + MAX_LINE(2); + printf("%sPlayerStainControl\n", charCursor); + + PlayerStainControl* stainControl = player->mStainControl; + printf("%d\n", stainControl->iVar1); + printf("%d\n", stainControl->iVar2); + printf("%d\n", stainControl->iVar3); + printf("%d\n", stainControl->iVar4); + printf("%d\n", stainControl->iVar5); + printf("%d\n", stainControl->iVar6); + printf("%d %d %d %d %d %d\n", stainControl->bVar1, stainControl->bVar2, stainControl->bVar3, stainControl->bVar4, stainControl->bVar5, stainControl->bVar6); + PRINT_FLOAT("fVar1", stainControl->fVar1); + PRINT_FLOAT("fVar2", stainControl->fVar2); + PRINT_FLOAT("fVar3", stainControl->fVar3); + PRINT_FLOAT("fVar4", stainControl->fVar4); + PRINT_FLOAT("fVar5", stainControl->fVar5); + printf(" StainType: %d\n", stainControl->mStainType); + + break; + } + case 3: { + MAX_LINE(2); + printf("%sWorldEndBorderKeeper\n", charCursor); + + break; + + WorldEndBorderKeeper* border = player->mWorldEndBorderKeeper; + + if (border) { + PRINT_VEC3("Player Pos", border->mPlayerTrans); + PRINT_VEC3("Player Vel", border->mPlayerVel); + PRINT_VEC3("Closest Point inside Border", border->mBorderPoint); + PRINT_VEC3("Pull Vel", border->mPullVel); + PRINT_FLOAT("Oscillation Frame", border->mOscillateFrame); + PRINT_FLOAT("Distance into Border", border->mDistIntoBorder); + printf(" Is Airborne: %s\n", border->mIsAirborne ? "True" : "False"); + + al::AreaObj* area = border->uVar1; + + printf(" Area Name: %s\n", area->mName); + printf(" Area Priority: %d\n", area->mPriority); + + al::AreaShape* areaShape = area->mAreaShape; + ACTOR_NAME(areaName, areaShape); + printf(" Area Shape: %s\n", areaName); + + sead::Vector3f areaTrans; + areaShape->calcTrans(&areaTrans); + PRINT_VEC3("Area Pos", areaTrans); + sead::Vector3f areaScale = areaShape->mScale; + PRINT_VEC3("Area Scale", areaScale); + } else { + printf(" No world border!\n"); + } + + // printf(" %s\n", stageScene->mDataHolder->field_0x98); // uchar* + + break; + } + case 4: { + MAX_LINE(2); + printf("%sWaterSurfaceFinder\n", charCursor); + + al::WaterSurfaceFinder* surfaceFinder = player->mWaterSurfaceFinder; + // PlayerStateSwim* stateSwim = player->mStateSwim; + + printf(" Is Near Surface: %s\n", surfaceFinder->mIsNearSurface ? "True" : "False"); + PRINT_FLOAT("Distance below Surface", surfaceFinder->mDistBelowSurface); + PRINT_VEC3("Surface", surfaceFinder->mSurfacePoint); + PRINT_VEC3("vVar2", surfaceFinder->vVar2); + PRINT_VEC3("vVar3", surfaceFinder->vVar3); + + break; + } + case 5: { + MAX_LINE(3); + printf("%sPlayerJudgeInWater\n", charCursor); + + static int judgeInWaterIdx = 0; + + INDEXRL(judgeInWaterIdx, 0, 3, 2); + printf("%sIndex: %d/4\n", charCursor, judgeInWaterIdx + 1); + + PlayerJudgeInWater* judgeInWaters[5] = {player->mJudgeInWater1, player->mJudgeInWater2, player->mJudgeInWater3, player->mJudgeInWater4}; + PlayerJudgeInWater* judgeInWater = judgeInWaters[judgeInWaterIdx]; + + printf(" bVar1: %s\n", judgeInWater->bVar1 ? "True" : "False"); + printf(" bVar2: %s\n", judgeInWater->bVar2 ? "True" : "False"); + printf(" bVar3: %s\n", judgeInWater->bVar3 ? "True" : "False"); + + printf(" Judge: %s", judgeInWater->judge() ? "True" : "False"); + + break; + } + case 6: { + MAX_LINE(3); + TITLE_FMT("%sCameraPoser", charCursor); + + static int snapShotIdx = 0; + + INDEXRL(snapShotIdx, 0, 0, 2); + printf("%sPage: %d/1\n", charCursor, snapShotIdx + 1); + + al::CameraPoser* curPoser; + al::CameraDirector* director = stageScene->getCameraDirector(); + if (director) { + al::CameraPoseUpdater* updater = director->getPoseUpdater(0); + if (updater && updater->mTicket) + curPoser = updater->mTicket->mPoser; + } + + if (curPoser) { + printf(" Name: %s\n", curPoser->getName()); + PRINT_VEC3("Pos", curPoser->mPosition); + PRINT_VEC3("Target", curPoser->mTargetTrans); + PRINT_FLOAT("FOV", curPoser->mFovyDegree); + + al::SnapShotCameraCtrl* snapShotCamera = curPoser->mSnapShotCameraCtrl; + if (snapShotCamera) { + printf(" %.3f %.3f\n", snapShotCamera->fVar1, snapShotCamera->fVar2); + printf(" %.3f %.3f\n", snapShotCamera->fVar3, snapShotCamera->mMaxZoomOutFovyDegree); + printf(" %.3f %.3f\n", snapShotCamera->mRollDegree, snapShotCamera->mRollTarget); + printf(" %x\n", snapShotCamera->uVar2); + printf(" %d %d %d %d\n", snapShotCamera->mIsValidLookAtOffset, snapShotCamera->mIsValidZoomFovy, snapShotCamera->mIsValidRoll, snapShotCamera->bVar1); + printf(" %d %.3f %.3f\n", snapShotCamera->mParam->bVar, snapShotCamera->mParam->fVar1, snapShotCamera->mParam->fVar2); + } + } + + break; + } + case 7: { + TITLE_FMT("%sPlayerCarryKeeper", charCursor); + + TOGGLE("Lock Current Item", options.lockCarry, 2); + + PlayerCarryKeeper* carryKeeper = player->mCarryKeeper; + + static int seedStateWaitIdx = 0; + + if (!carryKeeper) break; + + + if (!options.lockCarry) + currentCarry = carryKeeper->mSensorHeld; + + if (!currentCarry) { + printf(" N/A\n"); + break; + } + + al::LiveActor* actor = currentCarry->mHost; + if (!actor) break; + + ACTOR_NAME(currentActorName, actor); + printf(" Actor Name: %s\n", currentActorName); + + if (al::isEqualString(currentActorName, "GrowPlantSeed")) { + MAX_LINE(4); + INDEXRL(seedStateWaitIdx, 0, 1, 3); + printf("%sStateWait: %d/2\n", charCursor, seedStateWaitIdx + 1); + + GrowPlantSeed* nut = static_cast(actor); + GrowSeedStateWait* stateWaits[2] = { nut->mStateWait, nut->mStateWaitWater }; + GrowSeedStateWait* stateWait = stateWaits[seedStateWaitIdx]; + + PRINT_NERVE(nut); + printf(" %d %d %d %d %d %d %d\n", nut->bVar1, nut->bVar2, nut->bVar3, nut->bVar4, nut->bVar5, nut->bVar6, nut->bVar7); + printf(" %d %d %d %d\n", nut->iVar1, nut->iVar2, nut->iVar3, nut->iVar4); + printf(" Is Save: %s\n", nut->mIsSave ? "True" : "False"); + + if (!stateWait) { + printf(" StateWait: N/A\n"); + break; + } + + printf(" %d %d %d\n", stateWait->bVar1, stateWait->bVar2, stateWait->bVar3); + printf(" %d\n", stateWait->iVar1); + + + } else { + MAX_LINE(3); + } + break; + } + case 8: { + TITLE_FMT("%sApplication", charCursor); + MAX_LINE(3); + + + + + break; + } + case 9: { + TITLE_FMT("%sSensors", charCursor); + MAX_LINE(3); + + sead::PtrArray sensors = player->mHitSensorKeeper->mSensors; + static int sensorIdx = 0; + + if (sensors.capacity() <= 0) break; + + INDEXRL(sensorIdx, 0, sensors.capacity()-1, 2); + printf("%sIndex: %d/%d\n", charCursor, sensorIdx+1, sensors.capacity()); + al::HitSensor* curSensor = sensors[sensorIdx]; + + printf(" %p\n", curSensor); + + if (!curSensor) break; + + printf(" name: %s\n", curSensor->mName); + printf(" type: %u\n", curSensor->mType); + PRINT_FLOAT("radius", curSensor->mRadius); + PRINT_VEC3("vVar1", curSensor->vVar1); + PRINT_VEC3PTR("mFollowPos", curSensor->mFollowPos); + + break; + } + case 10: { + TITLE_FMT("%sPlayerActionAirMoveControl", charCursor); + MAX_LINE(3); + + PlayerActionAirMoveControl* airMoveControl = player->mStateJump->mActionAirMoveControl; + static int airMoveIdx = 0; + + INDEXRL(airMoveIdx, 0, 1, 2); + printf("%sPage %d/2\n", charCursor, airMoveIdx+1); + + if (airMoveIdx == 0) { + printf(" %d %d %d %d\n", airMoveControl->bVar1, airMoveControl->bVar2, airMoveControl->bVar3, airMoveControl->bVar4); + printf(" %d %d %d %d\n", airMoveControl->bVar5, airMoveControl->bVar6, airMoveControl->bVar7, airMoveControl->bVar8); + printf(" %d\n", airMoveControl->iVar1); + printf(" %d\n", airMoveControl->iVar2); + printf(" extend frame: %d\n", airMoveControl->mExtendFrame); + PRINT_FLOAT("fVar1", airMoveControl->fVar1); + PRINT_FLOAT("fVar2", airMoveControl->fVar2); + PRINT_FLOAT("fVar3", airMoveControl->fVar3); + PRINT_FLOAT("fVar4", airMoveControl->fVar4); + PRINT_FLOAT("fVar5", airMoveControl->fVar5); + PRINT_FLOAT("mFallSpeedMax", airMoveControl->mFallSpeedMax); + } + else if (airMoveIdx == 1) { + PRINT_VEC3("vVar1", airMoveControl->vVar1); + PRINT_VEC3("vVar2", airMoveControl->vVar2); + PRINT_VEC3("vVar3", airMoveControl->vVar3); + PRINT_VEC3("vVar4", airMoveControl->vVar4); + } + + break; + } + case 11: { + TITLE_FMT("%sEffectSystem", charCursor); + MAX_LINE(2); + + al::EffectSystem* effectSystem = stageScene->mLiveActorKit->mEffectSystem; + al::EffectSystemInfo effectSysInfo = effectSystem->mEffectSystemInfo; + al::EffectUserInfo* userInfo = alEffectFunction::tryFindEffectUser(&effectSysInfo, "CoinCollect"); + + al::EffectInfo* effectInfo = userInfo->mEffectInfo; + printf(" %d\n", effectInfo->mResourceCount); + + break; + } + case 12: { + TITLE_FMT("%sShineListLayout", charCursor); + MAX_LINE(2); +#if SMOVER == 130 + MAX_LINE(1); + printf(MSG_NO130); + break; +#endif +#if SMOVER == 100 + ShineListLayout* lyt = stageScene->mStateCollectionList->mShineList; + CommonVerticalList* verticalList = lyt->mVerticalList; + + printf("%d %d %d\n", lyt->mWorldIdx, lyt->mWorldCount, lyt->iVar3); + printf("%d %d %d\n", lyt->mCursorIdx, lyt->iVar5, lyt->iVar6); + printf("%d %d\n", lyt->bVar1, lyt->bVar2); + printf("%d %d %d\n", verticalList->iVar1, verticalList->mCursorIdx, verticalList->mTopIdx); + printf("%d %d %d\n", verticalList->mPrevCursorIdx, verticalList->mPrevTopIdx, verticalList->mDelayFrame); + printf("%d %d %d\n", verticalList->iVar7, verticalList->iVar8, verticalList->mItemCount); + printf("%d %d %d\n", verticalList->bVar1, verticalList->bVar2, verticalList->bVar3); + printf("%.3f %.3f %.3f\n", verticalList->fVar1, verticalList->fVar2, verticalList->fVar3); +#endif + break; + } + case 13: { + TITLE_FMT("%sHackCap", charCursor); + MAX_LINE(2); + + printf("%p\n", cappy->gap3); + printf("%p\n", cappy->mCapTargetInfo); + + break; + } + case 14: { + TITLE_FMT("%sCapManHeroDemoDirector", charCursor); + MAX_LINE(2); + + CapManHeroDemoDirector* demoDirector = static_cast(al::getSceneObj(stageScene, 3)); + if (!demoDirector) break; + + printf(" mTalkDemoCurrent: %p\n", demoDirector->mTalkDemoCurrent); + printf(" mTalkDemoFirstMoonGet: %p\n", demoDirector->mTalkDemoFirstMoonGet); + printf(" mTalkDemoStageStart: %p\n", demoDirector->mTalkDemoStageStart); + printf(" mTalkDemoMoonRock: %p\n", demoDirector->mTalkDemoMoonRock); + + break; + } + case 15: { + TITLE_FMT("%sPrimitiveDrawer shapes", charCursor); + MAX_LINE(5); + + + TOGGLE("Cube", testDrawCube, 2); + TOGGLE("Cylinder", testDrawCylinder, 3); + TOGGLE("Sphere", testDrawSphere, 4); + + break; + } + default: { + otherPageIdx = 0; + break; + } + } + + break; + } + case TestTalkatoo: { + TITLE("Talkatoo"); + MAX_LINE(4); + BACK_PAGE(Test, 0); +#if SMOVER == 130 + MAX_LINE(1); + printf(MSG_NO130); + break; +#endif +#if SMOVER == 100 + GameDataFile* curFile = stageScene->mDataHolder->mPlayingFile; + + int shinesTable[0x400]; + int shinesCount; + + INDEXSRL(curWorldId, curScenarioNo, 1, 0, 15, 1); + printf("%sWorld Id: %d\n", charCursor, curWorldId); + int moonRockScenario = stageScene->mDataHolder->mWorldList->getMoonRockScenarioNo(curWorldId); + + INDEXRL(curScenarioNo, 1, moonRockScenario, 2); + printf("%sScenario: %d/%d\n", charCursor, curScenarioNo, moonRockScenario); + + int tempScenarioNo = curFile->mScenarioNo[curWorldId]; + curFile->mScenarioNo[curWorldId] = curScenarioNo; + + curFile->calcShineIndexTableNameUnlockable(shinesTable, &shinesCount, curWorldId); + + INDEXRL(talkatooIndex, 0, shinesCount - 1, 3); + + if (shinesCount == 0) { + printf("%sNo moons available\n", charCursor); + curFile->mScenarioNo[curWorldId] = tempScenarioNo; + break; + } + + printf("%sIndex: %d/%d\n", charCursor, talkatooIndex+1, shinesCount); + + const char16_t* shineName = GameDataFunction::tryFindShineMessage(stageScene->mStateCollectionList->mShineList, curWorldId, shinesTable[talkatooIndex]); + + if (shineName) { + printf(" %s\r\n", shineName); + } + + curFile->mScenarioNo[curWorldId] = tempScenarioNo; +#endif + + break; + } + case TestLoadingZones: { + TITLE("Loading Zones"); + MAX_LINE(2); + BACK_PAGE(Menu, 0); + +#if SMOVER == 130 + MAX_LINE(1); + printf(MSG_NO130); + break; +#endif +#if SMOVER == 100 + INDEXRL(changeStageNum, 0, 1, 1); + printf("%sChangeStageInfo: %d/2\n", charCursor, changeStageNum+1); + + ChangeStageInfo* lz; + if (changeStageNum == 0) + lz = stageScene->mDataHolder->mPlayingFile->uVar4; + else if (changeStageNum == 1) + lz = stageScene->mDataHolder->mPlayingFile->uVar5; + + printf(" Stage: %s\n", lz->mStageName.mBuffer); + printf(" Entrance: %s\n", lz->mStageId.mBuffer); + printf(" ObjId: %s\n", lz->mObjId.mBuffer); + printf(" Wipe Type: %s\n", lz->mWipeType.mBuffer); + printf(" Scenario: %d\n", lz->mScenario); + printf(" Hint Priority: %d\n", lz->mHintPriority); + printf(" unknown bool: %s\n", lz->mUnkBool ? "True" : "False"); +#endif + + break; + } + default: { + curPage = Menu; + break; + } } - auto& page = mPages[*(u8*)&curPage]; - printf("%s%s (%d/%d) %s\n", curLine == 0 ? ">" : "", page.name, (int)curPage + 1, sizeof(mPages) / sizeof(mPages[0]), inputEnabled ? "" : "[Menu Disabled]"); - curMaxLine = 1; - page.update(*this); - } else { - textBuffer[0] = ' '; - textBuffer[1] = '\0'; + if (inputEnabled) { + if (heldDown || heldUp || heldLeft || heldRight) heldDirFrames++; + else heldDirFrames = 0; + + if (heldDown && heldDirFrames > HELD_THRESHOLD && curLine < maxLine-1) curLine++; + if (triggerDown) curLine++; + if (heldUp && heldDirFrames > HELD_THRESHOLD && curLine > 0) curLine--; + if (triggerUp) curLine--; + + if(curLine >= maxLine && !movingPage) curLine = 0; + if(curLine < 0 && !movingPage) curLine = maxLine - 1; + } } + #if SMOVER == 130 - al::showPane(getStageScene()->stageSceneLayout->coinCounter, "TxtDebug"); - al::setPaneStringFormat(getStageScene()->stageSceneLayout->coinCounter, "TxtDebug", textBuffer); + al::showPane(getStageScene()->mStageSceneLayout->coinCounter, "TxtDebug"); + al::setPaneStringFormat(getStageScene()->mStageSceneLayout->coinCounter, "TxtDebug", textBuffer); nextFrameNoLeftInput = false; #elif SMOVER == 100 p.printf(textBuffer); #endif + movingPage = false; + nextFrameNoLeftInput = false; nextFrameNoRightInput = false; + ext_input = 0; } - -void fl::ui::PracticeUI::toggle(const char* name, bool& value) -{ - cursor(curMaxLine); - printf("%s: %s\n", name, value ? "Enabled" : "Disabled"); - if (inputEnabled && !nextFrameNoLeftInput && !nextFrameNoRightInput && curLine == curMaxLine && (al::isPadTriggerLeft(CONTROLLER_AUTO) || al::isPadTriggerRight(CONTROLLER_AUTO))) - value = !value; - curMaxLine++; -} \ No newline at end of file diff --git a/source/fl/util.cpp b/source/fl/util.cpp index de6c264..94a9390 100644 --- a/source/fl/util.cpp +++ b/source/fl/util.cpp @@ -1,4 +1,7 @@ #include +#include "al/collision/CollisionParts.h" +#include "al/collision/KCollisionServer.h" +#include "al/util.hpp" sead::Vector3f fl::QuatToEuler(sead::Quatf *quat) { @@ -39,3 +42,31 @@ void* fl::memcpy (void *dest, const void *src, size_t len) *d++ = *s++; return dest; } + +void fl::fillTri(al::Triangle* tri, const al::CollisionParts &collisionParts, const al::KCPrismData *prismData, const al::KCPrismHeader *prismHeader) { + al::KCollisionServer* collisionServer = collisionParts.mKCollisionServer; + sead::Matrix34f baseMtx = collisionParts.mBaseMtx; + + sead::Vector3f faceNormal = *collisionServer->getFaceNormal(prismData, prismHeader); + tri->mFaceNormal.x = faceNormal.x * baseMtx.m[0][0] + faceNormal.y * baseMtx.m[0][1] + faceNormal.z * baseMtx.m[0][2]; + tri->mFaceNormal.y = faceNormal.x * baseMtx.m[1][0] + faceNormal.y * baseMtx.m[1][1] + faceNormal.z * baseMtx.m[1][2]; + tri->mFaceNormal.z = faceNormal.x * baseMtx.m[2][0] + faceNormal.y * baseMtx.m[2][1] + faceNormal.z * baseMtx.m[2][2]; + al::normalize(&tri->mFaceNormal); + + sead::Vector3f verts[3]; + collisionServer->calcPosLocal(verts, prismData, 0, prismHeader); + collisionServer->calcPosLocal(verts + 1, prismData, 1, prismHeader); + collisionServer->calcPosLocal(verts + 2, prismData, 2, prismHeader); + + tri->mVerts[0].x = verts[0].x * baseMtx.m[0][0] + verts[0].y * baseMtx.m[0][1] + verts[0].z * baseMtx.m[0][2]; + tri->mVerts[0].y = verts[0].x * baseMtx.m[1][0] + verts[0].y * baseMtx.m[1][1] + verts[0].z * baseMtx.m[1][2]; + tri->mVerts[0].z = verts[0].x * baseMtx.m[2][0] + verts[0].y * baseMtx.m[2][1] + verts[0].z * baseMtx.m[2][2]; + + tri->mVerts[1].x = verts[1].x * baseMtx.m[0][0] + verts[1].y * baseMtx.m[0][1] + verts[1].z * baseMtx.m[0][2]; + tri->mVerts[1].y = verts[1].x * baseMtx.m[1][0] + verts[1].y * baseMtx.m[1][1] + verts[1].z * baseMtx.m[1][2]; + tri->mVerts[1].z = verts[1].x * baseMtx.m[2][0] + verts[1].y * baseMtx.m[2][1] + verts[1].z * baseMtx.m[2][2]; + + tri->mVerts[2].x = verts[2].x * baseMtx.m[0][0] + verts[2].y * baseMtx.m[0][1] + verts[2].z * baseMtx.m[0][2]; + tri->mVerts[2].y = verts[2].x * baseMtx.m[1][0] + verts[2].y * baseMtx.m[1][1] + verts[2].z * baseMtx.m[1][2]; + tri->mVerts[2].z = verts[2].x * baseMtx.m[2][0] + verts[2].y * baseMtx.m[2][1] + verts[2].z * baseMtx.m[2][2]; +} diff --git a/source/main.cpp b/source/main.cpp index 96ce58a..990915c 100644 --- a/source/main.cpp +++ b/source/main.cpp @@ -1,14 +1,64 @@ #include "al/input/JoyPadAccelPoseAnalyzer.h" #include "al/util.hpp" -#include "fl/input.h" +#include "game/Layouts/CommonVerticalList.h" +#include "al/layout/RollParts.h" #include "fl/tas.h" #include "game/Layouts/MapLayout.h" +#include "game/Layouts/ShineListLayout.h" #include "rs/util.hpp" #include "sead/math/seadVector.h" #include #include #include #include +#include +#include "game/Player/PlayerJointControlKeeper.h" +#include "game/Actors/Megane.h" +#include "al/execute/ExecuteTableHolder.h" + +#include + +int pipeRandomness(int param) { + // not overridden, as no randomness + if(param == 0 || param == 1) return al::getRandom(param); + if(fl::ui::PracticeUI::instance().options.pipeMazeOverride) { + if(param == 2) return fl::ui::PracticeUI::instance().options.pipeMazeConfig[0]; + if(param == 3) return fl::ui::PracticeUI::instance().options.pipeMazeConfig[1]; + if(param == 5) return fl::ui::PracticeUI::instance().options.pipeMazeConfig[2]; + + smo::Server::instance().log("Unhandled pipeRandomness with param %d! Defaulting to 0.\n", param); + return 0; + } + return al::getRandom(param); +} + +void sequenceDrawHook(al::Sequence* sequence) +{ + bool shouldRender = fl::ui::PracticeUI::instance().options.shouldRender; + if(shouldRender) + sequence->drawMain(); +} + +void tasDrawKitHook(const al::Scene* scene, const char* kitName) { + fl::TasHolder::instance().update(); + + al::drawKit(scene, kitName); +} + +bool bgmStartSoundHook(nn::atk::SoundStartable* self, nn::atk::SoundHandle* a1, const char* a2, const nn::atk::SoundStartable::StartInfo* a3) { + if (fl::ui::PracticeUI::instance().options.muteBgm) + return false; + return self->StartSound(a1, a2, a3); +} + +int koopaHatRandomizerHook(int a1, int a2, int level, int* arr, int arrLength) { + int val = ((int(*)(int,int,int,int*,int)) uintptr_t(fl::__module_start__) + 0x000A34E4)(a1, a2, level, arr, arrLength); + return fl::ui::PracticeUI::instance().options.overrideBowserHat0 ? 0 : val; +} + +int koopaHatRandomHook(int param) { + return fl::ui::PracticeUI::instance().options.overrideBowserHat0 ? param-1 : al::getRandom(param); +} void stageSceneControlHook() { @@ -24,11 +74,61 @@ void stageSceneControlHook() : [input] "=r"(stageScene)); } +void stageSceneKillHook() { + fl::ui::PracticeUI& ui = fl::ui::PracticeUI::instance(); + ui.kill(); + fl::TasHolder::instance().onStageKill(); + + __asm("MOV X0, X19"); +} + void setGotShineVar(GameDataHolderWriter writer, const ShineInfo* shineInfo) { fl::ui::PracticeUI& ui = fl::ui::PracticeUI::instance(); - if (!ui.shineRefresh) - writer.mGameDataFile->setGotShine(shineInfo); + if (!ui.options.shineRefresh) + writer.mPlayingFile->setGotShine(shineInfo); +} + +void setPlayerJointUpdate(PlayerJointControlKeeper* keeper) +{ + fl::ui::PracticeUI& ui = fl::ui::PracticeUI::instance(); + // if (!ui.options.gravityChanged) + keeper->update(); +} + + +void executeTableHolderDrawCtor(al::ExecuteTableHolderDraw* table) { + table->debug_Enabled = true; + // __asm("STR X23, [X0, #0x88]"); + // memset(&table->mListAll, 0, 0x68); + __asm("ADD X0, X0, #0x18"); +} + +void executeTableHolderDrawExecute(al::ExecuteTableHolderDraw* table) { + if (table->arr1.size() <= 0 || !table->debug_Enabled) return; + int idx = 0; + while (idx < table->arr1.size()) { + table->arr1[idx]->executeList(); + idx++; + } +} + +void shineListLayoutListHook(ShineListLayout* lyt) { + if (al::isFirstStep(lyt)) + al::startAction(lyt, "Wait", nullptr); + + if (lyt->mRollParts->isJustChangeRoll()) { + lyt->mWorldIdx = lyt->mRollParts->iVar1; + lyt->updateWorldInfo(); + } + + lyt->mTopIndices[lyt->getSelectedWorldId()] = lyt->mVerticalList->mTopIdx; + lyt->mCursorIndices[lyt->getSelectedWorldId()] = lyt->mVerticalList->mCursorIdx; + + int input = lyt->mInput; + if (input < 3) { + + } } int fgetPadAccelerationDeviceNum(int port) @@ -38,27 +138,27 @@ int fgetPadAccelerationDeviceNum(int port) bool isGotShineVar(GameDataHolderAccessor accessor, const ShineInfo* shineInfo) { - return fl::ui::PracticeUI::instance().gotShineRefresh ? false : accessor.mGameDataFile->isGotShine(shineInfo); + return fl::ui::PracticeUI::instance().options.gotShineRefresh ? false : accessor.mPlayingFile->isGotShine(shineInfo); } bool isEnableCheckpointWarpVar(MapLayout* layout) { - return fl::ui::PracticeUI::instance().alwaysWarp ? true : layout->isEnableCheckpointWarp(); + return fl::ui::PracticeUI::instance().options.alwaysWarp ? true : layout->isEnableCheckpointWarp(); } bool isEnableSaveVar(StageScene* stageScene) { - return fl::ui::PracticeUI::instance().disableAutoSave ? false : stageScene->isEnableSave(); + return fl::ui::PracticeUI::instance().options.disableAutoSave ? false : stageScene->isEnableSave(); } bool isDefeatKoopaLv1Var(StageScene* stageScene) { #if SMOVER == 100 - return fl::ui::PracticeUI::instance().skipBowser ? true : stageScene->isDefeatKoopaLv1(); + return fl::ui::PracticeUI::instance().options.skipBowser ? true : stageScene->isDefeatKoopaLv1(); #endif #if SMOVER == 130 static int functionCalls = 0; - if (!fl::ui::PracticeUI::instance().skipBowser) { + if (!fl::ui::PracticeUI::instance().options.skipBowser) { functionCalls = 0; return stageScene->isDefeatKoopaLv1(); } @@ -78,6 +178,88 @@ bool isDefeatKoopaLv1Var(StageScene* stageScene) #endif } +bool isTriggerRollingRestartSwingVar(PlayerInput* playerInput) { + return fl::ui::PracticeUI::instance().options.buttonMotionRoll ? true : playerInput->isTriggerRollingRestartSwing(); +} + +void setLoadDataSelectingCurrentVar() { + __asm ("LDR W20, [X8, #0x3C]"); + + GameDataHolder* holder; + __asm ("MOV %[result], X0" : [result] "=r" (holder)); + + s32 fileId = fl::ui::PracticeUI::instance().options.loadCurrentFile ? 5 : holder->getPlayingFileId(); + + __asm ("MOV X0, %[input]" : [input] "=r" (fileId)); +} + +void setLoadDataSelectingConfirmVar() { + if (fl::ui::PracticeUI::instance().options.loadFileConfirm) + __asm ("ADD X9, X8, #0x78"); + else + __asm ("ADD X9, X8, #0x70"); +} + +void setRepeatCapBounceVar() { + if (fl::ui::PracticeUI::instance().options.repeatCapBounce) + __asm ("MOV W8, #1"); + else + __asm ("LDRB W8, [X8, #0x38]"); +} + +void setRepeatRainbowSpinVar() { + if (fl::ui::PracticeUI::instance().options.repeatRainbowSpin) + __asm ("MOV W8, #1"); + else + __asm ("LDRB W8, [X8, #0x39]"); +} + +void setWallJumpCapBounceVar() { + if (fl::ui::PracticeUI::instance().options.wallJumpCapBounce) + __asm ("MOV W8, WZR"); + else + __asm ("LDRB W8, [X8]"); +} + +void setDamageVar(PlayerHitPointData* hitPointData) { + fl::ui::PracticeUI& ui = fl::ui::PracticeUI::instance(); + if (!ui.options.noDamageLife) + hitPointData->damage(); +} + +int findUnlockShineNumVar(GameDataHolder* holder, bool* param_1, int param_2) { + fl::ui::PracticeUI& ui = fl::ui::PracticeUI::instance(); + if (ui.options.disableShineNumUnlock) { + return 0; + } + return holder->findUnlockShineNum(param_1, param_2); +} + +void nerveKeeperUpdateVar() { + // __asm ("LDR W8, [X18, #0x18]"); + al::NerveKeeper* nerveKeeper; + __asm ("MOV %[result], X19" : [result] "=r" (nerveKeeper)); + + nerveKeeper->mStep++; + + __asm ("MOV X19, %[input]" : [input] "=r" (nerveKeeper)); +} + +bool setPlayerEnableToSeeOddSpaceVar(al::LiveActor const* actor) { + fl::ui::PracticeUI& ui = fl::ui::PracticeUI::instance(); + if (ui.options.showOddSpace) + return true; + + PlayerActorHakoniwa* player = al::getPlayerActor(actor, 0); + if(!player) return false; + PlayerHackKeeper* hackKeeper = player->getPlayerHackKeeper(); + if (!hackKeeper || !al::isEqualString(hackKeeper->getCurrentHackName(), "Megane")) + return false; + + Megane* megane = static_cast(hackKeeper->mCurrentHackActor); + return megane->isWearingGlasses(); +} + bool isTriggerSnapShotModeVar(const al::IUseSceneObjHolder* objHolder) { return showMenu || fl::TasHolder::instance().isRunning ? false : rs::isTriggerSnapShotMode(objHolder); @@ -90,40 +272,38 @@ bool isTriggerAmiiboModeVar(const al::IUseSceneObjHolder* objHolder) bool fisModeDiverOrJungleGymRom() { - return fl::ui::PracticeUI::instance().isModeDiverOrJungleGymRom; + return fl::ui::PracticeUI::instance().modes.isModeDiverOrJungleGymRom; } bool fisModeDiverRom() { - return fl::ui::PracticeUI::instance().isModeDiverRom; + return fl::ui::PracticeUI::instance().modes.isModeDiverRom; } bool fisModeJungleGymRom() { - return fl::ui::PracticeUI::instance().isModeJungleGymRom; + return fl::ui::PracticeUI::instance().modes.isModeJungleGymRom; } bool fisModeE3LiveRom() { - return fl::ui::PracticeUI::instance().isModeE3LiveRom; + return fl::ui::PracticeUI::instance().modes.isModeE3LiveRom; } bool fisModeE3MovieRom() { - return fl::ui::PracticeUI::instance().isModeE3MovieRom; + return fl::ui::PracticeUI::instance().modes.isModeE3MovieRom; } bool fisModeEpdMovieRom() { - return fl::ui::PracticeUI::instance().isModeEpdMovieRom; + return fl::ui::PracticeUI::instance().modes.isModeEpdMovieRom; } -#if SMOVER == 100 bool fisPadTriggerLMotion(int port) { return fl::TasHolder::instance().isRunning ? false : al::isPadTriggerL(port); } -#endif void motionUpdate(al::JoyPadAccelPoseAnalyzer* dis) { @@ -139,7 +319,7 @@ void motionUpdate(al::JoyPadAccelPoseAnalyzer* dis) controllerPort = al::getPlayerControllerPort(dis->mControllerPort); dis->mAccelDeviceNum = al::getPadAccelerationDeviceNum(controllerPort); - if (fisPadTriggerL(controllerPort)) { + if (al::isPadTriggerL(controllerPort)) { if (h.oldMotion) { dis->mSwingLeft = false; dis->mSwingRight = true; @@ -148,7 +328,7 @@ void motionUpdate(al::JoyPadAccelPoseAnalyzer* dis) dis->mAccelRightVel = { 0.0f, 1.0f }; dis->mHistoryRight.hist0 = 1.4f; dis->mHistoryRight.hist1 = -0.5f; - } else if (fisPadTriggerUp(controllerPort)) { + } else if (al::isPadTriggerUp(controllerPort)) { dis->mSwingLeft = false; dis->mSwingRight = true; dis->mSwingAny = true; @@ -156,7 +336,7 @@ void motionUpdate(al::JoyPadAccelPoseAnalyzer* dis) dis->mAccelRightVel = { 0.0f, 1.0f }; dis->mHistoryRight.hist0 = 1.4f; dis->mHistoryRight.hist1 = -0.5f; - } else if (fisPadTriggerDown(controllerPort)) { + } else if (al::isPadTriggerDown(controllerPort)) { dis->mSwingLeft = false; dis->mSwingRight = true; dis->mSwingAny = true; @@ -164,7 +344,7 @@ void motionUpdate(al::JoyPadAccelPoseAnalyzer* dis) dis->mAccelRightVel = { 0.0f, -1.0f }; dis->mHistoryRight.hist0 = 1.4f; dis->mHistoryRight.hist1 = -0.5f; - } else if (fisPadTriggerLeft(controllerPort)) { + } else if (al::isPadTriggerLeft(controllerPort)) { dis->mSwingRight = false; dis->mSwingLeft = true; dis->mSwingAny = true; @@ -172,7 +352,7 @@ void motionUpdate(al::JoyPadAccelPoseAnalyzer* dis) dis->mAccelLeftVel = { -1.0f, 0.0f }; dis->mHistoryLeft.hist0 = 1.4f; dis->mHistoryLeft.hist1 = -0.5f; - } else if (fisPadTriggerRight(controllerPort)) { + } else if (al::isPadTriggerRight(controllerPort)) { dis->mSwingRight = true; dis->mSwingLeft = false; dis->mSwingAny = true; @@ -190,7 +370,7 @@ void motionUpdate(al::JoyPadAccelPoseAnalyzer* dis) dis->mHistoryRight.hist1 = -0.5f; } } else { - if (fisPadTriggerUp(controllerPort)) { + if (al::isPadTriggerUp(controllerPort)) { dis->mSwingLeft = true; dis->mSwingRight = true; dis->mSwingAny = true; @@ -203,7 +383,7 @@ void motionUpdate(al::JoyPadAccelPoseAnalyzer* dis) dis->mHistoryRight.hist0 = 1.4f; dis->mHistoryLeft.hist1 = -0.5f; dis->mHistoryRight.hist1 = -0.5f; - } else if (fisPadTriggerLeft(controllerPort)) { + } else if (al::isPadTriggerLeft(controllerPort)) { dis->mSwingLeft = true; dis->mSwingRight = true; dis->mSwingAny = true; @@ -216,7 +396,7 @@ void motionUpdate(al::JoyPadAccelPoseAnalyzer* dis) dis->mHistoryRight.hist0 = 1.4f; dis->mHistoryLeft.hist1 = -0.5f; dis->mHistoryRight.hist1 = -0.5f; - } else if (fisPadTriggerRight(controllerPort)) { + } else if (al::isPadTriggerRight(controllerPort)) { dis->mSwingLeft = true; dis->mSwingRight = true; dis->mSwingAny = true; @@ -229,7 +409,7 @@ void motionUpdate(al::JoyPadAccelPoseAnalyzer* dis) dis->mHistoryRight.hist0 = 1.4f; dis->mHistoryLeft.hist1 = -0.5f; dis->mHistoryRight.hist1 = -0.5f; - } else if (fisPadTriggerDown(controllerPort)) { + } else if (al::isPadTriggerDown(controllerPort)) { dis->mSwingLeft = true; dis->mSwingRight = true; dis->mSwingAny = true; @@ -271,8 +451,8 @@ bool isPatternReverse() int getMofumofuTarget(int a) { fl::ui::PracticeUI& ui = fl::ui::PracticeUI::instance(); - bool r = al::getRandom(a); + int r = al::getRandom(a); if (ui.curPattern != fl::ui::PracticeUI::Random) r = ui.mPatternEntries[ui.curPattern].target; return r; -} \ No newline at end of file +} diff --git a/source/seadVector.cpp b/source/seadVector.cpp new file mode 100644 index 0000000..3a7b99d --- /dev/null +++ b/source/seadVector.cpp @@ -0,0 +1,8 @@ +#include "sead/math/seadVector.h" + +namespace sead { + +template <> +const Vector3 Vector3::zero = {0,0,0}; + +}