ihateninjas/OdysseyDecomp
1
0
Fork 0
mirror of https://github.com/MonsterDruide1/OdysseyDecomp synced 2026-04-23 09:04:21 +00:00
Code Issues Actions 17 Packages Projects Releases Wiki Activity

lint: struct members as noPrefixCamelCase (#417)

Browse source
This commit is contained in:
LynxDev2 2025-03-02 01:26:13 +02:00 committed by GitHub
parent 9fb2083a7a
commit 3096a796c2
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
93 changed files with 551 additions and 545 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
.github/files/rebase-requirement-prs.txt vendored
View file

@ -1,3 +1,4 @@
#260
#337
#366
#417

2
lib/al/Library/Audio/AudioDirector.h
View file

@ -28,7 +28,7 @@ class PlayerHolder;
class AudioDirector : public IUseAreaObj, public HioNode, public IAudioSystemPause {
public:
struct PauseSystemEntry {
const char* mName;
const char* name;
bool _8;
bool _9;
};

2
lib/al/Library/Bgm/BgmKeeper.cpp
View file

@ -27,6 +27,6 @@ void BgmKeeper::update() {}
const char* BgmKeeper::getUserName() const {
if (mBgmUserInfo == nullptr)
return nullptr;
return mBgmUserInfo->mName;
return mBgmUserInfo->name;
}
} // namespace al

12
lib/al/Library/Camera/CameraPoserFlag.cpp
View file

@ -7,16 +7,16 @@ namespace al {
CameraPoserFlag::CameraPoserFlag() = default;
void CameraPoserFlag::load(const ByamlIter& iter) {
tryGetByamlBool(&mIsInvalidChangeSubjective, iter, "IsInvalidChangeSubjective");
tryGetByamlBool(&mIsValidKeepPreSelfPoseNextCameraByParam, iter,
tryGetByamlBool(&isInvalidChangeSubjective, iter, "IsInvalidChangeSubjective");
tryGetByamlBool(&isValidKeepPreSelfPoseNextCameraByParam, iter,
"IsValidKeepPreSelfPoseNextCameraByParam");
tryGetByamlBool(&mIsInvalidKeepPreSelfPoseNextCameraOverWriteProgram, iter,
tryGetByamlBool(&isInvalidKeepPreSelfPoseNextCameraOverWriteProgram, iter,
"IsInvalidKeepPreSelfPoseNextCameraOverWriteProgram");
tryGetByamlBool(&mIsInvalidKeepDistanceNextCamera, iter, "IsInvalidKeepDistanceNextCamera");
tryGetByamlBool(&isInvalidKeepDistanceNextCamera, iter, "IsInvalidKeepDistanceNextCamera");
}
bool CameraPoserFlag::isValidKeepPreSelfPoseNextCamera() const {
return mIsOverWriteProgram ? !mIsInvalidKeepPreSelfPoseNextCameraOverWriteProgram :
mIsValidKeepPreSelfPoseNextCameraByParam;
return isOverWriteProgram ? !isInvalidKeepPreSelfPoseNextCameraOverWriteProgram :
isValidKeepPreSelfPoseNextCameraByParam;
}
} // namespace al

26
lib/al/Library/Camera/CameraPoserFlag.h
View file

@ -12,21 +12,21 @@ struct CameraPoserFlag {
void load(const ByamlIter& iter);
bool isValidKeepPreSelfPoseNextCamera() const;
bool mIsFirstCalc = true;
bool mIsOffVerticalAbsorb = false;
bool mIsInvalidCollider = true;
bool isFirstCalc = true;
bool isOffVerticalAbsorb = false;
bool isInvalidCollider = true;
bool _3 = false;
bool mIsValidKeepPreSelfPoseNextCameraByParam = false;
bool mIsOverWriteProgram = false;
bool mIsInvalidKeepPreSelfPoseNextCameraOverWriteProgram = false;
bool mIsInvalidKeepDistanceNextCamera = false;
bool mIsInvalidKeepDistanceNextCameraIfNoCollide = false;
bool mIsValidCtrlSubjective = false;
bool mIsInvalidChangeSubjective = false;
bool mIsInvalidCameraBlur = false;
bool isValidKeepPreSelfPoseNextCameraByParam = false;
bool isOverWriteProgram = false;
bool isInvalidKeepPreSelfPoseNextCameraOverWriteProgram = false;
bool isInvalidKeepDistanceNextCamera = false;
bool isInvalidKeepDistanceNextCameraIfNoCollide = false;
bool isValidCtrlSubjective = false;
bool isInvalidChangeSubjective = false;
bool isInvalidCameraBlur = false;
bool _c = false;
bool mIsInvalidPreCameraEndAfterInterpole = false;
bool mIsStopUpdateGyro = false;
bool isInvalidPreCameraEndAfterInterpole = false;
bool isStopUpdateGyro = false;
};
static_assert(sizeof(CameraPoserFlag) == 0xF);

14
lib/al/Library/Camera/CameraResourceHolder.cpp
View file

@ -32,18 +32,18 @@ bool CameraResourceHolder::tryInitCameraResource(const Resource* resource, s32 u
getStageName(&stageName, resource->getArchiveName());
for (s32 i = 0; i < mNumEntries; i++)
if (isEqualString(stageName.cstr(), mEntries[i]->mStageName))
if (isEqualString(stageName.cstr(), mEntries[i]->stageName))
return false;
Entry* entry = new Entry;
if (resource->isExistFile(StringTmp<64>{"%s.byml", "CameraParam"}))
entry->mCameraParam = new ByamlIter(resource->getByml("CameraParam"));
entry->cameraParam = new ByamlIter(resource->getByml("CameraParam"));
if (resource->isExistFile(StringTmp<64>{"%s.byml", "InterpoleParam"}))
entry->mInterpoleParam = new ByamlIter(resource->getByml("InterpoleParam"));
entry->interpoleParam = new ByamlIter(resource->getByml("InterpoleParam"));
entry->mStageName = stageName;
entry->stageName = stageName;
mEntries[mNumEntries] = entry;
mNumEntries++;
@ -95,9 +95,9 @@ s32 CameraResourceHolder::calcEntranceCameraParamNum() const {
bool CameraResourceHolder::tryFindCameraParamList(ByamlIter* paramList, const char* stageName,
const char* paramName) const {
CameraResourceHolder::Entry* entry = findCameraResource(stageName);
if (!entry || !entry->mCameraParam)
if (!entry || !entry->cameraParam)
return false;
return entry->mCameraParam->tryGetIterByKey(paramList, paramName);
return entry->cameraParam->tryGetIterByKey(paramList, paramName);
}
void CameraResourceHolder::getEntranceCameraParamResource(ByamlIter* ticket, s32 index) const {
@ -108,7 +108,7 @@ void CameraResourceHolder::getEntranceCameraParamResource(ByamlIter* ticket, s32
CameraResourceHolder::Entry* CameraResourceHolder::findCameraResource(const char* stageName) const {
for (s32 i = 0; i < mNumEntries; i++)
if (isEqualString(stageName, mEntries[i]->mStageName))
if (isEqualString(stageName, mEntries[i]->stageName))
return mEntries[i];
return nullptr;

6
lib/al/Library/Camera/CameraResourceHolder.h
View file

@ -11,9 +11,9 @@ class PlacementId;
class CameraResourceHolder {
public:
struct Entry {
ByamlIter* mCameraParam = nullptr;
ByamlIter* mInterpoleParam = nullptr;
sead::FixedSafeString<128> mStageName = {""};
ByamlIter* cameraParam = nullptr;
ByamlIter* interpoleParam = nullptr;
sead::FixedSafeString<128> stageName = {""};
};
enum ParamType : s32 {

20
lib/al/Library/Camera/CameraShaker.cpp
View file

@ -100,7 +100,7 @@ void CameraShaker::exeWait() {
}
void CameraShaker::exeShake() {
if (isGreaterEqualStep(this, mActiveShake->mSteps)) {
if (isGreaterEqualStep(this, mActiveShake->steps)) {
if (mShakeLoop) {
setNerve(this, &NrvCameraShaker.ShakeLoop);
} else {
@ -111,23 +111,23 @@ void CameraShaker::exeShake() {
return;
}
f32 shakeSpeed = (mActiveShake->mSpeed * 360.0f) / mActiveShake->mSteps;
f32 shakeSpeed = (mActiveShake->speed * 360.0f) / mActiveShake->steps;
f32 currentShakeStrength =
sead::Mathf::cos(sead::Mathf::deg2rad(shakeSpeed * getNerveStep(this)));
f32 shakeOffset =
currentShakeStrength * (mActiveShake->mStrength *
(mActiveShake->mSteps - getNerveStep(this)) / mActiveShake->mSteps);
currentShakeStrength *
(mActiveShake->strength * (mActiveShake->steps - getNerveStep(this)) / mActiveShake->steps);
mOffset = {shakeOffset, shakeOffset};
if (mActiveShake->mDirection == ShakeDirection::Vertical)
if (mActiveShake->direction == ShakeDirection::Vertical)
mOffset.x = 0.0f;
}
void CameraShaker::exeShakeLoop() {
s32 nerveStep = getNerveStep(this);
f32 shakeStep = nerveStep <= 0 ? 0.0f : nerveStep / mShakeLoop->mSpeed * sead::Mathf::pi2();
f32 shakeOffset = mShakeLoop->mStrength * sead::Mathf::cos(shakeStep);
f32 shakeStep = nerveStep <= 0 ? 0.0f : nerveStep / mShakeLoop->speed * sead::Mathf::pi2();
f32 shakeOffset = mShakeLoop->strength * sead::Mathf::cos(shakeStep);
mOffset = {shakeOffset, shakeOffset};
if (mShakeLoop->mDirection == ShakeDirection::Vertical)
if (mShakeLoop->direction == ShakeDirection::Vertical)
mOffset.x = 0.0f;
}
@ -142,9 +142,9 @@ void CameraShaker::startShakeByIndex(s32 index, s32 steps) {
// requires doing this copy to match
// https://decomp.me/scratch/asjPP
ShakeInfo shake2 = shake;
mEditedShake = {shake.mName, steps, shake.mSpeed, shake.mStrength, shake.mDirection};
mEditedShake = {shake.name, steps, shake.speed, shake.strength, shake.direction};
mActiveShake = &mEditedShake;
mEditedShake.mSpeed = ((f32)steps / (f32)shake2.mSteps) * shake.mSpeed;
mEditedShake.speed = ((f32)steps / (f32)shake2.steps) * shake.speed;
}
setNerve(this, &Shake);

32
lib/al/Library/Camera/CameraShaker.h
View file

@ -11,36 +11,36 @@ public:
enum class ShakeDirection : s32 { Both, Vertical };
struct ShakeInfo {
const char* mName = nullptr;
s32 mSteps = 0;
f32 mSpeed = 0.0f;
f32 mStrength = 0.0f;
ShakeDirection mDirection = ShakeDirection::Both;
const char* name = nullptr;
s32 steps = 0;
f32 speed = 0.0f;
f32 strength = 0.0f;
ShakeDirection direction = ShakeDirection::Both;
bool operator>(const ShakeInfo& other) const {
if (mStrength < other.mStrength)
if (strength < other.strength)
return false;
if (other.mStrength < mStrength)
if (other.strength < strength)
return true;
if (other.mSteps > 0 && mSteps < 0)
if (other.steps > 0 && steps < 0)
return false;
if (other.mSteps < 0 && mSteps > 0)
if (other.steps < 0 && steps > 0)
return true;
if (mSteps < other.mSteps)
if (steps < other.steps)
return false;
if (other.mSteps < mSteps)
if (other.steps < steps)
return true;
s32 otherDirection = (s32)other.mDirection;
s32 direction = (s32)mDirection;
if (otherDirection < direction)
s32 otherDirection = (s32)other.direction;
s32 directionCopy = (s32)direction;
if (otherDirection < directionCopy)
return false;
if (direction < otherDirection)
if (directionCopy < otherDirection)
return true;
if (mSpeed < other.mSpeed)
if (speed < other.speed)
return true;
return false;
}

38
lib/al/Library/Camera/CameraStartInfo.h
View file

@ -7,25 +7,25 @@
namespace al {
struct CameraStartInfo {
CameraTicket::Priority mPrePriorityType;
const char* mPreCameraName;
f32 mPreCameraSwingAngleH;
f32 mPreCameraSwingAngleV;
f32 mPreCameraMaxSwingAngleH;
f32 mPreCameraMaxSwingAngleV;
bool mIsInvalidCollidePreCamera;
bool mIsInvalidKeepPreCameraDistance;
bool mIsInvalidKeepPreCameraDistanceIfNoCollide;
bool mIsValidResetPreCameraPose;
bool mIsValidKeepPreSelfCameraPose;
bool mIsGrounded;
bool mIsExistAreaAngleH;
f32 mAreaAngleH;
bool mIsExistAreaAngleV;
f32 mAreaAngleV;
bool mIsExistNextPoseByPreCamera;
f32 mNextAngleHByPreCamera;
f32 mNextAngleVByPreCamera;
CameraTicket::Priority prePriorityType;
const char* preCameraName;
f32 preCameraSwingAngleH;
f32 preCameraSwingAngleV;
f32 preCameraMaxSwingAngleH;
f32 preCameraMaxSwingAngleV;
bool isInvalidCollidePreCamera;
bool isInvalidKeepPreCameraDistance;
bool isInvalidKeepPreCameraDistanceIfNoCollide;
bool isValidResetPreCameraPose;
bool isValidKeepPreSelfCameraPose;
bool isGrounded;
bool isExistAreaAngleH;
f32 areaAngleH;
bool isExistAreaAngleV;
f32 areaAngleV;
bool isExistNextPoseByPreCamera;
f32 nextAngleHByPreCamera;
f32 nextAngleVByPreCamera;
};
static_assert(sizeof(CameraStartInfo) == 0x40);

8
lib/al/Library/Camera/SnapShotCameraCtrl.cpp
View file

@ -9,10 +9,10 @@ void SnapShotCameraCtrl::load(const ByamlIter& iter) {
ByamlIter paramIter;
if (!tryGetByamlIterByKey(&paramIter, iter, "SnapShotParam"))
return;
if (tryGetByamlF32(&param->mMinFovyDegree, paramIter, "MinFovyDegree"))
param->mHasMin = true;
if (tryGetByamlF32(&param->mMaxFovyDegree, paramIter, "MaxFovyDegree"))
param->mHasMax = true;
if (tryGetByamlF32(&param->minFovyDegree, paramIter, "MinFovyDegree"))
param->hasMin = true;
if (tryGetByamlF32(&param->maxFovyDegree, paramIter, "MaxFovyDegree"))
param->hasMax = true;
}
} // namespace al

8
lib/al/Library/Camera/SnapShotCameraCtrl.h
View file

@ -7,10 +7,10 @@
#include "Library/Yaml/ByamlIter.h"
struct CameraParam {
bool mHasMin;
bool mHasMax;
f32 mMinFovyDegree;
f32 mMaxFovyDegree;
bool hasMin;
bool hasMax;
f32 minFovyDegree;
f32 maxFovyDegree;
};
namespace al {

34
lib/al/Library/Collision/KCollisionServer.h
View file

@ -12,29 +12,29 @@ class CollisionParts;
class LiveActor;
struct KCPrismHeader {
u32 mPositionsOffset;
u32 mNormalsOffset;
u32 mTrianglesOffset;
u32 mOctreeOffset;
f32 mThickness;
sead::Vector3f mOctreeOrigin;
sead::Vector3u mWidthMask;
sead::Vector3u mWidthShift;
f32 mHitboxRadiusCap;
u32 positionsOffset;
u32 normalsOffset;
u32 trianglesOffset;
u32 octreeOffset;
f32 thickness;
sead::Vector3f octreeOrigin;
sead::Vector3u widthMask;
sead::Vector3u widthShift;
f32 hitboxRadiusCap;
};
struct KCPrismData {
f32 mLength;
u16 mPosIndex;
u16 mFaceNormalIndex;
u16 mEdgeNormalIndex[3];
u16 mCollisionType;
u32 mTriIndex;
f32 length;
u16 posIndex;
u16 faceNormalIndex;
u16 edgeNormalIndex[3];
u16 collisionType;
u32 triIndex;
};
struct KCHitInfo {
const KCPrismHeader* mHeader;
const KCPrismData* mData;
const KCPrismHeader* header;
const KCPrismData* data;
f32 _16;
u8 _20; // collision location, enum
};

8
lib/al/Library/Controller/PadDataPack.h
View file

@ -5,9 +5,9 @@
namespace al {
struct PadDataPack {
s32 mTrig = 0;
s32 mHold = 0;
sead::Vector2f mLeftStick = sead::Vector2f::zero;
sead::Vector2f mPointer = sead::Vector2f::zero;
s32 trig = 0;
s32 hold = 0;
sead::Vector2f leftStick = sead::Vector2f::zero;
sead::Vector2f pointer = sead::Vector2f::zero;
};
} // namespace al

20
lib/al/Library/Controller/PadRumbleFunction.h
View file

@ -12,21 +12,21 @@ struct PadRumbleParam {
f32 rumblePitchVol = 1.0f, f32 rumblePitchLeft = 1.0f,
f32 rumblePitchRight = 1.0f, s32 _18 = 0, bool isUseController = false,
bool _1d = false)
: mRumbleNear(rumbleNear), mRumbleFar(rumbleFar), mRumbleVolume(rumbleVolume),
mRumblePitchVol(rumblePitchVol), mRumblePitchLeft(rumblePitchLeft),
mRumblePitchRight(rumblePitchRight), field_18(_18), mIsUseController(isUseController),
: rumbleNear(rumbleNear), rumbleFar(rumbleFar), rumbleVolume(rumbleVolume),
rumblePitchVol(rumblePitchVol), rumblePitchLeft(rumblePitchLeft),
rumblePitchRight(rumblePitchRight), field_18(_18), isUseController(isUseController),
field_1d(_1d) {}
void setVolumeByBalance(f32);
f32 mRumbleNear;
f32 mRumbleFar;
f32 mRumbleVolume;
f32 mRumblePitchVol;
f32 mRumblePitchLeft;
f32 mRumblePitchRight;
f32 rumbleNear;
f32 rumbleFar;
f32 rumbleVolume;
f32 rumblePitchVol;
f32 rumblePitchLeft;
f32 rumblePitchRight;
s32 field_18;
bool mIsUseController;
bool isUseController;
bool field_1d;
};

8
lib/al/Library/Execute/ExecuteDirector.cpp
View file

@ -26,8 +26,8 @@ void ExecuteDirector::init(const ExecuteSystemInitInfo& initInfo) {
for (s32 i = 0; i < mUpdateTableCount; ++i) {
mUpdateTables[i] = new ExecuteTableHolderUpdate();
mUpdateTables[i]->init(UpdateTable[i].mName, initInfo, UpdateTable[i].mExecuteOrders,
UpdateTable[i].mExecuteOrderCount);
mUpdateTables[i]->init(UpdateTable[i].name, initInfo, UpdateTable[i].executeOrders,
UpdateTable[i].executeOrderCount);
}
mDrawTableCount = DrawTableSize;
@ -35,8 +35,8 @@ void ExecuteDirector::init(const ExecuteSystemInitInfo& initInfo) {
for (s32 i = 0; i < mDrawTableCount; ++i) {
mDrawTables[i] = new ExecuteTableHolderDraw();
mDrawTables[i]->init(DrawTable[i].mName, initInfo, DrawTable[i].mExecuteOrders,
DrawTable[i].mExecuteOrderCount);
mDrawTables[i]->init(DrawTable[i].name, initInfo, DrawTable[i].executeOrders,
DrawTable[i].executeOrderCount);
}
mRequestKeeper = new ExecuteRequestKeeper(mRequestCount);

8
lib/al/Library/Execute/ExecuteOrder.h
View file

@ -4,10 +4,10 @@
namespace al {
struct ExecuteOrder {
const char* mListName;
const char* mExecuteGroup;
s32 mListMaxSize;
const char* mGroupType;
const char* listName;
const char* executeGroup;
s32 listMaxSize;
const char* groupType;
};
static_assert(sizeof(ExecuteOrder) == 0x20);

2
lib/al/Library/Execute/ExecuteSystemInitInfo.h
View file

@ -8,7 +8,7 @@ namespace al {
struct ExecuteSystemInitInfo {
ExecuteSystemInitInfo();
agl::DrawContext* mDrawCtx;
agl::DrawContext* drawCtx;
};
static_assert(sizeof(ExecuteSystemInitInfo) == 0x8);

6
lib/al/Library/Execute/ExecuteTable.h
View file

@ -6,9 +6,9 @@ namespace al {
struct ExecuteOrder;
struct ExecuteTable {
const char* mName = nullptr;
const ExecuteOrder* mExecuteOrders = nullptr;
s32 mExecuteOrderCount = 0;
const char* name = nullptr;
const ExecuteOrder* executeOrders = nullptr;
s32 executeOrderCount = 0;
};
static_assert(sizeof(ExecuteTable) == 0x18);

18
lib/al/Library/Execute/ExecuteTablesImpl.h
View file

@ -385,7 +385,7 @@ constexpr bool strings_equal(const char* a, const char* b) {
static constexpr s32 getUpdateTableIndex(const char* listName) {
for (u64 i = 0; i < sizeof(updateTableArr) / sizeof(updateTableArr[0]); i++)
if (strings_equal(updateTableArr[i].mListName, listName))
if (strings_equal(updateTableArr[i].listName, listName))
return i;
return 0;
}
@ -393,17 +393,17 @@ static constexpr s32 getUpdateTableIndex(const char* listName) {
static constexpr al::ExecuteTable
createUpdateTable(const char* tableName, const char* startListName, const char* endListName) {
al::ExecuteTable drawTable;
drawTable.mName = tableName;
drawTable.name = tableName;
s32 startIndex = getUpdateTableIndex(startListName);
drawTable.mExecuteOrders = &updateTableArr[startIndex];
drawTable.mExecuteOrderCount = (getUpdateTableIndex(endListName) - startIndex) + 1;
drawTable.executeOrders = &updateTableArr[startIndex];
drawTable.executeOrderCount = (getUpdateTableIndex(endListName) - startIndex) + 1;
return drawTable;
}
static constexpr s32 getDrawTableIndex(const char* listName, const char* groupName) {
for (u64 i = 0; i < sizeof(drawTableArr) / sizeof(drawTableArr[0]); i++)
if (strings_equal(drawTableArr[i].mListName, listName) &&
strings_equal(drawTableArr[i].mExecuteGroup, groupName))
if (strings_equal(drawTableArr[i].listName, listName) &&
strings_equal(drawTableArr[i].executeGroup, groupName))
return i;
return 0;
}
@ -413,10 +413,10 @@ static constexpr al::ExecuteTable createDrawTable(const char* tableName, const c
const char* endListName,
const char* groupEndName) {
al::ExecuteTable drawTable;
drawTable.mName = tableName;
drawTable.name = tableName;
s32 startIndex = getDrawTableIndex(startListName, groupStartName);
drawTable.mExecuteOrders = &drawTableArr[startIndex];
drawTable.mExecuteOrderCount = (getDrawTableIndex(endListName, groupEndName) - startIndex) + 1;
drawTable.executeOrders = &drawTableArr[startIndex];
drawTable.executeOrderCount = (getDrawTableIndex(endListName, groupEndName) - startIndex) + 1;
return drawTable;
}

40
lib/al/Library/LiveActor/ActorInitInfo.cpp
View file

@ -22,35 +22,35 @@ void ActorInitInfo::initNew(
StageSwitchDirector* stageSwitchDirector, ModelGroup* modelGroup,
GraphicsSystemInfo* graphicsSystemInfo, ModelDrawBufferCounter* modelDrawBufferCounter,
LiveActorGroup* kitDrawingGroup) {
mActorSceneInfo.mModelDrawBufferCounter = modelDrawBufferCounter;
mActorSceneInfo.modelDrawBufferCounter = modelDrawBufferCounter;
mAllActorsGroup = allActorsGroup;
mActorFactory = actorFactory;
mActorResourceHolder = actorResourceHolder;
mEffectSystemInfo = effectSystemInfo;
mExecuteDirector = executeDirector;
mLayoutInitInfo = layoutInitInfo;
mActorSceneInfo.mAreaObjDirector = areaObjDirector;
mActorSceneInfo.areaObjDirector = areaObjDirector;
mHitSensorDirector = hitSensorDirector;
mStageSwitchDirector = stageSwitchDirector;
mScreenPointDirector = screenPointDirector;
mActorSceneInfo.mCameraDirector = cameraDirector;
mActorSceneInfo.mClippingDirector = clippingDirector;
mActorSceneInfo.mGameDataHolder = gameDataHolder;
mActorSceneInfo.mGravityHolder = gravityHolder;
mActorSceneInfo.mCollisionDirector = collisionDirector;
mActorSceneInfo.mDemoDirector = demoDirector;
mActorSceneInfo.mItemDirector = itemDirector;
mActorSceneInfo.mNatureDirector = natureDirector;
mActorSceneInfo.mGamePadSystem = gamePadSystem;
mActorSceneInfo.mPadRumbleDirector = padRumbleDirector;
mActorSceneInfo.mPlayerHolder = playerHolder;
mActorSceneInfo.mSceneObjHolder = sceneObjHolder;
mActorSceneInfo.mSceneStopCtrl = sceneStopCtrl;
mActorSceneInfo.mSceneMsgCtrl = sceneMsgCtrl;
mActorSceneInfo.mScreenCoverCtrl = screenCoverCtrl;
mActorSceneInfo.mShadowDirector = shadowDirector;
mActorSceneInfo.mModelGroup = modelGroup;
mActorSceneInfo.mGraphicsSystemInfo = graphicsSystemInfo;
mActorSceneInfo.cameraDirector = cameraDirector;
mActorSceneInfo.clippingDirector = clippingDirector;
mActorSceneInfo.gameDataHolder = gameDataHolder;
mActorSceneInfo.gravityHolder = gravityHolder;
mActorSceneInfo.collisionDirector = collisionDirector;
mActorSceneInfo.demoDirector = demoDirector;
mActorSceneInfo.itemDirector = itemDirector;
mActorSceneInfo.natureDirector = natureDirector;
mActorSceneInfo.gamePadSystem = gamePadSystem;
mActorSceneInfo.padRumbleDirector = padRumbleDirector;
mActorSceneInfo.playerHolder = playerHolder;
mActorSceneInfo.sceneObjHolder = sceneObjHolder;
mActorSceneInfo.sceneStopCtrl = sceneStopCtrl;
mActorSceneInfo.sceneMsgCtrl = sceneMsgCtrl;
mActorSceneInfo.screenCoverCtrl = screenCoverCtrl;
mActorSceneInfo.shadowDirector = shadowDirector;
mActorSceneInfo.modelGroup = modelGroup;
mActorSceneInfo.graphicsSystemInfo = graphicsSystemInfo;
mKitDrawingGroup = kitDrawingGroup;
mAudioDirector = audioDirector;
mPlacementInfo = placementInfo;

12
lib/al/Library/LiveActor/ActorSceneFunction.cpp
View file

@ -10,11 +10,11 @@ namespace al {
ActorSceneInfo::ActorSceneInfo() = default;
void stopScene(const LiveActor* actor, s32 stopFrames, s32 delayFrames) {
stopScene(actor->getSceneInfo()->mSceneStopCtrl, stopFrames, delayFrames);
stopScene(actor->getSceneInfo()->sceneStopCtrl, stopFrames, delayFrames);
}
bool isStopScene(const LiveActor* actor) {
return isStopScene(actor->getSceneInfo()->mSceneStopCtrl);
return isStopScene(actor->getSceneInfo()->sceneStopCtrl);
}
void stopScene(SceneStopCtrl* ctrl, s32 stopFrames, s32 delayFrames) {
@ -26,19 +26,19 @@ bool isStopScene(SceneStopCtrl* ctrl) {
}
void requestCaptureScreenCover(const LiveActor* actor, s32 coverFrames) {
actor->getSceneInfo()->mScreenCoverCtrl->requestCaptureScreenCover(coverFrames);
actor->getSceneInfo()->screenCoverCtrl->requestCaptureScreenCover(coverFrames);
}
bool requestStartDemo(const LiveActor* actor, const char* name) {
return actor->getSceneInfo()->mDemoDirector->requestStartDemo(name);
return actor->getSceneInfo()->demoDirector->requestStartDemo(name);
}
void requestEndDemo(const LiveActor* actor, const char* name) {
actor->getSceneInfo()->mDemoDirector->requestEndDemo(name);
actor->getSceneInfo()->demoDirector->requestEndDemo(name);
}
void addDemoActor(LiveActor* actor) {
actor->getSceneInfo()->mDemoDirector->addDemoActor(actor);
actor->getSceneInfo()->demoDirector->addDemoActor(actor);
}
} // namespace al

40
lib/al/Library/LiveActor/ActorSceneInfo.h
View file

@ -25,25 +25,25 @@ class ModelDrawBufferCounter;
struct ActorSceneInfo {
ActorSceneInfo();
AreaObjDirector* mAreaObjDirector = nullptr;
CameraDirector* mCameraDirector = nullptr;
ClippingDirector* mClippingDirector = nullptr;
CollisionDirector* mCollisionDirector = nullptr;
DemoDirector* mDemoDirector = nullptr;
GameDataHolderBase* mGameDataHolder = nullptr;
GravityHolder* mGravityHolder = nullptr;
ItemDirectorBase* mItemDirector = nullptr;
NatureDirector* mNatureDirector = nullptr;
const GamePadSystem* mGamePadSystem = nullptr;
PadRumbleDirector* mPadRumbleDirector = nullptr;
PlayerHolder* mPlayerHolder = nullptr;
SceneObjHolder* mSceneObjHolder = nullptr;
SceneStopCtrl* mSceneStopCtrl = nullptr;
SceneMsgCtrl* mSceneMsgCtrl = nullptr;
ScreenCoverCtrl* mScreenCoverCtrl = nullptr;
ShadowDirector* mShadowDirector = nullptr;
ModelGroup* mModelGroup = nullptr;
GraphicsSystemInfo* mGraphicsSystemInfo = nullptr;
ModelDrawBufferCounter* mModelDrawBufferCounter = nullptr;
AreaObjDirector* areaObjDirector = nullptr;
CameraDirector* cameraDirector = nullptr;
ClippingDirector* clippingDirector = nullptr;
CollisionDirector* collisionDirector = nullptr;
DemoDirector* demoDirector = nullptr;
GameDataHolderBase* gameDataHolder = nullptr;
GravityHolder* gravityHolder = nullptr;
ItemDirectorBase* itemDirector = nullptr;
NatureDirector* natureDirector = nullptr;
const GamePadSystem* gamePadSystem = nullptr;
PadRumbleDirector* padRumbleDirector = nullptr;
PlayerHolder* playerHolder = nullptr;
SceneObjHolder* sceneObjHolder = nullptr;
SceneStopCtrl* sceneStopCtrl = nullptr;
SceneMsgCtrl* sceneMsgCtrl = nullptr;
ScreenCoverCtrl* screenCoverCtrl = nullptr;
ShadowDirector* shadowDirector = nullptr;
ModelGroup* modelGroup = nullptr;
GraphicsSystemInfo* graphicsSystemInfo = nullptr;
ModelDrawBufferCounter* modelDrawBufferCounter = nullptr;
};
} // namespace al

54
lib/al/Library/LiveActor/HitReactionKeeper.h
View file

@ -19,33 +19,33 @@ class SeHitReactionInfo;
struct HitReactionInfo {
HitReactionInfo();
const char* mReactionName;
EffectHitReactionInfo* mEffectInfo;
SeHitReactionInfo* mSeInfo;
const char* mPadRumbleType;
f32 mPadRumbleDistance;
const char* mPadRumbleName;
const char* mPadWaveRumbleName;
f32 mPadWaveRumbleNearDistance;
f32 mPadWaveRumbleFarDistance;
f32 mPadWaveRumbleVolumeBalance;
bool mPadWaveRumbleIsUseDemo;
s32 mCameraShakeViewIndex;
const char* mCameraShakeType;
f32 mCameraShakeDistance;
const char* mCameraShakeName;
s32 mCameraShakeStep;
s32 mStopSceneFrame;
bool mIsStopSceneForHitEffect;
s32 mRadialBlurFrame;
f32 mRadialBlurRadiusBegin;
f32 mRadialBlurRadiusEnd;
f32 mRadialBlurStrengthBegin;
f32 mRadialBlurStrengthEnd;
f32 mRadialBlurAlphaBegin;
f32 mRadialBlurAlphaEnd;
bool mRadialBlurScreenSpace;
sead::Vector2f mRadialBlurScreenPos;
const char* reactionName;
EffectHitReactionInfo* effectInfo;
SeHitReactionInfo* seInfo;
const char* padRumbleType;
f32 padRumbleDistance;
const char* padRumbleName;
const char* padWaveRumbleName;
f32 padWaveRumbleNearDistance;
f32 padWaveRumbleFarDistance;
f32 padWaveRumbleVolumeBalance;
bool padWaveRumbleIsUseDemo;
s32 cameraShakeViewIndex;
const char* cameraShakeType;
f32 cameraShakeDistance;
const char* cameraShakeName;
s32 cameraShakeStep;
s32 stopSceneFrame;
bool isStopSceneForHitEffect;
s32 radialBlurFrame;
f32 radialBlurRadiusBegin;
f32 radialBlurRadiusEnd;
f32 radialBlurStrengthBegin;
f32 radialBlurStrengthEnd;
f32 radialBlurAlphaBegin;
f32 radialBlurAlphaEnd;
bool radialBlurScreenSpace;
sead::Vector2f radialBlurScreenPos;
};
class HitReactionKeeper {

8
lib/al/Library/LiveActor/LiveActor.cpp
View file

@ -31,19 +31,19 @@ const char* LiveActor::getName() const {
}
CollisionDirector* LiveActor::getCollisionDirector() const {
return mSceneInfo->mCollisionDirector;
return mSceneInfo->collisionDirector;
}
AreaObjDirector* LiveActor::getAreaObjDirector() const {
return mSceneInfo->mAreaObjDirector;
return mSceneInfo->areaObjDirector;
}
CameraDirector* LiveActor::getCameraDirector() const {
return mSceneInfo->mCameraDirector;
return mSceneInfo->cameraDirector;
}
SceneObjHolder* LiveActor::getSceneObjHolder() const {
return mSceneInfo->mSceneObjHolder;
return mSceneInfo->sceneObjHolder;
}
EffectKeeper* LiveActor::getEffectKeeper() const {

2
lib/al/Library/LiveActor/LiveActorKit.cpp
View file

@ -81,7 +81,7 @@ void LiveActorKit::init(s32 maxCameras) {
ExecuteSystemInitInfo info{};
mExecuteDirector = new ExecuteDirector(mMaxActors);
info.mDrawCtx = mSceneDrawContext;
info.drawCtx = mSceneDrawContext;
mExecuteDirector->init(info);
mModelDrawBufferUpdater = new ModelDrawBufferUpdater(mExecuteDirector);

54
lib/al/Library/LiveActor/SubActorKeeper.cpp
View file

@ -97,18 +97,18 @@ void SubActorKeeper::init(const ActorInitInfo& initInfo, const char* suffix, s32
bool isSyncAppear = false;
bool isGotSyncAppear = tryGetByamlBool(&isSyncAppear, subActorIter, "IsSyncAppear");
if (isSyncAppear)
actorInfo->mSyncType |= SubActorSync::cAppear;
actorInfo->syncType |= SubActorSync::cAppear;
bool isSyncHide = false;
bool isGotSyncHide = tryGetByamlBool(&isSyncHide, subActorIter, "IsSyncHide");
if (isSyncHide)
actorInfo->mSyncType |= SubActorSync::cHide;
actorInfo->syncType |= SubActorSync::cHide;
if (tryGetByamlKeyBoolOrFalse(subActorIter, "IsSyncAlphaMask"))
actorInfo->mSyncType |= SubActorSync::cAlphaMask;
actorInfo->syncType |= SubActorSync::cAlphaMask;
if (tryGetByamlKeyBoolOrFalse(subActorIter, "IsSyncClipping"))
actorInfo->mSyncType |= SubActorSync::cClipping;
actorInfo->syncType |= SubActorSync::cClipping;
bool isCalcDepthShadowLength = true;
tryGetByamlBool(&isCalcDepthShadowLength, subActorIter, "IsCalcDepthShadowLength");
@ -120,17 +120,17 @@ void SubActorKeeper::init(const ActorInitInfo& initInfo, const char* suffix, s32
PartsModel* partsModel = new PartsModel(actorObjectName);
partsModel->initPartsFixFileNoRegister(mRootActor, initInfo, actorModelName,
actorSuffix, actorFixFileSuffixName);
actorInfo->mSubActor = partsModel;
actorInfo->subActor = partsModel;
actorInfo->mSyncType =
(!isGotSyncAppear ? actorInfo->mSyncType | SubActorSync::cAppear :
actorInfo->mSyncType) |
actorInfo->syncType =
(!isGotSyncAppear ? actorInfo->syncType | SubActorSync::cAppear :
actorInfo->syncType) |
SubActorSync::cClipping;
if (isExistModel(partsModel)) {
actorInfo->mSyncType =
(!isGotSyncHide ? actorInfo->mSyncType | SubActorSync::cHide :
actorInfo->mSyncType) |
actorInfo->syncType =
(!isGotSyncHide ? actorInfo->syncType | SubActorSync::cHide :
actorInfo->syncType) |
SubActorSync::cAlphaMask;
}
} else if (isEqualString(actorClassName, "BreakModel")) {
@ -148,18 +148,18 @@ void SubActorKeeper::init(const ActorInitInfo& initInfo, const char* suffix, s32
jointMtxPtr, actionName);
initCreateActorNoPlacementInfo(breakModel, initInfo);
actorInfo->mSubActor = breakModel;
actorInfo->subActor = breakModel;
} else if (isEqualString(actorClassName, "SilhouetteModel")) {
actorInfo->mSubActor =
actorInfo->subActor =
new SilhouetteModel(mRootActor, initInfo, actorCategoryName);
} else if (isEqualString(actorClassName, "DepthShadowModel")) {
actorInfo->mSubActor = new DepthShadowModel(
actorInfo->subActor = new DepthShadowModel(
mRootActor, initInfo, actorCategoryName ? actorCategoryName : actorSuffix,
isCalcDepthShadowLength);
continue;
} else if (isEqualString(actorClassName, "InvincibleModel")) {
actorInfo->mSubActor =
actorInfo->subActor =
new ModelDrawParts("無敵モデル", mRootActor, initInfo, actorCategoryName);
} else {
if (!isEqualString(actorClassName, "SimpleCircleShadowXZ")) {
@ -185,16 +185,16 @@ void SubActorKeeper::init(const ActorInitInfo& initInfo, const char* suffix, s32
auto* sensor = getHitSensor(mRootActor, newSensorName);
actorInfo->mSubActor = createCollisionObj(
actorInfo->subActor = createCollisionObj(
mRootActor, initInfo, collName, sensor, jointName, collSuffixName);
if (actorObjectName)
actorInfo->mSubActor->setName(actorObjectName);
actorInfo->subActor->setName(actorObjectName);
continue;
}
actorInfo->mSubActor = new LiveActor(actorObjectName);
initActorWithArchiveName(actorInfo->mSubActor, initInfo, actorModelName,
actorInfo->subActor = new LiveActor(actorObjectName);
initActorWithArchiveName(actorInfo->subActor, initInfo, actorModelName,
actorSuffix);
continue;
@ -203,31 +203,31 @@ void SubActorKeeper::init(const ActorInitInfo& initInfo, const char* suffix, s32
SimpleCircleShadowXZ* dropShadow = new SimpleCircleShadowXZ(actorObjectName);
dropShadow->initSimpleCircleShadow(mRootActor, initInfo, actorModelName,
actorSuffix);
actorInfo->mSubActor = dropShadow;
actorInfo->subActor = dropShadow;
}
} else {
actorInfo->mSubActor = new LiveActor(actorObjectName);
actorInfo->subActor = new LiveActor(actorObjectName);
if (isUseHostPlacementInfo) {
initActorWithArchiveName(actorInfo->mSubActor, initInfo, actorModelName,
initActorWithArchiveName(actorInfo->subActor, initInfo, actorModelName,
actorSuffix);
} else {
initChildActorWithArchiveNameNoPlacementInfo(actorInfo->mSubActor, initInfo,
initChildActorWithArchiveNameNoPlacementInfo(actorInfo->subActor, initInfo,
actorModelName, actorSuffix);
}
}
initActorModelForceCubeMap(actorInfo->mSubActor, initInfo);
initActorModelForceCubeMap(actorInfo->subActor, initInfo);
if (isAliveResult) {
if (isAlive)
actorInfo->mSubActor->makeActorAlive();
actorInfo->subActor->makeActorAlive();
else
actorInfo->mSubActor->makeActorDead();
actorInfo->subActor->makeActorDead();
}
bool isShow = false;
if (tryGetByamlBool(&isShow, subActorIter, "IsShow") && !isShow)
hideModel(actorInfo->mSubActor);
hideModel(actorInfo->subActor);
}
}
}

8
lib/al/Library/LiveActor/SubActorKeeper.h
View file

@ -88,15 +88,15 @@ struct SubActorSync {
AL_BITS(SubActorSync)
};
class SubActorInfo {
struct SubActorInfo {
public:
SubActorInfo();
SubActorInfo(LiveActor* actor, SubActorSync syncType) : mSubActor(actor), mSyncType(syncType) {}
SubActorInfo(LiveActor* actor, SubActorSync syncType) : subActor(actor), syncType(syncType) {}
LiveActor* mSubActor = nullptr;
LiveActor* subActor = nullptr;
void* field_8 = nullptr;
SubActorSync mSyncType = SubActorSync::cNone;
SubActorSync syncType = SubActorSync::cNone;
};
class SubActorKeeper {

2
lib/al/Library/MapObj/ClockMapParts.cpp
View file

@ -43,7 +43,7 @@ void ClockMapParts::init(const ActorInitInfo& info) {
using ClockMapPartsFunctor = FunctorV0M<ClockMapParts*, void (ClockMapParts::*)()>;
tryInitSubActorKeeperChildStep(this, info);
initNerveAction(this, "Rotate", &NrvClockMapParts.mCollector, 0);
initNerveAction(this, "Rotate", &NrvClockMapParts.collector, 0);
initMapPartsActor(this, info, nullptr);
tryGetQuatPtr(this);
registerAreaHostMtx(this, info);

4
lib/al/Library/MapObj/ConveyerStep.cpp
View file

@ -64,13 +64,13 @@ void ConveyerStep::setTransByCoord(f32 coord, bool isForwards, bool isForceReset
if (index > -1) {
const ConveyerKey* conveyerKey = mConveyerKeyKeeper->getConveyerKey(index);
if (tryGetStringArg(&keyHitReactionName, conveyerKey->mPlacementInfo,
if (tryGetStringArg(&keyHitReactionName, conveyerKey->placementInfo,
"KeyHitReactionName") &&
(mKeyHitReactionName == nullptr ||
!isEqualString(mKeyHitReactionName, keyHitReactionName)))
startHitReaction(this, keyHitReactionName);
if (tryGetStringArg(&actionName, conveyerKey->mPlacementInfo, "ActionName") &&
if (tryGetStringArg(&actionName, conveyerKey->placementInfo, "ActionName") &&
(mActionName == nullptr || !isEqualString(mActionName, actionName)))
startAction(this, actionName);
}

2
lib/al/Library/MapObj/FallMapParts.cpp
View file

@ -29,7 +29,7 @@ namespace al {
FallMapParts::FallMapParts(const char* name) : LiveActor(name) {}
void FallMapParts::init(const ActorInitInfo& info) {
initNerveAction(this, "Wait", &NrvFallMapParts.mCollector, 0);
initNerveAction(this, "Wait", &NrvFallMapParts.collector, 0);
initMapPartsActor(this, info, nullptr);
registerAreaHostMtx(this, info);

2
lib/al/Library/MapObj/FloaterMapParts.cpp
View file

@ -29,7 +29,7 @@ namespace al {
FloaterMapParts::FloaterMapParts(const char* name) : LiveActor(name) {}
void FloaterMapParts::init(const ActorInitInfo& info) {
initNerveAction(this, "Wait", &NrvFloaterMapParts.mCollector, 0);
initNerveAction(this, "Wait", &NrvFloaterMapParts.collector, 0);
initMapPartsActor(this, info, nullptr);
tryGetQuatPtr(this);

2
lib/al/Library/MapObj/GateMapParts.cpp
View file

@ -32,7 +32,7 @@ GateMapParts::GateMapParts(const char* name) : LiveActor(name) {}
void GateMapParts::init(const ActorInitInfo& info) {
using GateMapPartsFunctor = FunctorV0M<GateMapParts*, void (GateMapParts::*)()>;
initNerveAction(this, "Wait", &NrvGateMapParts.mCollector, 0);
initNerveAction(this, "Wait", &NrvGateMapParts.collector, 0);
initMapPartsActor(this, info, nullptr);
tryGetQuatPtr(this);

2
lib/al/Library/MapObj/KeyMoveMapParts.cpp
View file

@ -40,7 +40,7 @@ KeyMoveMapParts::KeyMoveMapParts(const char* name) : LiveActor(name) {}
void KeyMoveMapParts::init(const ActorInitInfo& info) {
using KeyMoveMapPartsFunctor = FunctorV0M<KeyMoveMapParts*, void (KeyMoveMapParts::*)()>;
initNerveAction(this, "Wait", &NrvKeyMoveMapParts.mCollector, 0);
initNerveAction(this, "Wait", &NrvKeyMoveMapParts.collector, 0);
const char* suffix = nullptr;
tryGetStringArg(&suffix, info, "SuffixName");

2
lib/al/Library/MapObj/RailMoveMapParts.cpp
View file

@ -31,7 +31,7 @@ RailMoveMapParts::RailMoveMapParts(const char* name) : LiveActor(name) {}
void RailMoveMapParts::init(const ActorInitInfo& info) {
using RailMoveMapPartsFunctor = FunctorV0M<RailMoveMapParts*, void (RailMoveMapParts::*)()>;
initNerveAction(this, "StandBy", &NrvRailMoveMapParts.mCollector, 1);
initNerveAction(this, "StandBy", &NrvRailMoveMapParts.collector, 1);
initMapPartsActor(this, info, nullptr);
registerAreaHostMtx(this, info);

2
lib/al/Library/MapObj/RollingCubeMapParts.cpp
View file

@ -44,7 +44,7 @@ namespace al {
RollingCubeMapParts::RollingCubeMapParts(const char* name) : LiveActor(name) {}
void RollingCubeMapParts::init(const ActorInitInfo& info) {
initNerveAction(this, "Wait", &NrvRollingCubeMapParts.mCollector, 0);
initNerveAction(this, "Wait", &NrvRollingCubeMapParts.collector, 0);
initMapPartsActor(this, info, nullptr);
tryGetQuatPtr(this);

2
lib/al/Library/MapObj/RotateMapParts.cpp
View file

@ -30,7 +30,7 @@ void RotateMapParts::init(const ActorInitInfo& info) {
using RotateMapPartsFunctor = FunctorV0M<RotateMapParts*, void (RotateMapParts::*)()>;
tryInitSubActorKeeperChildStep(this, info);
initNerveAction(this, "Rotate", &NrvRotateMapParts.mCollector, 0);
initNerveAction(this, "Rotate", &NrvRotateMapParts.collector, 0);
initMapPartsActor(this, info, nullptr);
tryGetQuatPtr(this);
registerAreaHostMtx(this, info);

2
lib/al/Library/MapObj/SeesawMapParts.cpp
View file

@ -26,7 +26,7 @@ SeesawMapParts::SeesawMapParts(const char* name) : LiveActor(name) {}
void SeesawMapParts::init(const ActorInitInfo& info) {
tryInitSubActorKeeperChildStep(this, info);
initNerveAction(this, "Wait", &NrvSeesawMapParts.mCollector, 0);
initNerveAction(this, "Wait", &NrvSeesawMapParts.collector, 0);
initMapPartsActor(this, info, nullptr);
tryGetQuatPtr(this);

2
lib/al/Library/MapObj/SlideMapParts.cpp
View file

@ -32,7 +32,7 @@ SlideMapParts::SlideMapParts(const char* name) : LiveActor(name) {}
void SlideMapParts::init(const ActorInitInfo& info) {
using SlideMapPartsFunctor = FunctorV0M<SlideMapParts*, void (SlideMapParts::*)()>;
initNerveAction(this, "Move", &NrvSlideMapParts.mCollector, 0);
initNerveAction(this, "Move", &NrvSlideMapParts.collector, 0);
initMapPartsActor(this, info, tryGetMapPartsSuffix(info, "SlideMapParts"));
registerAreaHostMtx(this, info);

4
lib/al/Library/MapObj/SwingMapParts.cpp
View file

@ -36,9 +36,9 @@ void SwingMapParts::init(const ActorInitInfo& info) {
mSwingMovement = new SwingMovement(info);
if (mSwingMovement->isLeft())
initNerveAction(this, "MoveLeft", &NrvSwingMapParts.mCollector, 0);
initNerveAction(this, "MoveLeft", &NrvSwingMapParts.collector, 0);
else
initNerveAction(this, "MoveRight", &NrvSwingMapParts.mCollector, 0);
initNerveAction(this, "MoveRight", &NrvSwingMapParts.collector, 0);
tryInitSubActorKeeperChildStep(this, info);
initMapPartsActor(this, info, nullptr);

2
lib/al/Library/MapObj/SwitchDitherMapParts.cpp
View file

@ -21,7 +21,7 @@ void SwitchDitherMapParts::init(const ActorInitInfo& info) {
using SwitchDitherMapPartsFunctor =
FunctorV0M<SwitchDitherMapParts*, void (SwitchDitherMapParts::*)()>;
initNerveAction(this, "Wait", &NrvSwitchDitherMapParts.mCollector, 0);
initNerveAction(this, "Wait", &NrvSwitchDitherMapParts.collector, 0);
initMapPartsActor(this, info, nullptr);
bool isListenStartOnOff = listenStageSwitchOnOff(

2
lib/al/Library/MapObj/SwitchOpenMapParts.cpp
View file

@ -33,7 +33,7 @@ void SwitchOpenMapParts::init(const ActorInitInfo& info) {
using SwitchOpenMapPartsFunctor =
FunctorV0M<SwitchOpenMapParts*, void (SwitchOpenMapParts::*)()>;
initNerveAction(this, "Wait", &NrvSwitchOpenMapParts.mCollector, 0);
initNerveAction(this, "Wait", &NrvSwitchOpenMapParts.collector, 0);
const char* suffix = nullptr;
tryGetStringArg(&suffix, info, "SuffixName");

2
lib/al/Library/MapObj/WheelMapParts.cpp
View file

@ -32,7 +32,7 @@ WheelMapParts::WheelMapParts(const char* name) : LiveActor(name) {}
void WheelMapParts::init(const ActorInitInfo& info) {
tryInitSubActorKeeperChildStep(this, info);
initNerveAction(this, "Wait", &NrvWheelMapParts.mCollector, 0);
initNerveAction(this, "Wait", &NrvWheelMapParts.collector, 0);
initMapPartsActor(this, info, nullptr);
tryGetQuatPtr(this);
registerAreaHostMtx(this, info);

2
lib/al/Library/MapObj/WobbleMapParts.cpp
View file

@ -29,7 +29,7 @@ WobbleMapParts::WobbleMapParts(const char* name) : LiveActor(name) {}
void WobbleMapParts::init(const ActorInitInfo& info) {
tryInitSubActorKeeperChildStep(this, info);
initNerveAction(this, "Wait", &NrvWobbleMapParts.mCollector, 0);
initNerveAction(this, "Wait", &NrvWobbleMapParts.collector, 0);
initMapPartsActor(this, info, nullptr);
tryGetQuatPtr(this);
registerAreaHostMtx(this, info);

14
lib/al/Library/Message/MessageHolder.h
View file

@ -14,13 +14,13 @@ class MessageTag;
class MessageTagDataHolder;
struct ReplaceTimeInfo {
u32 mYear;
u32 mMonth;
u32 mDay;
u32 mHour;
u32 mMinute;
u32 mSecond;
u32 mCentiSecond;
u32 year;
u32 month;
u32 day;
u32 hour;
u32 minute;
u32 second;
u32 centiSecond;
};
class MessageHolder : public HioNode {

28
lib/al/Library/Movement/EnemyStateBlowDown.cpp
View file

@ -31,13 +31,13 @@ void EnemyStateBlowDown::start(const HitSensor* sensor) {
}
void EnemyStateBlowDown::start(const sead::Vector3f& dir) {
if (mParam->mFaceAwayFromActor)
if (mParam->faceAwayFromActor)
faceToDirection(mActor, -dir);
auto* actor = mActor;
sead::Vector3f direction = dir * mParam->mVelocityStrength;
sead::Vector3f direction = dir * mParam->velocityStrength;
sead::Vector3f gravity = getGravity(actor);
sead::Vector3f velocity = gravity * mParam->mGravityStrength;
sead::Vector3f velocity = gravity * mParam->gravityStrength;
setVelocity(actor, direction - velocity);
}
@ -78,34 +78,32 @@ void EnemyStateBlowDown::kill() {
void EnemyStateBlowDown::control() {
if (mBlowDownTimer == 0) {
if (mParam->mActionName)
startAction(mActor, mParam->mActionName);
if (mParam->actionName)
startAction(mActor, mParam->actionName);
if (isExistActorCollider(mActor))
onCollide(mActor);
}
if ((mParam->mBlowDownLength <= mBlowDownTimer) ||
(mParam->mActionName && isActionOneTime(mActor, mParam->mActionName) &&
if ((mParam->blowDownLength <= mBlowDownTimer) ||
(mParam->actionName && isActionOneTime(mActor, mParam->actionName) &&
isActionEnd(mActor)) ||
(isExistActorCollider(mActor) && isOnGround(mActor, 0))) {
kill();
return;
}
addVelocityToGravity(mActor, mParam->mVelocityMultiplier);
scaleVelocity(mActor, mParam->mVelocityScale);
addVelocityToGravity(mActor, mParam->velocityMultiplier);
scaleVelocity(mActor, mParam->velocityScale);
mBlowDownTimer++;
}
EnemyStateBlowDownParam::EnemyStateBlowDownParam() {}
EnemyStateBlowDownParam::EnemyStateBlowDownParam(const char* actionName)
: mActionName(actionName) {}
EnemyStateBlowDownParam::EnemyStateBlowDownParam(const char* actionName) : actionName(actionName) {}
EnemyStateBlowDownParam::EnemyStateBlowDownParam(const char* actionName, f32 velocityStrength,
f32 gravityStrength, f32 velocityMultiplier,
f32 velocityScale, s32 blowDownLength,
bool faceAwayFromActor)
: mActionName(actionName), mVelocityStrength(velocityStrength),
mGravityStrength(gravityStrength), mVelocityMultiplier(velocityMultiplier),
mVelocityScale(velocityScale), mBlowDownLength(blowDownLength),
mFaceAwayFromActor(faceAwayFromActor) {}
: actionName(actionName), velocityStrength(velocityStrength), gravityStrength(gravityStrength),
velocityMultiplier(velocityMultiplier), velocityScale(velocityScale),
blowDownLength(blowDownLength), faceAwayFromActor(faceAwayFromActor) {}
} // namespace al

14
lib/al/Library/Movement/EnemyStateBlowDown.h
View file

@ -16,13 +16,13 @@ public:
f32 velocityMultiplier, f32 velocityScale, s32 blowDownLength,
bool faceAwayFromActor);
const char* mActionName = "BlowDown";
f32 mVelocityStrength = 10.3f;
f32 mGravityStrength = 28.2f;
f32 mVelocityMultiplier = 1.1f;
f32 mVelocityScale = 0.995f;
s32 mBlowDownLength = 120;
bool mFaceAwayFromActor = true;
const char* actionName = "BlowDown";
f32 velocityStrength = 10.3f;
f32 gravityStrength = 28.2f;
f32 velocityMultiplier = 1.1f;
f32 velocityScale = 0.995f;
s32 blowDownLength = 120;
bool faceAwayFromActor = true;
};
class EnemyStateBlowDown : public ActorStateBase {

4
lib/al/Library/Nerve/NerveSetupUtil.h
View file

@ -38,7 +38,7 @@ namespace {
// and no variants without it have been found so far
}
al::initNerveAction(this, "Hide", &NrvExampleUseCase.mCollector, 0);
al::initNerveAction(this, "Hide", &NrvExampleUseCase.collector, 0);
*/
@ -106,7 +106,7 @@ al::initNerveAction(this, "Hide", &NrvExampleUseCase.mCollector, 0);
struct NrvStruct##Class { \
FOR_EACH(NERVE_ACTION_MAKE, Class, __VA_ARGS__) \
\
alNerveFunction::NerveActionCollector mCollector; \
alNerveFunction::NerveActionCollector collector; \
\
NrvStruct##Class() { \
FOR_EACH(NERVE_ACTION_CONSTRUCT, Class, __VA_ARGS__) \

2
lib/al/Library/Obj/CameraRailHolder.cpp
View file

@ -14,7 +14,7 @@ CameraRailHolder::CameraRailHolder(const char* name) : LiveActor(name) {}
void CameraRailHolder::init(const ActorInitInfo& info) {
initActorSceneInfo(this, info);
initExecutorWatchObj(this, info);
info.getActorSceneInfo().mCameraDirector->registerCameraRailHolder(this);
info.getActorSceneInfo().cameraDirector->registerCameraRailHolder(this);
mCameraRailCount = calcLinkChildNum(info, "Rail");

2
lib/al/Library/Obj/KeyMoveFollowTarget.cpp
View file

@ -25,7 +25,7 @@ KeyMoveFollowTarget::KeyMoveFollowTarget(const char* name) : LiveActor(name) {}
void KeyMoveFollowTarget::initKeyMoveFollowTarget(const ActorInitInfo& info,
const char* archiveName, const char* suffix) {
initNerveAction(this, "Wait", &NrvKeyMoveFollowTarget.mCollector, 0);
initNerveAction(this, "Wait", &NrvKeyMoveFollowTarget.collector, 0);
initActorWithArchiveName(this, info, archiveName, suffix);
mKeyPoseKeeper = createKeyPoseKeeper(info);

2
lib/al/Library/Play/Camera/CameraVerticalAbsorber.cpp
View file

@ -48,7 +48,7 @@ void CameraVerticalAbsorber::start(const sead::Vector3f& pos, const CameraStartI
return setNerve(this, &NrvCameraVerticalAbsorber.FollowClimbPoleNoInterp);
if (alCameraPoserFunction::isTargetGrabCeil(mCameraPoser))
return setNerve(this, &NrvCameraVerticalAbsorber.FollowSlow);
if (!info.mIsGrounded || alCameraPoserFunction::isTargetCollideGround(mCameraPoser))
if (!info.isGrounded || alCameraPoserFunction::isTargetCollideGround(mCameraPoser))
return setNerve(this, &NrvCameraVerticalAbsorber.FollowGround);
mPrevTargetTrans = alCameraPoserFunction::getPreLookAtPos(mCameraPoser);

16
lib/al/Library/Player/PlayerHolder.cpp
View file

@ -10,19 +10,19 @@ PlayerHolder::PlayerHolder(s32 count) {
void PlayerHolder::clear() {
for (s32 i = 0; i < mBufferSize; i++) {
mPlayers[i].mActor = nullptr;
mPlayers[i].mPadRumbleKeeper = nullptr;
mPlayers[i].actor = nullptr;
mPlayers[i].padRumbleKeeper = nullptr;
}
}
void PlayerHolder::registerPlayer(LiveActor* actor, PadRumbleKeeper* rumbleKeeper) {
mPlayers[mPlayerNum].mActor = actor;
mPlayers[mPlayerNum].mPadRumbleKeeper = rumbleKeeper;
mPlayers[mPlayerNum].actor = actor;
mPlayers[mPlayerNum].padRumbleKeeper = rumbleKeeper;
mPlayerNum++;
}
LiveActor* PlayerHolder::getPlayer(s32 index) const {
return mPlayers[index].mActor;
return mPlayers[index].actor;
}
LiveActor* PlayerHolder::tryGetPlayer(s32 index) const {
@ -31,7 +31,7 @@ LiveActor* PlayerHolder::tryGetPlayer(s32 index) const {
else if (mPlayerNum <= index)
return nullptr;
return mPlayers[index].mActor;
return mPlayers[index].actor;
}
s32 PlayerHolder::getPlayerNum() const {
@ -47,10 +47,10 @@ bool PlayerHolder::isFull() const {
}
bool PlayerHolder::isExistPadRumbleKeeper(s32 index) const {
return mPlayers[index].mPadRumbleKeeper != nullptr;
return mPlayers[index].padRumbleKeeper != nullptr;
}
PadRumbleKeeper* PlayerHolder::getPadRumbleKeeper(s32 index) const {
return mPlayers[index].mPadRumbleKeeper;
return mPlayers[index].padRumbleKeeper;
}
} // namespace al

4
lib/al/Library/Player/PlayerHolder.h
View file

@ -22,8 +22,8 @@ public:
private:
struct Player {
LiveActor* mActor = nullptr;
PadRumbleKeeper* mPadRumbleKeeper = nullptr;
LiveActor* actor = nullptr;
PadRumbleKeeper* padRumbleKeeper = nullptr;
};
Player* mPlayers = nullptr;

4
lib/al/Library/Projection/OrthoProjectionInfo.h
View file

@ -5,8 +5,8 @@
namespace al {
struct OrthoProjectionInfo {
f32 mNearClipWidth = -1.0f;
f32 mNearClipHeight = -1.0f;
f32 nearClipWidth = -1.0f;
f32 nearClipHeight = -1.0f;
};
static_assert(sizeof(OrthoProjectionInfo) == 0x8);

14
lib/al/Library/Se/Info/SeAudioInfo.h
View file

@ -17,12 +17,12 @@ struct SeUserInfo {
static s32 compareInfo(const SeUserInfo*, const SeUserInfo*);
const char* mName;
bool mIsPartsUser = false;
sead::PtrArray<const char*> mPartsUserNameList;
AudioInfoListWithParts* mEmitterInfoList;
AudioInfoListWithParts* mActionInfoList;
AudioInfoListWithParts* mPlayInfoList;
AudioInfoListWithParts* mHitReactionInfoList;
const char* name;
bool isPartsUser = false;
sead::PtrArray<const char*> partsUserNameList;
AudioInfoListWithParts* emitterInfoList;
AudioInfoListWithParts* actionInfoList;
AudioInfoListWithParts* playInfoList;
AudioInfoListWithParts* hitReactionInfoList;
};
} // namespace al

22
lib/al/Project/Action/ActionAnimInfo.h
View file

@ -4,22 +4,22 @@
namespace al {
struct ActionAnimDataInfo {
const char* mActionName = nullptr;
const char* actionName = nullptr;
f32 _8 = -1.0;
bool mIsKeepAnim = false;
bool mIsActionAnim = false;
bool isKeepAnim = false;
bool isActionAnim = false;
};
struct ActionAnimCtrlInfo {
ActionAnimCtrlInfo(s32 sklSize);
const char* mActionName;
u32 mSklDataCount;
ActionAnimDataInfo** mSklDatas;
ActionAnimDataInfo mMclData;
ActionAnimDataInfo mMtpData;
ActionAnimDataInfo mMtsData;
ActionAnimDataInfo mVisData;
s32 mPartNum;
const char* actionName;
u32 sklDataCount;
ActionAnimDataInfo** sklDatas;
ActionAnimDataInfo mclData;
ActionAnimDataInfo mtpData;
ActionAnimDataInfo mtsData;
ActionAnimDataInfo visData;
s32 partNum;
};
} // namespace al

6
lib/al/Project/Action/ActionEffectCtrl.h
View file

@ -6,9 +6,9 @@
namespace al {
struct ActionEffectCtrlInfo {
const char* mName;
const char* mMaterialName;
bool mHasEmittedEffect;
const char* name;
const char* materialName;
bool hasEmittedEffect;
};
class ActionEffectCtrl : public IUseEffectKeeper {

2
lib/al/Project/Action/ActionFlagCtrl.cpp
View file

@ -35,7 +35,7 @@ void ActionFlagCtrl::start(const char* name) {
ActionFlagCtrlInfo* ActionFlagCtrl::findFlagInfo(const char* name) const {
for (s32 i = 0; i < mInfoCount; i++) {
ActionFlagCtrlInfo* flagInfo = mInfos[i];
if (isEqualStringCase(flagInfo->mName, name))
if (isEqualStringCase(flagInfo->name, name))
return flagInfo;
}
return nullptr;

2
lib/al/Project/Action/ActionFlagCtrl.h
View file

@ -10,7 +10,7 @@ class HitSensorKeeper;
class LiveActor;
struct ActionFlagCtrlInfo {
const char* mName;
const char* name;
void* _8;
void* _10;
};

4
lib/al/Project/Action/ActionFunction.cpp
View file

@ -6,9 +6,9 @@
namespace alActionFunction {
const char* getAnimName(const al::ActionAnimCtrlInfo* infoCtrl,
const al::ActionAnimDataInfo* infoData) {
const char* animName = infoData->mActionName;
const char* animName = infoData->actionName;
if (animName == nullptr)
animName = infoCtrl->mActionName;
animName = infoCtrl->actionName;
return animName;
}
} // namespace alActionFunction

4
lib/al/Project/Action/ActionScreenEffectCtrl.h
View file

@ -6,8 +6,8 @@ namespace al {
class LiveActor;
struct ActionScreenEffectCtrlInfo {
const char* mName;
bool mIsActive;
const char* name;
bool isActive;
// note: member list not complete.
};

8
lib/al/Project/Anim/AnimInfo.h
View file

@ -8,10 +8,10 @@ class ResMaterialAnim;
namespace al {
struct AnimResInfo {
const char* mName;
const nn::g3d::ResMaterialAnim* mResMaterialAnim;
s32 mFrameMax;
bool mIsLoop;
const char* name;
const nn::g3d::ResMaterialAnim* resMaterialAnim;
s32 frameMax;
bool isLoop;
};
class AnimInfoTable {

4
lib/al/Project/Bgm/BgmInfo.cpp
View file

@ -27,10 +27,10 @@ void BgmChangeableParams::operator=(const BgmChangeableParams& value) {
BgmUserInfo::BgmUserInfo() {}
s32 BgmUserInfo::compareInfo(const BgmUserInfo* info_1, const BgmUserInfo* info_2) {
return strcmp(info_1->mName, info_2->mName);
return strcmp(info_1->name, info_2->name);
}
s32 BgmUserInfo::compareInfoByKey(const BgmUserInfo* info, const char* string) {
return strcmp(info->mName, string);
return strcmp(info->name, string);
}
} // namespace al

6
lib/al/Project/Bgm/BgmInfo.h
View file

@ -40,8 +40,8 @@ struct BgmUserInfo {
static s32 compareInfo(const BgmUserInfo*, const BgmUserInfo*);
static s32 compareInfoByKey(const BgmUserInfo*, const char*);
const char* mName = nullptr;
AudioInfoListWithParts* mBgmActionInfoList = nullptr;
AudioInfoListWithParts* mBgmSourceInfoList = nullptr;
const char* name = nullptr;
AudioInfoListWithParts* bgmActionInfoList = nullptr;
AudioInfoListWithParts* bgmSourceInfoList = nullptr;
};
} // namespace al

4
lib/al/Project/Controller/PadDataArcReader.cpp
View file

@ -21,13 +21,13 @@ void PadDataArcReader::readResource(const char* resourceName) {
mDataFrames = (PadDataPack*)resource->getOtherFile(filename);
checkEnd();
PadDataPack* checkFrame = mDataFrames;
while (checkFrame->mTrig != -1)
while (checkFrame->trig != -1)
checkFrame++;
mTotalFrame = checkFrame - mDataFrames;
}
void PadDataArcReader::checkEnd() {
if (mDataFrames[mCursorFrame].mTrig == -1)
if (mDataFrames[mCursorFrame].trig == -1)
mIsEnd = true;
}

2
lib/al/Project/LiveActor/ConveyerKeyKeeper.h
View file

@ -10,7 +10,7 @@ class PlacementInfo;
// TODO: I'm not sure about this
struct ConveyerKey {
void* _0[5];
const PlacementInfo& mPlacementInfo;
const PlacementInfo& placementInfo;
};
class ConveyerKeyKeeper {

4
src/Amiibo/AmiiboNpcDirector.cpp
View file

@ -56,7 +56,7 @@ void AmiiboNpcDirector::initAfterPlacementSceneObj(const al::ActorInitInfo& init
const sead::PtrArray<ShopItem::ItemInfo>& clothList = rs::getClothList(mNpcLayout);
for (s32 i = 0; i < clothList.size(); i++) {
if (al::isEqualString(clothList.at(i)->mName, currentCostumeTypeName)) {
if (al::isEqualString(clothList.at(i)->name, currentCostumeTypeName)) {
mClothName = rs::getDisplayName(mNpcLayout, *clothList.at(i));
break;
}
@ -66,7 +66,7 @@ void AmiiboNpcDirector::initAfterPlacementSceneObj(const al::ActorInitInfo& init
const sead::PtrArray<ShopItem::ItemInfo>& capList = rs::getCapList(mNpcLayout);
for (s32 i = 0; i < capList.size(); i++) {
if (al::isEqualString(capList.at(i)->mName, currentCapTypeName)) {
if (al::isEqualString(capList.at(i)->name, currentCapTypeName)) {
mCapName = rs::getDisplayName(mNpcLayout, *capList.at(i));
break;
}

46
src/Amiibo/SearchAmiiboDataTable.cpp
View file

@ -15,13 +15,13 @@ SearchAmiiboData::SearchAmiiboData() {
}
void SearchAmiiboData::init() {
mId = -1;
mNumberingId = -1;
mSearchStartTime = 0;
id = -1;
numberingId = -1;
searchStartTime = 0;
}
bool SearchAmiiboData::isInvalidId() const {
return mId == -1;
return id == -1;
}
SearchAmiiboDataTable::SearchAmiiboDataTable() {
@ -37,21 +37,21 @@ void SearchAmiiboDataTable::write(al::ByamlWriter* writer) {
writer->pushArray("SearchAmiiboData");
writer->pushHash();
writer->addInt("Id", mEntries[0].mId);
writer->addInt("NumberingId", mEntries[0].mNumberingId);
writer->addUInt64("SearchStartTime", mEntries[0].mSearchStartTime);
writer->addInt("Id", mEntries[0].id);
writer->addInt("NumberingId", mEntries[0].numberingId);
writer->addUInt64("SearchStartTime", mEntries[0].searchStartTime);
writer->pop();
writer->pushHash();
writer->addInt("Id", mEntries[1].mId);
writer->addInt("NumberingId", mEntries[1].mNumberingId);
writer->addUInt64("SearchStartTime", mEntries[1].mSearchStartTime);
writer->addInt("Id", mEntries[1].id);
writer->addInt("NumberingId", mEntries[1].numberingId);
writer->addUInt64("SearchStartTime", mEntries[1].searchStartTime);
writer->pop();
writer->pushHash();
writer->addInt("Id", mEntries[2].mId);
writer->addInt("NumberingId", mEntries[2].mNumberingId);
writer->addUInt64("SearchStartTime", mEntries[2].mSearchStartTime);
writer->addInt("Id", mEntries[2].id);
writer->addInt("NumberingId", mEntries[2].numberingId);
writer->addUInt64("SearchStartTime", mEntries[2].searchStartTime);
writer->pop();
writer->pop();
@ -67,9 +67,9 @@ void SearchAmiiboDataTable::read(const al::ByamlIter& iter) {
al::ByamlIter indexIter;
dataIter.tryGetIterByIndex(&indexIter, i);
indexIter.tryGetIntByKey(&mEntries[i].mId, "Id");
indexIter.tryGetIntByKey(&mEntries[i].mNumberingId, "NumberingId");
indexIter.tryGetUInt64ByKey(&mEntries[i].mSearchStartTime, "SearchStartTime");
indexIter.tryGetIntByKey(&mEntries[i].id, "Id");
indexIter.tryGetIntByKey(&mEntries[i].numberingId, "NumberingId");
indexIter.tryGetUInt64ByKey(&mEntries[i].searchStartTime, "SearchStartTime");
}
}
@ -78,7 +78,7 @@ s32 SearchAmiiboDataTable::getDataNumMax() const {
}
bool SearchAmiiboDataTable::isInvalidId(s32 index) const {
return mEntries[index].mId == -1;
return mEntries[index].id == -1;
}
const SearchAmiiboData& SearchAmiiboDataTable::getData(s32 index) const {
@ -86,24 +86,24 @@ const SearchAmiiboData& SearchAmiiboDataTable::getData(s32 index) const {
}
s32 SearchAmiiboDataTable::getId(s32 index) const {
return mEntries[index].mId;
return mEntries[index].id;
}
s32 SearchAmiiboDataTable::getNumberingId(s32 index) const {
return mEntries[index].mNumberingId;
return mEntries[index].numberingId;
}
void SearchAmiiboDataTable::setId(s32 id, s32 numberingId, s32 index) {
mEntries[index].mId = id;
mEntries[index].mNumberingId = numberingId;
mEntries[index].id = id;
mEntries[index].numberingId = numberingId;
}
u64 SearchAmiiboDataTable::getSearchStartTime(s32 index) const {
return mEntries[index].mSearchStartTime;
return mEntries[index].searchStartTime;
}
void SearchAmiiboDataTable::setSearchStartTime(u64 searchStartTime, s32 index) {
mEntries[index].mSearchStartTime = searchStartTime;
mEntries[index].searchStartTime = searchStartTime;
}
void SearchAmiiboDataTable::copy(s32 index, s32 other) {

6
src/Amiibo/SearchAmiiboDataTable.h
View file

@ -14,9 +14,9 @@ struct SearchAmiiboData {
void init();
bool isInvalidId() const;
s32 mId;
s32 mNumberingId;
u64 mSearchStartTime;
s32 id;
s32 numberingId;
u64 searchStartTime;
};
class SearchAmiiboDataTable : public al::HioNode {

2
src/Boss/BarrierField.cpp
View file

@ -24,7 +24,7 @@ NERVE_ACTIONS_MAKE_STRUCT(BarrierField, Appear, AppearBreedaMoonWorld, Hide, Dis
BarrierField::BarrierField(const char* name) : al::LiveActor(name) {}
void BarrierField::init(const al::ActorInitInfo& initInfo) {
al::initNerveAction(this, "Hide", &NrvBarrierField.mCollector, 0);
al::initNerveAction(this, "Hide", &NrvBarrierField.collector, 0);
al::initMapPartsActor(this, initInfo, nullptr);
al::tryGetArg(&mIsDisappearByShineGet, initInfo, "IsDisappearByShineGet");
if (al::isObjectName(initInfo, "WaterfallWorldHomeBarrier") &&

30
src/Enemy/EnemyStateHackStart.cpp
View file

@ -23,8 +23,8 @@ NERVES_MAKE_NOSTRUCT(EnemyStateHackStart, DiveIn, HackStart);
EnemyStateHackStartParam::EnemyStateHackStartParam(const char* actionName, const char* visAnimName,
const char* mtpAnimName, bool hasSubActors,
bool updateSubActorShadowMap)
: mActionName(actionName), mVisAnimName(visAnimName), mMtpAnimName(mtpAnimName),
mHasSubActors(hasSubActors), mUpdateSubActorShadowMap(updateSubActorShadowMap) {}
: actionName(actionName), visAnimName(visAnimName), mtpAnimName(mtpAnimName),
hasSubActors(hasSubActors), updateSubActorShadowMap(updateSubActorShadowMap) {}
static EnemyStateHackStartParam sEnemyStateHackStartParam("HackStart", 0, 0, 0, 0);
@ -65,14 +65,14 @@ f32 EnemyStateHackStart::calcHackStartNerveRate() const {
if (!isHackStart())
return 0.0f;
s32 frameMax = al::getActionFrameMax(mActor, mParam->mActionName);
s32 frameMax = al::getActionFrameMax(mActor, mParam->actionName);
return al::calcNerveRate(this, frameMax);
}
void EnemyStateHackStart::exeDiveIn() {
if (!rs::isHackStartDemoEnterMario(mHackActor))
return;
if (mParam->mActionName)
if (mParam->actionName)
al::setNerve(this, &HackStart);
else
kill();
@ -81,25 +81,25 @@ void EnemyStateHackStart::exeDiveIn() {
void EnemyStateHackStart::exeHackStart() {
if (al::isFirstStep(this)) {
mPlayerHackStartShaderCtrl->start();
al::startAction(mActor, mParam->mActionName);
al::startAction(mActor, mParam->actionName);
if (mParam->mHasSubActors) {
if (mParam->hasSubActors) {
s32 subActorNum = al::getSubActorNum(mActor);
for (s32 i = 0; i < subActorNum; i++)
if (al::isExistAction(al::getSubActor(mActor, i), mParam->mActionName))
al::startAction(al::getSubActor(mActor, i), mParam->mActionName);
if (al::isExistAction(al::getSubActor(mActor, i), mParam->actionName))
al::startAction(al::getSubActor(mActor, i), mParam->actionName);
}
if (mParam->mVisAnimName)
al::startVisAnim(mActor, mParam->mVisAnimName);
if (mParam->mMtpAnimName)
al::startMtpAnim(mActor, mParam->mMtpAnimName);
if (mParam->visAnimName)
al::startVisAnim(mActor, mParam->visAnimName);
if (mParam->mtpAnimName)
al::startMtpAnim(mActor, mParam->mtpAnimName);
al::LiveActor* actor = mActor;
if (al::isExistDepthShadowMapCtrl(actor)) {
al::invalidateShadow(actor);
al::offDepthShadowModel(actor);
al::validateDepthShadowMap(actor);
}
if (mParam->mUpdateSubActorShadowMap) {
if (mParam->updateSubActorShadowMap) {
s32 subActorNum = al::getSubActorNum(mActor);
for (s32 i = 0; i < subActorNum; i++) {
al::LiveActor* subActor = al::getSubActor(mActor, i);
@ -125,7 +125,7 @@ void startHackSwitchShadow(al::LiveActor* actor, const EnemyStateHackStartParam*
al::offDepthShadowModel(actor);
al::validateDepthShadowMap(actor);
}
if (param && param->mUpdateSubActorShadowMap) {
if (param && param->updateSubActorShadowMap) {
s32 subActorNum = al::getSubActorNum(actor);
for (s32 i = 0; i < subActorNum; i++) {
al::LiveActor* subActor = al::getSubActor(actor, i);
@ -144,7 +144,7 @@ void endHackSwitchShadow(al::LiveActor* actor, const EnemyStateHackStartParam* p
al::onDepthShadowModel(actor);
al::invalidateDepthShadowMap(actor);
}
if (param && param->mUpdateSubActorShadowMap) {
if (param && param->updateSubActorShadowMap) {
s32 subActorNum = al::getSubActorNum(actor);
for (s32 i = 0; i < subActorNum; i++) {
al::LiveActor* subActor = al::getSubActor(actor, i);

10
src/Enemy/EnemyStateHackStart.h
View file

@ -14,11 +14,11 @@ struct PlayerHackStartShaderParam;
struct EnemyStateHackStartParam {
EnemyStateHackStartParam(const char*, const char*, const char*, bool, bool);
const char* mActionName;
const char* mVisAnimName;
const char* mMtpAnimName;
bool mHasSubActors;
bool mUpdateSubActorShadowMap;
const char* actionName;
const char* visAnimName;
const char* mtpAnimName;
bool hasSubActors;
bool updateSubActorShadowMap;
};
class EnemyStateHackStart : public al::ActorStateBase {

2
src/Enemy/EnemyStateRunAway.cpp
View file

@ -24,7 +24,7 @@ EnemyStateRunAway::EnemyStateRunAway(al::LiveActor* actor, const ParamEnemyState
void EnemyStateRunAway::appear() {
setDead(false);
if (mParam->mShouldFaceDir)
if (mParam->shouldFaceDir)
mIsNeedToFaceToDirection = true;
al::calcFrontDir(&mFrontDir, mActor);
calcRunDirBase(&mFrontDir);

2
src/Enemy/EnemyStateRunAway.h
View file

@ -10,7 +10,7 @@ struct ParamEnemyStateRunAway {
f32 field_8;
f32 field_c;
f32 field_10;
bool mShouldFaceDir;
bool shouldFaceDir;
};
class EnemyStateRunAway : public al::ActorStateBase {

17
src/Enemy/EnemyStateSwoon.h
View file

@ -13,16 +13,15 @@ struct EnemyStateSwoonInitParam {
EnemyStateSwoonInitParam(const char* startName, const char* defaultName, const char* endName,
const char* trampledName, const char* startFallName,
const char* startLandName)
: mStartName(startName), mDefaultName(defaultName), mEndName(endName),
mTrampledName(trampledName), mStartFallName(startFallName),
mStartLandName(startLandName) {}
: startName(startName), defaultName(defaultName), endName(endName),
trampledName(trampledName), startFallName(startFallName), startLandName(startLandName) {}
const char* mStartName = "SwoonStart";
const char* mDefaultName = "Swoon";
const char* mEndName = "SwoonEnd";
const char* mTrampledName = "SwoonTrampled";
const char* mStartFallName = "SwoonStartFall";
const char* mStartLandName = "SwoonStartLand";
const char* startName = "SwoonStart";
const char* defaultName = "Swoon";
const char* endName = "SwoonEnd";
const char* trampledName = "SwoonTrampled";
const char* startFallName = "SwoonStartFall";
const char* startLandName = "SwoonStartLand";
const char* _30 = nullptr;
const char* _38 = nullptr;
const char* _40 = nullptr;

2
src/Layout/MapTerrainLayout.cpp
View file

@ -15,7 +15,7 @@ bool MapTerrainLayout::tryChangePrintWorld(s32 worldId) {
if (!mMapData)
return false;
al::setPaneTexture(this, "PicMap00", mMapData->mTexture2dMap);
al::setPaneTexture(this, "PicMap00", mMapData->texture2dMap);
al::setPaneLocalScale(this, "PicMap00", sead::Vector2f(256.0f, 256.0f));
return true;

2
src/Layout/MenuSelectParts.cpp
View file

@ -251,7 +251,7 @@ void MenuSelectParts::exeSelect() {
alPadRumbleFunction::makePadRumbleParamNearFarVolumePitch(&param, 0.0f, 500.0f,
pitch * 0.05f, pitch);
param.mIsUseController = 1;
param.isUseController = 1;
alPadRumbleFunction::startPadRumbleNo3DWithParam(
alPadRumbleFunction::getPadRumbleDirector(mLayoutActor), "240Hz単発", param, -1);

16
src/Layout/ShopLayoutInfo.h
View file

@ -7,17 +7,17 @@ namespace ShopItem {
enum class ItemType : u32 { Cloth, Cap, Gift, Sticker, UseItem, Moon };
struct ShopItemInfo {
s32 mCharacterId;
s32 mNumberingId;
s32 characterId;
s32 numberingId;
};
struct ItemInfo {
s32 mIndex;
char mName[0x80];
ItemType mType;
u32 mItemCount;
ShopItemInfo* mShopItemInfo;
bool mIsAOC;
s32 index;
char name[0x80];
ItemType type;
u32 itemCount;
ShopItemInfo* shopItemInfo;
bool isAOC;
};
} // namespace ShopItem

2
src/Npc/Achievement.cpp
View file

@ -6,5 +6,5 @@
Achievement::Achievement(const AchievementInfo* info) : mInfo(info) {}
bool Achievement::isGet(GameDataHolderAccessor accessor) const {
return mIsGet || rs::checkGetAchievement(accessor, mInfo->mName);
return mIsGet || rs::checkGetAchievement(accessor, mInfo->name);
}

12
src/Npc/AchievementHolder.cpp
View file

@ -35,14 +35,14 @@ bool AchievementHolder::isGetMoon(s32 index, GameDataHolderAccessor accessor) co
bool AchievementHolder::isAchieve(s32 index, GameDataHolderAccessor accessor) const {
return getAchievementProgressCurrent(index, accessor) >=
mAchievementInfoReader->get(index)->mNum;
mAchievementInfoReader->get(index)->num;
}
s32 AchievementHolder::getAchievementProgressCurrent(s32 index,
GameDataHolderAccessor accessor) const {
s32 progressCurrentRow = getAchievementProgressCurrentRow(index, accessor);
auto* infoItem = mAchievementInfoReader->get(index);
const char** name = infoItem ? &infoItem->mName : nullptr;
const char** name = infoItem ? &infoItem->name : nullptr;
if (al::isEqualSubString(*name, "Shine_")) {
s32 max = 999;
@ -65,13 +65,13 @@ s32 AchievementHolder::getAchievementProgressCurrent(s32 index,
}
s32 AchievementHolder::getAchievementProgressMax(s32 index, GameDataHolderAccessor) const {
return mAchievementInfoReader->get(index)->mNum;
return mAchievementInfoReader->get(index)->num;
}
s32 AchievementHolder::getAchievementProgressCurrentRow(s32 index,
GameDataHolderAccessor accessor) const {
auto* infoItem = mAchievementInfoReader->get(index);
const char** name = infoItem ? &infoItem->mName : nullptr;
const char** name = infoItem ? &infoItem->name : nullptr;
if (al::isEqualString(*name, "Scenario_Ending"))
return 1;
@ -171,7 +171,7 @@ s32 AchievementHolder::calcAchieveTotalNum(GameDataHolderAccessor accessor) cons
s32 count = 0;
for (s32 i = 0; i < mArray.capacity(); i++)
if (getAchievementProgressCurrent(i, accessor) >= mAchievementInfoReader->get(i)->mNum)
if (getAchievementProgressCurrent(i, accessor) >= mAchievementInfoReader->get(i)->num)
count++;
return count;
@ -190,7 +190,7 @@ s32 AchievementHolder::calcMoonGetTotalNum(GameDataHolderAccessor accessor) cons
Achievement* AchievementHolder::tryGetNewAchievement(GameDataHolderAccessor accessor) const {
for (s32 i = 0; i < mArray.capacity(); i++)
if (!mArray[i]->isGet(accessor) &&
getAchievementProgressCurrent(i, accessor) >= mAchievementInfoReader->unsafeAt(i)->mNum)
getAchievementProgressCurrent(i, accessor) >= mAchievementInfoReader->unsafeAt(i)->num)
return mArray[i];
return nullptr;
}

2
src/Npc/AchievementInfoReader.cpp
View file

@ -41,7 +41,7 @@ void AchievementInfoReader::init() {
s32 AchievementInfoReader::tryFindIndexByName(const char* name) const {
for (s32 i = 0; i < mAchievements.size(); i++)
if (al::isEqualString(name, mAchievements[i]->mName))
if (al::isEqualString(name, mAchievements[i]->name))
return i;
return -1;
}

14
src/Npc/AchievementInfoReader.h
View file

@ -2,17 +2,15 @@
#include <container/seadPtrArray.h>
#include "Library/Base/StringUtil.h"
class AchievementInfo {
struct AchievementInfo {
public:
AchievementInfo(const char* name, s32 num, s32 level, const char* note)
: mName(name), mNum(num), mLevel(level), mNote(note) {}
: name(name), num(num), level(level), note(note) {}
const char* mName;
s32 mNum;
s32 mLevel;
const char* mNote;
const char* name;
s32 num;
s32 level;
const char* note;
};
class AchievementInfoReader {

4
src/Npc/FukuwaraiFaceParts.cpp
View file

@ -229,8 +229,8 @@ f32 FukuwaraiFaceParts::calcScore(bool isMario) const {
return -5.0f;
}
return bodyPart.mBasePoints + bodyPart.mDistancePoints * calcScoreDistRate() +
bodyPart.mAnglePoints * calcScoreAngleRate();
return bodyPart.basePoints + bodyPart.distancePoints * calcScoreDistRate() +
bodyPart.anglePoints * calcScoreAngleRate();
}
bool FukuwaraiFaceParts::isPlaced() const {

6
src/Npc/FukuwaraiFaceParts.h
View file

@ -12,9 +12,9 @@ class PlayerHackStartShaderCtrl;
struct FukuwaraiPart {
const char* name;
f32 mBasePoints;
f32 mAnglePoints;
f32 mDistancePoints;
f32 basePoints;
f32 anglePoints;
f32 distancePoints;
};
class FukuwaraiFaceParts : public al::LiveActor {

56
src/Player/PlayerCostumeInfo.cpp
View file

@ -4,11 +4,11 @@
#include "Library/Math/MathUtil.h"
PlayerHeadCostumeInfo::PlayerHeadCostumeInfo(const char* a1) {
mCostumeName = a1;
costumeName = a1;
}
PlayerBodyCostumeInfo::PlayerBodyCostumeInfo(const char* a1) {
mCostumeName = a1;
costumeName = a1;
}
PlayerCostumeInfo::PlayerCostumeInfo() = default;
@ -19,83 +19,83 @@ void PlayerCostumeInfo::init(const PlayerBodyCostumeInfo* body, const PlayerHead
}
bool PlayerCostumeInfo::isEnableBigEar() const {
return mBodyInfo->mIsBigEar && mHeadInfo->mIsEnableBigEar;
return mBodyInfo->isBigEar && mHeadInfo->isEnableBigEar;
}
bool PlayerCostumeInfo::isEnableHairNoCap() const {
return mHeadInfo->mIsEnableHairNoCap &&
(mBodyInfo->mIsUseBodyHair && mBodyInfo->mIsExistHairNoCap);
return mHeadInfo->isEnableHairNoCap &&
(mBodyInfo->isUseBodyHair && mBodyInfo->isExistHairNoCap);
}
bool PlayerCostumeInfo::isEnableCostume2D() const {
if (mBodyInfo->mIsNoPairHead)
return al::isEqualString(mHeadInfo->mCostumeName, "Mario");
return al::isEqualString(mBodyInfo->mCostumeName, mHeadInfo->mCostumeName);
if (mBodyInfo->isNoPairHead)
return al::isEqualString(mHeadInfo->costumeName, "Mario");
return al::isEqualString(mBodyInfo->costumeName, mHeadInfo->costumeName);
}
bool PlayerCostumeInfo::isNeedShrinkNose() const {
return mHeadInfo->mIsShrinkNose;
return mHeadInfo->isShrinkNose;
}
bool PlayerCostumeInfo::isNeedBodyHair() const {
if (!mBodyInfo->mIsUseBodyHair || (mBodyInfo->mIsMario64 && mHeadInfo->mIsMario64))
if (!mBodyInfo->isUseBodyHair || (mBodyInfo->isMario64 && mHeadInfo->isMario64))
return false;
return true;
}
bool PlayerCostumeInfo::isNeedSyncBodyHair() const {
#ifdef MATCHING_HACK_NX_CLANG
s64 v1 = *(s64*)&mBodyInfo->mIsUseBodyHair;
s64 v1 = *(s64*)&mBodyInfo->isUseBodyHair;
if (!((char)v1))
return false;
if ((v1 & 0xFF00000000LL) && mHeadInfo->mIsMario64)
if ((v1 & 0xFF00000000LL) && mHeadInfo->isMario64)
return false;
return !mBodyInfo->mIsMario64;
return !mBodyInfo->isMario64;
#else
if (!mBodyInfo->mIsUseBodyHair)
if (!mBodyInfo->isUseBodyHair)
return false;
if (mBodyInfo->mIsMario64 && mHeadInfo->mIsMario64)
if (mBodyInfo->isMario64 && mHeadInfo->isMario64)
return false;
return !mBodyInfo->mIsMario64;
return !mBodyInfo->isMario64;
#endif
}
bool PlayerCostumeInfo::isNeedFullFaceAnim() const {
return mHeadInfo->mIsFullFace;
return mHeadInfo->isFullFace;
}
bool PlayerCostumeInfo::isHidePainNose() const {
return mBodyInfo->mIsHidePainNose || mHeadInfo->mIsInvisibleHead;
return mBodyInfo->isHidePainNose || mHeadInfo->isInvisibleHead;
}
bool PlayerCostumeInfo::isEnableEarring() const {
if (mBodyInfo->mIsUseEarringPeach)
return !mHeadInfo->mIsHideEarringPeach;
return !mBodyInfo->mIsUseEarringLink || !mHeadInfo->mIsHideEarringLink;
if (mBodyInfo->isUseEarringPeach)
return !mHeadInfo->isHideEarringPeach;
return !mBodyInfo->isUseEarringLink || !mHeadInfo->isHideEarringLink;
}
bool PlayerCostumeInfo::isSyncFaceBeard() const {
return mBodyInfo->mIsUseBeard && mHeadInfo->mIsHideBeard;
return mBodyInfo->isUseBeard && mHeadInfo->isHideBeard;
}
bool PlayerCostumeInfo::isSyncStrap() const {
return mHeadInfo->mIsUseStrap && !mBodyInfo->mIsUseBeard;
return mHeadInfo->isUseStrap && !mBodyInfo->isUseBeard;
}
bool PlayerCostumeInfo::isFollowJoeStrap() const {
return mHeadInfo->mIsUseStrap && !mBodyInfo->mIsMario64;
return mHeadInfo->isUseStrap && !mBodyInfo->isMario64;
}
bool PlayerCostumeInfo::isPreventHeadPain() const {
return mHeadInfo->mIsPreventHead;
return mHeadInfo->isPreventHead;
}
bool PlayerCostumeInfo::isInvisibleHead() const {
return mHeadInfo->mIsInvisibleHead;
return mHeadInfo->isInvisibleHead;
}
s32 PlayerCostumeInfo::calcWarmLevel(s32 baseLevel) const {
if (mBodyInfo->mIsIgnoreTemperature)
if (mBodyInfo->isIgnoreTemperature)
return false;
return al::clamp(mBodyInfo->mWarmLevel + baseLevel, -3, 3);
return al::clamp(mBodyInfo->warmLevel + baseLevel, -3, 3);
}

56
src/Player/PlayerCostumeInfo.h
View file

@ -6,40 +6,40 @@ struct PlayerHeadCostumeInfo {
public:
PlayerHeadCostumeInfo(const char*);
const char* mCostumeName;
bool mIsFullFace = false;
bool mIsShrinkNose = false;
bool mIsPreventHead = false;
bool mIsEnableBigEar = false;
bool mIsEnableHairNoCap = false;
bool mIsMario64 = false;
bool mIsHaveShort = false;
bool mIsHideBeard = false;
bool mIsHideEarringPeach = false;
bool mIsHideEarringLink = false;
bool mIsUseStrap = false;
bool mIsInvisibleHead = false;
const char* costumeName;
bool isFullFace = false;
bool isShrinkNose = false;
bool isPreventHead = false;
bool isEnableBigEar = false;
bool isEnableHairNoCap = false;
bool isMario64 = false;
bool isHaveShort = false;
bool isHideBeard = false;
bool isHideEarringPeach = false;
bool isHideEarringLink = false;
bool isUseStrap = false;
bool isInvisibleHead = false;
};
struct PlayerBodyCostumeInfo {
public:
PlayerBodyCostumeInfo(const char*);
const char* mCostumeName;
s32 mWarmLevel = 0;
bool mIsIgnoreTemperature = false;
bool mIsUseHeadSuffix = false;
bool mIsBigEar = false;
bool mIsHideHeadHair = false;
bool mIsUseBodyHair = false;
bool mIsExistHairNoCap = false;
bool mIsUseShortHead = false;
bool mIsNoPairHead = false;
bool mIsMario64 = false;
bool mIsHidePainNose = false;
bool mIsUseBeard = false;
bool mIsUseEarringPeach = false;
bool mIsUseEarringLink = false;
const char* costumeName;
s32 warmLevel = 0;
bool isIgnoreTemperature = false;
bool isUseHeadSuffix = false;
bool isBigEar = false;
bool isHideHeadHair = false;
bool isUseBodyHair = false;
bool isExistHairNoCap = false;
bool isUseShortHead = false;
bool isNoPairHead = false;
bool isMario64 = false;
bool isHidePainNose = false;
bool isUseBeard = false;
bool isUseEarringPeach = false;
bool isUseEarringLink = false;
};
class PlayerCostumeInfo {

14
src/Player/PlayerJumpMessageRequest.cpp
View file

@ -3,11 +3,11 @@
PlayerJumpMessageRequest::PlayerJumpMessageRequest() {}
void PlayerJumpMessageRequest::clear() {
mJumpType = PlayerJumpType::Standard;
mJumpPower = 0.0f;
mExtendFrame = 0;
mTurnJumpAngle = {0.0f, 0.0f, 0.0f};
mActorTrans = {0.0f, 0.0f, 0.0f};
mIsSpinClockwise = false;
mIsEnableStandUp = false;
jumpType = PlayerJumpType::Standard;
jumpPower = 0.0f;
extendFrame = 0;
turnJumpAngle = {0.0f, 0.0f, 0.0f};
actorTrans = {0.0f, 0.0f, 0.0f};
isSpinClockwise = false;
isEnableStandUp = false;
}

14
src/Player/PlayerJumpMessageRequest.h
View file

@ -11,11 +11,11 @@ struct PlayerJumpMessageRequest {
PlayerJumpMessageRequest();
void clear();
PlayerJumpType mJumpType = PlayerJumpType::Standard;
f32 mJumpPower = 0;
s32 mExtendFrame = 0;
sead::Vector3f mTurnJumpAngle = {0.0f, 0.0f, 0.0f};
sead::Vector3f mActorTrans = {0.0f, 0.0f, 0.0f};
bool mIsSpinClockwise = 0;
bool mIsEnableStandUp = 0;
PlayerJumpType jumpType = PlayerJumpType::Standard;
f32 jumpPower = 0;
s32 extendFrame = 0;
sead::Vector3f turnJumpAngle = {0.0f, 0.0f, 0.0f};
sead::Vector3f actorTrans = {0.0f, 0.0f, 0.0f};
bool isSpinClockwise = 0;
bool isEnableStandUp = 0;
};

18
src/Player/PlayerModelHolder.cpp
View file

@ -8,13 +8,13 @@ PlayerModelHolder::PlayerModelHolder(u32 bufferSize) {
void PlayerModelHolder::registerModel(al::LiveActor* liveActor, const char* name) {
Entry* entry = new Entry{liveActor};
entry->mName = name;
entry->name = name;
mBuffer.pushBack(entry);
}
void PlayerModelHolder::changeModel(const char* name) {
for (auto it = mBuffer.begin(), end = mBuffer.end(); it != end; ++it) {
if (al::isEqualString(it->mName, sead::SafeString(name))) {
if (al::isEqualString(it->name, sead::SafeString(name))) {
mCurrentModel = &*it;
return;
}
@ -23,22 +23,22 @@ void PlayerModelHolder::changeModel(const char* name) {
al::LiveActor* PlayerModelHolder::findModelActor(const char* name) const {
for (auto it = mBuffer.begin(), end = mBuffer.end(); it != end; ++it)
if (al::isEqualString(it->mName, sead::SafeString(name)))
return it->mLiveActor;
return mCurrentModel->mLiveActor;
if (al::isEqualString(it->name, sead::SafeString(name)))
return it->actor;
return mCurrentModel->actor;
}
al::LiveActor* PlayerModelHolder::tryFindModelActor(const char* name) const {
for (auto it = mBuffer.begin(), end = mBuffer.end(); it != end; ++it)
if (al::isEqualString(it->mName, sead::SafeString(name)))
return it->mLiveActor;
if (al::isEqualString(it->name, sead::SafeString(name)))
return it->actor;
return nullptr;
}
bool PlayerModelHolder::isCurrentModelLabel(const char* name) const {
return al::isEqualString(mCurrentModel->mName.cstr(), name);
return al::isEqualString(mCurrentModel->name.cstr(), name);
}
bool PlayerModelHolder::isCurrentModelLabelSubString(const char* name) const {
return al::isEqualSubString(mCurrentModel->mName.cstr(), name);
return al::isEqualSubString(mCurrentModel->name.cstr(), name);
}

6
src/Player/PlayerModelHolder.h
View file

@ -10,10 +10,10 @@ class LiveActor;
class PlayerModelHolder {
public:
struct Entry {
Entry(al::LiveActor* liveActor) : mLiveActor(liveActor) {}
Entry(al::LiveActor* actor) : actor(actor) {}
sead::FixedSafeString<128> mName;
al::LiveActor* mLiveActor;
sead::FixedSafeString<128> name;
al::LiveActor* actor;
};
PlayerModelHolder(u32);

24
src/Sequence/GameSequenceInfo.cpp
View file

@ -65,19 +65,19 @@ void GameSequenceInfo::setShopStatus(s32 shopStatus) {
namespace rs {
void setSceneStatusBossBattle(const al::LiveActor* actor) {
((GameDataHolder*)actor->getSceneInfo()->mGameDataHolder)
((GameDataHolder*)actor->getSceneInfo()->gameDataHolder)
->getSequenceInfo()
->setSceneStatusBossBattle();
}
void setSceneStatusBossBattleEnd(const al::LiveActor* actor) {
((GameDataHolder*)actor->getSceneInfo()->mGameDataHolder)
((GameDataHolder*)actor->getSceneInfo()->gameDataHolder)
->getSequenceInfo()
->setSceneStatusBossBattleEnd();
}
void setSceneStatusBossBattleEndForPlayerAnim(const al::LiveActor* actor) {
((GameDataHolder*)actor->getSceneInfo()->mGameDataHolder)
((GameDataHolder*)actor->getSceneInfo()->gameDataHolder)
->getSequenceInfo()
->setSceneStatusBossBattleEndForPlayerAnim();
}
@ -87,7 +87,7 @@ bool isSceneStatusBossBattle(GameDataHolderAccessor accessor) {
}
bool isSceneStatusBossBattleForPlayerAnim(const al::LiveActor* actor) {
return ((GameDataHolder*)actor->getSceneInfo()->mGameDataHolder)
return ((GameDataHolder*)actor->getSceneInfo()->gameDataHolder)
->getSequenceInfo()
->isSceneStatusBossBattleForPlayerAnim();
}
@ -106,7 +106,7 @@ bool isInvalidSaveStage(const char* stageName) {
}
bool isWipeOpenEnd(const al::LiveActor* actor) {
return ((GameDataHolder*)actor->getSceneInfo()->mGameDataHolder)
return ((GameDataHolder*)actor->getSceneInfo()->gameDataHolder)
->getSequenceInfo()
->isWipeOpenEnd();
}
@ -125,43 +125,43 @@ bool isShopStatusBuyItem(const al::LiveActor* actor) {
}
bool isShopStatusBuyShine(const al::LiveActor* actor) {
return ((GameDataHolder*)actor->getSceneInfo()->mGameDataHolder)
return ((GameDataHolder*)actor->getSceneInfo()->gameDataHolder)
->getSequenceInfo()
->isShopStatus(GameSequenceInfo::ShopStatus_BuyShine);
}
bool isShopStatusBuyShineMany(const al::LiveActor* actor) {
return ((GameDataHolder*)actor->getSceneInfo()->mGameDataHolder)
return ((GameDataHolder*)actor->getSceneInfo()->gameDataHolder)
->getSequenceInfo()
->isShopStatus(GameSequenceInfo::ShopStatus_BuyShineMany);
}
bool isShopStatusBuyMaxLifeUpItem(const al::LiveActor* actor) {
return ((GameDataHolder*)actor->getSceneInfo()->mGameDataHolder)
return ((GameDataHolder*)actor->getSceneInfo()->gameDataHolder)
->getSequenceInfo()
->isShopStatus(GameSequenceInfo::ShopStatus_BuyMaxLifeUpItem);
}
void setShopStatusBuyShine(const al::LiveActor* actor) {
((GameDataHolder*)actor->getSceneInfo()->mGameDataHolder)
((GameDataHolder*)actor->getSceneInfo()->gameDataHolder)
->getSequenceInfo()
->setShopStatus(GameSequenceInfo::ShopStatus_BuyShine);
}
void setShopStatusBuyShineMany(const al::LiveActor* actor) {
((GameDataHolder*)actor->getSceneInfo()->mGameDataHolder)
((GameDataHolder*)actor->getSceneInfo()->gameDataHolder)
->getSequenceInfo()
->setShopStatus(GameSequenceInfo::ShopStatus_BuyShineMany);
}
void setShopStatusBuyMaxLifeUpItem(const al::LiveActor* actor) {
((GameDataHolder*)actor->getSceneInfo()->mGameDataHolder)
((GameDataHolder*)actor->getSceneInfo()->gameDataHolder)
->getSequenceInfo()
->setShopStatus(GameSequenceInfo::ShopStatus_BuyMaxLifeUpItem);
}
void setShopStatusNone(const al::LiveActor* actor) {
((GameDataHolder*)actor->getSceneInfo()->mGameDataHolder)
((GameDataHolder*)actor->getSceneInfo()->gameDataHolder)
->getSequenceInfo()
->setShopStatus(GameSequenceInfo::ShopStatus_None);
}

16
src/System/MapDataHolder.h
View file

@ -16,15 +16,15 @@ class IUseSceneObjHolder;
} // namespace al
struct MapData {
sead::Matrix44f mViewProjMatrix;
sead::Matrix34f mViewMatrix;
sead::Matrix44f mProjMatrix;
nn::ui2d::TextureInfo* mTexture2dMap;
sead::Matrix44f viewProjMatrix;
sead::Matrix34f viewMatrix;
sead::Matrix44f projMatrix;
nn::ui2d::TextureInfo* texture2dMap;
void* field_b8; // TODO unknown type
s32 mPartsNum;
void** mParts; // TODO unknown type
s32 mWorldScenarioNum;
sead::PtrArray<MapData> mScenarioMapData;
s32 partsNum;
void** parts; // TODO unknown type
s32 worldScenarioNum;
sead::PtrArray<MapData> scenarioMapData;
};
class MapDataHolder {

18
tools/check-format.py
View file

@ -320,15 +320,20 @@ def common_self_other(c, path, is_header):
# Header files
def header_sorted_visibility(c, path):
is_in_struct = False
visibilities_ordered = ["public:", "protected:", "private:"]
nest_level = [-2] # -2 = outside of class ; -1 = inside class ; 0 = public ; 1 = protected ; 2 = private
should_start_class = False
for line in c.splitlines():
if re.search(r"^\s*struct.*{", line):
is_in_struct = True
if "};" in line:
is_in_struct = False
line = line[0:line.find("//")] if "//" in line else line
if line.endswith("\\"): line = line[0:-1]
line = line.strip()
if line not in visibilities_ordered:
header_check_line(line, path, nest_level[-1], should_start_class)
header_check_line(line, path, nest_level[-1], should_start_class, is_in_struct)
if "{" in line and "}" in line:
if CHECK(lambda a: a.count("{") == a.count("}") or (a.startswith("{") and a.endswith("}};")), line,
"Unbalanced \"{\" and \"}\" in the same line! (exception: end of brace-initialized array)",
@ -367,15 +372,20 @@ def header_sorted_visibility(c, path):
if not runAllChecks:
exit(1)
def header_check_line(line, path, visibility, should_start_class):
def header_check_line(line, path, visibility, should_start_class, is_in_struct):
if is_in_struct:
if re.search(r"\w+[\*&]*\s+m[A-Z]", line):
FAIL("Struct member variables should be formatted as noPrefixCamelCase!", line, path)
if visibility == -2: # outside of class/struct/...
if (line.startswith("class") and (not line.endswith(";") or "{" in line)) or should_start_class:
if ": " in line and not ": public" in line and not ": virtual public" in line:
FAIL("All superclasses must be public!", line, path)
if should_start_class and not ": " in line and not line.startswith("public") and not line.startswith(
"virtual public"):
FAIL("All superclasses must be public!", line, path)
FAIL("All superclasses must be public!", line, path)
if line.startswith("class") and "{" in line and ": " in line:
index = 0