From a7a7c1f904622c7fa883124e57ca8bc42088c9ea Mon Sep 17 00:00:00 2001 From: RootCubed Date: Thu, 7 May 2026 08:43:23 +0200 Subject: [PATCH 01/29] dBg_c 69% matching (nice) --- include/game/bases/d_3d.hpp | 10 + include/game/bases/d_a_player_manager.hpp | 3 + include/game/bases/d_bg.hpp | 310 +++- include/game/bases/d_bg_global.hpp | 63 + include/game/bases/d_bg_parameter.hpp | 19 +- include/game/bases/d_bg_tex.hpp | 32 + include/game/bases/d_cd_data.hpp | 13 +- include/game/bases/d_info.hpp | 3 +- include/game/bases/d_p_switch_manager.hpp | 12 + include/game/bases/d_s_stage.hpp | 1 + include/game/mLib/m_3d/proc.hpp | 2 + include/game/mLib/m_vec.hpp | 5 + include/game/mLib/m_video.hpp | 10 +- slices/wiimj2d.json | 15 +- source/dol/bases/d_a_player_base.cpp | 8 +- source/dol/bases/d_actor.cpp | 4 +- source/dol/bases/d_bg.cpp | 1956 +++++++++++++++++++++ source/dol/bases/d_cc.cpp | 4 +- 18 files changed, 2432 insertions(+), 38 deletions(-) create mode 100644 include/game/bases/d_3d.hpp create mode 100644 include/game/bases/d_bg_global.hpp create mode 100644 include/game/bases/d_bg_tex.hpp create mode 100644 include/game/bases/d_p_switch_manager.hpp create mode 100644 source/dol/bases/d_bg.cpp diff --git a/include/game/bases/d_3d.hpp b/include/game/bases/d_3d.hpp new file mode 100644 index 00000000..41fd6453 --- /dev/null +++ b/include/game/bases/d_3d.hpp @@ -0,0 +1,10 @@ +#pragma once +#include + +namespace d3d { + +class proc_c : public m3d::proc_c { + +}; + +} // namespace d3d diff --git a/include/game/bases/d_a_player_manager.hpp b/include/game/bases/d_a_player_manager.hpp index c82490dc..51fb8eb7 100644 --- a/include/game/bases/d_a_player_manager.hpp +++ b/include/game/bases/d_a_player_manager.hpp @@ -43,6 +43,9 @@ class daPyMng_c { } return res; } + static u8 getActScrollInfo(); /// @unofficial + static int getScrollNum(); + static bool isScrollMode1() { return getScrollNum() == 1; } static bool checkPlayer(u8 plrNo) { return mActPlayerInfo & (1 << plrNo); } static int getRest(PLAYER_TYPE_e plrNo) { return mRest[plrNo]; } diff --git a/include/game/bases/d_bg.hpp b/include/game/bases/d_bg.hpp index 526d4dff..0f7ad2d1 100644 --- a/include/game/bases/d_bg.hpp +++ b/include/game/bases/d_bg.hpp @@ -1,12 +1,124 @@ #pragma once +#include +#include +#include +#include +#include +#include #include +#include -class dBg_c { +struct dBgCheckUnit { + // dBgCheckUnit() {} + // float x, y; + unsigned long long a; + // u8 a, b, c; + // int d; + // u8 test[8]; + // u32 flags[2]; + + // bool checkBit(int bit) { + // if (bit > 32) { + // return flags[1] & (1 << (bit - 32)); + // } else { + // return flags[0] & (1 << bit); + // } + // } + // void setBit(int bit) { + // if (bit > 32) { + // flags[1] |= (1 << (bit - 32)); + // } else { + // flags[0] |= (1 << bit); + // } + // } + // void clearBit(int bit) { + // if (bit > 32) { + // flags[0] &= (1 << (bit - 32)); + // flags[1] &= ~0; + // } else { + // flags[0] &= ~0; + // flags[1] &= (1 << bit); + // } + // } +}; + +class dProcShareProc_c : public d3d::proc_c { +public: + dProcShareProc_c() : idk(0) {} + // virtual ~dProcShareProc_c() {} + mAllocator_c mAlloc; + u32 idk; +}; + +class dShareBgTexProc_c : public dProcShareProc_c { +public: + dShareBgTexProc_c() {} + // virtual ~dShareBgTexProc_c() {} + virtual void remove(); + + void create(bgTex_c *, EGG::Heap *); +}; + +struct dBgScrollLimit_c { + float mL, mR, mU, mD; + float mL2, mR2, mU2, mD2; + float mL3, mR3, mU3, mD3; + float mL4, mR4, mU4, mD4; + u16 mFlags; +}; + +class dBgBound_c { +public: + dBgBound_c() : mLeft(0.0f), mRight(0.0f), mUp(0.0f), mDown(0.0f) {} + + float mLeft, mRight, mUp, mDown; +}; + +struct dBgSomeInfo_c { + dBgSomeInfo_c() : + m_10(0), m_14(0), m_18(0), m_1c(0) {} + + dBgBound_c mBounds; + int m_10, m_14, m_18, m_1c, m_20, m_24, m_28, m_2c, m_30; +}; + +struct dBgSubstruct2_c { +public: + float mFloat1, mFloat2, mFloat3, mFloat4; + u8 mU8_1; + u8 mU8_2; + u8 mU8_3; +}; + +struct dBgAnimObj_c { + void set(dBgAnimObj_c obj) { *this = obj; } + + float mX, mY; + u8 mType; +}; + +struct dHeapSize_c { +public: + dHeapSize_c(size_t size) : mSize(size) {} + + size_t mSize; +}; + +struct sBgThing { + u16 m_00; + u16 m_02; + int m_04; + int m_08; + int m_0c; +};; + +class dBg_c : public dBase_c { class dBg_autoScroll_c { public: dBg_autoScroll_c() {} ~dBg_autoScroll_c() {} + // char data[0x1c]; mVec3_c mPos; float m_0c; float m_10; @@ -17,31 +129,189 @@ class dBg_c { }; public: - u8 mPad1[0x8fe70]; - float m_8fe00; - u8 mPad2[0x2c]; - float mLoopOffset; - u8 mPad3[0x20]; - float mLiquidHeight; - u8 mPad4[0x144]; - float mDispScale; - float m_8ffa8; - float mPrevDispScale; - u8 mPad5[0x61]; - u8 m_90009; - u8 mPad6[0x30]; - dBg_autoScroll_c mAutoscrolls[2]; - u8 mPad7[0x1a]; - u8 m_9008e; + dBg_c(); + virtual ~dBg_c(); + + void CreateBgCheckBuffer(); + + unsigned long long fn_800774A0(u16); + static unsigned long long fn_80081960(unsigned long long, int); + dBgUnit_c *fn_80077520(u16 param_2, u16 param_3, u8 param_4, int *param_5, bool b); + + unsigned long long getBgCheckBuff(u16); + unsigned long long *getpBgCheckBuff(u16); + u16 GetUnitNumber(u16, u16, u8, bool); + u16 GetMaskedUnitNumber(u16, u16, u8); + unsigned long long GetBgCheckData(u16, u16, u8); + u32 GetUnitTypeInfo(u16, u16, u8); + u32 GetUnitKindInfo(u16, u16, u8); + void CoinGetCommon(u16, u16, int, u16 *, u16 *, u16 *); + void CoinGetBitSet(u16, u16, int); + bool CoinGetBitCheck(u16, u16, int); + void BgUnitChange(u16, u16, int, u16); + bool CheckExistLayer(u8); + void DispScaleCalc(); + void CreateBgTex(); + void RemoveBgTex(); + + bgTex_c *__createBgTex(int, u16, u16, u16, u16, int, int); + void fn_80078250(u16, u16, u16, u32); + void fn_80078300(); + void fn_80077860(u16, u16, int, u16); + void setWaterInWave(float, float, u8); + void setBubble(float, float, u8, u8); + + void InitWmSwitchPushed(); + bool IsWmSwitchPushed(); + + dPanelObjMgr_c *getPanelObjMgr(int idx); - float getLiquidHeight() const { return mLiquidHeight; } + static u16 dBg_getUpLimitScroll(u8); + static int dBg_getScrlAreaDataSize(u8); + static sScrollAreaData *dBg_getScrlAreaDataP(u8, u8); + bool dBg_isFlyPlayer(); + int dBg_isCloudFlyPlayer(); + bool dBg_isCloudFlyPlayerMulti(); // [Not static? bruh] - void setWaterInWave(float x, float y, u8 type); + float fn_80078860(float); + + float getMaxLeftPos(); float getLeftLimit(); + float getMaxRightPos(); float getRightLimit(); + float getLeftLimitSingle(); + float getLeftLimitMulti(); + float getZoomTargetMin_Common(); + float getZoomTargetMin(); + float getZoomTargetMid_Common(); + float getZoomTargetMid(); + float getZoomTargetMax_Common(); + float getZoomTargetMax(); + + float getZoomSpreadLine(); + float getZoomSpreadLine2(); + float getZoomShrinkLine(); + float getZoomShrinkLine2(); + + void calcLookatOffs(); + void calcLookatOffsLimit(); + void calcLookatOffsX(dActor_c *); + void calcLookatOffsY(dActor_c *); + + void initAutoScroll(); + void calcLoopAutoScroll(); + void calcAutoScroll(); + void AutoScroll_start(); + void AutoScroll_stop(); + void calcScroll( const mVec3_c&, int ); + void calcMultiScroll( int ); + void initScroll(); + + void fn_8007ac40(dBgSomeInfo_c *, int); + void fn_8007ba70(dBgSomeInfo_c *); + float fn_8007bba0(dBgSomeInfo_c *); + float fn_8007bbf0(dBgSomeInfo_c *); + bool fn_8007bc40(dBgSomeInfo_c *, float); + mVec2_c fn_8007bd40(dBgSomeInfo_c *, float, float, float *); + float fn_8007c7d0(float); + void fn_8007ca90(dBgSomeInfo_c *, int, int); + void fn_8007cd70(dBgSomeInfo_c *, dBgSomeInfo_c *, int); + + float getAreaUpLimitScroll(); + + static void bg_createHeap(); + static void bg_destroyHeap(); float getDispScale() { return mDispScale; } - float getPrevDispScale() { return mPrevDispScale; } + float getPrevDispScale() { return mMoreFloats3[1]; } + float getScaleFactor() { return 1.0f / mDispScale; } + + float getLiquidHeight() const { return mMoreFloats7[5]; } + + typedef void (dBg_c::*callbackFunc)(dBgSomeInfo_c *, int); + + unsigned long long *mBgCheckBuffer; + int mBgThingsRelated; + sBgThing mBgThings[256]; + dBgScrollLimit_c mScrLimit[64][8][16]; + dBgSubstruct2_c mData2[64][20]; + int mGrassCount; + int mFlowerCount; + dBgAnimObj_c mGrass[100]; + dBgAnimObj_c mFlowers[100]; + u8 mUnused1[56]; + float m_8fda8; + u8 mUnused2[40]; + float mBounds4[4]; + float mBounds3[4]; + float mL, mR, mU, mD; + float mMoreFloats[1]; + mVec2_c mSomeSize; + mVec2_c mPrevSomeSize; + mVec2_c mSomePos; + mVec2_c mPrevSomePos; + float mMoreFloats6[2]; + float mLoopOffsetX; + float mLoopOffsetY; + mVec2_c mSomeParameterPos; + float mMoreFloats7[7]; + float mWaveRelated[80]; + float mDispScale; + float mMoreFloats3[4]; + u8 mU8s[5]; + float mZoomDenom; + u8 m_8ffbc; + float mLLimit, mRLimit, mULimit, mDLimit; + float mLLimitSingle, mRLimitSingle, mULimitSingle, mDLimitSingle; + float mLLimitMulti, mRLimitMulti, mULimitMulti, mDLimitMulti; + float mPlayerPosY; + int mIdkI; + float mIdkF[4]; + u8 m_90008; + u8 m_90009; + u8 m_9000a; + callbackFunc mCallbackFunc; + float m_90018; + int m_9001c; + float m_90020; + u8 m_90024; + float mMoreFloats5[5]; + dBg_autoScroll_c mAutoscrolls[2]; + u8 mPad2[8]; + int m_9007c, m_90080; + float m_90084; + short m_90088, m_9008a; + u8 m_9008c, m_9008d; + u8 mLimitRelated; + u8 mLimitRelated2; + u8 m_90090, mScrollID, m_90092, m_90093; + u8 mPad[12]; + float mZoomWeight; + u8 mZoomRelated; + u8 m_900a5, m_900a6, m_900a7, m_900a8; + float m_900ac, m_900b0; + u8 m_900b4; + short m_900b6; + float m_900b8, m_900bc; + float mWaveX[20]; + float mWaveY[20]; + u8 mWaveType[20]; + bool mWaveActive[20]; + float mBubbleX[200]; + float mBubbleY[200]; + u8 mBubbleType[200]; + u8 mBubbleType2[200]; + short m_90958; + u8 m_9095a, m_9095b, m_9095c, m_9095d; + float m_90960; + float m_90964; + dBgSomeInfo_c mSomeInfo1; + dBgSomeInfo_c mSomeInfo2; + bgTex_c *mTex[3]; + dShareBgTexProc_c *mTexProc; + dBgTexMng_c mTexMng; static dBg_c *m_bg_p; + static dHeapSize_c m_HeapSize; + static EGG::FrmHeap *m_FrmHeap_p; }; diff --git a/include/game/bases/d_bg_global.hpp b/include/game/bases/d_bg_global.hpp new file mode 100644 index 00000000..8d6b5655 --- /dev/null +++ b/include/game/bases/d_bg_global.hpp @@ -0,0 +1,63 @@ +#pragma once +#include + +enum UNIT_NUM_e { + UNIT_0 = 0, + UNIT_GRASS_L = 416, ///< Grass (left edge) + UNIT_GRASS_C1, ///< Grass (center 1) + UNIT_GRASS_C2, ///< Grass (center 2) + UNIT_GRASS_C3, ///< Grass (center 3) + UNIT_GRASS_R, ///< Grass (right edge) + UNIT_FLOWER_1 = 432, ///< Yellow flower + UNIT_FLOWER_2, ///< Red flower + UNIT_FLOWER_3, ///< Blue flower + UNIT_GRASS_FLOWER_1 = 448, ///< Grass with yellow flower + UNIT_GRASS_FLOWER_2, ///< Grass with red flower + UNIT_GRASS_FLOWER_3, ///< Grass with blue flower +}; + +#define UNIT_IS_GRASS(x) (\ + x == UNIT_GRASS_L || \ + x == UNIT_GRASS_C1 || x == UNIT_GRASS_C2 || x == UNIT_GRASS_C3 || \ + x == UNIT_GRASS_R \ +) + +#define UNIT_IS_FLOWER(x) (\ + x == UNIT_FLOWER_1 || \ + x == UNIT_FLOWER_2 || \ + x == UNIT_FLOWER_3 \ +) + +#define UNIT_IS_GRASS_FLOWER(x) (\ + x == UNIT_GRASS_FLOWER_1 || \ + x == UNIT_GRASS_FLOWER_2 || \ + x == UNIT_GRASS_FLOWER_3 \ +) + +class dBgUnit_c { +public: + dBgUnit_c *fn_80083b40(u16, u16, int *, bool); ///< @unofficial + + static bool fn_80081900(u16, u16 *); ///< @unofficial + static u16 cvtNum(u16); ///< @unofficial + + u16 mUnitNumber; +}; + +struct dBgData_c { + u32 mLayer0; + u32 mLayer1; + u32 mLayer2; +}; + + +class dBgGlobal_c { +public: + virtual ~dBgGlobal_c(); + char *getEnvironment(int, int); + dBgUnit_c *GetBgUnitP(int, int); + + dBgData_c mData[100]; + + static dBgGlobal_c *ms_pInstance; +}; diff --git a/include/game/bases/d_bg_parameter.hpp b/include/game/bases/d_bg_parameter.hpp index 0fc1f72a..a2cb8f5a 100644 --- a/include/game/bases/d_bg_parameter.hpp +++ b/include/game/bases/d_bg_parameter.hpp @@ -20,11 +20,13 @@ class dBgParameter_c { BG_SCROLL_Y_UP, }; - u8 mPad1[0x38]; + u8 mPad1[0x30]; + mVec2_c m_30; mVec2_c mPos; mVec2_c mSize; - float m_48; - u8 mPad2[0x34]; + mVec2_c mCenter; + u8 mPad2[0x2c]; + float m_78; u8 mScrollDirX; ///< See BG_SCROLL_DIR_X_e. u8 mScrollDirY; ///< See BG_SCROLL_DIR_Y_e. @@ -33,6 +35,12 @@ class dBgParameter_c { const mVec2_c &pos() const { return mPos; } const mVec2_c &size() const { return mSize; } + float posX() const { return mPos.x; } + float posY() const { return mPos.y; } + + float width() const { return mSize.x; } + float height() const { return mSize.y; } + float xStart() const { return pos().x; } float yStart() const { return pos().y; } float xSize() const { return size().x; } @@ -51,6 +59,11 @@ class dBgParameter_c { return y - offset > yStart(); } + u16 getOneGetBuff(u16, u16, int); + u16 setOneGetBuff(u16, u16, int, u16); + + static float m_78_offset() { return 112.0f - getInstance()->m_78; } + static dBgParameter_c *getInstance() { return ms_Instance_p; } static dBgParameter_c *ms_Instance_p; diff --git a/include/game/bases/d_bg_tex.hpp b/include/game/bases/d_bg_tex.hpp new file mode 100644 index 00000000..8c819a81 --- /dev/null +++ b/include/game/bases/d_bg_tex.hpp @@ -0,0 +1,32 @@ +#pragma once +#include +#include + +class dPanelObjMgr_c { + u8 mPad[12]; +}; + +class bgTex_c { +public: + bgTex_c(); + virtual ~bgTex_c() {} + void create(u16, u16, u16, u16, int, int, EGG::Heap *, u16); + void setOpaBuffer(u16, u16, u16); + void setUnitChange(u16, u16, u16); + + u16 mCount; + u16 mSmth; + u8 mPad[0x30]; + dPanelObjMgr_c mPanelObjMgr; +}; + +class dBgTexMng_c { +public: + dBgTexMng_c(); + virtual ~dBgTexMng_c(); + + void create(EGG::Heap *); + + u8 mPad[0x54]; + bool mWmSwitchRelated; +}; diff --git a/include/game/bases/d_cd_data.hpp b/include/game/bases/d_cd_data.hpp index dd1c49db..30021157 100644 --- a/include/game/bases/d_cd_data.hpp +++ b/include/game/bases/d_cd_data.hpp @@ -36,9 +36,12 @@ class sOptionData { /// @unofficial struct sScrollData { - u8 mPad1[0x10]; + int mX, mY; + int mXCloud, mYCloud; u16 mID; - u8 mPad2[0x6]; + u16 mUpLimit; + u16 m_16; + u16 m_18; }; /// @unofficial @@ -49,7 +52,11 @@ struct sBlock4Data { /// @unofficial struct sBgData { u16 mID; - u8 mPad[0x16]; + u16 m_02; + int m_04; + int m_08; + int m_0c; + u8 mPad[0x8]; }; /// @unofficial diff --git a/include/game/bases/d_info.hpp b/include/game/bases/d_info.hpp index 9e4798fa..bbbc3ecb 100644 --- a/include/game/bases/d_info.hpp +++ b/include/game/bases/d_info.hpp @@ -68,7 +68,8 @@ class dInfo_c { bool m_6c; u8 pad4[0x2c]; int m_9c; - u8 pad5[0x2e4]; + u8 pad5[0x2e0]; + bool mIsWmSwitchHit; int mCharIDs[4]; bool mIsWorldSelect; ///< Whether the World Select Menu is being displayed. u8 pad6[0x1e]; diff --git a/include/game/bases/d_p_switch_manager.hpp b/include/game/bases/d_p_switch_manager.hpp new file mode 100644 index 00000000..a0a99724 --- /dev/null +++ b/include/game/bases/d_p_switch_manager.hpp @@ -0,0 +1,12 @@ +#pragma once + +class dPSwManager_c { +public: + enum SwType_e { + SW_TYPE_0 + }; + + bool checkSwitch(SwType_e); + + static dPSwManager_c *ms_instance; +}; diff --git a/include/game/bases/d_s_stage.hpp b/include/game/bases/d_s_stage.hpp index ca43d9b5..bd964b18 100644 --- a/include/game/bases/d_s_stage.hpp +++ b/include/game/bases/d_s_stage.hpp @@ -39,6 +39,7 @@ class dScStage_c : public dScene_c { u8 mCurrFile; u8 mCurrAreaNo; u8 mCurrLayer; + u8 m_1211; u8 getCurrWorld() const { return mCurrWorld; } u8 getCurrArea() const { return mCurrAreaNo; } diff --git a/include/game/mLib/m_3d/proc.hpp b/include/game/mLib/m_3d/proc.hpp index bc73cbec..edabae07 100644 --- a/include/game/mLib/m_3d/proc.hpp +++ b/include/game/mLib/m_3d/proc.hpp @@ -7,6 +7,8 @@ namespace m3d { class proc_c : public scnLeaf_c { public: + virtual ~proc_c() {} + virtual scnLeaf_c::leafType_e getType() const { return scnLeaf_c::TYPE_PROC; }; virtual void drawOpa(); diff --git a/include/game/mLib/m_vec.hpp b/include/game/mLib/m_vec.hpp index 9201d99c..1ec56590 100644 --- a/include/game/mLib/m_vec.hpp +++ b/include/game/mLib/m_vec.hpp @@ -204,6 +204,11 @@ class mVec3_c : public EGG::Vector3f { /// @brief Inequality operator. bool operator!=(const mVec3_c &v) const { return x != v.x || y != v.y || z != v.z; } + /// @brief Returns the length of the vector. + float len() const { + return EGG::Mathf::sqrt(x * x + y * y + z * z); + } + float xzLen() const { return EGG::Mathf::sqrt(x * x + z * z); } diff --git a/include/game/mLib/m_video.hpp b/include/game/mLib/m_video.hpp index 9fbd8319..9fcb01b4 100644 --- a/include/game/mLib/m_video.hpp +++ b/include/game/mLib/m_video.hpp @@ -3,14 +3,20 @@ class mVideo { public: - static void create(); + GXRenderModeObj &mRenderModeObj; float getWidth() const { return mRenderModeObj.fbWidth; } float getHeight() const { return mRenderModeObj.efbHeight; } + static void create(); + + static float getLayoutWidth() { return l_rayoutWidthF; } + static float getLayoutHeight() { return l_rayoutHeightF; } + static float getSmth(float offs) { return (m_video->mRenderModeObj.efbHeight - offs) * 0.5f; } - GXRenderModeObj &mRenderModeObj; + static float l_rayoutWidthF; + static float l_rayoutHeightF; static mVideo *m_video; }; diff --git a/slices/wiimj2d.json b/slices/wiimj2d.json index 39962977..f3fbf998 100644 --- a/slices/wiimj2d.json +++ b/slices/wiimj2d.json @@ -246,11 +246,24 @@ ".sdata2": "0xbb0-0xbc0" } }, + { + "source": "dol/bases/d_bg.cpp", + "nonMatching": true, + "memoryRanges": { + ".text": "0x70850-0x77a00", + ".ctors": "0xb0-0xb4", + ".rodata": "0x1978-0x1be0", + ".data": "0x11040-0x11140", + ".sdata": "0x2d0-0x2d8", + ".sbss": "0x208-0x218", + ".sdata2": "0xc90-0xdd0" + } + }, { "source": "dol/bases/d_cc.cpp", "memoryRanges": { ".text": "0x85a80-0x87500", - ".ctors": "0xc0-c4", + ".ctors": "0xc0-0xc4", ".rodata": "0x2408-0x2418", ".data": "0x12a00-0x12a60", ".sbss": "0x2a0-0x2b0", diff --git a/source/dol/bases/d_a_player_base.cpp b/source/dol/bases/d_a_player_base.cpp index d7e264c2..5d0d736e 100644 --- a/source/dol/bases/d_a_player_base.cpp +++ b/source/dol/bases/d_a_player_base.cpp @@ -4500,7 +4500,7 @@ void daPlBase_c::updateEndingDance() { } else if (dAudio::isBgmAccentSign(64)) { mKey.onDemoShake(); } else if (dAudio::isBgmAccentSign(128)) { - if (dBgParameter_c::ms_Instance_p->m_48 > mPos.x) { + if (dBgParameter_c::ms_Instance_p->mCenter.x > mPos.x) { mDirection = 0; } else { mDirection = 1; @@ -5435,7 +5435,7 @@ float daPlBase_c::getWaterCheckPosY() { void daPlBase_c::checkWater() { mWaterType = dBc_c::WATER_CHECK_NONE; mPrevWaterHeight = mWaterHeight; - mWaterHeight = dBg_c::m_bg_p->m_8fe00; + mWaterHeight = dBg_c::m_bg_p->mD; u8 waterCheck = dBc_c::checkWater(mPos.x, mPos.y, mLayer, &mWaterHeight); if (waterCheck != dBc_c::WATER_CHECK_NONE && mPos.y <= mWaterHeight) { onNowBgCross(BGC_WATER_TOUCH); @@ -5715,7 +5715,7 @@ void daPlBase_c::underOverCheck() { } } if (cond == 1) { - if (selfTop < bgTop && selfTop < dBg_c::m_bg_p->m_8fe00) { + if (selfTop < bgTop && selfTop < dBg_c::m_bg_p->mD) { setFallDownDemo(); } } else if (selfTop < bgTop) { @@ -5786,7 +5786,7 @@ void daPlBase_c::checkDisplayOutDead() { offset = 0.0f; if (!isStatus(STATUS_B8)) { - if (dBg_c::m_bg_p->mAutoscrolls[0].mActive && dBg_c::m_bg_p->m_9008e != 4) { + if (dBg_c::m_bg_p->mAutoscrolls[0].mActive && dBg_c::m_bg_p->mLimitRelated != 4) { offset = -(mWallBcData.mOffset / 4096.0f - 1.0f + getVisSizeX()); } else if (daPyMng_c::mNum > 1) { offset = 16.0f; diff --git a/source/dol/bases/d_actor.cpp b/source/dol/bases/d_actor.cpp index c9de85c3..b22af527 100644 --- a/source/dol/bases/d_actor.cpp +++ b/source/dol/bases/d_actor.cpp @@ -221,7 +221,7 @@ dAcPy_c *dActor_c::searchNearPlayerNormal(mVec2_c &delta, const mVec2_c &pos) { dAcPy_c *dActor_c::searchNearPlayerLoop(mVec2_c &delta, const mVec2_c &pos) { dAcPy_c *closestPlayer = nullptr; - float loopOffset = dBg_c::m_bg_p->mLoopOffset; + float loopOffset = dBg_c::m_bg_p->mLoopOffsetX; mVec2_c loopPos; loopPos.x = dScStage_c::getLoopPosX(pos.x); @@ -286,7 +286,7 @@ bool dActor_c::getTrgToSrcDirLoop(float trgX, float srcX) { float loopSrcX = dScStage_c::getLoopPosX(srcX); float diffX = loopTrgX - loopSrcX; - float loopOffset = dBg_c::m_bg_p->mLoopOffset / 2; + float loopOffset = dBg_c::m_bg_p->mLoopOffsetX / 2; if (diffX < 0.0f) { return !(diffX < -loopOffset); } else { diff --git a/source/dol/bases/d_bg.cpp b/source/dol/bases/d_bg.cpp new file mode 100644 index 00000000..82ec671d --- /dev/null +++ b/source/dol/bases/d_bg.cpp @@ -0,0 +1,1956 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +dHeapSize_c dBg_c::m_HeapSize(0x10000); +EGG::FrmHeap *dBg_c::m_FrmHeap_p = nullptr; +dBg_c *dBg_c::m_bg_p = nullptr; + +void dBg_c::bg_createHeap() { + if (m_FrmHeap_p != nullptr) { + return; + } + m_FrmHeap_p = mHeap::createFrmHeap( + m_HeapSize.mSize, EGG::Heap::getCurrentHeap(), + nullptr, 0x20, mHeap::OPT_NONE + ); +} + +void dBg_c::bg_destroyHeap() { + if (m_FrmHeap_p == nullptr) { + return; + } + + m_FrmHeap_p->destroy(); + m_FrmHeap_p = nullptr; +} + +dBg_c::dBg_c() { + m_bg_p = this; + mBgCheckBuffer = nullptr; + + mBounds4[0] = 0.0f; + mBounds4[1] = 0.0f; + mBounds4[2] = 0.0f; + mBounds4[3] = 0.0f; + + mBounds3[0] = 0.0f; + mBounds3[1] = 0.0f; + mBounds3[2] = 0.0f; + + mMoreFloats[1] = 0.0f; + mMoreFloats[2] = 0.0f; + mMoreFloats[3] = 0.0f; + mMoreFloats[4] = 0.0f; + mMoreFloats[5] = 0.0f; + mMoreFloats[6] = 0.0f; + mMoreFloats[7] = 0.0f; + mMoreFloats[8] = 0.0f; + mMoreFloats[9] = 0.0f; + mMoreFloats[10] = 0.0f; + mLoopOffsetX = 0.0f; + mLoopOffsetY = 0.0f; + mSomeParameterPos.set(0.0f, 0.0f); + mMoreFloats7[1] = 0.0f; + mMoreFloats7[2] = 0.0f; + mMoreFloats[0] = 0.0f; + mMoreFloats7[3] = 0.0f; + mMoreFloats7[4] = 0.0f; + mMoreFloats7[5] = 0.0f; + mMoreFloats7[6] = 0.0f; + + for (int i = 0; i < (int) ARRAY_SIZE(mWaveRelated); i++) { + mWaveRelated[i] = -999999.0f; + } + + mDispScale = 1.0f; + mMoreFloats3[0] = 1.0f; + mMoreFloats3[1] = 1.0f; + mMoreFloats3[2] = 0.0f; + mZoomDenom = 1.0f; + mMoreFloats3[3] = -999999.0f; + mU8s[0] = 0; + mU8s[1] = 0; + mU8s[2] = 0; + m_8ffbc = 0; + mLLimit = 0.0f; + mRLimit = 0.0f; + mULimit = 0.0f; + mDLimit = 0.0f; + mLLimitSingle = 0.0f; + mRLimitSingle = 0.0f; + mULimitSingle = 0.0f; + mDLimitSingle = 0.0f; + mLLimitMulti = 0.0f; + mRLimitMulti = 0.0f; + mULimitMulti = 0.0f; + mDLimitMulti = 0.0f; + m_90008 = 0; + m_90009 = 0; + m_9000a = 0; + mMoreFloats7[0] = 0.0f; + m_90018 = 1.0f; + m_9001c = 0; + m_90020 = 0.0f; + m_90024 = 0; + mMoreFloats5[0] = 1.0f; + mMoreFloats5[3] = 0.0f; + mMoreFloats5[4] = 0.0f; + m_9007c = 0; + m_90080 = 0; + m_90084 = 0.0f; + m_90088 = 0; + m_9008a = 0; + mLimitRelated = 0; + mLimitRelated2 = 0; + m_90090 = 0; + mScrollID = 0; + m_90092 = 0; + m_90093 = 0; + m_900b6 = 0; + m_900b4 = 0; + + mCallbackFunc = &dBg_c::fn_8007ac40; + mTex[0] = nullptr; + mTex[1] = nullptr; + mTex[2] = nullptr; + mTexProc = nullptr; + initAutoScroll(); + m_9095c = 0; + InitWmSwitchPushed(); +} + +dBg_c::~dBg_c() { + m_bg_p = nullptr; +} + +unsigned long long dBg_c::getBgCheckBuff(u16 idx) { + return mBgCheckBuffer[idx]; +} + +unsigned long long *dBg_c::getpBgCheckBuff(u16 idx) { + return &mBgCheckBuffer[idx]; +} + +unsigned long long dBg_c::fn_800774A0(u16 idx) { + u32 idk = idx / 1024U; + u32 bufIdx = idx % 1024U; + unsigned long long cu = getBgCheckBuff(bufIdx); + cu = fn_80081960(cu, idx); + unsigned long long mask = (1ULL << 42); + if (bufIdx > 0x100U) { + u32 top = cu >> 32; + u32 bottom = cu & 0xFFFFFFFF; + // unsigned long long n = ((unsigned long long) top << 32) | (bottom & ~(0x400)); + if ((cu & mask) != 0 && idk != 0) { + return ((unsigned long long) (top & ~(0x400)) << 32) | bottom; + } + } + return cu; +} + +dBgUnit_c *dBg_c::fn_80077520(u16 x, u16 y, u8 layer, int *param_5, bool b) { + int file = dScStage_c::m_instance->mCurrFile; + dBgUnit_c *bgUnit = dBgGlobal_c::ms_pInstance->GetBgUnitP(file, layer); + return bgUnit->fn_80083b40(x, y, param_5, b); +} + +u16 fn_80081ab0(u16); + +u16 dBg_c::GetUnitNumber(u16 x, u16 y, u8 layer, bool p4) { + dBgUnit_c *unit = fn_80077520(x, y, layer, 0, false); + u16 res = -1; + if (unit != nullptr) { + if (p4) { + res = fn_80081ab0(unit->mUnitNumber); + } else { + res = unit->mUnitNumber; + } + } + return res; +} + +u16 dBg_c::GetMaskedUnitNumber(u16 p1, u16 p2, u8 p3) { + u16 data = GetUnitNumber(p1, p2, p3, true); + if (data != (u16) -1) { + data &= 0x3ff; + } + return data; +} + +unsigned long long dBg_c::GetBgCheckData(u16 p1, u16 p2, u8 p3) { + int loopPos = dScStage_c::getLoopPosX(p1); + dBgUnit_c *data = fn_80077520(loopPos, p2, p3, 0, false); + return fn_800774A0(data->mUnitNumber); +} + +u32 dBg_c::GetUnitTypeInfo(u16 p1, u16 p2, u8 p3) { + return GetBgCheckData(p1, p2, p3) >> 32; +} + +u32 dBg_c::GetUnitKindInfo(u16 p1, u16 p2, u8 p3) { + return GetBgCheckData(p1, p2, p3) & 0xFFFFFFFF; +} + +u16 fn_800834b0(u16); + +void dBg_c::CoinGetCommon(u16 p1, u16 p2, int p3, u16 *p4, u16 *p5, u16 *p6) { + int currCourse = dScStage_c::m_instance->mCurrCourse; + u16 var1 = (p2 & 0xf00) * 4; + u16 var3 = p1 / 16 & 0x1f0; + u8 var4 = p1 / 16; + u8 var5 = p2 / 16 & 0xf; + *p4 = dBgParameter_c::ms_Instance_p->getOneGetBuff(currCourse, var1 + var3 + var5, p3); + *p5 = fn_800834b0(var4); + *p6 = var1 + var3 + var5; +} + +void dBg_c::CoinGetBitSet(u16 p1, u16 p2, int p3) { + u16 c; + u16 a; + u16 b; + CoinGetCommon(p1, p2, p3, &a, &b, &c); + a |= b; + dBgParameter_c::ms_Instance_p->setOneGetBuff(dScStage_c::m_instance->mCurrFile, c, p3, a); +} + +bool dBg_c::CoinGetBitCheck(u16 p1, u16 p2, int p3) { + u16 c; + u16 a; + u16 b; + CoinGetCommon(p1, p2, p3, &a, &b, &c); + return (a & b) != 0; +} + +void dBg_c::BgUnitChange(u16 p1, u16 p2, int p3, u16 p4) { + if (p4 == 2 && dPSwManager_c::ms_instance->checkSwitch(dPSwManager_c::SW_TYPE_0)) { + p4 = 4; + } + int idk; + dBgUnit_c *unit = fn_80077520(p1, p2, p3, &idk, true); + if (idk != 0) { + u16 smth = 0; + if (dBgUnit_c::fn_80081900(unit->mUnitNumber, &smth)) { + CoinGetBitSet(p1, p2, p3); + } + u16 n = dBgUnit_c::cvtNum(p4); + if (n == 0xffff) { + if (p4 == 138) { + unit->mUnitNumber &= 0x3ff; + } else if (p4 == 139) { + unit->mUnitNumber |= 0x400; + } + } else { + unit->mUnitNumber = n; + mTex[p3]->setUnitChange(p1 / 16, p2 / 16, n); + } + } +} + +bool dBg_c::CheckExistLayer(u8 layer) { + dScStage_c *stage = dScStage_c::m_instance; + dBgGlobal_c *g = dBgGlobal_c::ms_pInstance; + switch (layer) { + case 0: + return true; + case 1: + if (g->mData[stage->mCurrFile].mLayer1 != 0) { + return true; + } + break; + case 2: + if (g->mData[stage->mCurrFile].mLayer2 != 0) { + return true; + } + break; + } + return false; +} + +void dBg_c::CreateBgCheckBuffer() { + mBgCheckBuffer = new(m_FrmHeap_p, 4) unsigned long long[0x400]; + + int file = dScStage_c::m_instance->mCurrFile; + + char path[64]; + char resName[64]; + + for (int i = 0; i < 4; i++) { + char *env = dBgGlobal_c::ms_pInstance->getEnvironment(file, i); + + if (env[0] != '\0') { + sprintf(path, "BG_chk/d_bgchk_%s.bin", env); + sprintf(resName, "%s", env); + + nw4r::g3d::ResFile data = dResMng_c::m_instance->getRes(resName, path); + for (int j = 0; j < 0x100; j++) { + u64 *buff = getpBgCheckBuff(i * 0x100 + j); + *buff = data.ofs_to_ptr_raw(0)[j]; + } + } + } +} + +void dBg_c::DispScaleCalc() { + float scale = mDispScale; + if (scale == 0.0f) { + scale = 1.0f; + } + dBgParameter_c::ms_Instance_p->mSize.x = mVideo::l_rayoutWidthF / scale; + dBgParameter_c::ms_Instance_p->mSize.y = mVideo::l_rayoutHeightF / scale; +} + +void dBg_c::CreateBgTex() { + mTexMng.create(mHeap::g_gameHeaps[2]); + + u16 w = mL - mR; + + u16 h = mU - mD; + + u16 texWidthMaybe = mL / 16; + u16 texHeightMaybe = -mU / 16; + + u16 iMu = mU; + u16 iMd = mD; + + if ((w & 0xf) != 0) { + w /= 16; + w++; + } else { + w /= 16; + } + + if ((h & 0xf) != 0) { + h /= 16; + h++; + } else { + h /= 16; + if ((iMu & 0xF) != 0) { + h++; + } + if ((iMd & 0xF) != 0) { + h++; + } + } + + if (dScStage_c::m_loopType == 0) { + w += 2; + texWidthMaybe--; + } + h += 2; + texHeightMaybe--; + mTex[0] = __createBgTex(0, texWidthMaybe, texHeightMaybe, w, h, 0, 4); + if (CheckExistLayer(1)) { + mTex[1] = __createBgTex(1, texWidthMaybe, texHeightMaybe, w, h, 127, 3); + } + if (CheckExistLayer(2)) { + mTex[2] = __createBgTex(2, texWidthMaybe, texHeightMaybe, w, h, 3, -1); + mTexProc = new(m_FrmHeap_p, 4) dShareBgTexProc_c(); + mTexProc->create(mTex[2], m_FrmHeap_p); + } +} + +void dBg_c::RemoveBgTex() { + delete mTexProc; + mTexProc = nullptr; + for (int i = 0; i < 3; i++) { + delete mTex[i]; + mTex[i] = nullptr; + } +} + +bgTex_c *dBg_c::__createBgTex(int layer, u16 tw, u16 th, u16 w, u16 h, int i1, int i2) { + bgTex_c *tex = nullptr; + dScStage_c *stage = dScStage_c::m_instance; + dBgGlobal_c *bgGlobal = dBgGlobal_c::ms_pInstance; + dBgUnit_c *bgUnit = bgGlobal->GetBgUnitP(stage->mCurrFile, layer); + if (bgUnit != nullptr) { + tex = new(m_FrmHeap_p, 4) bgTex_c(); + tex->create(tw, th, w, h, i1, i2, mHeap::g_gameHeaps[0], layer); + bool check = false; + + char *env = bgGlobal->getEnvironment(stage->mCurrFile, 1); + if (env[0] != '\0' && + (strcmp(env, "Pa1_nohara") == 0 + || strcmp(env, "Pa1_nohara2") == 0 + || strcmp(env, "Pa1_daishizen") == 0) + ) { + check = true; + } + + for (u16 y = 0; y < tex->mCount; y++) { + u16 x = 0; + if (tex->mSmth == 0) { + continue; + } + unsigned int unitX, unitY; + unitY = (y + th) * 16; + while (x < tex->mSmth) { + unitX = (x + tw) * 16; + u16 unitNum = GetUnitNumber(unitX, unitY, layer, false); + if (unitNum == 0xffff) { + unitNum = UNIT_0; + } + if (check && (UNIT_IS_GRASS(unitNum) || UNIT_IS_FLOWER(unitNum) || UNIT_IS_GRASS_FLOWER(unitNum))) { + int grassIdx = mGrassCount; + int flowerIdx = mFlowerCount; + dBgAnimObj_c animObj; + animObj.mX = unitX + 8; + animObj.mY = -(float) (unitY + 16); + if (UNIT_IS_GRASS(unitNum) || UNIT_IS_GRASS_FLOWER(unitNum)) { + if (UNIT_IS_GRASS(unitNum)) { + animObj.mType = unitNum - UNIT_GRASS_L; + } else { + animObj.mType = unitNum - UNIT_GRASS_FLOWER_1 + 1; // use center grass style + } + dBgAnimObj_c animObjGrass = animObj; + mGrass[grassIdx] = animObjGrass; + if (grassIdx < 100) { + grassIdx++; + } + mGrassCount = grassIdx; + } + if (UNIT_IS_FLOWER(unitNum) || UNIT_IS_GRASS_FLOWER(unitNum)) { + if (unitNum == 432 || unitNum == 433 || unitNum == 434) { + animObj.mType = unitNum - UNIT_FLOWER_1; + } else { + animObj.mType = unitNum - UNIT_GRASS_FLOWER_1; + } + dBgAnimObj_c animObjFlower = animObj; + mFlowers[flowerIdx] = animObjFlower; + // [BUG: should use flowerIdx here] + if (grassIdx < 100) { + flowerIdx++; + } + mFlowerCount = flowerIdx; + } + unitNum = UNIT_0; + } + tex->setOpaBuffer(x, y, unitNum); + x++; + } + } + } + return tex; +} + +u16 dBg_c::dBg_getUpLimitScroll(u8 layer) { + dCdFile_c *file = dCd_c::m_instance->getFileP(dScStage_c::m_instance->mCurrFile); + u8 id = file->getAreaID(layer); + int scrollID = file->getAreaScroll(id); + return file->getScrollDataP(scrollID)->mUpLimit; +} + +int dBg_c::dBg_getScrlAreaDataSize(u8 layer) { + dCdFile_c *file = dCd_c::m_instance->getFileP(dScStage_c::m_instance->mCurrFile); + return file->mScrlAreaCount; +} + +sScrollAreaData *dBg_c::dBg_getScrlAreaDataP(u8 layer, u8 idx) { + dCdFile_c *file = dCd_c::m_instance->getFileP(dScStage_c::m_instance->mCurrFile); + return file->getScrlAreaDataP(idx); +} + +void dBg_c::fn_80078250(u16 p1, u16 p2, u16 p3, u32 p4) { + if (mBgThingsRelated > 255) { + return; + } + sBgThing *thing = nullptr; + for (int i = 0; i < 256; i++) { + if (mBgThings[i].m_08 == 0) { + thing = &mBgThings[i]; + break; + } + } + thing->m_00 = p2; + thing->m_02 = p3; + thing->m_04 = p4; + if (p1 == 42) { + thing->m_08 = 28; + thing->m_0c = 4; + } else { + thing->m_0c = 4; + if (p1 == 40) { + thing->m_08 = 32; + } else { + thing->m_08 = 56; + } + } + fn_80077860(p2, p3, p4, 0); +} + +void dBg_c::fn_80078300() { + for (int i = 0; i < 256; i++) { + sBgThing *thing = &mBgThings[i]; + if (thing->m_08 == 0) { + continue; + } + // thing->m_08--; + if (--thing->m_08 != 0) { + continue; + } + fn_80077860(thing->m_00, thing->m_02, thing->m_04, thing->m_0c); + mBgThingsRelated--; + + mVec2_c pos; + pos.x = thing->m_00; + pos.y = -thing->m_02; + dAudio::SoundEffectID_t(SE_OBJ_COIN_APP).playMapSound(pos, 0); + } +} + +void dBg_c::setWaterInWave(float x, float y, u8 type) { + for (int i = 0; i < 20; i++) { + if (!mWaveActive[i]) { + mWaveActive[i] = true; + mWaveX[i] = x; + mWaveY[i] = y; + mWaveType[i] = type; + return; + } + } +} + +void dBg_c::setBubble(float x, float y, u8 type, u8 type2) { + for (int i = 0; i < 200; i++) { + if (mBubbleType[i] == 0) { + mBubbleType[i] = type; + mBubbleX[i] = x; + mBubbleY[i] = y; + mBubbleType2[i] = type2; + return; + } + } +} + +void dBg_c::InitWmSwitchPushed() { + dInfo_c *info = dInfo_c::m_instance; + mTexMng.mWmSwitchRelated = false; + if (info->mIsWmSwitchHit) { + mTexMng.mWmSwitchRelated = true; + } + if ((dInfo_c::mGameFlag & 0x10) == 0) { + return; + } + mTexMng.mWmSwitchRelated = true; +} + +bool dBg_c::IsWmSwitchPushed() { + return mTexMng.mWmSwitchRelated; +} + +dPanelObjMgr_c *dBg_c::getPanelObjMgr(int idx) { + return &mTex[idx]->mPanelObjMgr; +} + +bool dBg_c::dBg_isFlyPlayer() { + bool res = false; + u8 scrInfo = daPyMng_c::getActScrollInfo(); + for (int i = 0; i < 4; i++) { + dAcPy_c *pl = daPyMng_c::getPlayer(i); + if (pl == nullptr || ((scrInfo & (1 << i)) == 0)) { + continue; + } + if (pl->mScrollMode == 2 || pl->mScrollMode == 6) { + res = true; + } + } + return res; +} + +int dBg_c::dBg_isCloudFlyPlayer() { + int res = false; + u8 scrInfo = daPyMng_c::getActScrollInfo(); + for (int i = 0; i < 4; i++) { + dAcPy_c *pl = daPyMng_c::getPlayer(i); + if (pl == nullptr || ((scrInfo & (1 << i)) == 0)) { + continue; + } + if (pl->mScrollMode == 6) { + res = true; + } + } + return res; +} + +bool dBg_c::dBg_isCloudFlyPlayerMulti() { + bool res = false; + u8 scrInfo = daPyMng_c::getActScrollInfo(); + for (int i = 0; i < 4; i++) { + dAcPy_c *pl = daPyMng_c::getPlayer(i); + if (pl == nullptr || ((scrInfo & (1 << i)) == 0)) { + continue; + } + if (pl->mScrollMode == 6) { + dBgParameter_c *param = dBgParameter_c::ms_Instance_p; + if (pl->mPc.m_30.y > param->mPos.y - 160.0f && mDispScale < 0.7f + || mDispScale >= 0.7f && pl->mPc.m_30.y > param->mPos.y - 48.0f) { + res = true; + } + } + } + return res; +} + +float dBg_c::fn_80078860(float f) { + float tmp = f; + switch (mZoomRelated) { + case 1: tmp = 19.0f / 14.0f; break; + case 16: tmp = 10.0f / 7.0f; break; + case 2: tmp = 12.0f / 7.0f; break; + case 3: tmp = 2.0f; break; + + case 4: tmp = mZoomDenom; tmp = 1.0f / tmp; break; + case 5: f = 1.0f; tmp = 0.7f; break; + case 6: tmp = 1.0f; break; + case 7: f = 0.7f; tmp = 1.0f; break; + case 8: tmp = 1.0f; break; + case 9: tmp = 17.0f / 14.0f; break; + + case 10: f = 1.0f; tmp = 1.0f; break; + case 11: f = 1.0f; tmp = 17.0f / 14.0f; break; + case 12: f = 1.0f; tmp = 19.0f / 14.0f; break; + case 13: f = 1.0f; tmp = 10.0f / 7.0f; break; + case 14: f = 1.0f; tmp = 12.0f / 7.0f; break; + case 15: f = 1.0f; tmp = 2.0f; break; + + case 17: f = 3.0f / 4.0f; tmp = 3.0f / 4.0f; break; + case 18: f = 3.0f / 4.0f; tmp = 1.0f; break; + case 19: f = 3.0f / 4.0f; tmp = 17.0f / 14.0f; break; + case 20: f = 3.0f / 4.0f; tmp = 19.0f / 14.0f; break; + case 21: f = 3.0f / 4.0f; tmp = 10.0f / 7.0f; break; + case 22: f = 3.0f / 4.0f; tmp = 12.0f / 7.0f; break; + case 23: f = 3.0f / 4.0f; tmp = 2.0f; break; + } + return f + mZoomWeight * (tmp - f); +} + +float dBg_c::getMaxLeftPos() { + float maxLeft = mL; + if (mLimitRelated != 1 && mLimitRelated != 4 && 1.0f / getDispScale() < getZoomTargetMax_Common()) { + maxLeft += + getZoomTargetMax_Common() * mVideo::getLayoutWidth() * 0.5f - + 1.0f / getDispScale() * mVideo::getLayoutWidth() * 0.5f; + } + return maxLeft; +} + +float dBg_c::getLeftLimit() { + float maxLeft = mLLimit; + if (mLimitRelated != 1 && mLimitRelated != 4 && 1.0f / getDispScale() < getZoomTargetMax_Common()) { + maxLeft += + getZoomTargetMax_Common() * mVideo::getLayoutWidth() * 0.5f - + 1.0f / getDispScale() * mVideo::getLayoutWidth() * 0.5f; + } + return maxLeft; +} + +float dBg_c::getMaxRightPos() { + float maxRight = mR; + if (mLimitRelated != 1 && mLimitRelated != 4 && 1.0f / getDispScale() < getZoomTargetMax_Common()) { + maxRight -= + getZoomTargetMax_Common() * mVideo::getLayoutWidth() * 0.5f - + 1.0f / getDispScale() * mVideo::getLayoutWidth() * 0.5f; + } + return maxRight; +} + +float dBg_c::getRightLimit() { + float maxRight = mRLimit; + if (mLimitRelated != 1 && mLimitRelated != 4 && 1.0f / getDispScale() < getZoomTargetMax_Common()) { + maxRight -= + getZoomTargetMax_Common() * mVideo::getLayoutWidth() * 0.5f - + 1.0f / getDispScale() * mVideo::getLayoutWidth() * 0.5f; + } + return maxRight; +} + +float dBg_c::getLeftLimitSingle() { + return mLLimitSingle; +} + +float dBg_c::getLeftLimitMulti() { + return mLLimitMulti; +} + +float dBg_c::getZoomTargetMin_Common() { + float zoomTargetMode1[] = { + 1.0f, 1.0f, 1.0f, 1.4285715f, + 1.3571428f, 1.2142857f, 1.2142857f, 1.2142857f, + 0.5f, 1.2142857f, 1.2142857f + }; + float zoomTargetMode3[] = { + 1.0f, 1.3571428f, 1.7142857f, 2.0f, + 1.2142857f, 1.4285715f, 1.1428572f, 2.0f, + 0.5f, 0.75f + }; + float zoomTargetMode2[] = { + 1.0f, 1.0f, 1.0f, 1.3571428f, 1.3571428f, + 1.3571428f, 1.2142857f, 1.2142857f + }; + if (mLimitRelated == 0 || mLimitRelated == 1 || mLimitRelated == 6 || mLimitRelated == 7) { + return zoomTargetMode1[mLimitRelated2]; + } else if (mLimitRelated == 2) { + return zoomTargetMode2[mLimitRelated2]; + } else { + return zoomTargetMode3[mLimitRelated2]; + } +} + +float dBg_c::getZoomTargetMin() { + return fn_80078860(getZoomTargetMin_Common()); +} + +float dBg_c::getZoomTargetMid_Common() { + float zoomTargetMode1[] = { + 1.4285715f, 1.3571428f, 1.3571428f, 1.7142857f, + 1.7142857f, 1.7142857f, 1.7142857f, 1.4285715f, + 0.78571427f, 1.4642857f, 1.4285715f + }; + float zoomTargetMode2[] = { + 1.3571428f, 1.3571428f, 1.3571428f, 1.3571428f, + 1.7142857f, 1.7142857f, 1.7142857f, 1.4642857f + }; + if (mLimitRelated == 0 || mLimitRelated == 1 || mLimitRelated == 6 || mLimitRelated == 7) { + return zoomTargetMode1[mLimitRelated2]; + } else if (mLimitRelated == 2) { + return zoomTargetMode2[mLimitRelated2]; + } else { + return getZoomTargetMin_Common(); + } +} + +float dBg_c::getZoomTargetMid() { + return fn_80078860(getZoomTargetMid_Common()); +} + +float dBg_c::getZoomTargetMax_Common() { + float zoomTargetMode1[] = { + 1.3571428f, 1.7142857f, 2.0f, 1.7142857f, + 2.0f, 1.7142857f, 2.0f, 1.4285715f, + 1.0f, 1.7142857f, 2.0f + }; + float zoomTargetMode2[] = { + 1.3571428f, 1.7142857f, 2.0f, 1.7142857f, + 2.0f, 2.0f, 2.0f, 1.7142857f + }; + float res; + if (mLimitRelated == 0 || mLimitRelated == 1 || mLimitRelated == 6 || mLimitRelated == 7) { + res = zoomTargetMode1[mLimitRelated2]; + } else if (mLimitRelated == 2) { + res = zoomTargetMode2[mLimitRelated2]; + } else { + res = getZoomTargetMin_Common(); + } + float lWidth = mVideo::l_rayoutWidthF; + float ofsX = mLoopOffsetX; + if (res * lWidth > ofsX) { + res = mLoopOffsetX / mVideo::l_rayoutWidthF; + } + float lHeight = mVideo::l_rayoutHeightF; + float ofsY = mLoopOffsetY; + if (res * lHeight > ofsY) { + res = mLoopOffsetY / mVideo::l_rayoutHeightF; + } + return res; +} + +float dBg_c::getZoomTargetMax() { + float res = fn_80078860(getZoomTargetMax_Common()); + float lWidth = mVideo::l_rayoutWidthF; + float ofsX = mLoopOffsetX; + if (res * lWidth > ofsX) { + res = mLoopOffsetX / mVideo::l_rayoutWidthF; + } + float lHeight = mVideo::l_rayoutHeightF; + float ofsY = mLoopOffsetY; + if (res * lHeight > ofsY) { + res = mLoopOffsetY / mVideo::l_rayoutHeightF; + } + mZoomDenom = 1.0 / res; // [1.0f was not used] + return res; +} + +float dBg_c::getZoomSpreadLine() { + float zoomSpreadMode1[] = { + 0.55, 0.54, 0.54, 0.75, 0.72, 0.63, 0.63, 0.62, 0.26, 0.62, 0.62 + }; + float zoomSpreadMode2[] = { + 0.54, 0.54, 0.54, 0.72, 0.72, 0.72, 0.63, 0.62 + }; + float res = 0.0f; + if (mLimitRelated == 0 || mLimitRelated == 1 || mLimitRelated == 6 || mLimitRelated == 7) { + res = zoomSpreadMode1[mLimitRelated2]; + } else if (mLimitRelated == 2) { + res = zoomSpreadMode2[mLimitRelated2]; + } + return res; +} + +float dBg_c::getZoomSpreadLine2() { + float zoomSpreadMode1[] = { + 0.55, 0.72, 0.73, 0.75, 0.98, 0.63, 0.98, 0.62, 0.34, 0.78, 0.77 + }; + float zoomSpreadMode2[] = { + 0.54, 0.72, 0.73, 0.72, 0.98, 0.98, 0.98, 0.78 + }; + float res = 0.0f; + if (mLimitRelated == 0 || mLimitRelated == 1 || mLimitRelated == 6 || mLimitRelated == 7) { + res = zoomSpreadMode1[mLimitRelated2]; + } else if (mLimitRelated == 2) { + res = zoomSpreadMode2[mLimitRelated2]; + } + return res; +} + +float dBg_c::getZoomShrinkLine() { + float zoomSpreadMode1[] = { + 0.45, 0.39, 0.39, 0.6, 0.58, 0.49, 0.49, 0.48, 0.19, 0.48, 0.48 + }; + float zoomSpreadMode2[] = { + 0.39, 0.39, 0.39, 0.58, 0.58, 0.58, 0.49, 0.48 + }; + float res = 0.0f; + if (mLimitRelated == 0 || mLimitRelated == 1 || mLimitRelated == 6 || mLimitRelated == 7) { + res = zoomSpreadMode1[mLimitRelated2]; + } else if (mLimitRelated == 2) { + res = zoomSpreadMode2[mLimitRelated2]; + } + return res; +} + +float dBg_c::getZoomShrinkLine2() { + float zoomSpreadMode1[] = { + 0.45, 0.58, 0.59, 0.6, 0.83, 0.49, 0.83, 0.48, 0.26, 0.62, 0.64 + }; + float zoomSpreadMode2[] = { + 0.39, 0.58, 0.59, 0.58, 0.83, 0.83, 0.83, 0.62 + }; + float res = 0.0f; + if (mLimitRelated == 0 || mLimitRelated == 1 || mLimitRelated == 6 || mLimitRelated == 7) { + res = zoomSpreadMode1[mLimitRelated2]; + } else if (mLimitRelated == 2) { + res = zoomSpreadMode2[mLimitRelated2]; + } + return res; +} + +void dBg_c::calcLookatOffs() { + dAcPy_c *player = daPyMng_c::getPlayer(daPyMng_c::mCtrlPlrNo); + if (player != nullptr) { + DispScaleCalc(); + calcLookatOffsLimit(); + calcLookatOffsX(player); + calcLookatOffsY(player); + } +} + +void dBg_c::calcLookatOffsLimit() { + dCdFile_c *file = dCd_c::m_instance->getFileP(dScStage_c::m_instance->mCurrFile); + float scale = mDispScale; + if (scale == 0.0f) { + scale = 1.0f; + } + mBounds4[2] = 32.0f / scale; + mBounds4[3] = 32.0f / scale; + float smth1 = 80.0f; + float smth2 = 72.0f; + if (dBg_isCloudFlyPlayer() == 1 && (!mU8s[4] || mAutoscrolls[0].mActive)) { + smth1 = 88.0f; + smth2 = 88.0f; + smth1 += file->getScrollDataP(mScrollID)->mXCloud; + smth2 -= file->getScrollDataP(mScrollID)->mYCloud; + } else { + smth1 += file->getScrollDataP(mScrollID)->mX; + smth2 -= file->getScrollDataP(mScrollID)->mY; + } + if (mU8s[4] && !mAutoscrolls[0].mActive) { + smth1 += (int) file->getScrollDataP(mScrollID)->m_16; + smth2 -= (int) file->getScrollDataP(mScrollID)->m_18; + } + smth1 += mBounds3[3]; + smth2 -= mBounds3[3]; + sLib::addCalc(&mBounds3[0], smth1, 0.1f, 10.0f, 0.001f); + sLib::addCalc(&mBounds3[1], smth2, 0.1f, 10.0f, 0.001f); +} + +void dBg_c::calcLookatOffsX(dActor_c *actor) { + float deltaX = actor->mPosDelta.x; + deltaX = 0.333f * deltaX; + + float smth = m_8fda8; + + if (deltaX == 0.0f) { + return; + } + + if (deltaX - smth > 0.04f) { + deltaX = smth + 0.04f; + } else if (deltaX - smth < -0.04f) { + deltaX = smth - 0.04f; + } + + if (deltaX > 1.6f) { + deltaX = 1.6f; + } else if (deltaX < -1.6f) { + deltaX = -1.6f; + } + + float b40 = mBounds4[0]; + float b42 = mBounds4[2]; + float smth3 = b40 + deltaX; + mBounds4[0] = smth3; + if (smth3 > b42) { + deltaX = b42 - b40; + mBounds4[0] = b42; + } else if (smth3 < -mBounds4[3]) { + mBounds4[0] = -mBounds4[3]; + deltaX = mBounds4[0] - b40; + } + + m_8fda8 = deltaX; +} + +void dBg_c::calcLookatOffsY(dActor_c *actor) { + dAcPy_c *pl = (dAcPy_c *) actor; + float deltaY = pl->mPc.m_30.y - mPlayerPosY; + float halfHeight2 = mSomeSize.y / 2 - mBounds3[0]; + float halfHeight = mSomeSize.y / 2 - mBounds3[1]; + if (deltaY > 0.0f) { + deltaY += mBounds4[1]; + mBounds4[1] = deltaY; + if (deltaY >= halfHeight2) { + mBounds4[1] = halfHeight2; + } + return; + } + if (deltaY < 0.0f) { + halfHeight = -halfHeight; + deltaY += mBounds4[1]; + mBounds4[1] = deltaY; + if (halfHeight >= deltaY) { + mBounds4[1] = halfHeight; + } + return; + } + if (mBounds4[1] >= halfHeight2) { + mBounds4[1] = halfHeight2; + } + halfHeight = -halfHeight; + if (mBounds4[1] <= halfHeight) { + mBounds4[1] = halfHeight; + } +} + +void dBg_c::initAutoScroll() { + dBgParameter_c *bgParam = dBgParameter_c::getInstance(); + dScStage_c *stage = dScStage_c::m_instance; + + mAutoscrolls[0].mActive = false; + mAutoscrolls[0].mPos.x = bgParam->mPos.x; + mAutoscrolls[0].mPos.y = bgParam->mPos.y; + mAutoscrolls[0].m_0c = 0.0f; + mAutoscrolls[0].m_10 = 0.0f; + mAutoscrolls[0].m_14 = 0; + mAutoscrolls[0].m_15 = 0; + mAutoscrolls[0].m_16 = 0; + mAutoscrolls[0].m_17 = 0; + mAutoscrolls[0].m_18 = false; + mAutoscrolls[0].m_19 = 0; + m_9007c = 0; + m_90080 = 0; + m_90084 = 0.0f; + m_9008c = 0; + m_9008d = 1; + if (stage->mCurrWorld != WORLD_2) return; + if (stage->mCurrCourse != STAGE_CASTLE) return; + if (stage->mCurrFile != 0) return; + mAutoscrolls[0].m_0c = 0.6f; +} + +void dBg_c::calcLoopAutoScroll() { + dBgParameter_c *bgParam = dBgParameter_c::ms_Instance_p; + float maxX = 6000.0f; + + mVec3_c unitVec; + mVec3_c pos; + unitVec.x = 1.0f; + unitVec.y = 0.0f; + + float actualY = bgParam->mSize.y + mDLimit; + + pos = mAutoscrolls[0].mPos; + mSomeParameterPos = bgParam->mPos; + + if (m_90958 == 1) { + if (bgParam->mPos.x > 2290.0f) { + pos.x -= mLoopOffsetX; + } + } else if (m_90958 == 2) { + if (bgParam->mPos.x > 3790.0f) { + pos.x -= mLoopOffsetX; + } + } else if (m_90958 == 3) { + if (bgParam->mPos.x > 5420.0f) { + pos.x -= mLoopOffsetX; + } + } + + pos.y = actualY; + + float f2 = 0.6f; + if ( + (bgParam->mPos.x > 675.0 && bgParam->mPos.x < 1100.0) || + (bgParam->mPos.x > 2280.0 && bgParam->mPos.x < 2700.0) || + (bgParam->mPos.x > 3820.0 && bgParam->mPos.x < 4300.0) || + (bgParam->mPos.x > 5420.0 && bgParam->mPos.x < 5900.0) + ) { + f2 = 4.8f; + } + if ((dActor_c::mExecStop & 8) == 0) { + if (f2 <= 0.6f) { + sLib::addCalc(&mAutoscrolls[0].m_0c, f2, 0.02f, 0.03f, 0.001f); + } else { + sLib::addCalc(&mAutoscrolls[0].m_0c, f2, 0.01f, 0.01f, 0.0001f); + } + pos.x += unitVec.x * mAutoscrolls[0].m_0c; + pos.y += unitVec.y * mAutoscrolls[0].m_0c; + pos.z = 0.0f; + } + if (pos.x > maxX) { + pos.x = maxX; + } + mAutoscrolls[0].mPos = pos; + mSomePos.x = pos.x; + mSomePos.y = pos.y; + float lWidth = mVideo::l_rayoutWidthF; + float lHeight = mVideo::l_rayoutHeightF; + float target = m_bg_p->getZoomTargetMin(); + mDispScale = 1.0f / target; + mSomeSize.x = lWidth * (1.0f / mDispScale); + mSomeSize.y = lHeight * (1.0f / mDispScale); +} + +void dBg_c::calcAutoScroll() { + dScStage_c *stage = dScStage_c::m_instance; + mVec2_c bgSize = dBgParameter_c::getInstance()->mSize; + sRailInfoData *ri = dRail_c::getRailInfoP(mAutoscrolls[0].m_14); + dCdFile_c *file = dCd_c::m_instance->getFileP(stage->mCurrCourse); + + float leftLim = getLeftLimit(); + float rightLim = getRightLimit() - bgSize.x; + float upLim = mULimit; + float downLim = bgSize.y - mDLimit; + bool cond1 = true; + bool cond2 = true; + if (stage->mCurrWorld == WORLD_2 && stage->mCurrCourse == STAGE_CASTLE && stage->mCurrFile == 0) { + calcLoopAutoScroll(); + } else if ((dActor_c::mExecStop & 8) == 0 && m_9008c == 0) { + sBgData *base = &file->mpBg2Data[ri->mNodeIdx]; + if (m_9008d != 0) { + for (int i = 0; i < 999; i++) { + int idx = m_9007c; + // dBgThing_c *tmp = &base[m_9007c]; + if (m_90009 == 0) { + if (mAutoscrolls[0].mPos.x > base[idx].mID) { + m_9007c++; + } else { + break; + } + } + } + } + m_9008d = 0; + mVec3_c asPos; + asPos.x = mAutoscrolls[0].mPos.x; + asPos.y = mAutoscrolls[0].mPos.y; + asPos.z = 0.0f; + rightLim = asPos.y; + int tmp = m_9007c; + if (m_90080 < 999) { + sBgData *base = &file->mpBg2Data[ri->mNodeIdx]; + mVec3_c bgThingVec; + bgThingVec.x = base->mID; + bgThingVec.y = base->m_04; + bgThingVec.z = 0.0f; + mVec3_c asCopy = asPos; + if (tmp > 0) { + asCopy.x = (base - 1)->mID; + asCopy.y = (base - 1)->m_04; + } + mVec3_c someVec = bgThingVec - asCopy; + float calcArg = 0.0f; + someVec.normalize(); + mVec3_c someVec2 = asCopy - asPos; + someVec2.normalize(); + float len = someVec2.len(); + short ang1 = cM::atan2s(someVec2.y, len); + short ang2 = cM::atan2s(someVec2.x, someVec2.z); + if (m_90080 == 0 && m_9007c <= 1 || mAutoscrolls[0].m_15 != 0) { + m_90088 = ang1; + m_9008a = ang2; + } else { + sLib::addCalcAngle(&m_90088, ang1, 60, 250, 1); + sLib::addCalcAngle(&m_9008a, ang2, 60, 250, 1); + } + mVec3_c idk; + idk.x = mAng(m_90088).cos() * mAng(m_9008a).sin(); + idk.y = mAng(m_90088).sin(); + idk.z = mAng(m_90088).cos() * mAng(m_9008a).cos(); + sLib::addCalc(&mAutoscrolls[0].m_0c, asPos.y, 1.0f, calcArg, 0.0001f); + mAutoscrolls[0].mPos.z = 0.0f; + mAutoscrolls[0].mPos.x += idk.y * mAutoscrolls[0].m_0c; + mAutoscrolls[0].mPos.y += idk.z * mAutoscrolls[0].m_0c; + float dist = mAutoscrolls[0].mPos.distTo(bgThingVec); + bool cond3 = false; + bool cond4 = false; + if (mAutoscrolls[0].m_18 == 1) { + cond3 = true; + } else if (mAutoscrolls[0].m_18 == 2) { + cond4 = true; + } + if (( + cond4 || someVec.x == 0.0f || + (someVec.x > 0.0f && bgThingVec.x <= mAutoscrolls[0].mPos.x) || + (someVec.x <= 0.0f && (mAutoscrolls[0].mPos.x <= bgThingVec.x)) + ) && ( + cond3 || someVec.y == 0.0f || + (someVec.y > 0.0f && bgThingVec.y <= mAutoscrolls[0].mPos.y) || + (someVec.y <= 0.0f && (mAutoscrolls[0].mPos.y <= bgThingVec.y)) + )) { + m_9007c++; + if (m_9007c >= ri->mCount) { + switch (mAutoscrolls[0].m_17) { + case 0: + AutoScroll_stop(); + break; + case 1: + m_9007c = mAutoscrolls[0].m_16; + m_90080++; + break; + default: + m_9007c = ri->mCount - 1; + m_90080 = 999; + break; + } + return; + } + } + if (mAutoscrolls[0].mPos.x < leftLim) { + leftLim = mAutoscrolls[0].mPos.x; + if (rightLim < leftLim) { + leftLim = leftLim; + } + } + if (mAutoscrolls[0].mPos.y < downLim) { + downLim = mAutoscrolls[0].mPos.y; + if (upLim < downLim) { + downLim = downLim; + } + } + switch (mAutoscrolls[0].m_18) { + case 0: + cond1 = true; + cond2 = true; + break; + case 1: + cond1 = true; + cond2 = false; + break; + case 2: + cond1 = false; + cond2 = true; + break; + } + if (cond1) { + rightLim = -999999.0f; + for (int i = 0; i < 4; i++) { + dAcPy_c *pl = daPyMng_c::getPlayer(i); + if (pl != nullptr) { + upLim = pl->m_68; + if (upLim > rightLim) { + rightLim = upLim; + } + } + } + mSomePos.x = leftLim; + } + if (cond2) { + mSomePos.y = downLim; + } + + float lWidth = mVideo::l_rayoutWidthF; + float lHeight = mVideo::l_rayoutHeightF; + mDispScale = 1.0f / m_bg_p->getZoomTargetMin(); + mSomeSize.x = lWidth * (1.0f / mDispScale); + mSomeSize.y = lHeight * (1.0f / mDispScale); + } + } +} + +void dBg_c::AutoScroll_start() { + mAutoscrolls[0].mActive = true; +} + +void dBg_c::AutoScroll_stop() { + mAutoscrolls[0].mActive = false; +} + +void dBg_c::calcScroll(const mVec3_c &pos, int param_2) { + dBgParameter_c *bgParam = dBgParameter_c::getInstance(); + float lWidth = mVideo::l_rayoutWidthF; + float lHeight = mVideo::l_rayoutHeightF; + if (m_bg_p->m_9095a == 0) { + m_bg_p->getZoomTargetMax(); // unused return value + if (mMoreFloats3[3] > 0.0f) { + float bgVal = dBgParameter_c::getInstance()->m_30.y; + float tmp2 = bgVal * (1.0f / mMoreFloats3[3] - 1.0f / m_bg_p->getZoomTargetMin()); + mDispScale = tmp2 + 1.0f / m_bg_p->getZoomTargetMin(); + } + m_90018 = mDispScale; + mMoreFloats5[1] = mDispScale; + lWidth *= 1.0f / mDispScale; + lHeight *= 1.0f / mDispScale; + mSomeSize.x = lWidth; + mSomeSize.y = lHeight; + float leftLimit = getLeftLimit(); + float rightLimit = getRightLimit() - lWidth; + float upLimit = mULimit; + float downLimit = lHeight + mDLimit; + bool cond1 = true; + bool cond2 = true; + float maxLeft = getMaxLeftPos(); + mSomeParameterPos = bgParam->mPos; + mPlayerPosY = pos.y; + float bounds40 = mBounds4[0]; + float bounds41 = mBounds4[1]; + float y = (pos.y + mSomeSize.y * 0.5f) - bounds41; + float x = (pos.x + bounds40) - lHeight * 0.5f; + float idkX = x; + if (dScStage_c::m_loopType != 2) { + if (y < idkX) { + idkX = leftLimit; + } else if (y > rightLimit) { + idkX = rightLimit; + } + } else { + if (dScStage_c::m_instance->mCurrWorld == WORLD_2 && + dScStage_c::m_instance->mCurrCourse == STAGE_CASTLE && + dScStage_c::m_instance->mCurrFile == 0 && + m_90958 == 0 + ) { + if (y < idkX) { + idkX = leftLimit; + } else if (y > rightLimit) { + idkX = rightLimit; + } + } + } + if (y < downLimit) { + downLimit = y; + if (upLimit > y) { + downLimit = upLimit; + } + } + if (mAutoscrolls[0].mActive) { + switch (mAutoscrolls[0].m_18) { + case 0: + cond1 = false; + cond2 = false; + break; + case 1: + cond1 = false; + cond2 = true; + break; + case 2: + cond1 = true; + cond2 = false; + break; + } + } + if (cond1) { + mSomePos.x = idkX; + } + if (cond2) { + if ( + getAreaUpLimitScroll() > -999999.0f && + dBgParameter_c::getInstance()->mPos.y >= getAreaUpLimitScroll() && + downLimit > getAreaUpLimitScroll() && + dBg_isFlyPlayer() == 0 + ) { + downLimit = getAreaUpLimitScroll(); + } + if (param_2 != 0 || getAreaUpLimitScroll() <= -999999.0f) { + mSomePos.y = downLimit; + } else { + sLib::chase(&mSomePos.y, downLimit, 16.0f); + } + } + if (mLimitRelated == 1 || mLimitRelated == 4) { + mSomePos.x = maxLeft + mLoopOffsetX * 0.5f - mSomeSize.x * 0.5f; + } + if (mLimitRelated == 6) { + mSomePos.y = mD + mSomeSize.y; + } + mBounds4[0] = bounds40; + mBounds4[1] = bounds41; + if (!mAutoscrolls[0].mActive) { + mAutoscrolls[0].mPos.x = mSomePos.x; + mAutoscrolls[0].mPos.y = mSomePos.y; + } + if (m_900a7 != 0) { + mSomePos.x = m_900ac - mSomeSize.x * 0.5f; + mSomePos.y = m_900b0 + mSomeSize.y; + } + } + fn_8007ca90(&mSomeInfo1, m_90009, 1); + fn_8007ca90(&mSomeInfo1, m_9000a, 1); + if (m_bg_p->m_9095a == 0) { + fn_8007cd70(&mSomeInfo2, &mSomeInfo1, 1); + } +} + +void dBg_c::calcMultiScroll(int arg1) { + int scrollNum = daPyMng_c::getScrollNum(); + fn_8007ca90(&mSomeInfo1, m_90009, scrollNum); + fn_8007ca90(&mSomeInfo1, m_9000a, scrollNum); + if (m_bg_p->m_9095a == 0) { + fn_8007cd70(&mSomeInfo2, &mSomeInfo1, arg1); + (this->*mCallbackFunc)(&mSomeInfo2, arg1); + } +} + +void dBg_c::fn_8007ac40(dBgSomeInfo_c *info, int arg1) { + dBgBound_c b = info->mBounds; + + float lWidth = mVideo::l_rayoutWidthF; + float lHeight = mVideo::l_rayoutHeightF; + + float invScale = 1.0f / mDispScale; + float zoom = 1.0f / mZoomDenom; + + float tmpUp = std::fabs(b.mDown - b.mUp) / lHeight; + float tmpRight = std::fabs(b.mLeft - b.mRight) / lWidth; + + float spL = m_bg_p->getZoomSpreadLine(); + float spL2 = m_bg_p->getZoomSpreadLine2(); + float shL = m_bg_p->getZoomShrinkLine(); + float shL2 = m_bg_p->getZoomShrinkLine2(); + float tgMin = m_bg_p->getZoomTargetMin(); + float tgMid = m_bg_p->getZoomTargetMid(); + float tgMax = m_bg_p->getZoomTargetMax(); + + dScStage_c *stage = dScStage_c::m_instance; + + bool bVar7 = false; + + float scale; + if (mLimitRelated == 1) { + scale = 1.2f; + } else { + scale = 0.9f; + } + b.mUp = tmpUp * scale; + mVec2_c r = fn_8007bd40(info, zoom, scale, &mWaveRelated[0x4d]); + b.mRight = tmpRight; + if (mLimitRelated == 1) { + r.x = r.y; + b.mRight = b.mUp; + } + if (mLimitRelated == 6 || mLimitRelated == 7) { + r.y = r.x - 1.0f; + b.mUp = b.mRight; + } + if (mLimitRelated == 2) { + if ((mLimitRelated2 == 5 || mLimitRelated2 == 6) || (mLimitRelated2 == 1 || mLimitRelated2 == 2)) { + if (invScale < m_bg_p->getZoomTargetMax() && spL2 < b.mRight) { + b.mRight = spL2; + } + if (!dBg_isFlyPlayer() && mU8s[2] == 0 && spL2 < b.mUp) { + b.mUp = spL2; + } + } else { + if (invScale <= m_bg_p->getZoomTargetMid() && spL < b.mRight) { + b.mRight = spL; + } + if (!dBg_isFlyPlayer() && mU8s[2] == 0 && spL < b.mUp) { + b.mUp = spL; + } + } + } + if (mLimitRelated == 0 && mLimitRelated2 == 10) { + if (dBg_isCloudFlyPlayerMulti() == 1) { + b.mRight = spL2 + 0.01f; + } else if (shL2 - 0.01 < b.mRight || m_9095b != 0) { + b.mRight = shL2 - 0.01f; + } + b.mUp = b.mRight - 1.0f; + } + if (b.mUp < b.mRight) { + b.mUp = b.mRight; + } + if ((daPyDemoMng_c::mspInstance->mFlags & 1) == 0) { + if (m_90024 == 0) { + if (b.mUp <= spL) { + mMoreFloats5[0] = tgMin; + } else { + mMoreFloats5[0] = tgMid; + m_90024 = 1; + } + } else if (m_90024 == 1) { + if (b.mUp <= spL2) { + if (shL <= b.mUp) { + if (spL <= b.mUp) { + mMoreFloats5[0] = tgMid; + } + } else { + bVar7 = true; + if (m_900b6 > 120) { + mMoreFloats5[0] = tgMin; + m_90024 = 0; + } + } + } else { + mMoreFloats5[0] = tgMax; + m_90024 = 2; + } + } else if (m_90024 == 2) { + if (shL2 <= b.mUp) { + if (spL2 <= b.mUp) { + mMoreFloats5[0] = tgMax; + } + } else { + bVar7 = true; + if (m_900b6 > 120) { + mMoreFloats5[0] = tgMid; + m_90024 = 1; + } + } + } + if (mMoreFloats5[0] == tgMax) { + if (mMoreFloats5[2] != tgMid ) { + b.mRight = m_90018; + if (mMoreFloats5[1] <= b.mRight) { + mMoreFloats5[1] = b.mRight; + } + mMoreFloats5[2] = tgMid; + } + } else { + mMoreFloats5[2] = tgMin; + } + if (bVar7) { + m_900b6++; + } else { + m_900b6 = 0; + } + } else { + mMoreFloats5[0] = m_90018; + } + float fVar28 = mMoreFloats5[0]; + float fVar25 = m_90018; + if (mMoreFloats5[0] > m_90018) { + fVar25 = 0.25f; + float calcArg = 0.0015f; + float scale = 0.003f; + if (mZoomRelated != 0 && mZoomRelated != 8) { + fVar25 = 1.0f; + calcArg = 0.1; + scale = 1.0f; + } + if (m_9001c == 0) { + sLib::addCalc(&m_90018, fVar28, fVar25, scale * (b.mUp * b.mUp * b.mUp * 6.0f + 1.0f), calcArg); + } + fVar25 = m_90018; + if (fVar25 < mMoreFloats5[1]) { + if (std::fabs(fVar28 - fVar25) > 0.1f) { + m_9001c = 90; + } + m_90018 = mMoreFloats5[1]; + } + } else if (m_90018 <= mMoreFloats5[0]) { + mMoreFloats5[1] = mMoreFloats5[2]; + } else { + fVar25 = 0.5f; + float calcArg = 0.0015f; + float scale = 0.003f; + if (mZoomRelated != 0 && mZoomRelated != 8) { + fVar25 = 1.0f; + calcArg = 0.1; + scale = 1.0f; + } + if (m_9001c == 0) { + sLib::addCalc(&m_90018, fVar28, fVar25, scale * (b.mUp * b.mUp * b.mUp * 6.0f + 1.0f), calcArg); + } + mMoreFloats5[1] = mMoreFloats5[2]; + } + if (m_9001c != 0) { + m_9001c--; + } + if (zoom < m_90018) { + m_90018 = zoom; + } + if (zoom > m_90018) { + m_90018 = zoom; + } else if (tgMax < m_90018) { + m_90018 = tgMax; + } + float copy_90018 = m_90018; + float val = -(mDLimit - mULimit); + if (val < m_90018 - mVideo::getLayoutHeight()) { + m_90018 = m_90018 / mVideo::getLayoutHeight(); + } + if (getAreaUpLimitScroll() > -999999.0f) { + float upLimit = getAreaUpLimitScroll(); + if (mU8s[2] == 0) { + m_90964 = 1.0f; + } else { + sLib::addCalc(&m_90964, 0.0f, 0.5f, 0.01f, 0.01f); + } + copy_90018 += m_90964 * (val / fVar28 - copy_90018); + } + mPrevSomeSize.x = lWidth * copy_90018; + mPrevSomeSize.y = lHeight * copy_90018; + mDispScale = 1.0f / copy_90018; + fVar28 *= 0.5f; + float mLP = getMaxLeftPos(); + float mRP = getMaxRightPos(); + float w = (info->mBounds.mRight + info->mBounds.mLeft) * 0.5f; + float u = mU; + float d = mD; + if (dScStage_c::m_loopType != 2) { + if (mLP > w - fVar28) { + w += mLP - (w - fVar28); + } else if (mRP < w + fVar28) { + w -= (w + fVar28) - mRP; + } + } + w -= fVar28; + if (mLimitRelated == 1 || mLimitRelated == 4) { + w = mLP + mLoopOffsetX * 0.5f - mPrevSomeSize.x * 0.5f; + if ( + dScStage_c::m_instance->mCurrWorld == 11 && + dScStage_c::m_instance->mCurrCourse == 65 && + dScStage_c::m_instance->mCurrFile == 1 + ) { + w -= 48.0f; + } + } + bool check = false; + if (mLimitRelated != 1 && mLimitRelated != 4 && fn_8007bc40(info, copy_90018)) { + fn_8007ba70(info); + check = true; + } + float newW = w; + if (dScStage_c::m_loopType != 2) { + newW = getLeftLimit(); + float d = getRightLimit() - newW; + if (newW <= w) { + newW = w; + if (d < w) { + newW = d; + } + } + } + if (!check && dScStage_c::m_loopType != 1) { + mPrevSomePos.x = newW; + } + int iVar9 = 0; + float fnres = fn_8007bbf0(info); + float fVar12 = 0.5f; + if (fnres < mPrevSomePos.y && (m_90009 == 3 || m_9000a == 3)) { + iVar9 = 16; + fVar12 = fnres; + } + float fnres2 = fn_8007bba0(info); + if (mPrevSomePos.y < fnres2) { + if (m_90009 == 1 || m_9000a == 2) { + iVar9 = 1; + fVar12 = fnres2; + } else if (m_9000a == 3 && iVar9 == 0) { + int rounded = fnres2 - mPrevSomePos.y; + mBounds3[3] = rounded; + } + } + if (iVar9 != 0 && iVar9 == 17 && (m_90009 == 1 || m_9000a == 1)) { + fVar12 = fnres2; + } + if (iVar9 != 0) { + if (fVar12 < (int) mPrevSomePos.y) { + float diff = mPrevSomePos.y - fVar12; + if (diff < 16.0f) { + mMoreFloats5[2] -= diff; + } else { + mMoreFloats5[2] -= 16.0f; + } + } else if ((int) mPrevSomePos.y < fVar12) { + float diff = fVar12 - mPrevSomePos.y; + if (diff < 16.0f) { + mMoreFloats5[2] += diff; + } else { + mMoreFloats5[2] += 16.0f; + } + } + } + if (mPrevSomePos.y + 32.0f < info->mBounds.mUp) { + info->mBounds.mUp = mPrevSomePos.y + 32.0f; + } + if (info->mBounds.mDown < mPrevSomePos.y - mPrevSomeSize.y - 32.0f) { + info->mBounds.mDown = mPrevSomePos.y - mPrevSomeSize.y - 32.0f; + } + calcLookatOffsLimit(); +} + +void dBg_c::fn_8007ba70(dBgSomeInfo_c *info) { + float fVar1 = info->mBounds.mLeft; + float w = mPrevSomeSize.x; + float fVar4; + if (m_90009 == 2 || m_9000a == 2) { + fVar4 = 112.0f - dBgParameter_c::getInstance()->m_78; + fVar1 = info->mBounds.mRight; + } else { + fVar4 = w - (112.0f - dBgParameter_c::getInstance()->m_78); + } + fVar1 -= fVar4; + if (fVar1 - mPrevSomePos.x > 6.0f) { + fVar1 = mPrevSomePos.x + 6.0f; + } else if (fVar1 - mPrevSomePos.x < -6.0f) { + fVar1 = mPrevSomePos.x - 6.0f; + } + float ll = getLeftLimit(); + float d = getRightLimit() - w; + float newW = fVar1; + if (dScStage_c::m_loopType != 2) { + newW = ll; + if (fVar1 < newW) { + newW = fVar1; + if (d > w) { + newW = d; + } + } + } + mPrevSomePos.x = newW; +} + +float dBg_c::fn_8007bba0(dBgSomeInfo_c *info) { + float tmp = 64.0f + info->mBounds.mUp; + if (tmp - mPrevSomePos.y < -6.0f) { + tmp = mPrevSomePos.y - 6.0f; + } + if (!(tmp > mULimit)) { + return tmp; + } + return mULimit; +} + +float dBg_c::fn_8007bbf0(dBgSomeInfo_c *info) { + float sizeY = dBgParameter_c::getInstance()->mSize.y; + float tmp = info->mBounds.mDown + (sizeY - 32.0f); + if (tmp - mPrevSomePos.y > 6.0f) { + tmp = mPrevSomePos.y + 6.0f; + } + if (!(tmp < sizeY + mDLimit)) { + return tmp; + } + return mDLimit; +} + +bool dBg_c::fn_8007bc40(dBgSomeInfo_c *info, float f) { + float fVar1 = info->mBounds.mLeft; + float fVar2 = info->mBounds.mRight; + float ll = getLeftLimit(); + float rl = getRightLimit(); + float fVar4 = dBgParameter_c::m_78_offset(); + float fVar3 = fVar4; + if (fVar1 < ll + fVar4) { + fVar3 = fVar1 - ll; + } + if (fVar2 > rl - dBgParameter_c::m_78_offset()) { + fVar4 = rl - fVar2; + } + if (f * mVideo::getLayoutWidth() - (fVar3 + fVar4) > info->mBounds.mRight - info->mBounds.mLeft) { + return true; + } else { + return false; + } +} + +mVec2_c dBg_c::fn_8007bd40(dBgSomeInfo_c *info, float f1, float f2, float *f3) { + mVec2_c result(0.0f, 0.0f); + + float fVar1; + float fVar2; + float fVar3; + float fVar4; + float fVar5; + float fVar6; + float fVar7; + float fVar8; + + fVar5 = mVideo::l_rayoutHeightF; + fVar4 = mVideo::l_rayoutWidthF; + fVar7 = getLeftLimit(); + fVar8 = getRightLimit(); + fVar1 = 112.0f; + fVar2 = mULimit; + fVar3 = mDLimit; + fVar6 = fVar1; + if (f3[0] - 112.0f < fVar7) { + fVar6 = f3[0] - fVar7; + } + if (fVar8 < f3[1] + 112.0f) { + fVar1 = fVar8 - f3[1]; + } + fVar7 = 1.0f; + fVar4 = (fVar1 + fVar6 + (f3[1] - f3[0])) / fVar4; + if ((fVar4 >= 1.0f) && (fVar7 = fVar4, f1 < fVar4)) { + fVar7 = f1; + } + fVar1 = 88.0f; + fVar4 = 80.0f; + if (fVar2 < f3[2] + 88.0f) { + fVar1 = fVar2 - f3[2]; + } + if (f3[3] - 80.0f < fVar3) { + fVar4 = f3[3] - fVar3; + } + fVar2 = 1.0f; + fVar5 = ((fVar4 + fVar1 + (f3[2] - f3[3])) * f2) / fVar5; + if ((fVar5 >= 1.0f) && (fVar2 = fVar5, f1 < fVar5)) { + fVar2 = f1; + } + + return result; +} + +void dBg_c::initScroll() { + dScStage_c *stage = dScStage_c::m_instance; + dBgParameter_c *bgParam = dBgParameter_c::getInstance(); + + float playerBoundL = -1e6f; + float playerBoundR = 1e6f; + float playerBoundU = 1e6f; + float playerBoundD = -1e6f; + + for (int i = 0; i < 4; i++) { + mVec3_c pos = daPyMng_c::getPlayerSetPos(stage->mCurrFile, stage->m_1211); + float x = pos.x; + float y = pos.y; + if (x < playerBoundL) { + playerBoundL = x; + } + if (x > playerBoundR) { + playerBoundR = x; + } + if (y > playerBoundU) { + playerBoundU = y; + } + if (y < playerBoundD) { + playerBoundD = y; + } + } + mSomeInfo2.mBounds.mLeft = playerBoundL; + mSomeInfo2.mBounds.mRight = playerBoundR; + mSomeInfo2.mBounds.mUp = playerBoundU; + mSomeInfo2.mBounds.mDown = playerBoundD; + mSomeInfo1.mBounds.mLeft = playerBoundL; + mSomeInfo1.mBounds.mRight = playerBoundR; + mSomeInfo1.mBounds.mUp = playerBoundU; + mSomeInfo1.mBounds.mDown = playerBoundD; + mIdkI = 0; + mIdkF[0] = 0.0f; + mIdkF[1] = 0.0f; + mIdkF[2] = 0.0f; + mIdkF[3] = 0.0f; + mVec3_c plPos = daPyMng_c::getPlayerSetPos(stage->mCurrFile, stage->m_1211); + mPlayerPosY = plPos.y; + mBounds3[0] = 80.0f; + mBounds3[1] = 72.0f; + mBounds3[3] = 0.0f; + calcLookatOffs(); + if (stage->mCurrWorld == WORLD_8 && stage->mCurrCourse == STAGE_7) { + mBounds4[1] += 4.0f; + } + calcScroll(plPos, 1); + + mPrevSomePos = mSomePos; + bgParam->mPos = mSomePos; + + m_90960 = mSomePos.y; + + mPrevSomeSize = mSomeSize; + bgParam->mSize = mSomeSize; + + float halfWidth = bgParam->mSize.x * 0.5f; + float halfHeight = bgParam->mSize.y * 0.5f; + bgParam->mCenter.x = bgParam->mPos.x + halfWidth; + bgParam->mCenter.y = bgParam->mPos.y - halfHeight; + + mU8s[3] = 0; + mU8s[4] = 0; + mU8s[5] = 0; + + if (!daPyMng_c::isScrollMode1()) { + mMoreFloats5[3] = mSomePos.y; + } + m_9001c = 0; + m_90018 = 1.0f; + m_90024 = 0; + mMoreFloats5[0] = -1.0f; + mMoreFloats5[1] = 1.0f; + mMoreFloats5[2] = 1.0f; + mMoreFloats5[4] = 0.0f; + mSomeParameterPos.x = dBgParameter_c::ms_Instance_p->mPos.x; + mSomeParameterPos.y = dBgParameter_c::ms_Instance_p->mPos.y; + + dBgScrollLimit_c zeroLimit; + zeroLimit.mL = 0.0f; + zeroLimit.mR = 0.0f; + zeroLimit.mU = 0.0f; + zeroLimit.mD = 0.0f; + zeroLimit.mL2 = 0.0f; + zeroLimit.mR2 = 0.0f; + zeroLimit.mU2 = 0.0f; + zeroLimit.mD2 = 0.0f; + zeroLimit.mL3 = 0.0f; + zeroLimit.mR3 = 0.0f; + zeroLimit.mU3 = 0.0f; + zeroLimit.mD3 = 0.0f; + zeroLimit.mL4 = 0.0f; + zeroLimit.mR4 = 0.0f; + zeroLimit.mU4 = 0.0f; + zeroLimit.mD4 = 0.0f; + zeroLimit.mFlags = 0; + + for (int i = 0; i < 64; i++) { + for (int j = 0; j < 8; j++) { + for (int k = 0; k < 16; k++) { + mScrLimit[i][j][k] = zeroLimit; + } + } + } + + dBgSubstruct2_c emptySubstruct2; + emptySubstruct2.mFloat1 = 0.0f; + emptySubstruct2.mFloat2 = 0.0f; + emptySubstruct2.mFloat3 = 0.0f; + emptySubstruct2.mFloat4 = 0.0f; + emptySubstruct2.mU8_1 = 99; + emptySubstruct2.mU8_2 = 0; + emptySubstruct2.mU8_3 = 0; + + for (int i = 0; i < 64; i++) { + for (int j = 0; j < 20; j++) { + mData2[i][j] = emptySubstruct2; + } + } + + dBgAnimObj_c animObj; + animObj.mX = 0.0f; + animObj.mY = 0.0f; + animObj.mType = -1; + + mGrassCount = 0; + mFlowerCount = 0; + + for (int i = 0; i < 100; i++) { + mGrass[i] = animObj; + } + + for (int i = 0; i < 100; i++) { + mFlowers[i] = animObj; + } + + mZoomWeight = 0.0f; + mZoomRelated = 0; + m_900a5 = 0; + m_900a6 = 0; + m_900a7 = 0; + m_900a8 = 0; + m_900ac = 0.0f; + m_900b0 = 0.0f; + m_900b8 = 0.0f; + m_900bc = 0.0f; + + for (int i = 0; i < 20; i++) { + mWaveX[i] = 0.0f; + mWaveType[i] = 0; + mWaveActive[i] = false; + } + + for (int i = 0; i < 200; i++) { + mBubbleX[i] = 0.0f; + mBubbleY[i] = 0.0f; + mBubbleType[i] = 0; + mBubbleType2[i] = 0; + } + + m_90958 = 0; + m_9095a = 0; + m_9095b = 0; + m_90964 = 1.0f; +} + +float dBg_c::fn_8007c7d0(float x) { + float res = x; + float loopOffset = mLoopOffsetX; + if (dScStage_c::m_loopType == 2) { + if (dBgParameter_c::ms_Instance_p->posX() < getMaxLeftPos()) { + float tmp1 = getMaxLeftPos() + (getMaxRightPos() - getMaxLeftPos()) * 0.5f; + float bgW = dBgParameter_c::ms_Instance_p->width(); + float bgX = dBgParameter_c::ms_Instance_p->posX(); + bgW += getMaxLeftPos(); + if (bgX > bgW && tmp1 > x) { + res -= loopOffset; + } + } else if (dBgParameter_c::ms_Instance_p->posX() > getMaxRightPos() - dBgParameter_c::ms_Instance_p->width()) { + float tmp1 = getMaxLeftPos() + (getMaxRightPos() - getMaxLeftPos()) * 0.5f; + float bgW = dBgParameter_c::ms_Instance_p->width(); + float bgX = dBgParameter_c::ms_Instance_p->posX(); + if (dBgParameter_c::ms_Instance_p->posX() < getMaxRightPos() && tmp1 < x) { + res += loopOffset; + } + } + } + return res; +} + +bool isRightPlayer(dAcPy_c *pl1, dAcPy_c *pl2) { + float p1 = dBg_c::m_bg_p->fn_8007c7d0(pl1->m_129c.x); + float p2 = dBg_c::m_bg_p->fn_8007c7d0(pl2->m_129c.x); + return p1 > p2; +} + +bool isLeftPlayer(dAcPy_c *pl1, dAcPy_c *pl2) { + float p1 = dBg_c::m_bg_p->fn_8007c7d0(pl1->m_129c.x); + float p2 = dBg_c::m_bg_p->fn_8007c7d0(pl2->m_129c.x); + return p1 < p2; +} + +bool isUpPlayer(dAcPy_c *pl1, dAcPy_c *pl2) { + return pl1->mPc.m_30.y > pl2->mPc.m_30.y; +} + +bool isDownPlayer(dAcPy_c *pl1, dAcPy_c *pl2) { + return pl1->mPc.m_30.y < pl2->mPc.m_30.y; +} + +void swap(dAcPy_c **pl1, dAcPy_c **pl2) { + dAcPy_c *tmp = *pl1; + *pl1 = *pl2; + *pl2 = tmp; +} diff --git a/source/dol/bases/d_cc.cpp b/source/dol/bases/d_cc.cpp index 16a334f1..26e7c4f5 100644 --- a/source/dol/bases/d_cc.cpp +++ b/source/dol/bases/d_cc.cpp @@ -332,9 +332,9 @@ bool dCc_c::_hitCheckLoop(dCc_c *c1, dCc_c *c2) { } if (p1.x < p2.x) { - p1.incX(dBg_c::m_bg_p->mLoopOffset); + p1.incX(dBg_c::m_bg_p->mLoopOffsetX); } else { - p2.incX(dBg_c::m_bg_p->mLoopOffset); + p2.incX(dBg_c::m_bg_p->mLoopOffsetX); } if (_hitCheckSquare(c1, c2, p1, p2)) { return true; From 6f5f83eb20987450dad976d02c3abb29bc79fa77 Mon Sep 17 00:00:00 2001 From: RootCubed Date: Thu, 7 May 2026 08:45:37 +0200 Subject: [PATCH 02/29] dBg_c 86% matching --- include/game/bases/d_bg.hpp | 33 ++- source/dol/bases/d_bg.cpp | 532 +++++++++++++++++++++++++++++++++++- 2 files changed, 538 insertions(+), 27 deletions(-) diff --git a/include/game/bases/d_bg.hpp b/include/game/bases/d_bg.hpp index 0f7ad2d1..06e04fbf 100644 --- a/include/game/bases/d_bg.hpp +++ b/include/game/bases/d_bg.hpp @@ -76,10 +76,11 @@ class dBgBound_c { struct dBgSomeInfo_c { dBgSomeInfo_c() : - m_10(0), m_14(0), m_18(0), m_1c(0) {} + m_10(nullptr), m_14(nullptr), m_18(0), m_1c(0) {} dBgBound_c mBounds; - int m_10, m_14, m_18, m_1c, m_20, m_24, m_28, m_2c, m_30; + dAcPy_c *m_10, *m_14; + int m_18, m_1c, m_20, m_24, m_28, m_2c, m_30; }; struct dBgSubstruct2_c { @@ -88,6 +89,7 @@ struct dBgSubstruct2_c { u8 mU8_1; u8 mU8_2; u8 mU8_3; + u8 mU8_4; }; struct dBgAnimObj_c { @@ -203,19 +205,26 @@ class dBg_c : public dBase_c { void calcAutoScroll(); void AutoScroll_start(); void AutoScroll_stop(); - void calcScroll( const mVec3_c&, int ); + void calcScroll(const mVec3_c&, int); void calcMultiScroll( int ); void initScroll(); - void fn_8007ac40(dBgSomeInfo_c *, int); - void fn_8007ba70(dBgSomeInfo_c *); - float fn_8007bba0(dBgSomeInfo_c *); - float fn_8007bbf0(dBgSomeInfo_c *); - bool fn_8007bc40(dBgSomeInfo_c *, float); - mVec2_c fn_8007bd40(dBgSomeInfo_c *, float, float, float *); - float fn_8007c7d0(float); - void fn_8007ca90(dBgSomeInfo_c *, int, int); - void fn_8007cd70(dBgSomeInfo_c *, dBgSomeInfo_c *, int); + void fn_8007ac40(dBgSomeInfo_c *, int); ///< @unofficial + void fn_8007ba70(dBgSomeInfo_c *); ///< @unofficial + float fn_8007bba0(dBgSomeInfo_c *); ///< @unofficial + float fn_8007bbf0(dBgSomeInfo_c *); ///< @unofficial + bool fn_8007bc40(dBgSomeInfo_c *, float); ///< @unofficial + mVec2_c fn_8007bd40(dBgSomeInfo_c *, float, float, float *); ///< @unofficial + float fn_8007c7d0(float); ///< @unofficial + void fn_8007ca90(dBgSomeInfo_c *, int, int); ///< @unofficial + void fn_8007cd70(dBgSomeInfo_c *, dBgSomeInfo_c *, int); ///< @unofficial + + u8 freeUpScrollLimit(dBgScrollLimit_c *scrollLimit, int group, int area); ///< @unofficial + u8 freeUpScrollLimit2(dBgScrollLimit_c *scrollLimit, int group, int area); ///< @unofficial + + void setScrollLimit(dBgScrollLimit_c *scrollLimit, int areaNo, int type, int group); ///< @unofficial + + void fn_8007E060(dBgSubstruct2_c *s, int idx); float getAreaUpLimitScroll(); diff --git a/source/dol/bases/d_bg.cpp b/source/dol/bases/d_bg.cpp index 82ec671d..14d45028 100644 --- a/source/dol/bases/d_bg.cpp +++ b/source/dol/bases/d_bg.cpp @@ -15,6 +15,7 @@ #include #include #include +#include #include dHeapSize_c dBg_c::m_HeapSize(0x10000); @@ -1061,13 +1062,14 @@ void dBg_c::calcAutoScroll() { if (stage->mCurrWorld == WORLD_2 && stage->mCurrCourse == STAGE_CASTLE && stage->mCurrFile == 0) { calcLoopAutoScroll(); } else if ((dActor_c::mExecStop & 8) == 0 && m_9008c == 0) { - sBgData *base = &file->mpBg2Data[ri->mNodeIdx]; + sBgThing *bgThings = mBgThings; + sBgThing *base = &bgThings[ri->mNodeIdx]; if (m_9008d != 0) { for (int i = 0; i < 999; i++) { int idx = m_9007c; // dBgThing_c *tmp = &base[m_9007c]; if (m_90009 == 0) { - if (mAutoscrolls[0].mPos.x > base[idx].mID) { + if (mAutoscrolls[0].mPos.x > base[idx].m_00) { m_9007c++; } else { break; @@ -1083,22 +1085,27 @@ void dBg_c::calcAutoScroll() { rightLim = asPos.y; int tmp = m_9007c; if (m_90080 < 999) { - sBgData *base = &file->mpBg2Data[ri->mNodeIdx]; + sBgThing *base = &bgThings[m_90080]; mVec3_c bgThingVec; - bgThingVec.x = base->mID; - bgThingVec.y = base->m_04; + bgThingVec.x = base->m_00; + bgThingVec.y = -(float) base->m_02; bgThingVec.z = 0.0f; - mVec3_c asCopy = asPos; + mVec3_c asCopy; if (tmp > 0) { - asCopy.x = (base - 1)->mID; - asCopy.y = (base - 1)->m_04; + asCopy.x = (base - 1)->m_00; + asCopy.y = -(float) (base - 1)->m_02; + asCopy.z = 0.0f; + } else { + asCopy = asPos; } - mVec3_c someVec = bgThingVec - asCopy; + mVec3_c someVec = bgThingVec; + someVec -= asCopy; float calcArg = 0.0f; someVec.normalize(); - mVec3_c someVec2 = asCopy - asPos; + mVec3_c someVec2 = asCopy; + someVec -= asPos; someVec2.normalize(); - float len = someVec2.len(); + float len = someVec2.xzLen(); short ang1 = cM::atan2s(someVec2.y, len); short ang2 = cM::atan2s(someVec2.x, someVec2.z); if (m_90080 == 0 && m_9007c <= 1 || mAutoscrolls[0].m_15 != 0) { @@ -1151,14 +1158,15 @@ void dBg_c::calcAutoScroll() { return; } } - if (mAutoscrolls[0].mPos.x < leftLim) { - leftLim = mAutoscrolls[0].mPos.x; + mVec3_c asPosCopy = mAutoscrolls[0].mPos; + if (asPosCopy.x < leftLim) { + leftLim = asPosCopy.x; if (rightLim < leftLim) { leftLim = leftLim; } } - if (mAutoscrolls[0].mPos.y < downLim) { - downLim = mAutoscrolls[0].mPos.y; + if (asPosCopy.y < downLim) { + downLim = asPosCopy.y; if (upLim < downLim) { downLim = downLim; } @@ -1954,3 +1962,497 @@ void swap(dAcPy_c **pl1, dAcPy_c **pl2) { *pl1 = *pl2; *pl2 = tmp; } + +void dBg_c::fn_8007ca90(dBgSomeInfo_c *info, int i1, int i2) { + static bool (*compareFuncs[4])(dAcPy_c *, dAcPy_c *) = { + isRightPlayer, + isLeftPlayer, + isUpPlayer, + isDownPlayer + }; + dAcPy_c *pls[4]; + int count2 = 0; + int count = 0; + for (int i = 0; i < 4; i++) { + dAcPy_c *pl = daPyMng_c::getPlayer(i); + pls[i] = pl; + if (pl != nullptr) { + if (pl->mPowerup == POWERUP_MUSHROOM) { + pls[i] = nullptr; + } + if (pl->mPowerup == POWERUP_MINI_MUSHROOM) { + count++; + } + } + if (pls[i] != nullptr) { + count2++; + } + if (m_90009 == 1 && pl != nullptr && pl->mPowerup == POWERUP_MINI_MUSHROOM) { + pls[i] = nullptr; + } + } + info->m_30 = count2; + if (count2 <= count) { + m_bg_p->m_9095a = 1; + return; + } + + m_bg_p->m_9095a = 0; + // sort players + for (int i = 0; i < 3; i++) { + for (int j = i + 1; j < 4; j++) { + dAcPy_c *pl1 = pls[i]; + dAcPy_c *pl2 = pls[j]; + if (pls[j] != nullptr) { + if (pls[i] == nullptr) { + swap(&pls[i], &pls[j]); + } else if (compareFuncs[i1 & 0xFF](pl1, pl2)) { + swap(&pls[i], &pls[j]); + } + } + } + } + dAcPy_c *pl1, *pl2; + pl1 = pls[0]; + pl2 = pls[i2 - 1]; + switch (i1) { + case 0: + if (pls[0] != nullptr) { + info->m_14 = pl1; + info->mBounds.mRight = fn_8007c7d0(pl1->m_68); + info->m_24 = pl1->mPlayerType; + } + if (pls[i2 - 1] != nullptr) { + info->m_10 = pl2; + info->mBounds.mLeft = fn_8007c7d0(pl2->m_68); + info->m_20 = pl2->mPlayerType; + } + break; + case 2: + if (pls[i2 - 1] != nullptr) { + info->m_14 = pl2; + info->mBounds.mRight = fn_8007c7d0(pl2->m_68); + info->m_24 = pl2->mPlayerType; + } + if (pls[0] != nullptr) { + info->m_10 = pl1; + info->mBounds.mLeft = fn_8007c7d0(pl1->m_68); + info->m_20 = pl1->mPlayerType; + } + break; + case 1: + if (pls[0] != nullptr) { + info->m_14 = pl1; + info->mBounds.mUp = pl1->mAmiRelated2; + info->m_24 = pl1->mPlayerType; + } + if (pls[i2 - 1] != nullptr) { + info->m_10 = pl2; + info->mBounds.mDown = pl2->mAmiRelated2; + info->m_20 = pl2->mPlayerType; + } + break; + case 3: + if (pls[i2 - 1] != nullptr) { + info->m_14 = pl2; + info->mBounds.mUp = pl2->mAmiRelated2; + info->m_24 = pl2->mPlayerType; + } + if (pls[0] != nullptr) { + info->m_10 = pl1; + info->mBounds.mDown = pl1->mAmiRelated2; + info->m_20 = pl1->mPlayerType; + } + break; + } +} + +void dBg_c::fn_8007cd70(dBgSomeInfo_c *info1, dBgSomeInfo_c *info2, int i1) { + mVec2_c p = dBgParameter_c::getInstance()->mPos; + mVec2_c s = dBgParameter_c::getInstance()->mSize; + bool cond = false; + if ((dActor_c::mExecStop & 2) != 0) { + return; + } + if (i1 != 0 || dScStage_c::m_exeFrame < 10) { + info1->m_20 = info2->m_20; + info1->m_24 = info2->m_24; + info1->m_28 = info2->m_28; + info1->m_2c = info2->m_2c; + info1->m_30 = info2->m_30; + } + if ( + info1->m_30 != info2->m_30 && + info1->m_20 != info2->m_20 || + info1->m_24 != info2->m_24 || + info1->m_28 != info2->m_28 || + info1->m_2c != info2->m_2c + ) { + cond = true; + } + bool cond2 = false; + bool bVar14 = false; + dScStage_c *stage = dScStage_c::m_instance; + dBgParameter_c *bgParam = dBgParameter_c::getInstance(); + info1->m_20 = info2->m_20; + info1->m_24 = info2->m_24; + info1->m_28 = info2->m_28; + info1->m_2c = info2->m_2c; + info1->m_30 = info2->m_30; + dBgBound_c b = info1->mBounds; + mVec2_c tmp((b.mLeft + b.mRight) * 0.5f, (b.mUp + b.mDown) * 0.5f); + float l = info2->mBounds.mLeft; + if (info2->mBounds.mLeft < p.x) { + l = p.x; + } + float r = info2->mBounds.mRight; + if (p.x + s.x < info2->mBounds.mRight) { + r = p.x + s.x; + } + float u = info2->mBounds.mUp; + if (info2->mBounds.mUp < p.y) { + u = p.y; + } + float d = info2->mBounds.mDown; + if (info2->mBounds.mDown < p.y + s.y) { + d = p.y + s.y; + } + float fVar4 = 32.0f; + if (dScStage_c::m_loopType == 2 || i1 == 1) { + info1->mBounds.mLeft = l; + info1->mBounds.mRight = r; + info1->mBounds.mUp = u + 8.0f; + info1->mBounds.mDown = d - 8.0f; + } else { + if (m_90009 == 3) { + fVar4 = 80.0f; + } + if (b.mUp < info2->mBounds.mUp && p.y - fVar4 < info2->mBounds.mUp || + d < b.mDown && d < fVar4 + (p.y - s.y) + ) { + cond2 = true; + } + float w1 = (info1->mBounds.mRight - info1->mBounds.mLeft) * 0.5f; + float h1 = (info1->mBounds.mUp - info1->mBounds.mDown) * 0.5f; + float w2 = (info2->mBounds.mRight - info2->mBounds.mLeft) * 0.5f; + float h2 = (info2->mBounds.mUp - info2->mBounds.mDown) * 0.5f; + float dw = w2 - w1; + float dh = h2 - h1; + float len = sqrt(dw * dw + dh * dh); + if (len == 0.0f) { + dh = 1.0f; + dw = 1.0f; + } else { + dh /= len; + dw /= len; + } + float fVar5 = fabsf(dw); + float fVar6, fVar7; + float fVar12 = fVar5 * 6.0f; + float fVar13 = fabsf(dh) * 12.0f; + if (stage->mCurrWorld == WORLD_8 && stage->mCurrCourse == STAGE_7 || cond) { + fVar6 = 6.0f; + fVar7 = 0.5f; + fVar5 *= 6.0; + } else { + fVar6 = 2.0f; + fVar7 = 0.2f; + } + fVar6 *= fabsf(dh); + + float calcArg1 = 0.1f; + float calcArg2 = 0.005f; + float calcArg3 = 0.0001f; + if (cond2) { + mIdkI = 120; + mIdkF[0] = 1.0f; + mIdkF[1] = 1.0f; + mIdkF[2] = 1.0f; + mIdkF[3] = 1.0f; + } + if (mIdkI != 0) { + mIdkI--; + fVar4 = 1.0f; + } + + if (b.mLeft > l) { + sLib::addCalc(&mIdkF[0], 0.0f, calcArg1, calcArg2, calcArg3); + } else if (l > bgParam->mPos.x + bgParam->mSize.x * 0.5f) { + sLib::addCalc(&mIdkF[0], 0.0f, calcArg1, calcArg2, calcArg3); + } else { + sLib::addCalc(&mIdkF[0], fVar4, calcArg1, calcArg2, calcArg3); + } + sLib::addCalc(&b.mLeft, l, mIdkF[0] * (fVar7 - 0.5f) + 0.5f, fVar12 + mIdkF[0] * (fVar5 - fVar12), 0.1f); + + if (r > b.mRight) { + sLib::addCalc(&mIdkF[1], 0.0f, calcArg1, calcArg2, calcArg3); + } else if (bgParam->mPos.x + bgParam->mSize.x * 0.5f > r) { + sLib::addCalc(&mIdkF[1], 0.0f, calcArg1, calcArg2, calcArg3); + } else { + sLib::addCalc(&mIdkF[1], fVar4, calcArg1, calcArg2, calcArg3); + } + sLib::addCalc(&b.mRight, l, mIdkF[1] * (fVar7 - 0.5f) + 0.5f, fVar12 + mIdkF[1] * (fVar5 - fVar12), 0.1f); + + if (b.mUp > u) { + sLib::addCalc(&mIdkF[2], 0.0f, calcArg1, calcArg2, calcArg3); + } else if (u > bgParam->mPos.x + bgParam->mSize.x * 0.5f) { + sLib::addCalc(&mIdkF[2], 0.0f, calcArg1, calcArg2, calcArg3); + } else { + sLib::addCalc(&mIdkF[2], fVar4, calcArg1, calcArg2, calcArg3); + } + sLib::addCalc(&b.mUp, l, mIdkF[2] * (fVar7 - 0.5f) + 0.5f, fVar12 + mIdkF[2] * (fVar5 - fVar12), 0.1f); + + if (d > b.mDown) { + sLib::addCalc(&mIdkF[3], 0.0f, calcArg1, calcArg2, calcArg3); + } else if (bgParam->mPos.x + bgParam->mSize.x * 0.5f > d) { + sLib::addCalc(&mIdkF[3], 0.0f, calcArg1, calcArg2, calcArg3); + } else { + sLib::addCalc(&mIdkF[3], fVar4, calcArg1, calcArg2, calcArg3); + } + sLib::addCalc(&b.mDown, l, mIdkF[3] * (fVar7 - 0.5f) + 0.5f, fVar12 + mIdkF[3] * (fVar5 - fVar12), 0.1f); + + info1->mBounds = b; + } + float r2 = info1->mBounds.mRight; + float l2 = info1->mBounds.mLeft; + float u2 = info1->mBounds.mUp; + float d2 = info1->mBounds.mDown; + float ll = m_bg_p->getLeftLimit(); + if (p.x > ll && m_bg_p->getRightLimit() > p.x + s.x) { + m_bg_p->m_900b8 = (l2 + r2) * 0.5f - tmp.x; + } else { + m_bg_p->m_900b8 = 0.0f; + } + if (m_bg_p->mULimit > p.y && p.y - s.y > m_bg_p->mDLimit) { + m_bg_p->m_900bc = (u2 + d2) * 0.5f - tmp.y; + } else { + m_bg_p->m_900bc = 0.0f; + } +} + +u8 dBg_c::freeUpScrollLimit(dBgScrollLimit_c *scrollLimit, int group, int area) { + u8 idx = 0; + dBgScrollLimit_c *base = mScrLimit[area][group]; + for (; idx < 16; idx++) { + // idx = i; + if (base[idx].mR2 >= scrollLimit->mR2) { + break; + } + } + if (idx >= 16) { + idx = 0; + } + dBgScrollLimit_c *curr; + if (idx != 15) { + u8 l = 15 - idx; + // u8 r = 15; + idx = 15; + while (l != 0) { + idx--; + curr = &base[l]; + *curr = base[idx]; + l--; + } + } + + curr->mL = 0.0f; + curr->mR = 0.0f; + curr->mU = 0.0f; + curr->mD = 0.0f; + curr->mL2 = 0.0f; + curr->mR2 = 0.0f; + curr->mU2 = 0.0f; + curr->mD2 = 0.0f; + curr->mL3 = 0.0f; + curr->mR3 = 0.0f; + curr->mU3 = 0.0f; + curr->mD3 = 0.0f; + curr->mFlags = 0; + + return (int) idx; +} + +u8 dBg_c::freeUpScrollLimit2(dBgScrollLimit_c *scrollLimit, int group, int area) { + u8 idx = 0; + dBgScrollLimit_c *base = mScrLimit[area][group]; + for (; idx < 16; idx++) { + // idx = i; + if (base[idx].mD3 >= scrollLimit->mD3) { + break; + } + } + if (idx >= 16) { + idx = 0; + } + dBgScrollLimit_c *curr; + if (idx != 15) { + u8 l = 15 - idx; + // u8 r = 15; + idx = 15; + while (l != 0) { + idx--; + curr = &base[l]; + *curr = base[idx]; + l--; + } + } + + curr->mL = 0.0f; + curr->mR = 0.0f; + curr->mU = 0.0f; + curr->mD = 0.0f; + curr->mL2 = 0.0f; + curr->mR2 = 0.0f; + curr->mU2 = 0.0f; + curr->mD2 = 0.0f; + curr->mL3 = 0.0f; + curr->mR3 = 0.0f; + curr->mU3 = 0.0f; + curr->mD3 = 0.0f; + curr->mFlags = 0; + + return idx; +} + +void dBg_c::setScrollLimit(dBgScrollLimit_c *scrollLimit, int areaNo, int type, int group) { + u8 idx; + dBgScrollLimit_c *curr; + switch (type) { + case 0: + case 3: + idx = freeUpScrollLimit(scrollLimit, group, areaNo); + curr = &mScrLimit[areaNo][group][idx]; + curr->mL = scrollLimit->mL; + curr->mR = scrollLimit->mR; + curr->mU = scrollLimit->mU; + curr->mD = scrollLimit->mD; + curr->mL2 = scrollLimit->mL2; + curr->mR2 = scrollLimit->mR2; + curr->mU2 = scrollLimit->mU2; + curr->mD2 = scrollLimit->mD2; + curr->mL3 = scrollLimit->mL3; + curr->mR3 = scrollLimit->mR3; + curr->mU3 = scrollLimit->mU3; + curr->mD3 = scrollLimit->mD3; + curr->mL4 = scrollLimit->mL4; + curr->mR4 = scrollLimit->mR4; + curr->mU4 = scrollLimit->mU4; + curr->mD4 = scrollLimit->mD4; + curr->mFlags = scrollLimit->mFlags | 3; + break; + case 1: + for (idx = 0; idx < 16; idx++) { + dBgScrollLimit_c *curr = &mScrLimit[areaNo][group][idx]; + if ((curr->mFlags & 2) == 0 && curr->mR2 == scrollLimit->mR2) { + break; + } + } + if (idx >= 16) { + idx = freeUpScrollLimit(scrollLimit, group, areaNo); + } + curr = &mScrLimit[areaNo][group][idx]; + curr->mL = scrollLimit->mL; + curr->mU = scrollLimit->mU; + curr->mD = scrollLimit->mD; + curr->mL2 = scrollLimit->mL2; + curr->mR2 = scrollLimit->mR2; + curr->mL4 = scrollLimit->mL4; + curr->mR4 = scrollLimit->mR4; + curr->mU4 = scrollLimit->mU4; + curr->mD4 = scrollLimit->mD4; + curr->mFlags = curr->mFlags | scrollLimit->mFlags | 2; + break; + case 2: + for (idx = 0; idx < 16; idx++) { + dBgScrollLimit_c *curr = &mScrLimit[areaNo][group][idx]; + if ((curr->mFlags & 1) == 0 && curr->mR2 == scrollLimit->mR2) { + break; + } + } + if (idx >= 16) { + idx = freeUpScrollLimit(scrollLimit, group, areaNo); + } + curr = &mScrLimit[areaNo][group][idx]; + curr->mR = 16 + (int) scrollLimit->mR; + curr->mU = scrollLimit->mU; + curr->mD = scrollLimit->mD; + curr->mL2 = scrollLimit->mL2; + curr->mR2 = scrollLimit->mR2; + curr->mL4 = scrollLimit->mL4; + curr->mR4 = scrollLimit->mR4; + curr->mU4 = scrollLimit->mU4; + curr->mD4 = scrollLimit->mD4; + curr->mFlags = curr->mFlags | scrollLimit->mFlags | 1; + break; + case 4: + for (idx = 0; idx < 16; idx++) { + dBgScrollLimit_c *curr = &mScrLimit[areaNo][group][idx]; + if ((curr->mFlags & 2) == 0 && curr->mD3 == scrollLimit->mD3) { + break; + } + } + if (idx >= 16) { + idx = freeUpScrollLimit2(scrollLimit, group, areaNo); + } + curr = &mScrLimit[areaNo][group][idx]; + curr->mU2 = scrollLimit->mU2; + curr->mL3 = scrollLimit->mL3; + curr->mR3 = scrollLimit->mR3; + curr->mU3 = scrollLimit->mU3; + curr->mD3 = scrollLimit->mD3; + curr->mL4 = scrollLimit->mL4; + curr->mR4 = scrollLimit->mR4; + curr->mU4 = scrollLimit->mU4; + curr->mD4 = scrollLimit->mD4; + curr->mFlags = curr->mFlags | scrollLimit->mFlags | 2; + break; + case 5: + for (idx = 0; idx < 16; idx++) { + dBgScrollLimit_c *curr = &mScrLimit[areaNo][group][idx]; + if ((curr->mFlags & 1) == 0 && curr->mD3 == scrollLimit->mD3) { + break; + } + } + if (idx >= 16) { + idx = freeUpScrollLimit2(scrollLimit, group, areaNo); + } + curr = &mScrLimit[areaNo][group][idx]; + curr->mD2 = 16 + (int) scrollLimit->mD2; + curr->mL3 = scrollLimit->mL3; + curr->mR3 = scrollLimit->mR3; + curr->mU3 = scrollLimit->mU3; + curr->mD3 = scrollLimit->mD3; + curr->mL4 = scrollLimit->mL4; + curr->mR4 = scrollLimit->mR4; + curr->mU4 = scrollLimit->mU4; + curr->mD4 = scrollLimit->mD4; + curr->mFlags = curr->mFlags | scrollLimit->mFlags | 1; + break; + } +} + +void dBg_c::fn_8007E060(dBgSubstruct2_c *s, int idx) { + for (u8 i = 0; i < 20; i++) { + dBgSubstruct2_c *curr = &mData2[idx][i]; + if (curr->mU8_1 >= 99) { + curr->mFloat1 = s->mFloat1; + curr->mFloat2 = s->mFloat2; + curr->mFloat3 = s->mFloat3; + curr->mFloat4 = s->mFloat4; + curr->mU8_1 = s->mU8_1; + curr->mU8_2 = s->mU8_2; + curr->mU8_3 = s->mU8_3; + return; + } + } +} + +float dBg_c::getAreaUpLimitScroll() { + dBgParameter_c *bgParam = dBgParameter_c::getInstance(); + float sizeY = bgParam->mSize.y; + float posY = bgParam->mPos.y; + float m = m_bg_p->getZoomTargetMin() * mVideo::getLayoutHeight(); + float diff = posY - sizeY; + float res = mMoreFloats3[0] + diff + m; + return res; +} From 4d114cc9527839a3459b44db87e5180b0147893b Mon Sep 17 00:00:00 2001 From: user Date: Thu, 1 May 2025 22:06:14 +0200 Subject: [PATCH 03/29] Match dBg_c::fn_8007E060 --- include/game/bases/d_bg.hpp | 3 ++- source/dol/bases/d_bg.cpp | 2 +- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/include/game/bases/d_bg.hpp b/include/game/bases/d_bg.hpp index 06e04fbf..eed7e303 100644 --- a/include/game/bases/d_bg.hpp +++ b/include/game/bases/d_bg.hpp @@ -234,9 +234,10 @@ class dBg_c : public dBase_c { float getDispScale() { return mDispScale; } float getPrevDispScale() { return mMoreFloats3[1]; } float getScaleFactor() { return 1.0f / mDispScale; } - float getLiquidHeight() const { return mMoreFloats7[5]; } + dBgSubstruct2_c * getData2(int idx, int i) { return &mData2[idx][i]; } + typedef void (dBg_c::*callbackFunc)(dBgSomeInfo_c *, int); unsigned long long *mBgCheckBuffer; diff --git a/source/dol/bases/d_bg.cpp b/source/dol/bases/d_bg.cpp index 14d45028..69a7bc4e 100644 --- a/source/dol/bases/d_bg.cpp +++ b/source/dol/bases/d_bg.cpp @@ -2433,7 +2433,7 @@ void dBg_c::setScrollLimit(dBgScrollLimit_c *scrollLimit, int areaNo, int type, void dBg_c::fn_8007E060(dBgSubstruct2_c *s, int idx) { for (u8 i = 0; i < 20; i++) { - dBgSubstruct2_c *curr = &mData2[idx][i]; + dBgSubstruct2_c *curr = getData2(idx, i); if (curr->mU8_1 >= 99) { curr->mFloat1 = s->mFloat1; curr->mFloat2 = s->mFloat2; From 3b2ff13dfbe45671f7ba6ae13d662bf1e0c5c504 Mon Sep 17 00:00:00 2001 From: RootCubed Date: Thu, 7 May 2026 08:46:29 +0200 Subject: [PATCH 04/29] dBg_c 87% matching --- include/game/bases/d_bg.hpp | 11 ++- source/dol/bases/d_bg.cpp | 186 +++++++++++++++++------------------- 2 files changed, 95 insertions(+), 102 deletions(-) diff --git a/include/game/bases/d_bg.hpp b/include/game/bases/d_bg.hpp index eed7e303..21f19fea 100644 --- a/include/game/bases/d_bg.hpp +++ b/include/game/bases/d_bg.hpp @@ -76,11 +76,11 @@ class dBgBound_c { struct dBgSomeInfo_c { dBgSomeInfo_c() : - m_10(nullptr), m_14(nullptr), m_18(0), m_1c(0) {} + m_10(nullptr), m_14(nullptr), m_18(nullptr), m_1c(nullptr) {} dBgBound_c mBounds; - dAcPy_c *m_10, *m_14; - int m_18, m_1c, m_20, m_24, m_28, m_2c, m_30; + dAcPy_c *m_10, *m_14, *m_18, *m_1c; + int m_20, m_24, m_28, m_2c, m_30; }; struct dBgSubstruct2_c { @@ -173,7 +173,7 @@ class dBg_c : public dBase_c { static sScrollAreaData *dBg_getScrlAreaDataP(u8, u8); bool dBg_isFlyPlayer(); int dBg_isCloudFlyPlayer(); - bool dBg_isCloudFlyPlayerMulti(); // [Not static? bruh] + int dBg_isCloudFlyPlayerMulti(); // [Not static? bruh] float fn_80078860(float); @@ -219,7 +219,7 @@ class dBg_c : public dBase_c { void fn_8007ca90(dBgSomeInfo_c *, int, int); ///< @unofficial void fn_8007cd70(dBgSomeInfo_c *, dBgSomeInfo_c *, int); ///< @unofficial - u8 freeUpScrollLimit(dBgScrollLimit_c *scrollLimit, int group, int area); ///< @unofficial + u8 freeUpScrollLimit(const dBgScrollLimit_c &scrollLimit, int group, int area); ///< @unofficial u8 freeUpScrollLimit2(dBgScrollLimit_c *scrollLimit, int group, int area); ///< @unofficial void setScrollLimit(dBgScrollLimit_c *scrollLimit, int areaNo, int type, int group); ///< @unofficial @@ -236,6 +236,7 @@ class dBg_c : public dBase_c { float getScaleFactor() { return 1.0f / mDispScale; } float getLiquidHeight() const { return mMoreFloats7[5]; } + dBgScrollLimit_c *getScrLim(int area, int group, int idx) { return &mScrLimit[area][group][idx]; } dBgSubstruct2_c * getData2(int idx, int i) { return &mData2[idx][i]; } typedef void (dBg_c::*callbackFunc)(dBgSomeInfo_c *, int); diff --git a/source/dol/bases/d_bg.cpp b/source/dol/bases/d_bg.cpp index 69a7bc4e..0883df1c 100644 --- a/source/dol/bases/d_bg.cpp +++ b/source/dol/bases/d_bg.cpp @@ -589,7 +589,7 @@ int dBg_c::dBg_isCloudFlyPlayer() { return res; } -bool dBg_c::dBg_isCloudFlyPlayerMulti() { +int dBg_c::dBg_isCloudFlyPlayerMulti() { bool res = false; u8 scrInfo = daPyMng_c::getActScrollInfo(); for (int i = 0; i < 4; i++) { @@ -1373,57 +1373,58 @@ void dBg_c::fn_8007ac40(dBgSomeInfo_c *info, int arg1) { } else { scale = 0.9f; } - b.mUp = tmpUp * scale; + float someTmp2 = tmpUp * scale; mVec2_c r = fn_8007bd40(info, zoom, scale, &mWaveRelated[0x4d]); - b.mRight = tmpRight; + float someTmp = tmpRight; if (mLimitRelated == 1) { r.x = r.y; - b.mRight = b.mUp; + someTmp = someTmp2; } if (mLimitRelated == 6 || mLimitRelated == 7) { r.y = r.x - 1.0f; - b.mUp = b.mRight; + someTmp2 = someTmp; } if (mLimitRelated == 2) { if ((mLimitRelated2 == 5 || mLimitRelated2 == 6) || (mLimitRelated2 == 1 || mLimitRelated2 == 2)) { - if (invScale < m_bg_p->getZoomTargetMax() && spL2 < b.mRight) { - b.mRight = spL2; + if (invScale < m_bg_p->getZoomTargetMax() && spL2 > someTmp) { + someTmp = spL2; } - if (!dBg_isFlyPlayer() && mU8s[2] == 0 && spL2 < b.mUp) { - b.mUp = spL2; + if (!dBg_isFlyPlayer() && mU8s[2] == 0 && spL2 > someTmp2) { + someTmp2 = spL2; } } else { - if (invScale <= m_bg_p->getZoomTargetMid() && spL < b.mRight) { - b.mRight = spL; + if (invScale <= m_bg_p->getZoomTargetMid() && spL > someTmp) { + someTmp = spL; } - if (!dBg_isFlyPlayer() && mU8s[2] == 0 && spL < b.mUp) { - b.mUp = spL; + if (!dBg_isFlyPlayer() && mU8s[2] == 0 && spL > someTmp2) { + someTmp2 = spL; } } } if (mLimitRelated == 0 && mLimitRelated2 == 10) { - if (dBg_isCloudFlyPlayerMulti() == 1) { - b.mRight = spL2 + 0.01f; - } else if (shL2 - 0.01 < b.mRight || m_9095b != 0) { - b.mRight = shL2 - 0.01f; + if (dBg_isCloudFlyPlayerMulti() != 1) { + someTmp = shL2 - 0.01f; + if (someTmp2 > someTmp || m_9095b != 0) { + someTmp = spL2 + 0.01f; + } } - b.mUp = b.mRight - 1.0f; + someTmp2 = someTmp - 1.0f; } - if (b.mUp < b.mRight) { - b.mUp = b.mRight; + if (someTmp2 > someTmp) { + someTmp2 = someTmp; } if ((daPyDemoMng_c::mspInstance->mFlags & 1) == 0) { if (m_90024 == 0) { - if (b.mUp <= spL) { + if (someTmp2 <= spL) { mMoreFloats5[0] = tgMin; } else { mMoreFloats5[0] = tgMid; m_90024 = 1; } } else if (m_90024 == 1) { - if (b.mUp <= spL2) { - if (shL <= b.mUp) { - if (spL <= b.mUp) { + if (someTmp2 <= spL2) { + if (shL <= someTmp2) { + if (spL <= someTmp2) { mMoreFloats5[0] = tgMid; } } else { @@ -1438,8 +1439,8 @@ void dBg_c::fn_8007ac40(dBgSomeInfo_c *info, int arg1) { m_90024 = 2; } } else if (m_90024 == 2) { - if (shL2 <= b.mUp) { - if (spL2 <= b.mUp) { + if (shL2 <= someTmp2) { + if (spL2 <= someTmp2) { mMoreFloats5[0] = tgMax; } } else { @@ -1481,7 +1482,7 @@ void dBg_c::fn_8007ac40(dBgSomeInfo_c *info, int arg1) { scale = 1.0f; } if (m_9001c == 0) { - sLib::addCalc(&m_90018, fVar28, fVar25, scale * (b.mUp * b.mUp * b.mUp * 6.0f + 1.0f), calcArg); + sLib::addCalc(&m_90018, fVar28, fVar25, scale * (someTmp2 * someTmp2 * someTmp2 * 6.0f + 1.0f), calcArg); } fVar25 = m_90018; if (fVar25 < mMoreFloats5[1]) { @@ -1502,7 +1503,7 @@ void dBg_c::fn_8007ac40(dBgSomeInfo_c *info, int arg1) { scale = 1.0f; } if (m_9001c == 0) { - sLib::addCalc(&m_90018, fVar28, fVar25, scale * (b.mUp * b.mUp * b.mUp * 6.0f + 1.0f), calcArg); + sLib::addCalc(&m_90018, fVar28, fVar25, scale * (someTmp2 * someTmp2 * someTmp2 * 6.0f + 1.0f), calcArg); } mMoreFloats5[1] = mMoreFloats5[2]; } @@ -1621,6 +1622,7 @@ void dBg_c::fn_8007ac40(dBgSomeInfo_c *info, int arg1) { info->mBounds.mDown = mPrevSomePos.y - mPrevSomeSize.y - 32.0f; } calcLookatOffsLimit(); + // ... } void dBg_c::fn_8007ba70(dBgSomeInfo_c *info) { @@ -2042,26 +2044,26 @@ void dBg_c::fn_8007ca90(dBgSomeInfo_c *info, int i1, int i2) { break; case 1: if (pls[0] != nullptr) { - info->m_14 = pl1; + info->m_18 = pl1; info->mBounds.mUp = pl1->mAmiRelated2; - info->m_24 = pl1->mPlayerType; + info->m_28 = pl1->mPlayerType; } if (pls[i2 - 1] != nullptr) { - info->m_10 = pl2; + info->m_1c = pl2; info->mBounds.mDown = pl2->mAmiRelated2; - info->m_20 = pl2->mPlayerType; + info->m_2c = pl2->mPlayerType; } break; case 3: if (pls[i2 - 1] != nullptr) { - info->m_14 = pl2; + info->m_18 = pl2; info->mBounds.mUp = pl2->mAmiRelated2; - info->m_24 = pl2->mPlayerType; + info->m_28 = pl2->mPlayerType; } if (pls[0] != nullptr) { - info->m_10 = pl1; + info->m_1c = pl1; info->mBounds.mDown = pl1->mAmiRelated2; - info->m_20 = pl1->mPlayerType; + info->m_2c = pl1->mPlayerType; } break; } @@ -2230,51 +2232,46 @@ void dBg_c::fn_8007cd70(dBgSomeInfo_c *info1, dBgSomeInfo_c *info2, int i1) { } } -u8 dBg_c::freeUpScrollLimit(dBgScrollLimit_c *scrollLimit, int group, int area) { +u8 dBg_c::freeUpScrollLimit(const dBgScrollLimit_c &scrollLimit, int group, int area) { + dBgScrollLimit_c *base = getScrLim(area, group, 0); u8 idx = 0; - dBgScrollLimit_c *base = mScrLimit[area][group]; for (; idx < 16; idx++) { // idx = i; - if (base[idx].mR2 >= scrollLimit->mR2) { + if (base[idx].mR2 >= scrollLimit.mR2) { break; } } if (idx >= 16) { idx = 0; } - dBgScrollLimit_c *curr; - if (idx != 15) { - u8 l = 15 - idx; - // u8 r = 15; - idx = 15; - while (l != 0) { - idx--; - curr = &base[l]; - *curr = base[idx]; - l--; - } - } - - curr->mL = 0.0f; - curr->mR = 0.0f; - curr->mU = 0.0f; - curr->mD = 0.0f; - curr->mL2 = 0.0f; - curr->mR2 = 0.0f; - curr->mU2 = 0.0f; - curr->mD2 = 0.0f; - curr->mL3 = 0.0f; - curr->mR3 = 0.0f; - curr->mU3 = 0.0f; - curr->mD3 = 0.0f; - curr->mFlags = 0; - - return (int) idx; + dBgScrollLimit_c *currSL, *prevSL; + u8 prev = 15; + for (u32 i = idx; i != 15; i++) { + prevSL = getScrLim(area, group, prev); + currSL = getScrLim(area, group, --prev); + *prevSL = *currSL; + } + + currSL->mL = 0.0f; + currSL->mR = 0.0f; + currSL->mU = 0.0f; + currSL->mD = 0.0f; + currSL->mL2 = 0.0f; + currSL->mR2 = 0.0f; + currSL->mU2 = 0.0f; + currSL->mD2 = 0.0f; + currSL->mL3 = 0.0f; + currSL->mR3 = 0.0f; + currSL->mU3 = 0.0f; + currSL->mD3 = 0.0f; + currSL->mFlags = 0; + + return idx; } u8 dBg_c::freeUpScrollLimit2(dBgScrollLimit_c *scrollLimit, int group, int area) { + dBgScrollLimit_c *base = getScrLim(area, group, 0); u8 idx = 0; - dBgScrollLimit_c *base = mScrLimit[area][group]; for (; idx < 16; idx++) { // idx = i; if (base[idx].mD3 >= scrollLimit->mD3) { @@ -2284,32 +2281,27 @@ u8 dBg_c::freeUpScrollLimit2(dBgScrollLimit_c *scrollLimit, int group, int area) if (idx >= 16) { idx = 0; } - dBgScrollLimit_c *curr; - if (idx != 15) { - u8 l = 15 - idx; - // u8 r = 15; - idx = 15; - while (l != 0) { - idx--; - curr = &base[l]; - *curr = base[idx]; - l--; - } - } - - curr->mL = 0.0f; - curr->mR = 0.0f; - curr->mU = 0.0f; - curr->mD = 0.0f; - curr->mL2 = 0.0f; - curr->mR2 = 0.0f; - curr->mU2 = 0.0f; - curr->mD2 = 0.0f; - curr->mL3 = 0.0f; - curr->mR3 = 0.0f; - curr->mU3 = 0.0f; - curr->mD3 = 0.0f; - curr->mFlags = 0; + dBgScrollLimit_c *currSL, *prevSL; + u8 prev = 15; + for (u32 i = idx; i != 15; i++) { + prevSL = getScrLim(area, group, prev); + currSL = getScrLim(area, group, --prev); + *prevSL = *currSL; + } + + currSL->mL = 0.0f; + currSL->mR = 0.0f; + currSL->mU = 0.0f; + currSL->mD = 0.0f; + currSL->mL2 = 0.0f; + currSL->mR2 = 0.0f; + currSL->mU2 = 0.0f; + currSL->mD2 = 0.0f; + currSL->mL3 = 0.0f; + currSL->mR3 = 0.0f; + currSL->mU3 = 0.0f; + currSL->mD3 = 0.0f; + currSL->mFlags = 0; return idx; } @@ -2320,7 +2312,7 @@ void dBg_c::setScrollLimit(dBgScrollLimit_c *scrollLimit, int areaNo, int type, switch (type) { case 0: case 3: - idx = freeUpScrollLimit(scrollLimit, group, areaNo); + idx = freeUpScrollLimit(*scrollLimit, group, areaNo); curr = &mScrLimit[areaNo][group][idx]; curr->mL = scrollLimit->mL; curr->mR = scrollLimit->mR; @@ -2348,7 +2340,7 @@ void dBg_c::setScrollLimit(dBgScrollLimit_c *scrollLimit, int areaNo, int type, } } if (idx >= 16) { - idx = freeUpScrollLimit(scrollLimit, group, areaNo); + idx = freeUpScrollLimit(*scrollLimit, group, areaNo); } curr = &mScrLimit[areaNo][group][idx]; curr->mL = scrollLimit->mL; @@ -2370,7 +2362,7 @@ void dBg_c::setScrollLimit(dBgScrollLimit_c *scrollLimit, int areaNo, int type, } } if (idx >= 16) { - idx = freeUpScrollLimit(scrollLimit, group, areaNo); + idx = freeUpScrollLimit(*scrollLimit, group, areaNo); } curr = &mScrLimit[areaNo][group][idx]; curr->mR = 16 + (int) scrollLimit->mR; From 3d420fc6977d2e6f38962d7219d3b53f3e6c736d Mon Sep 17 00:00:00 2001 From: RootCubed Date: Wed, 7 May 2025 16:46:17 +0200 Subject: [PATCH 05/29] dBg_c 91% matching --- include/game/bases/d_bg.hpp | 4 +- source/dol/bases/d_bg.cpp | 323 ++++++++++++++++++++++-------------- 2 files changed, 198 insertions(+), 129 deletions(-) diff --git a/include/game/bases/d_bg.hpp b/include/game/bases/d_bg.hpp index 21f19fea..b3174401 100644 --- a/include/game/bases/d_bg.hpp +++ b/include/game/bases/d_bg.hpp @@ -210,11 +210,11 @@ class dBg_c : public dBase_c { void initScroll(); void fn_8007ac40(dBgSomeInfo_c *, int); ///< @unofficial - void fn_8007ba70(dBgSomeInfo_c *); ///< @unofficial + void fn_8007ba70(const dBgSomeInfo_c *); ///< @unofficial float fn_8007bba0(dBgSomeInfo_c *); ///< @unofficial float fn_8007bbf0(dBgSomeInfo_c *); ///< @unofficial bool fn_8007bc40(dBgSomeInfo_c *, float); ///< @unofficial - mVec2_c fn_8007bd40(dBgSomeInfo_c *, float, float, float *); ///< @unofficial + mVec2_c fn_8007bd40(dBgSomeInfo_c *, float, float); ///< @unofficial float fn_8007c7d0(float); ///< @unofficial void fn_8007ca90(dBgSomeInfo_c *, int, int); ///< @unofficial void fn_8007cd70(dBgSomeInfo_c *, dBgSomeInfo_c *, int); ///< @unofficial diff --git a/source/dol/bases/d_bg.cpp b/source/dol/bases/d_bg.cpp index 0883df1c..5f900586 100644 --- a/source/dol/bases/d_bg.cpp +++ b/source/dol/bases/d_bg.cpp @@ -1374,7 +1374,7 @@ void dBg_c::fn_8007ac40(dBgSomeInfo_c *info, int arg1) { scale = 0.9f; } float someTmp2 = tmpUp * scale; - mVec2_c r = fn_8007bd40(info, zoom, scale, &mWaveRelated[0x4d]); + mVec2_c r = fn_8007bd40(info, zoom, scale); float someTmp = tmpRight; if (mLimitRelated == 1) { r.x = r.y; @@ -1385,7 +1385,7 @@ void dBg_c::fn_8007ac40(dBgSomeInfo_c *info, int arg1) { someTmp2 = someTmp; } if (mLimitRelated == 2) { - if ((mLimitRelated2 == 5 || mLimitRelated2 == 6) || (mLimitRelated2 == 1 || mLimitRelated2 == 2)) { + if (mLimitRelated2 == 5 || mLimitRelated2 == 6 || mLimitRelated2 == 1 || mLimitRelated2 == 2) { if (invScale < m_bg_p->getZoomTargetMax() && spL2 > someTmp) { someTmp = spL2; } @@ -1452,7 +1452,7 @@ void dBg_c::fn_8007ac40(dBgSomeInfo_c *info, int arg1) { } } if (mMoreFloats5[0] == tgMax) { - if (mMoreFloats5[2] != tgMid ) { + if (mMoreFloats5[2] != tgMid) { b.mRight = m_90018; if (mMoreFloats5[1] <= b.mRight) { mMoreFloats5[1] = b.mRight; @@ -1481,19 +1481,15 @@ void dBg_c::fn_8007ac40(dBgSomeInfo_c *info, int arg1) { calcArg = 0.1; scale = 1.0f; } - if (m_9001c == 0) { - sLib::addCalc(&m_90018, fVar28, fVar25, scale * (someTmp2 * someTmp2 * someTmp2 * 6.0f + 1.0f), calcArg); - } + sLib::addCalc(&m_90018, fVar28, fVar25, scale * (someTmp2 * someTmp2 * someTmp2 * 6.0f + 1.0f), calcArg); fVar25 = m_90018; - if (fVar25 < mMoreFloats5[1]) { + if (fVar25 > mMoreFloats5[1]) { if (std::fabs(fVar28 - fVar25) > 0.1f) { m_9001c = 90; } m_90018 = mMoreFloats5[1]; } - } else if (m_90018 <= mMoreFloats5[0]) { - mMoreFloats5[1] = mMoreFloats5[2]; - } else { + } else if (mMoreFloats5[0] > m_90018) { fVar25 = 0.5f; float calcArg = 0.0015f; float scale = 0.003f; @@ -1506,31 +1502,33 @@ void dBg_c::fn_8007ac40(dBgSomeInfo_c *info, int arg1) { sLib::addCalc(&m_90018, fVar28, fVar25, scale * (someTmp2 * someTmp2 * someTmp2 * 6.0f + 1.0f), calcArg); } mMoreFloats5[1] = mMoreFloats5[2]; + } else { + mMoreFloats5[1] = mMoreFloats5[2]; } if (m_9001c != 0) { m_9001c--; } - if (zoom < m_90018) { + if (m_90018 > zoom) { m_90018 = zoom; } - if (zoom > m_90018) { + if (m_90018 < zoom) { m_90018 = zoom; - } else if (tgMax < m_90018) { + } else if (m_90018 > tgMax) { m_90018 = tgMax; } float copy_90018 = m_90018; float val = -(mDLimit - mULimit); - if (val < m_90018 - mVideo::getLayoutHeight()) { + if (val < m_90018 * mVideo::getLayoutHeight()) { m_90018 = m_90018 / mVideo::getLayoutHeight(); } if (getAreaUpLimitScroll() > -999999.0f) { - float upLimit = getAreaUpLimitScroll(); + float divres = (mD - getAreaUpLimitScroll()) / mVideo::getLayoutHeight(); if (mU8s[2] == 0) { m_90964 = 1.0f; } else { sLib::addCalc(&m_90964, 0.0f, 0.5f, 0.01f, 0.01f); } - copy_90018 += m_90964 * (val / fVar28 - copy_90018); + copy_90018 += m_90964 * (divres - copy_90018); } mPrevSomeSize.x = lWidth * copy_90018; mPrevSomeSize.y = lHeight * copy_90018; @@ -1568,9 +1566,9 @@ void dBg_c::fn_8007ac40(dBgSomeInfo_c *info, int arg1) { if (dScStage_c::m_loopType != 2) { newW = getLeftLimit(); float d = getRightLimit() - newW; - if (newW <= w) { + if (newW < w) { newW = w; - if (d < w) { + if (d > w) { newW = d; } } @@ -1578,11 +1576,11 @@ void dBg_c::fn_8007ac40(dBgSomeInfo_c *info, int arg1) { if (!check && dScStage_c::m_loopType != 1) { mPrevSomePos.x = newW; } - int iVar9 = 0; + u8 iVar9 = 0; float fnres = fn_8007bbf0(info); float fVar12 = 0.5f; if (fnres < mPrevSomePos.y && (m_90009 == 3 || m_9000a == 3)) { - iVar9 = 16; + iVar9 |= 0x10; fVar12 = fnres; } float fnres2 = fn_8007bba0(info); @@ -1590,23 +1588,23 @@ void dBg_c::fn_8007ac40(dBgSomeInfo_c *info, int arg1) { if (m_90009 == 1 || m_9000a == 2) { iVar9 = 1; fVar12 = fnres2; - } else if (m_9000a == 3 && iVar9 == 0) { + } else if (m_9000a == 3 && (iVar9 & 0x10) == 0) { int rounded = fnres2 - mPrevSomePos.y; mBounds3[3] = rounded; } } - if (iVar9 != 0 && iVar9 == 17 && (m_90009 == 1 || m_9000a == 1)) { + if (iVar9 == 0 || iVar9 != 17 && (m_90009 == 1 || m_9000a == 1)) { fVar12 = fnres2; } if (iVar9 != 0) { - if (fVar12 < (int) mPrevSomePos.y) { + if ((int) fVar12 < (int) mPrevSomePos.y) { float diff = mPrevSomePos.y - fVar12; if (diff < 16.0f) { mMoreFloats5[2] -= diff; } else { mMoreFloats5[2] -= 16.0f; } - } else if ((int) mPrevSomePos.y < fVar12) { + } else if ((int) mPrevSomePos.y < (int) fVar12) { float diff = fVar12 - mPrevSomePos.y; if (diff < 16.0f) { mMoreFloats5[2] += diff; @@ -1621,36 +1619,95 @@ void dBg_c::fn_8007ac40(dBgSomeInfo_c *info, int arg1) { if (info->mBounds.mDown < mPrevSomePos.y - mPrevSomeSize.y - 32.0f) { info->mBounds.mDown = mPrevSomePos.y - mPrevSomeSize.y - 32.0f; } + float dVar12 = mMoreFloats5[4] + lHeight * 0.5f + (copy_90018 - 1.0f); calcLookatOffsLimit(); - // ... + + float fVar14 = mMoreFloats6[0]; + if (getAreaUpLimitScroll() > -999999.0f) { + if (getAreaUpLimitScroll() < dBgParameter_c::ms_Instance_p->mPos.y) { + mU8s[2] = 1; + } else if (getAreaUpLimitScroll() < fVar14) { + if (!dBg_isFlyPlayer() && copy_90018 <= -(mD - getAreaUpLimitScroll()) / mVideo::getLayoutHeight()) { + fVar14 = getAreaUpLimitScroll(); + } + } + } + float upperBound = mULimit; + float lowerBound = mDLimit + mPrevSomeSize.y; + float finalY = fVar14; + + if (finalY < upperBound) { + mMoreFloats5[4] += lowerBound - finalY; + finalY = lowerBound; + } else if (finalY > lowerBound) { + mMoreFloats5[4] -= upperBound - finalY; + finalY = upperBound; + } + + if (mLimitRelated == 6) { + mMoreFloats5[4] = 0.0f; + finalY = lowerBound; + } + + if (m_9095c == 0) { + if ((stage->mCurrCourse != STAGE_DOOMSHIP || stage->mCurrFile != 2) && stage->mCurrCourse != STAGE_CASTLE) { + mMoreFloats5[4] = m_90960 - dVar12; + } + m_9095c = 1; + } + + if (arg1 != 0 || getAreaUpLimitScroll() <= -999999.0f) { + mPrevSomePos.y = finalY; + } else { + sLib::chase(&mPrevSomePos.y, finalY, 16.0f); + } + + if (m_900a7 != 0) { + mPrevSomePos.x = m_900ac - 0.5f * mPrevSomeSize.x; + mPrevSomePos.y = m_900b0 + mPrevSomeSize.y; + } + + // Auto-scroll backup + if (!mAutoscrolls[0].mActive) { + mAutoscrolls[0].mPos.x = mPrevSomePos.x; + mAutoscrolls[0].mPos.y = mPrevSomePos.y; + } } -void dBg_c::fn_8007ba70(dBgSomeInfo_c *info) { - float fVar1 = info->mBounds.mLeft; +struct stack_struct_s { + float x; + float padding[2]; + float y; + float padding2; +}; + +void dBg_c::fn_8007ba70(const dBgSomeInfo_c *info) { + stack_struct_s thing; + thing.y = info->mBounds.mRight; + thing.x = info->mBounds.mLeft; + float smth = thing.y; float w = mPrevSomeSize.x; float fVar4; if (m_90009 == 2 || m_9000a == 2) { fVar4 = 112.0f - dBgParameter_c::getInstance()->m_78; - fVar1 = info->mBounds.mRight; + smth = thing.x; } else { fVar4 = w - (112.0f - dBgParameter_c::getInstance()->m_78); } - fVar1 -= fVar4; - if (fVar1 - mPrevSomePos.x > 6.0f) { - fVar1 = mPrevSomePos.x + 6.0f; - } else if (fVar1 - mPrevSomePos.x < -6.0f) { - fVar1 = mPrevSomePos.x - 6.0f; + float tmp = smth - fVar4; + if (tmp - mPrevSomePos.x > 6.0f) { + tmp = mPrevSomePos.x + 6.0f; + } else if (tmp - mPrevSomePos.x < -6.0f) { + tmp = mPrevSomePos.x - 6.0f; } float ll = getLeftLimit(); float d = getRightLimit() - w; - float newW = fVar1; + float newW = tmp; if (dScStage_c::m_loopType != 2) { - newW = ll; - if (fVar1 < newW) { - newW = fVar1; - if (d > w) { - newW = d; - } + if (tmp < newW) { + newW = ll; + } else if (newW > d) { + newW = d; } } mPrevSomePos.x = newW; @@ -1699,50 +1756,51 @@ bool dBg_c::fn_8007bc40(dBgSomeInfo_c *info, float f) { } } -mVec2_c dBg_c::fn_8007bd40(dBgSomeInfo_c *info, float f1, float f2, float *f3) { +mVec2_c dBg_c::fn_8007bd40(dBgSomeInfo_c *info, float f1, float f2) { mVec2_c result(0.0f, 0.0f); - float fVar1; - float fVar2; - float fVar3; - float fVar4; - float fVar5; - float fVar6; - float fVar7; - float fVar8; - - fVar5 = mVideo::l_rayoutHeightF; - fVar4 = mVideo::l_rayoutWidthF; - fVar7 = getLeftLimit(); - fVar8 = getRightLimit(); - fVar1 = 112.0f; - fVar2 = mULimit; - fVar3 = mDLimit; - fVar6 = fVar1; - if (f3[0] - 112.0f < fVar7) { - fVar6 = f3[0] - fVar7; - } - if (fVar8 < f3[1] + 112.0f) { - fVar1 = fVar8 - f3[1]; - } - fVar7 = 1.0f; - fVar4 = (fVar1 + fVar6 + (f3[1] - f3[0])) / fVar4; - if ((fVar4 >= 1.0f) && (fVar7 = fVar4, f1 < fVar4)) { - fVar7 = f1; + float fVar4 = mVideo::getLayoutWidth(); + float fVar5 = mVideo::getLayoutHeight(); + float ll = getLeftLimit(); + float rl = getRightLimit(); + float uLim = mULimit; + float dLim = mDLimit; + float fVar1 = 112.0f; + float tmpLeft = info->mBounds.mLeft - 112.0f; + float fVar6 = 112.0f; + float tmpRight = info->mBounds.mRight + 112.0f; + if (tmpLeft < ll) { + fVar6 = info->mBounds.mLeft - ll; + } + if (tmpRight > rl) { + fVar1 = rl - info->mBounds.mRight; + } + float resX = 1.0f; + float tmpX = (fVar1 + (info->mBounds.mRight - info->mBounds.mLeft) + fVar6) / fVar4; + if (tmpX < 1.0f) { + resX = tmpX; + } else if (tmpX > f1) { + resX = f1; } fVar1 = 88.0f; fVar4 = 80.0f; - if (fVar2 < f3[2] + 88.0f) { - fVar1 = fVar2 - f3[2]; + float tmpUp = info->mBounds.mUp + 88.0f; + float tmpDown = info->mBounds.mDown - 80.0f; + if (tmpUp > uLim) { + fVar1 = uLim - info->mBounds.mUp; } - if (f3[3] - 80.0f < fVar3) { - fVar4 = f3[3] - fVar3; + if (tmpDown < dLim) { + fVar4 = info->mBounds.mDown - dLim; } - fVar2 = 1.0f; - fVar5 = ((fVar4 + fVar1 + (f3[2] - f3[3])) * f2) / fVar5; - if ((fVar5 >= 1.0f) && (fVar2 = fVar5, f1 < fVar5)) { - fVar2 = f1; + float resY = 1.0f; + float tmpY = ((fVar4 + (info->mBounds.mUp - info->mBounds.mDown) + fVar1) * f2) / fVar5; + if (tmpY < 1.0f) { + resY = tmpY; + } else if (tmpY > f1) { + resY = f1; } + result.x = resX; + result.y = resY; return result; } @@ -2070,8 +2128,10 @@ void dBg_c::fn_8007ca90(dBgSomeInfo_c *info, int i1, int i2) { } void dBg_c::fn_8007cd70(dBgSomeInfo_c *info1, dBgSomeInfo_c *info2, int i1) { - mVec2_c p = dBgParameter_c::getInstance()->mPos; - mVec2_c s = dBgParameter_c::getInstance()->mSize; + float px = dBgParameter_c::getInstance()->mPos.x; + float py = dBgParameter_c::getInstance()->mPos.y; + float sx = dBgParameter_c::getInstance()->mSize.x; + float sy = dBgParameter_c::getInstance()->mSize.y; bool cond = false; if ((dActor_c::mExecStop & 2) != 0) { return; @@ -2094,59 +2154,57 @@ void dBg_c::fn_8007cd70(dBgSomeInfo_c *info1, dBgSomeInfo_c *info2, int i1) { } bool cond2 = false; bool bVar14 = false; - dScStage_c *stage = dScStage_c::m_instance; - dBgParameter_c *bgParam = dBgParameter_c::getInstance(); info1->m_20 = info2->m_20; info1->m_24 = info2->m_24; info1->m_28 = info2->m_28; info1->m_2c = info2->m_2c; info1->m_30 = info2->m_30; + dBgParameter_c *bgParam = dBgParameter_c::getInstance(); + dScStage_c *stage = dScStage_c::m_instance; dBgBound_c b = info1->mBounds; mVec2_c tmp((b.mLeft + b.mRight) * 0.5f, (b.mUp + b.mDown) * 0.5f); float l = info2->mBounds.mLeft; - if (info2->mBounds.mLeft < p.x) { - l = p.x; - } float r = info2->mBounds.mRight; - if (p.x + s.x < info2->mBounds.mRight) { - r = p.x + s.x; - } float u = info2->mBounds.mUp; - if (info2->mBounds.mUp < p.y) { - u = p.y; - } float d = info2->mBounds.mDown; - if (info2->mBounds.mDown < p.y + s.y) { - d = p.y + s.y; + if (l < px) { + l = px; + } + if (r > px + sx) { + r = px + sx; + } + if (u > py) { + u = py; + } + if (d < py - sy) { + d = py - sy; } float fVar4 = 32.0f; if (dScStage_c::m_loopType == 2 || i1 == 1) { - info1->mBounds.mLeft = l; info1->mBounds.mRight = r; + info1->mBounds.mLeft = l; info1->mBounds.mUp = u + 8.0f; - info1->mBounds.mDown = d - 8.0f; + info1->mBounds.mDown = d; } else { if (m_90009 == 3) { fVar4 = 80.0f; } - if (b.mUp < info2->mBounds.mUp && p.y - fVar4 < info2->mBounds.mUp || - d < b.mDown && d < fVar4 + (p.y - s.y) - ) { + if (b.mUp > u && py - fVar4 > u || d < b.mDown && d < fVar4 + (py - sy)) { cond2 = true; } - float w1 = (info1->mBounds.mRight - info1->mBounds.mLeft) * 0.5f; - float h1 = (info1->mBounds.mUp - info1->mBounds.mDown) * 0.5f; - float w2 = (info2->mBounds.mRight - info2->mBounds.mLeft) * 0.5f; - float h2 = (info2->mBounds.mUp - info2->mBounds.mDown) * 0.5f; + float w1 = (info1->mBounds.mRight + info1->mBounds.mLeft) * 0.5f; + float h1 = (info1->mBounds.mUp + info1->mBounds.mDown) * 0.5f; + float w2 = (info2->mBounds.mRight + info2->mBounds.mLeft) * 0.5f; + float h2 = (info2->mBounds.mUp + info2->mBounds.mDown) * 0.5f; float dw = w2 - w1; float dh = h2 - h1; float len = sqrt(dw * dw + dh * dh); - if (len == 0.0f) { + if (len != 0.0f) { + dw = (w2 - w1) / len; + dh = (h2 - h1) / len; + } else { dh = 1.0f; dw = 1.0f; - } else { - dh /= len; - dw /= len; } float fVar5 = fabsf(dw); float fVar6, fVar7; @@ -2155,7 +2213,7 @@ void dBg_c::fn_8007cd70(dBgSomeInfo_c *info1, dBgSomeInfo_c *info2, int i1) { if (stage->mCurrWorld == WORLD_8 && stage->mCurrCourse == STAGE_7 || cond) { fVar6 = 6.0f; fVar7 = 0.5f; - fVar5 *= 6.0; + fVar5 *= 6.0f; } else { fVar6 = 2.0f; fVar7 = 0.2f; @@ -2165,6 +2223,8 @@ void dBg_c::fn_8007cd70(dBgSomeInfo_c *info1, dBgSomeInfo_c *info2, int i1) { float calcArg1 = 0.1f; float calcArg2 = 0.005f; float calcArg3 = 0.0001f; + float calcScale = 0.5f; + float calcAdd = 0.5f; if (cond2) { mIdkI = 120; mIdkF[0] = 1.0f; @@ -2177,41 +2237,51 @@ void dBg_c::fn_8007cd70(dBgSomeInfo_c *info1, dBgSomeInfo_c *info2, int i1) { fVar4 = 1.0f; } - if (b.mLeft > l) { + float tmp1, tmp2; + + if (l < b.mLeft) { sLib::addCalc(&mIdkF[0], 0.0f, calcArg1, calcArg2, calcArg3); - } else if (l > bgParam->mPos.x + bgParam->mSize.x * 0.5f) { + } else if (l > bgParam->mPos.x + bgParam->mSize.x / 2.0f) { sLib::addCalc(&mIdkF[0], 0.0f, calcArg1, calcArg2, calcArg3); } else { sLib::addCalc(&mIdkF[0], fVar4, calcArg1, calcArg2, calcArg3); } - sLib::addCalc(&b.mLeft, l, mIdkF[0] * (fVar7 - 0.5f) + 0.5f, fVar12 + mIdkF[0] * (fVar5 - fVar12), 0.1f); + tmp1 = mIdkF[0] * (fVar7 - calcScale) + calcAdd; + tmp2 = fVar12 + mIdkF[0] * (fVar5 - fVar12); + sLib::addCalc(&b.mLeft, l, tmp1, tmp2, 0.1f); if (r > b.mRight) { sLib::addCalc(&mIdkF[1], 0.0f, calcArg1, calcArg2, calcArg3); - } else if (bgParam->mPos.x + bgParam->mSize.x * 0.5f > r) { + } else if (r < bgParam->mPos.x + bgParam->mSize.x / 2.0f) { sLib::addCalc(&mIdkF[1], 0.0f, calcArg1, calcArg2, calcArg3); } else { sLib::addCalc(&mIdkF[1], fVar4, calcArg1, calcArg2, calcArg3); } - sLib::addCalc(&b.mRight, l, mIdkF[1] * (fVar7 - 0.5f) + 0.5f, fVar12 + mIdkF[1] * (fVar5 - fVar12), 0.1f); + tmp1 = mIdkF[1] * (fVar7 - calcScale) + calcAdd; + tmp2 = fVar12 + mIdkF[1] * (fVar5 - fVar12); + sLib::addCalc(&b.mRight, l, tmp1, tmp2, 0.1f); - if (b.mUp > u) { + if (u > b.mUp) { sLib::addCalc(&mIdkF[2], 0.0f, calcArg1, calcArg2, calcArg3); - } else if (u > bgParam->mPos.x + bgParam->mSize.x * 0.5f) { + } else if (u < bgParam->mPos.y - bgParam->mSize.y / 2.0f) { sLib::addCalc(&mIdkF[2], 0.0f, calcArg1, calcArg2, calcArg3); } else { sLib::addCalc(&mIdkF[2], fVar4, calcArg1, calcArg2, calcArg3); } - sLib::addCalc(&b.mUp, l, mIdkF[2] * (fVar7 - 0.5f) + 0.5f, fVar12 + mIdkF[2] * (fVar5 - fVar12), 0.1f); + tmp1 = mIdkF[2] * (fVar7 - calcScale) + calcAdd; + tmp2 = fVar13 + mIdkF[2] * (fVar5 - fVar13); + sLib::addCalc(&b.mUp, l, tmp1, tmp2, 0.1f); - if (d > b.mDown) { + if (d < b.mDown) { sLib::addCalc(&mIdkF[3], 0.0f, calcArg1, calcArg2, calcArg3); - } else if (bgParam->mPos.x + bgParam->mSize.x * 0.5f > d) { + } else if (d > bgParam->mPos.y - bgParam->mSize.y / 2.0f) { sLib::addCalc(&mIdkF[3], 0.0f, calcArg1, calcArg2, calcArg3); } else { sLib::addCalc(&mIdkF[3], fVar4, calcArg1, calcArg2, calcArg3); } - sLib::addCalc(&b.mDown, l, mIdkF[3] * (fVar7 - 0.5f) + 0.5f, fVar12 + mIdkF[3] * (fVar5 - fVar12), 0.1f); + tmp1 = mIdkF[3] * (fVar7 - calcScale) + calcAdd; + tmp2 = fVar13 + mIdkF[3] * (fVar5 - fVar13); + sLib::addCalc(&b.mDown, l, tmp1, tmp2, 0.1f); info1->mBounds = b; } @@ -2219,16 +2289,17 @@ void dBg_c::fn_8007cd70(dBgSomeInfo_c *info1, dBgSomeInfo_c *info2, int i1) { float l2 = info1->mBounds.mLeft; float u2 = info1->mBounds.mUp; float d2 = info1->mBounds.mDown; - float ll = m_bg_p->getLeftLimit(); - if (p.x > ll && m_bg_p->getRightLimit() > p.x + s.x) { - m_bg_p->m_900b8 = (l2 + r2) * 0.5f - tmp.x; - } else { + float h_lr = (l2 + r2) * 0.5f; + float h_ud = (u2 + d2) * 0.5f; + if (m_bg_p->getLeftLimit() <= px || px + sx <= m_bg_p->getRightLimit()) { m_bg_p->m_900b8 = 0.0f; - } - if (m_bg_p->mULimit > p.y && p.y - s.y > m_bg_p->mDLimit) { - m_bg_p->m_900bc = (u2 + d2) * 0.5f - tmp.y; } else { + m_bg_p->m_900b8 = h_lr - tmp.x; + } + if (py >= m_bg_p->mULimit || py - sy <= m_bg_p->mDLimit) { m_bg_p->m_900bc = 0.0f; + } else { + m_bg_p->m_900bc = h_ud - tmp.y; } } @@ -2443,8 +2514,6 @@ float dBg_c::getAreaUpLimitScroll() { dBgParameter_c *bgParam = dBgParameter_c::getInstance(); float sizeY = bgParam->mSize.y; float posY = bgParam->mPos.y; - float m = m_bg_p->getZoomTargetMin() * mVideo::getLayoutHeight(); - float diff = posY - sizeY; - float res = mMoreFloats3[0] + diff + m; - return res; + float m = m_bg_p->getZoomTargetMin() * mVideo::getLayoutHeight() + (posY - sizeY); + return mMoreFloats3[3] + m; } From f0f6eca0bf859cb2a6562c9412e51bb9d05fcd5e Mon Sep 17 00:00:00 2001 From: RootCubed Date: Thu, 7 May 2026 08:50:20 +0200 Subject: [PATCH 06/29] dBg_c 92% matching --- include/game/bases/d_bg.hpp | 7 +- source/dol/bases/d_bg.cpp | 123 +++++++++++++++++------------------- 2 files changed, 64 insertions(+), 66 deletions(-) diff --git a/include/game/bases/d_bg.hpp b/include/game/bases/d_bg.hpp index b3174401..b804562f 100644 --- a/include/game/bases/d_bg.hpp +++ b/include/game/bases/d_bg.hpp @@ -89,7 +89,6 @@ struct dBgSubstruct2_c { u8 mU8_1; u8 mU8_2; u8 mU8_3; - u8 mU8_4; }; struct dBgAnimObj_c { @@ -190,6 +189,10 @@ class dBg_c : public dBase_c { float getZoomTargetMax_Common(); float getZoomTargetMax(); + float calcDispScale(float bgVal, float tmp1) { + return (1.0f / getZoomTargetMin()) + bgVal * (1.0f / tmp1 - (1.0f / getZoomTargetMin())); + } + float getZoomSpreadLine(); float getZoomSpreadLine2(); float getZoomShrinkLine(); @@ -269,7 +272,7 @@ class dBg_c : public dBase_c { float mWaveRelated[80]; float mDispScale; float mMoreFloats3[4]; - u8 mU8s[5]; + u8 mU8s[6]; float mZoomDenom; u8 m_8ffbc; float mLLimit, mRLimit, mULimit, mDLimit; diff --git a/source/dol/bases/d_bg.cpp b/source/dol/bases/d_bg.cpp index 5f900586..6dc12e09 100644 --- a/source/dol/bases/d_bg.cpp +++ b/source/dol/bases/d_bg.cpp @@ -54,16 +54,12 @@ dBg_c::dBg_c() { mBounds3[1] = 0.0f; mBounds3[2] = 0.0f; - mMoreFloats[1] = 0.0f; - mMoreFloats[2] = 0.0f; - mMoreFloats[3] = 0.0f; - mMoreFloats[4] = 0.0f; - mMoreFloats[5] = 0.0f; - mMoreFloats[6] = 0.0f; - mMoreFloats[7] = 0.0f; - mMoreFloats[8] = 0.0f; - mMoreFloats[9] = 0.0f; - mMoreFloats[10] = 0.0f; + mSomeSize.set(0.0f, 0.0f); + mPrevSomeSize.set(0.0f, 0.0f); + mSomePos.set(0.0f, 0.0f); + mPrevSomePos.set(0.0f, 0.0f); + mMoreFloats6[0] = 0.0f; + mMoreFloats6[1] = 0.0f; mLoopOffsetX = 0.0f; mLoopOffsetY = 0.0f; mSomeParameterPos.set(0.0f, 0.0f); @@ -211,12 +207,12 @@ u32 dBg_c::GetUnitKindInfo(u16 p1, u16 p2, u8 p3) { u16 fn_800834b0(u16); void dBg_c::CoinGetCommon(u16 p1, u16 p2, int p3, u16 *p4, u16 *p5, u16 *p6) { - int currCourse = dScStage_c::m_instance->mCurrCourse; + int file = dScStage_c::m_instance->mCurrFile; u16 var1 = (p2 & 0xf00) * 4; u16 var3 = p1 / 16 & 0x1f0; u8 var4 = p1 / 16; u8 var5 = p2 / 16 & 0xf; - *p4 = dBgParameter_c::ms_Instance_p->getOneGetBuff(currCourse, var1 + var3 + var5, p3); + *p4 = dBgParameter_c::ms_Instance_p->getOneGetBuff(file, var1 + var3 + var5, p3); *p5 = fn_800834b0(var4); *p6 = var1 + var3 + var5; } @@ -1190,7 +1186,7 @@ void dBg_c::calcAutoScroll() { for (int i = 0; i < 4; i++) { dAcPy_c *pl = daPyMng_c::getPlayer(i); if (pl != nullptr) { - upLim = pl->m_68; + upLim = pl->mPc.m_30.x; if (upLim > rightLim) { rightLim = upLim; } @@ -1221,40 +1217,42 @@ void dBg_c::AutoScroll_stop() { void dBg_c::calcScroll(const mVec3_c &pos, int param_2) { dBgParameter_c *bgParam = dBgParameter_c::getInstance(); - float lWidth = mVideo::l_rayoutWidthF; - float lHeight = mVideo::l_rayoutHeightF; + float lWidth = mVideo::getLayoutWidth(); + float lHeight = mVideo::getLayoutHeight(); if (m_bg_p->m_9095a == 0) { m_bg_p->getZoomTargetMax(); // unused return value - if (mMoreFloats3[3] > 0.0f) { + float tmp1 = mMoreFloats3[0]; + if (tmp1 > 0.0f) { float bgVal = dBgParameter_c::getInstance()->m_30.y; - float tmp2 = bgVal * (1.0f / mMoreFloats3[3] - 1.0f / m_bg_p->getZoomTargetMin()); - mDispScale = tmp2 + 1.0f / m_bg_p->getZoomTargetMin(); + mDispScale = m_bg_p->calcDispScale(bgVal, tmp1); } m_90018 = mDispScale; mMoreFloats5[1] = mDispScale; - lWidth *= 1.0f / mDispScale; - lHeight *= 1.0f / mDispScale; - mSomeSize.x = lWidth; - mSomeSize.y = lHeight; + float invDispScale = 1.0f / mDispScale; + mSomeSize.x = lWidth * invDispScale; + mSomeSize.y = lHeight * invDispScale; + float width = mSomeSize.x; + float halfWidth = width * 0.5f; float leftLimit = getLeftLimit(); - float rightLimit = getRightLimit() - lWidth; - float upLimit = mULimit; - float downLimit = lHeight + mDLimit; + float rightLimit = getRightLimit() - width; bool cond1 = true; bool cond2 = true; + float upLimit = mULimit; + float downLimit = lHeight + mDLimit; float maxLeft = getMaxLeftPos(); mSomeParameterPos = bgParam->mPos; mPlayerPosY = pos.y; + float height = mSomeSize.y; + float halfHeight = height * 0.5f; float bounds40 = mBounds4[0]; float bounds41 = mBounds4[1]; - float y = (pos.y + mSomeSize.y * 0.5f) - bounds41; - float x = (pos.x + bounds40) - lHeight * 0.5f; - float idkX = x; + float x = pos.x + bounds40 - halfWidth; + float y = pos.y + halfHeight - bounds41; if (dScStage_c::m_loopType != 2) { - if (y < idkX) { - idkX = leftLimit; - } else if (y > rightLimit) { - idkX = rightLimit; + if (x < leftLimit) { + x = leftLimit; + } else if (x > rightLimit) { + x = rightLimit; } } else { if (dScStage_c::m_instance->mCurrWorld == WORLD_2 && @@ -1262,18 +1260,17 @@ void dBg_c::calcScroll(const mVec3_c &pos, int param_2) { dScStage_c::m_instance->mCurrFile == 0 && m_90958 == 0 ) { - if (y < idkX) { - idkX = leftLimit; - } else if (y > rightLimit) { - idkX = rightLimit; + if (x < leftLimit) { + x = leftLimit; + } else if (x > rightLimit) { + x = rightLimit; } } } if (y < downLimit) { - downLimit = y; - if (upLimit > y) { - downLimit = upLimit; - } + y = downLimit; + } else if (y > upLimit) { + y = upLimit; } if (mAutoscrolls[0].mActive) { switch (mAutoscrolls[0].m_18) { @@ -1292,28 +1289,28 @@ void dBg_c::calcScroll(const mVec3_c &pos, int param_2) { } } if (cond1) { - mSomePos.x = idkX; + mSomePos.x = x; } if (cond2) { if ( getAreaUpLimitScroll() > -999999.0f && - dBgParameter_c::getInstance()->mPos.y >= getAreaUpLimitScroll() && - downLimit > getAreaUpLimitScroll() && + dBgParameter_c::getInstance()->posY() <= getAreaUpLimitScroll() && + y > getAreaUpLimitScroll() && dBg_isFlyPlayer() == 0 ) { - downLimit = getAreaUpLimitScroll(); + y = getAreaUpLimitScroll(); } if (param_2 != 0 || getAreaUpLimitScroll() <= -999999.0f) { - mSomePos.y = downLimit; + mSomePos.y = y; } else { - sLib::chase(&mSomePos.y, downLimit, 16.0f); + sLib::chase(&mSomePos.y, y, 16.0f); } } if (mLimitRelated == 1 || mLimitRelated == 4) { mSomePos.x = maxLeft + mLoopOffsetX * 0.5f - mSomeSize.x * 0.5f; } if (mLimitRelated == 6) { - mSomePos.y = mD + mSomeSize.y; + mSomePos.y = mSomeSize.y + mD; } mBounds4[0] = bounds40; mBounds4[1] = bounds41; @@ -1322,7 +1319,7 @@ void dBg_c::calcScroll(const mVec3_c &pos, int param_2) { mAutoscrolls[0].mPos.y = mSomePos.y; } if (m_900a7 != 0) { - mSomePos.x = m_900ac - mSomeSize.x * 0.5f; + mSomePos.x = m_900ac - mSomeSize.x / 2; mSomePos.y = m_900b0 + mSomeSize.y; } } @@ -1385,7 +1382,7 @@ void dBg_c::fn_8007ac40(dBgSomeInfo_c *info, int arg1) { someTmp2 = someTmp; } if (mLimitRelated == 2) { - if (mLimitRelated2 == 5 || mLimitRelated2 == 6 || mLimitRelated2 == 1 || mLimitRelated2 == 2) { + if (mLimitRelated2 >= 5 && mLimitRelated2 <= 7 || mLimitRelated2 >= 1 && mLimitRelated2 <= 2) { if (invScale < m_bg_p->getZoomTargetMax() && spL2 > someTmp) { someTmp = spL2; } @@ -1863,10 +1860,8 @@ void dBg_c::initScroll() { mPrevSomeSize = mSomeSize; bgParam->mSize = mSomeSize; - float halfWidth = bgParam->mSize.x * 0.5f; - float halfHeight = bgParam->mSize.y * 0.5f; - bgParam->mCenter.x = bgParam->mPos.x + halfWidth; - bgParam->mCenter.y = bgParam->mPos.y - halfHeight; + bgParam->mCenter.x = bgParam->mPos.x + bgParam->mSize.x * 0.5f; + bgParam->mCenter.y = bgParam->mPos.y - bgParam->mSize.y * 0.5f; mU8s[3] = 0; mU8s[4] = 0; @@ -2037,17 +2032,17 @@ void dBg_c::fn_8007ca90(dBgSomeInfo_c *info, int i1, int i2) { dAcPy_c *pl = daPyMng_c::getPlayer(i); pls[i] = pl; if (pl != nullptr) { - if (pl->mPowerup == POWERUP_MUSHROOM) { + if (pl->mScrollMode == 1) { pls[i] = nullptr; } - if (pl->mPowerup == POWERUP_MINI_MUSHROOM) { + if (pl->mScrollMode == 3) { count++; } } if (pls[i] != nullptr) { count2++; } - if (m_90009 == 1 && pl != nullptr && pl->mPowerup == POWERUP_MINI_MUSHROOM) { + if (m_90009 == 1 && pl != nullptr && pl->mScrollMode == 3) { pls[i] = nullptr; } } @@ -2079,48 +2074,48 @@ void dBg_c::fn_8007ca90(dBgSomeInfo_c *info, int i1, int i2) { case 0: if (pls[0] != nullptr) { info->m_14 = pl1; - info->mBounds.mRight = fn_8007c7d0(pl1->m_68); + info->mBounds.mRight = fn_8007c7d0(pl1->mPc.m_30.x); info->m_24 = pl1->mPlayerType; } if (pls[i2 - 1] != nullptr) { info->m_10 = pl2; - info->mBounds.mLeft = fn_8007c7d0(pl2->m_68); + info->mBounds.mLeft = fn_8007c7d0(pl2->mPc.m_30.x); info->m_20 = pl2->mPlayerType; } break; case 2: if (pls[i2 - 1] != nullptr) { info->m_14 = pl2; - info->mBounds.mRight = fn_8007c7d0(pl2->m_68); + info->mBounds.mRight = fn_8007c7d0(pl2->mPc.m_30.x); info->m_24 = pl2->mPlayerType; } if (pls[0] != nullptr) { info->m_10 = pl1; - info->mBounds.mLeft = fn_8007c7d0(pl1->m_68); + info->mBounds.mLeft = fn_8007c7d0(pl1->mPc.m_30.x); info->m_20 = pl1->mPlayerType; } break; case 1: if (pls[0] != nullptr) { info->m_18 = pl1; - info->mBounds.mUp = pl1->mAmiRelated2; + info->mBounds.mUp = pl1->mPc.m_30.y; info->m_28 = pl1->mPlayerType; } if (pls[i2 - 1] != nullptr) { info->m_1c = pl2; - info->mBounds.mDown = pl2->mAmiRelated2; + info->mBounds.mDown = pl2->mPc.m_30.y; info->m_2c = pl2->mPlayerType; } break; case 3: if (pls[i2 - 1] != nullptr) { info->m_18 = pl2; - info->mBounds.mUp = pl2->mAmiRelated2; + info->mBounds.mUp = pl2->mPc.m_30.y; info->m_28 = pl2->mPlayerType; } if (pls[0] != nullptr) { info->m_1c = pl1; - info->mBounds.mDown = pl1->mAmiRelated2; + info->mBounds.mDown = pl1->mPc.m_30.y; info->m_2c = pl1->mPlayerType; } break; From e148a8b682fbf53347f071e6a5f109ea9ba7b208 Mon Sep 17 00:00:00 2001 From: RootCubed Date: Wed, 28 May 2025 22:17:39 +0200 Subject: [PATCH 07/29] fn_80078300 matching --- source/dol/bases/d_bg.cpp | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/source/dol/bases/d_bg.cpp b/source/dol/bases/d_bg.cpp index 6dc12e09..f7b317b4 100644 --- a/source/dol/bases/d_bg.cpp +++ b/source/dol/bases/d_bg.cpp @@ -1341,16 +1341,16 @@ void dBg_c::calcMultiScroll(int arg1) { } void dBg_c::fn_8007ac40(dBgSomeInfo_c *info, int arg1) { - dBgBound_c b = info->mBounds; + // dBgBound_c b = info->mBounds; - float lWidth = mVideo::l_rayoutWidthF; - float lHeight = mVideo::l_rayoutHeightF; + float lWidth = mVideo::getLayoutWidth(); + float lHeight = mVideo::getLayoutHeight(); float invScale = 1.0f / mDispScale; float zoom = 1.0f / mZoomDenom; - float tmpUp = std::fabs(b.mDown - b.mUp) / lHeight; - float tmpRight = std::fabs(b.mLeft - b.mRight) / lWidth; + float tmpRight = std::fabs(info->mBounds.mRight - info->mBounds.mLeft) / lWidth; + float tmpUp = std::fabs(info->mBounds.mUp - info->mBounds.mDown) / lHeight; float spL = m_bg_p->getZoomSpreadLine(); float spL2 = m_bg_p->getZoomSpreadLine2(); @@ -1450,9 +1450,9 @@ void dBg_c::fn_8007ac40(dBgSomeInfo_c *info, int arg1) { } if (mMoreFloats5[0] == tgMax) { if (mMoreFloats5[2] != tgMid) { - b.mRight = m_90018; - if (mMoreFloats5[1] <= b.mRight) { - mMoreFloats5[1] = b.mRight; + info->mBounds.mRight = m_90018; + if (mMoreFloats5[1] <= info->mBounds.mRight) { + mMoreFloats5[1] = info->mBounds.mRight; } mMoreFloats5[2] = tgMid; } From 4d1d1340551db7e415ea667ddbce3993f7542a99 Mon Sep 17 00:00:00 2001 From: RootCubed Date: Thu, 29 May 2025 10:27:55 +0200 Subject: [PATCH 08/29] Continued progress on dBg_c::calcAutoScroll --- source/dol/bases/d_bg.cpp | 52 ++++++++++++++++++++++----------------- 1 file changed, 29 insertions(+), 23 deletions(-) diff --git a/source/dol/bases/d_bg.cpp b/source/dol/bases/d_bg.cpp index f7b317b4..51689619 100644 --- a/source/dol/bases/d_bg.cpp +++ b/source/dol/bases/d_bg.cpp @@ -1044,15 +1044,17 @@ void dBg_c::calcLoopAutoScroll() { } void dBg_c::calcAutoScroll() { - dScStage_c *stage = dScStage_c::m_instance; - mVec2_c bgSize = dBgParameter_c::getInstance()->mSize; + dBgParameter_c *bgParam = dBgParameter_c::ms_Instance_p; + float bgW = bgParam->mSize.x; + float bgH = bgParam->mSize.y; sRailInfoData *ri = dRail_c::getRailInfoP(mAutoscrolls[0].m_14); + dScStage_c *stage = dScStage_c::m_instance; dCdFile_c *file = dCd_c::m_instance->getFileP(stage->mCurrCourse); float leftLim = getLeftLimit(); - float rightLim = getRightLimit() - bgSize.x; + float rightLim = getRightLimit() - bgW; float upLim = mULimit; - float downLim = bgSize.y - mDLimit; + float downLim = bgH + mDLimit; bool cond1 = true; bool cond2 = true; if (stage->mCurrWorld == WORLD_2 && stage->mCurrCourse == STAGE_CASTLE && stage->mCurrFile == 0) { @@ -1065,7 +1067,7 @@ void dBg_c::calcAutoScroll() { int idx = m_9007c; // dBgThing_c *tmp = &base[m_9007c]; if (m_90009 == 0) { - if (mAutoscrolls[0].mPos.x > base[idx].m_00) { + if (mAutoscrolls[0].mPos.x > (short) base[idx].m_00) { m_9007c++; } else { break; @@ -1078,26 +1080,28 @@ void dBg_c::calcAutoScroll() { asPos.x = mAutoscrolls[0].mPos.x; asPos.y = mAutoscrolls[0].mPos.y; asPos.z = 0.0f; - rightLim = asPos.y; + // rightLim = asPos.y; int tmp = m_9007c; if (m_90080 < 999) { sBgThing *base = &bgThings[m_90080]; mVec3_c bgThingVec; - bgThingVec.x = base->m_00; - bgThingVec.y = -(float) base->m_02; + bgThingVec.x = (short) base->m_00; + bgThingVec.y = -(float) (short) base->m_02; bgThingVec.z = 0.0f; mVec3_c asCopy; if (tmp > 0) { - asCopy.x = (base - 1)->m_00; - asCopy.y = -(float) (base - 1)->m_02; + asCopy.x = (short) (base - 1)->m_00; + asCopy.y = -(float) (short) (base - 1)->m_02; asCopy.z = 0.0f; } else { asCopy = asPos; } mVec3_c someVec = bgThingVec; someVec -= asCopy; - float calcArg = 0.0f; + mVec3_c tmpCopy = someVec; someVec.normalize(); + float calcArg = *(float *) &base->m_04; // FIXME + float calcArg2 = *(float *) &base->m_08; // FIXME mVec3_c someVec2 = asCopy; someVec -= asPos; someVec2.normalize(); @@ -1115,7 +1119,7 @@ void dBg_c::calcAutoScroll() { idk.x = mAng(m_90088).cos() * mAng(m_9008a).sin(); idk.y = mAng(m_90088).sin(); idk.z = mAng(m_90088).cos() * mAng(m_9008a).cos(); - sLib::addCalc(&mAutoscrolls[0].m_0c, asPos.y, 1.0f, calcArg, 0.0001f); + sLib::addCalc(&mAutoscrolls[0].m_0c, calcArg2, 1.0f, calcArg, 0.0001f); mAutoscrolls[0].mPos.z = 0.0f; mAutoscrolls[0].mPos.x += idk.y * mAutoscrolls[0].m_0c; mAutoscrolls[0].mPos.y += idk.z * mAutoscrolls[0].m_0c; @@ -1154,18 +1158,20 @@ void dBg_c::calcAutoScroll() { return; } } - mVec3_c asPosCopy = mAutoscrolls[0].mPos; + mSomeParameterPos = bgParam->mPos; + mVec3_c asPosCopy; + asPosCopy.x = mAutoscrolls[0].mPos.x; + asPosCopy.y = mAutoscrolls[0].mPos.y; + asPosCopy.z = mAutoscrolls[0].mPos.z; if (asPosCopy.x < leftLim) { - leftLim = asPosCopy.x; - if (rightLim < leftLim) { - leftLim = leftLim; - } + asPosCopy.x = leftLim; + } else if (asPosCopy.x > rightLim) { + asPosCopy.x = rightLim; } if (asPosCopy.y < downLim) { - downLim = asPosCopy.y; - if (upLim < downLim) { - downLim = downLim; - } + asPosCopy.y = downLim; + } else if (asPosCopy.y > upLim) { + asPosCopy.y = upLim; } switch (mAutoscrolls[0].m_18) { case 0: @@ -1192,10 +1198,10 @@ void dBg_c::calcAutoScroll() { } } } - mSomePos.x = leftLim; + mSomePos.x = asPosCopy.x; } if (cond2) { - mSomePos.y = downLim; + mSomePos.y = asPosCopy.y; } float lWidth = mVideo::l_rayoutWidthF; From fab7af091640fa5b75b6fa29842e60e29a5df9b7 Mon Sep 17 00:00:00 2001 From: RootCubed Date: Thu, 29 May 2025 13:34:21 +0200 Subject: [PATCH 09/29] dBg_c 93% matching --- include/game/bases/d_bg_tex.hpp | 4 +- include/game/bases/d_s_stage.hpp | 1 + source/dol/bases/d_bg.cpp | 82 ++++++++++++++++---------------- 3 files changed, 45 insertions(+), 42 deletions(-) diff --git a/include/game/bases/d_bg_tex.hpp b/include/game/bases/d_bg_tex.hpp index 8c819a81..b12b9d53 100644 --- a/include/game/bases/d_bg_tex.hpp +++ b/include/game/bases/d_bg_tex.hpp @@ -16,7 +16,9 @@ class bgTex_c { u16 mCount; u16 mSmth; - u8 mPad[0x30]; + u8 mPad[0x28]; + u16 m_30; + u8 mPad2[6]; dPanelObjMgr_c mPanelObjMgr; }; diff --git a/include/game/bases/d_s_stage.hpp b/include/game/bases/d_s_stage.hpp index bd964b18..b0505195 100644 --- a/include/game/bases/d_s_stage.hpp +++ b/include/game/bases/d_s_stage.hpp @@ -26,6 +26,7 @@ class dScStage_c : public dScene_c { typedef void (*changePosFunc)(mVec3_c *); static void setChangePosFunc(int); + static dScStage_c *getInstance() { return m_instance; } static void setTitleReplayRandomTable(); diff --git a/source/dol/bases/d_bg.cpp b/source/dol/bases/d_bg.cpp index 51689619..a4c45f72 100644 --- a/source/dol/bases/d_bg.cpp +++ b/source/dol/bases/d_bg.cpp @@ -206,15 +206,16 @@ u32 dBg_c::GetUnitKindInfo(u16 p1, u16 p2, u8 p3) { u16 fn_800834b0(u16); -void dBg_c::CoinGetCommon(u16 p1, u16 p2, int p3, u16 *p4, u16 *p5, u16 *p6) { +void dBg_c::CoinGetCommon(u16 tileIndex, u16 cellIndex, int someCounter, u16* out1, u16* out2, u16* out3) { int file = dScStage_c::m_instance->mCurrFile; - u16 var1 = (p2 & 0xf00) * 4; - u16 var3 = p1 / 16 & 0x1f0; - u8 var4 = p1 / 16; - u8 var5 = p2 / 16 & 0xf; - *p4 = dBgParameter_c::ms_Instance_p->getOneGetBuff(file, var1 + var3 + var5, p3); - *p5 = fn_800834b0(var4); - *p6 = var1 + var3 + var5; + + int tmp = (cellIndex & 0xF00) << 2; + tmp += (cellIndex >> 4) & 0xF; + tmp += ((tileIndex >> 4) & 0x1F0); + + *out1 = dBgParameter_c::ms_Instance_p->getOneGetBuff(file, tmp, someCounter); + *out2 = fn_800834b0((tileIndex / 16) & 0x0F); + *out3 = tmp; } void dBg_c::CoinGetBitSet(u16 p1, u16 p2, int p3) { @@ -392,7 +393,7 @@ bgTex_c *dBg_c::__createBgTex(int layer, u16 tw, u16 th, u16 w, u16 h, int i1, i for (u16 y = 0; y < tex->mCount; y++) { u16 x = 0; - if (tex->mSmth == 0) { + if (tex->m_30 == 0) { continue; } unsigned int unitX, unitY; @@ -1049,25 +1050,26 @@ void dBg_c::calcAutoScroll() { float bgH = bgParam->mSize.y; sRailInfoData *ri = dRail_c::getRailInfoP(mAutoscrolls[0].m_14); dScStage_c *stage = dScStage_c::m_instance; - dCdFile_c *file = dCd_c::m_instance->getFileP(stage->mCurrCourse); - - float leftLim = getLeftLimit(); - float rightLim = getRightLimit() - bgW; - float upLim = mULimit; - float downLim = bgH + mDLimit; + dCdFile_c *file = dCd_c::m_instance->getFileP(stage->mCurrFile); + + float calcArg2, calcArg; + float leftLim, rightLim, upLim, downLim; + leftLim = getLeftLimit(); + rightLim = getRightLimit() - bgW; + upLim = mULimit; + downLim = bgH + mDLimit; bool cond1 = true; bool cond2 = true; if (stage->mCurrWorld == WORLD_2 && stage->mCurrCourse == STAGE_CASTLE && stage->mCurrFile == 0) { calcLoopAutoScroll(); } else if ((dActor_c::mExecStop & 8) == 0 && m_9008c == 0) { - sBgThing *bgThings = mBgThings; - sBgThing *base = &bgThings[ri->mNodeIdx]; + sRailNodeData *base = &file->mpRailNodes[ri->mNodeIdx]; if (m_9008d != 0) { for (int i = 0; i < 999; i++) { int idx = m_9007c; // dBgThing_c *tmp = &base[m_9007c]; if (m_90009 == 0) { - if (mAutoscrolls[0].mPos.x > (short) base[idx].m_00) { + if (mAutoscrolls[0].mPos.x > base[idx].mX) { m_9007c++; } else { break; @@ -1080,30 +1082,29 @@ void dBg_c::calcAutoScroll() { asPos.x = mAutoscrolls[0].mPos.x; asPos.y = mAutoscrolls[0].mPos.y; asPos.z = 0.0f; - // rightLim = asPos.y; int tmp = m_9007c; - if (m_90080 < 999) { - sBgThing *base = &bgThings[m_90080]; + int offset = m_90080; + if (offset < 999) { mVec3_c bgThingVec; - bgThingVec.x = (short) base->m_00; - bgThingVec.y = -(float) (short) base->m_02; - bgThingVec.z = 0.0f; mVec3_c asCopy; + mVec3_c someVec2; + mVec3_c idk; + mVec3_c someVec; + bgThingVec.x = base[offset].mX; + bgThingVec.y = -(float) base[offset].mY; + bgThingVec.z = 0.0f; if (tmp > 0) { - asCopy.x = (short) (base - 1)->m_00; - asCopy.y = -(float) (short) (base - 1)->m_02; + asCopy.x = (&base[offset] - 1)->mX; + asCopy.y = -(float) (&base[offset] - 1)->mY; asCopy.z = 0.0f; } else { asCopy = asPos; } - mVec3_c someVec = bgThingVec; - someVec -= asCopy; - mVec3_c tmpCopy = someVec; + someVec = bgThingVec - asCopy; someVec.normalize(); - float calcArg = *(float *) &base->m_04; // FIXME - float calcArg2 = *(float *) &base->m_08; // FIXME - mVec3_c someVec2 = asCopy; - someVec -= asPos; + calcArg = base[offset].mSpeed; + calcArg2 = base[offset].mAccel; + someVec2 = bgThingVec - asPos; someVec2.normalize(); float len = someVec2.xzLen(); short ang1 = cM::atan2s(someVec2.y, len); @@ -1115,14 +1116,13 @@ void dBg_c::calcAutoScroll() { sLib::addCalcAngle(&m_90088, ang1, 60, 250, 1); sLib::addCalcAngle(&m_9008a, ang2, 60, 250, 1); } - mVec3_c idk; idk.x = mAng(m_90088).cos() * mAng(m_9008a).sin(); idk.y = mAng(m_90088).sin(); idk.z = mAng(m_90088).cos() * mAng(m_9008a).cos(); - sLib::addCalc(&mAutoscrolls[0].m_0c, calcArg2, 1.0f, calcArg, 0.0001f); + sLib::addCalc(&mAutoscrolls[0].m_0c, calcArg, 1.0f, calcArg2, 0.0001f); + mAutoscrolls[0].mPos.x += idk.x * mAutoscrolls[0].m_0c; + mAutoscrolls[0].mPos.y += idk.y * mAutoscrolls[0].m_0c; mAutoscrolls[0].mPos.z = 0.0f; - mAutoscrolls[0].mPos.x += idk.y * mAutoscrolls[0].m_0c; - mAutoscrolls[0].mPos.y += idk.z * mAutoscrolls[0].m_0c; float dist = mAutoscrolls[0].mPos.distTo(bgThingVec); bool cond3 = false; bool cond4 = false; @@ -1133,11 +1133,11 @@ void dBg_c::calcAutoScroll() { } if (( cond4 || someVec.x == 0.0f || - (someVec.x > 0.0f && bgThingVec.x <= mAutoscrolls[0].mPos.x) || + (someVec.x > 0.0f && mAutoscrolls[0].mPos.x >= bgThingVec.x) || (someVec.x <= 0.0f && (mAutoscrolls[0].mPos.x <= bgThingVec.x)) ) && ( cond3 || someVec.y == 0.0f || - (someVec.y > 0.0f && bgThingVec.y <= mAutoscrolls[0].mPos.y) || + (someVec.y > 0.0f && mAutoscrolls[0].mPos.y >= bgThingVec.y) || (someVec.y <= 0.0f && (mAutoscrolls[0].mPos.y <= bgThingVec.y)) )) { m_9007c++; @@ -2437,7 +2437,7 @@ void dBg_c::setScrollLimit(dBgScrollLimit_c *scrollLimit, int areaNo, int type, idx = freeUpScrollLimit(*scrollLimit, group, areaNo); } curr = &mScrLimit[areaNo][group][idx]; - curr->mR = 16 + (int) scrollLimit->mR; + curr->mR = (short) (scrollLimit->mR + 16.0f); curr->mU = scrollLimit->mU; curr->mD = scrollLimit->mD; curr->mL2 = scrollLimit->mL2; @@ -2481,7 +2481,7 @@ void dBg_c::setScrollLimit(dBgScrollLimit_c *scrollLimit, int areaNo, int type, idx = freeUpScrollLimit2(scrollLimit, group, areaNo); } curr = &mScrLimit[areaNo][group][idx]; - curr->mD2 = 16 + (int) scrollLimit->mD2; + curr->mD2 = (short) (scrollLimit->mD2 + 16.0f); curr->mL3 = scrollLimit->mL3; curr->mR3 = scrollLimit->mR3; curr->mU3 = scrollLimit->mU3; From 4f9db0701bda09bb1a64bdc3586d7f8d17fd1363 Mon Sep 17 00:00:00 2001 From: RootCubed Date: Thu, 7 May 2026 08:52:09 +0200 Subject: [PATCH 10/29] calcLookatOffsX and calcLookatOffsY matching --- include/game/bases/d_s_stage.hpp | 1 - source/dol/bases/d_bg.cpp | 115 ++++++++++++++++--------------- 2 files changed, 58 insertions(+), 58 deletions(-) diff --git a/include/game/bases/d_s_stage.hpp b/include/game/bases/d_s_stage.hpp index b0505195..bd964b18 100644 --- a/include/game/bases/d_s_stage.hpp +++ b/include/game/bases/d_s_stage.hpp @@ -26,7 +26,6 @@ class dScStage_c : public dScene_c { typedef void (*changePosFunc)(mVec3_c *); static void setChangePosFunc(int); - static dScStage_c *getInstance() { return m_instance; } static void setTitleReplayRandomTable(); diff --git a/source/dol/bases/d_bg.cpp b/source/dol/bases/d_bg.cpp index a4c45f72..b45d01f0 100644 --- a/source/dol/bases/d_bg.cpp +++ b/source/dol/bases/d_bg.cpp @@ -316,48 +316,48 @@ void dBg_c::DispScaleCalc() { void dBg_c::CreateBgTex() { mTexMng.create(mHeap::g_gameHeaps[2]); - u16 w = mL - mR; - - u16 h = mU - mD; - - u16 texWidthMaybe = mL / 16; - u16 texHeightMaybe = -mU / 16; - - u16 iMu = mU; - u16 iMd = mD; - - if ((w & 0xf) != 0) { - w /= 16; - w++; + u16 iMu, iMd, iw, ih; + u16 texWidthMaybe, texHeightMaybe; + + texWidthMaybe = mL / 16.0f; + texHeightMaybe = -mU / 16.0f; + iMu = mU; + iMd = mD; + iw = mL - mR; + ih = mU - mD; + + if ((iw & 0xF) != 0) { + iw /= 16; + iw++; } else { - w /= 16; + iw /= 16; } - if ((h & 0xf) != 0) { - h /= 16; - h++; + if ((ih & 0xF) != 0) { + ih /= 16; + ih++; } else { - h /= 16; + ih /= 16; if ((iMu & 0xF) != 0) { - h++; + ih++; } if ((iMd & 0xF) != 0) { - h++; + ih++; } } if (dScStage_c::m_loopType == 0) { - w += 2; + iw += 2; texWidthMaybe--; } - h += 2; + ih += 2; texHeightMaybe--; - mTex[0] = __createBgTex(0, texWidthMaybe, texHeightMaybe, w, h, 0, 4); + mTex[0] = __createBgTex(0, texWidthMaybe, texHeightMaybe, iw, ih, 0, 4); if (CheckExistLayer(1)) { - mTex[1] = __createBgTex(1, texWidthMaybe, texHeightMaybe, w, h, 127, 3); + mTex[1] = __createBgTex(1, texWidthMaybe, texHeightMaybe, iw, ih, 127, 3); } if (CheckExistLayer(2)) { - mTex[2] = __createBgTex(2, texWidthMaybe, texHeightMaybe, w, h, 3, -1); + mTex[2] = __createBgTex(2, texWidthMaybe, texHeightMaybe, iw, ih, 3, -1); mTexProc = new(m_FrmHeap_p, 4) dShareBgTexProc_c(); mTexProc->create(mTex[2], m_FrmHeap_p); } @@ -889,18 +889,19 @@ void dBg_c::calcLookatOffsLimit() { void dBg_c::calcLookatOffsX(dActor_c *actor) { float deltaX = actor->mPosDelta.x; - deltaX = 0.333f * deltaX; + deltaX = deltaX * 0.333f; - float smth = m_8fda8; + float tmp = m_8fda8; if (deltaX == 0.0f) { return; } - if (deltaX - smth > 0.04f) { - deltaX = smth + 0.04f; - } else if (deltaX - smth < -0.04f) { - deltaX = smth - 0.04f; + float diff = deltaX - tmp; + if (diff > 0.04f) { + deltaX = m_8fda8 + 0.04f; + } else if (diff < -0.04f) { + deltaX = m_8fda8 - 0.04f; } if (deltaX > 1.6f) { @@ -911,12 +912,11 @@ void dBg_c::calcLookatOffsX(dActor_c *actor) { float b40 = mBounds4[0]; float b42 = mBounds4[2]; - float smth3 = b40 + deltaX; - mBounds4[0] = smth3; - if (smth3 > b42) { + mBounds4[0] = b40 + deltaX; + if (b40 + deltaX > b42) { deltaX = b42 - b40; mBounds4[0] = b42; - } else if (smth3 < -mBounds4[3]) { + } else if (b40 + deltaX < -mBounds4[3]) { mBounds4[0] = -mBounds4[3]; deltaX = mBounds4[0] - b40; } @@ -926,32 +926,33 @@ void dBg_c::calcLookatOffsX(dActor_c *actor) { void dBg_c::calcLookatOffsY(dActor_c *actor) { dAcPy_c *pl = (dAcPy_c *) actor; - float deltaY = pl->mPc.m_30.y - mPlayerPosY; - float halfHeight2 = mSomeSize.y / 2 - mBounds3[0]; - float halfHeight = mSomeSize.y / 2 - mBounds3[1]; + + float h = mSomeSize.y; + + float tmp2 = mPlayerPosY; + float tmp1 = pl->mPc.m_30.y; + float deltaY = tmp1 - tmp2; + + float halfHeight2 = h * 0.5f - mBounds3[0]; + float halfHeight = h * 0.5f - mBounds3[1]; + if (deltaY > 0.0f) { - deltaY += mBounds4[1]; - mBounds4[1] = deltaY; - if (deltaY >= halfHeight2) { + mBounds4[1] += deltaY; + if (mBounds4[1] >= halfHeight2) { mBounds4[1] = halfHeight2; } - return; - } - if (deltaY < 0.0f) { - halfHeight = -halfHeight; - deltaY += mBounds4[1]; - mBounds4[1] = deltaY; - if (halfHeight >= deltaY) { - mBounds4[1] = halfHeight; + } else if (deltaY < 0.0f) { + mBounds4[1] += deltaY; + if (mBounds4[1] <= -halfHeight) { + mBounds4[1] = -halfHeight; + } + } else { + if (mBounds4[1] >= halfHeight2) { + mBounds4[1] = halfHeight2; + } + if (mBounds4[1] <= -halfHeight) { + mBounds4[1] = -halfHeight; } - return; - } - if (mBounds4[1] >= halfHeight2) { - mBounds4[1] = halfHeight2; - } - halfHeight = -halfHeight; - if (mBounds4[1] <= halfHeight) { - mBounds4[1] = halfHeight; } } From da2ab219328af58a2cf82a3523d3bf81a922acca Mon Sep 17 00:00:00 2001 From: RootCubed Date: Thu, 29 May 2025 16:33:36 +0200 Subject: [PATCH 11/29] Make some parameters const (Can be assumed from XOR trick on symbols) --- include/game/bases/d_bg.hpp | 12 +++---- include/game/bases/d_bg_parameter.hpp | 1 + source/dol/bases/d_bg.cpp | 46 +++++++++++++-------------- 3 files changed, 30 insertions(+), 29 deletions(-) diff --git a/include/game/bases/d_bg.hpp b/include/game/bases/d_bg.hpp index b804562f..ca975b65 100644 --- a/include/game/bases/d_bg.hpp +++ b/include/game/bases/d_bg.hpp @@ -212,12 +212,12 @@ class dBg_c : public dBase_c { void calcMultiScroll( int ); void initScroll(); - void fn_8007ac40(dBgSomeInfo_c *, int); ///< @unofficial + void fn_8007ac40(const dBgSomeInfo_c *, int); ///< @unofficial void fn_8007ba70(const dBgSomeInfo_c *); ///< @unofficial - float fn_8007bba0(dBgSomeInfo_c *); ///< @unofficial - float fn_8007bbf0(dBgSomeInfo_c *); ///< @unofficial - bool fn_8007bc40(dBgSomeInfo_c *, float); ///< @unofficial - mVec2_c fn_8007bd40(dBgSomeInfo_c *, float, float); ///< @unofficial + float fn_8007bba0(const dBgSomeInfo_c *); ///< @unofficial + float fn_8007bbf0(const dBgSomeInfo_c *); ///< @unofficial + bool fn_8007bc40(const dBgSomeInfo_c *, float); ///< @unofficial + mVec2_c fn_8007bd40(const dBgSomeInfo_c *, float, float); ///< @unofficial float fn_8007c7d0(float); ///< @unofficial void fn_8007ca90(dBgSomeInfo_c *, int, int); ///< @unofficial void fn_8007cd70(dBgSomeInfo_c *, dBgSomeInfo_c *, int); ///< @unofficial @@ -242,7 +242,7 @@ class dBg_c : public dBase_c { dBgScrollLimit_c *getScrLim(int area, int group, int idx) { return &mScrLimit[area][group][idx]; } dBgSubstruct2_c * getData2(int idx, int i) { return &mData2[idx][i]; } - typedef void (dBg_c::*callbackFunc)(dBgSomeInfo_c *, int); + typedef void (dBg_c::*callbackFunc)(const dBgSomeInfo_c *, int); unsigned long long *mBgCheckBuffer; int mBgThingsRelated; diff --git a/include/game/bases/d_bg_parameter.hpp b/include/game/bases/d_bg_parameter.hpp index a2cb8f5a..368a6614 100644 --- a/include/game/bases/d_bg_parameter.hpp +++ b/include/game/bases/d_bg_parameter.hpp @@ -34,6 +34,7 @@ class dBgParameter_c { const mVec2_c &pos() const { return mPos; } const mVec2_c &size() const { return mSize; } + float getM78() const { return m_78; } float posX() const { return mPos.x; } float posY() const { return mPos.y; } diff --git a/source/dol/bases/d_bg.cpp b/source/dol/bases/d_bg.cpp index b45d01f0..36666782 100644 --- a/source/dol/bases/d_bg.cpp +++ b/source/dol/bases/d_bg.cpp @@ -1347,7 +1347,7 @@ void dBg_c::calcMultiScroll(int arg1) { } } -void dBg_c::fn_8007ac40(dBgSomeInfo_c *info, int arg1) { +void dBg_c::fn_8007ac40(const dBgSomeInfo_c *info, int arg1) { // dBgBound_c b = info->mBounds; float lWidth = mVideo::getLayoutWidth(); @@ -1457,7 +1457,7 @@ void dBg_c::fn_8007ac40(dBgSomeInfo_c *info, int arg1) { } if (mMoreFloats5[0] == tgMax) { if (mMoreFloats5[2] != tgMid) { - info->mBounds.mRight = m_90018; + // info->mBounds.mRight = m_90018; if (mMoreFloats5[1] <= info->mBounds.mRight) { mMoreFloats5[1] = info->mBounds.mRight; } @@ -1617,12 +1617,12 @@ void dBg_c::fn_8007ac40(dBgSomeInfo_c *info, int arg1) { } } } - if (mPrevSomePos.y + 32.0f < info->mBounds.mUp) { - info->mBounds.mUp = mPrevSomePos.y + 32.0f; - } - if (info->mBounds.mDown < mPrevSomePos.y - mPrevSomeSize.y - 32.0f) { - info->mBounds.mDown = mPrevSomePos.y - mPrevSomeSize.y - 32.0f; - } + // if (mPrevSomePos.y + 32.0f < info->mBounds.mUp) { + // info->mBounds.mUp = mPrevSomePos.y + 32.0f; + // } + // if (info->mBounds.mDown < mPrevSomePos.y - mPrevSomeSize.y - 32.0f) { + // info->mBounds.mDown = mPrevSomePos.y - mPrevSomeSize.y - 32.0f; + // } float dVar12 = mMoreFloats5[4] + lHeight * 0.5f + (copy_90018 - 1.0f); calcLookatOffsLimit(); @@ -1689,35 +1689,35 @@ void dBg_c::fn_8007ba70(const dBgSomeInfo_c *info) { stack_struct_s thing; thing.y = info->mBounds.mRight; thing.x = info->mBounds.mLeft; + float fVar4; float smth = thing.y; float w = mPrevSomeSize.x; - float fVar4; if (m_90009 == 2 || m_9000a == 2) { - fVar4 = 112.0f - dBgParameter_c::getInstance()->m_78; + fVar4 = 112.0f - dBgParameter_c::ms_Instance_p->getM78(); smth = thing.x; } else { - fVar4 = w - (112.0f - dBgParameter_c::getInstance()->m_78); + fVar4 = w - (112.0f - dBgParameter_c::ms_Instance_p->getM78()); } float tmp = smth - fVar4; - if (tmp - mPrevSomePos.x > 6.0f) { + float diff = tmp - mPrevSomePos.x; + if (diff > 6.0f) { tmp = mPrevSomePos.x + 6.0f; - } else if (tmp - mPrevSomePos.x < -6.0f) { + } else if (diff < -6.0f) { tmp = mPrevSomePos.x - 6.0f; } float ll = getLeftLimit(); float d = getRightLimit() - w; - float newW = tmp; if (dScStage_c::m_loopType != 2) { - if (tmp < newW) { - newW = ll; - } else if (newW > d) { - newW = d; + if (tmp < ll) { + tmp = ll; + } else if (tmp > d) { + tmp = d; } } - mPrevSomePos.x = newW; + mPrevSomePos.x = tmp; } -float dBg_c::fn_8007bba0(dBgSomeInfo_c *info) { +float dBg_c::fn_8007bba0(const dBgSomeInfo_c *info) { float tmp = 64.0f + info->mBounds.mUp; if (tmp - mPrevSomePos.y < -6.0f) { tmp = mPrevSomePos.y - 6.0f; @@ -1728,7 +1728,7 @@ float dBg_c::fn_8007bba0(dBgSomeInfo_c *info) { return mULimit; } -float dBg_c::fn_8007bbf0(dBgSomeInfo_c *info) { +float dBg_c::fn_8007bbf0(const dBgSomeInfo_c *info) { float sizeY = dBgParameter_c::getInstance()->mSize.y; float tmp = info->mBounds.mDown + (sizeY - 32.0f); if (tmp - mPrevSomePos.y > 6.0f) { @@ -1740,7 +1740,7 @@ float dBg_c::fn_8007bbf0(dBgSomeInfo_c *info) { return mDLimit; } -bool dBg_c::fn_8007bc40(dBgSomeInfo_c *info, float f) { +bool dBg_c::fn_8007bc40(const dBgSomeInfo_c *info, float f) { float fVar1 = info->mBounds.mLeft; float fVar2 = info->mBounds.mRight; float ll = getLeftLimit(); @@ -1760,7 +1760,7 @@ bool dBg_c::fn_8007bc40(dBgSomeInfo_c *info, float f) { } } -mVec2_c dBg_c::fn_8007bd40(dBgSomeInfo_c *info, float f1, float f2) { +mVec2_c dBg_c::fn_8007bd40(const dBgSomeInfo_c *info, float f1, float f2) { mVec2_c result(0.0f, 0.0f); float fVar4 = mVideo::getLayoutWidth(); From 78fa23760f35a6116fd087518dbc4bb741372284 Mon Sep 17 00:00:00 2001 From: RootCubed Date: Tue, 18 Nov 2025 10:06:50 +0100 Subject: [PATCH 12/29] Official names, various small fixes --- include/game/bases/d_bg.hpp | 4 +- source/dol/bases/d_bg.cpp | 102 ++++++++++++++++++------------------ 2 files changed, 53 insertions(+), 53 deletions(-) diff --git a/include/game/bases/d_bg.hpp b/include/game/bases/d_bg.hpp index ca975b65..687ba558 100644 --- a/include/game/bases/d_bg.hpp +++ b/include/game/bases/d_bg.hpp @@ -156,8 +156,8 @@ class dBg_c : public dBase_c { void RemoveBgTex(); bgTex_c *__createBgTex(int, u16, u16, u16, u16, int, int); - void fn_80078250(u16, u16, u16, u32); - void fn_80078300(); + void EntryWakuCoin(ulong, u16, u16, int); + void SetWakuCoin(); void fn_80077860(u16, u16, int, u16); void setWaterInWave(float, float, u8); void setBubble(float, float, u8, u8); diff --git a/source/dol/bases/d_bg.cpp b/source/dol/bases/d_bg.cpp index 36666782..2e26d38e 100644 --- a/source/dol/bases/d_bg.cpp +++ b/source/dol/bases/d_bg.cpp @@ -447,24 +447,7 @@ bgTex_c *dBg_c::__createBgTex(int layer, u16 tw, u16 th, u16 w, u16 h, int i1, i return tex; } -u16 dBg_c::dBg_getUpLimitScroll(u8 layer) { - dCdFile_c *file = dCd_c::m_instance->getFileP(dScStage_c::m_instance->mCurrFile); - u8 id = file->getAreaID(layer); - int scrollID = file->getAreaScroll(id); - return file->getScrollDataP(scrollID)->mUpLimit; -} - -int dBg_c::dBg_getScrlAreaDataSize(u8 layer) { - dCdFile_c *file = dCd_c::m_instance->getFileP(dScStage_c::m_instance->mCurrFile); - return file->mScrlAreaCount; -} - -sScrollAreaData *dBg_c::dBg_getScrlAreaDataP(u8 layer, u8 idx) { - dCdFile_c *file = dCd_c::m_instance->getFileP(dScStage_c::m_instance->mCurrFile); - return file->getScrlAreaDataP(idx); -} - -void dBg_c::fn_80078250(u16 p1, u16 p2, u16 p3, u32 p4) { +void dBg_c::EntryWakuCoin(ulong p1, u16 p2, u16 p3, int p4) { if (mBgThingsRelated > 255) { return; } @@ -492,7 +475,7 @@ void dBg_c::fn_80078250(u16 p1, u16 p2, u16 p3, u32 p4) { fn_80077860(p2, p3, p4, 0); } -void dBg_c::fn_80078300() { +void dBg_c::SetWakuCoin() { for (int i = 0; i < 256; i++) { sBgThing *thing = &mBgThings[i]; if (thing->m_08 == 0) { @@ -605,6 +588,23 @@ int dBg_c::dBg_isCloudFlyPlayerMulti() { return res; } +u16 dBg_c::dBg_getUpLimitScroll(u8 layer) { + dCdFile_c *file = dCd_c::m_instance->getFileP(dScStage_c::m_instance->mCurrFile); + u8 id = file->getAreaID(layer); + int scrollID = file->getAreaScroll(id); + return file->getScrollDataP(scrollID)->mUpLimit; +} + +int dBg_c::dBg_getScrlAreaDataSize(u8 layer) { + dCdFile_c *file = dCd_c::m_instance->getFileP(dScStage_c::m_instance->mCurrFile); + return file->mScrlAreaCount; +} + +sScrollAreaData *dBg_c::dBg_getScrlAreaDataP(u8 layer, u8 idx) { + dCdFile_c *file = dCd_c::m_instance->getFileP(dScStage_c::m_instance->mCurrFile); + return file->getScrlAreaDataP(idx); +} + float dBg_c::fn_80078860(float f) { float tmp = f; switch (mZoomRelated) { @@ -1350,6 +1350,8 @@ void dBg_c::calcMultiScroll(int arg1) { void dBg_c::fn_8007ac40(const dBgSomeInfo_c *info, int arg1) { // dBgBound_c b = info->mBounds; + float boundScale = 0.5f; + float lWidth = mVideo::getLayoutWidth(); float lHeight = mVideo::getLayoutHeight(); @@ -1384,7 +1386,7 @@ void dBg_c::fn_8007ac40(const dBgSomeInfo_c *info, int arg1) { r.x = r.y; someTmp = someTmp2; } - if (mLimitRelated == 6 || mLimitRelated == 7) { + if (mLimitRelated2 >= 6 && mLimitRelated2 <= 7) { r.y = r.x - 1.0f; someTmp2 = someTmp; } @@ -1418,42 +1420,40 @@ void dBg_c::fn_8007ac40(const dBgSomeInfo_c *info, int arg1) { someTmp2 = someTmp; } if ((daPyDemoMng_c::mspInstance->mFlags & 1) == 0) { - if (m_90024 == 0) { - if (someTmp2 <= spL) { - mMoreFloats5[0] = tgMin; - } else { - mMoreFloats5[0] = tgMid; - m_90024 = 1; - } - } else if (m_90024 == 1) { - if (someTmp2 <= spL2) { - if (shL <= someTmp2) { - if (spL <= someTmp2) { - mMoreFloats5[0] = tgMid; - } + switch (m_90024) { + case 0: + if (someTmp2 > spL) { + mMoreFloats5[0] = tgMid; + m_90024 = 1; } else { + mMoreFloats5[0] = tgMin; + } + break; + case 1: + if (someTmp2 > spL2) { + mMoreFloats5[0] = tgMax; + m_90024 = 2; + } else if (someTmp2 < shL) { bVar7 = true; if (m_900b6 > 120) { mMoreFloats5[0] = tgMin; m_90024 = 0; } + } else if (someTmp2 > spL) { + mMoreFloats5[0] = tgMid; } - } else { - mMoreFloats5[0] = tgMax; - m_90024 = 2; - } - } else if (m_90024 == 2) { - if (shL2 <= someTmp2) { - if (spL2 <= someTmp2) { + break; + case 2: + if (someTmp2 > shL2) { + bVar7 = true; + if (m_900b6 > 120) { + mMoreFloats5[0] = tgMid; + m_90024 = 1; + } + } else if (someTmp2 > spL2) { mMoreFloats5[0] = tgMax; } - } else { - bVar7 = true; - if (m_900b6 > 120) { - mMoreFloats5[0] = tgMid; - m_90024 = 1; - } - } + break; } if (mMoreFloats5[0] == tgMax) { if (mMoreFloats5[2] != tgMid) { @@ -1537,7 +1537,7 @@ void dBg_c::fn_8007ac40(const dBgSomeInfo_c *info, int arg1) { mPrevSomeSize.x = lWidth * copy_90018; mPrevSomeSize.y = lHeight * copy_90018; mDispScale = 1.0f / copy_90018; - fVar28 *= 0.5f; + fVar28 *= boundScale; float mLP = getMaxLeftPos(); float mRP = getMaxRightPos(); float w = (info->mBounds.mRight + info->mBounds.mLeft) * 0.5f; @@ -2208,10 +2208,10 @@ void dBg_c::fn_8007cd70(dBgSomeInfo_c *info1, dBgSomeInfo_c *info2, int i1) { dh = 1.0f; dw = 1.0f; } - float fVar5 = fabsf(dw); + float fVar5 = std::fabs(dw); float fVar6, fVar7; float fVar12 = fVar5 * 6.0f; - float fVar13 = fabsf(dh) * 12.0f; + float fVar13 = std::fabs(dh) * 12.0f; if (stage->mCurrWorld == WORLD_8 && stage->mCurrCourse == STAGE_7 || cond) { fVar6 = 6.0f; fVar7 = 0.5f; @@ -2220,7 +2220,7 @@ void dBg_c::fn_8007cd70(dBgSomeInfo_c *info1, dBgSomeInfo_c *info2, int i1) { fVar6 = 2.0f; fVar7 = 0.2f; } - fVar6 *= fabsf(dh); + fVar6 *= std::fabs(dh); float calcArg1 = 0.1f; float calcArg2 = 0.005f; From 760d61917535767a8154b0e78bf009a3f891df20 Mon Sep 17 00:00:00 2001 From: RootCubed Date: Tue, 18 Nov 2025 11:18:07 +0100 Subject: [PATCH 13/29] `dBg_c::CvtBgCheckFromUnitNo` matching --- include/game/bases/d_bg.hpp | 36 +--------------------------------- source/dol/bases/d_bg.cpp | 39 ++++++++++++++++++++----------------- 2 files changed, 22 insertions(+), 53 deletions(-) diff --git a/include/game/bases/d_bg.hpp b/include/game/bases/d_bg.hpp index 687ba558..079bed03 100644 --- a/include/game/bases/d_bg.hpp +++ b/include/game/bases/d_bg.hpp @@ -8,40 +8,6 @@ #include #include -struct dBgCheckUnit { - // dBgCheckUnit() {} - // float x, y; - unsigned long long a; - // u8 a, b, c; - // int d; - // u8 test[8]; - // u32 flags[2]; - - // bool checkBit(int bit) { - // if (bit > 32) { - // return flags[1] & (1 << (bit - 32)); - // } else { - // return flags[0] & (1 << bit); - // } - // } - // void setBit(int bit) { - // if (bit > 32) { - // flags[1] |= (1 << (bit - 32)); - // } else { - // flags[0] |= (1 << bit); - // } - // } - // void clearBit(int bit) { - // if (bit > 32) { - // flags[0] &= (1 << (bit - 32)); - // flags[1] &= ~0; - // } else { - // flags[0] &= ~0; - // flags[1] &= (1 << bit); - // } - // } -}; - class dProcShareProc_c : public d3d::proc_c { public: dProcShareProc_c() : idk(0) {} @@ -135,7 +101,7 @@ class dBg_c : public dBase_c { void CreateBgCheckBuffer(); - unsigned long long fn_800774A0(u16); + unsigned long long CvtBgCheckFromUnitNo(u16); static unsigned long long fn_80081960(unsigned long long, int); dBgUnit_c *fn_80077520(u16 param_2, u16 param_3, u8 param_4, int *param_5, bool b); diff --git a/source/dol/bases/d_bg.cpp b/source/dol/bases/d_bg.cpp index 2e26d38e..7a178530 100644 --- a/source/dol/bases/d_bg.cpp +++ b/source/dol/bases/d_bg.cpp @@ -136,29 +136,32 @@ dBg_c::~dBg_c() { m_bg_p = nullptr; } -unsigned long long dBg_c::getBgCheckBuff(u16 idx) { +u64 dBg_c::getBgCheckBuff(u16 idx) { return mBgCheckBuffer[idx]; } -unsigned long long *dBg_c::getpBgCheckBuff(u16 idx) { +u64 *dBg_c::getpBgCheckBuff(u16 idx) { return &mBgCheckBuffer[idx]; } -unsigned long long dBg_c::fn_800774A0(u16 idx) { - u32 idk = idx / 1024U; - u32 bufIdx = idx % 1024U; - unsigned long long cu = getBgCheckBuff(bufIdx); - cu = fn_80081960(cu, idx); - unsigned long long mask = (1ULL << 42); - if (bufIdx > 0x100U) { - u32 top = cu >> 32; - u32 bottom = cu & 0xFFFFFFFF; - // unsigned long long n = ((unsigned long long) top << 32) | (bottom & ~(0x400)); - if ((cu & mask) != 0 && idk != 0) { - return ((unsigned long long) (top & ~(0x400)) << 32) | bottom; +u64 dBg_c::CvtBgCheckFromUnitNo(u16 num) { + u32 x = num >> 10; + + int oldNum = num; + num &= 0x3FF; + + u64 data = getBgCheckBuff(num); + u64 maskedData = fn_80081960(data, oldNum); + + if (num > 256) { + u32 top = maskedData >> 32; + u32 bottom = maskedData & 0xFFFFFFFF; + if (maskedData & (1ULL << 42) && x != 0) { + top &= ~(1 << (42 - 32)); + maskedData = ((u64) top << 32) | bottom; } } - return cu; + return maskedData; } dBgUnit_c *dBg_c::fn_80077520(u16 x, u16 y, u8 layer, int *param_5, bool b) { @@ -190,10 +193,10 @@ u16 dBg_c::GetMaskedUnitNumber(u16 p1, u16 p2, u8 p3) { return data; } -unsigned long long dBg_c::GetBgCheckData(u16 p1, u16 p2, u8 p3) { +u64 dBg_c::GetBgCheckData(u16 p1, u16 p2, u8 p3) { int loopPos = dScStage_c::getLoopPosX(p1); dBgUnit_c *data = fn_80077520(loopPos, p2, p3, 0, false); - return fn_800774A0(data->mUnitNumber); + return CvtBgCheckFromUnitNo(data->mUnitNumber); } u32 dBg_c::GetUnitTypeInfo(u16 p1, u16 p2, u8 p3) { @@ -281,7 +284,7 @@ bool dBg_c::CheckExistLayer(u8 layer) { } void dBg_c::CreateBgCheckBuffer() { - mBgCheckBuffer = new(m_FrmHeap_p, 4) unsigned long long[0x400]; + mBgCheckBuffer = new(m_FrmHeap_p, 4) u64[0x400]; int file = dScStage_c::m_instance->mCurrFile; From 24d66662c75f6efe617a1d466be8bb791197843e Mon Sep 17 00:00:00 2001 From: RootCubed Date: Thu, 7 May 2026 08:53:40 +0200 Subject: [PATCH 14/29] `dBg_c::CreateBgTex` matching more --- include/game/bases/d_bg.hpp | 11 ++++++++ include/game/bases/d_bg_global.hpp | 2 +- source/dol/bases/d_bg.cpp | 43 +++++++++++++++--------------- 3 files changed, 33 insertions(+), 23 deletions(-) diff --git a/include/game/bases/d_bg.hpp b/include/game/bases/d_bg.hpp index 079bed03..dbce7497 100644 --- a/include/game/bases/d_bg.hpp +++ b/include/game/bases/d_bg.hpp @@ -205,6 +205,17 @@ class dBg_c : public dBase_c { float getScaleFactor() { return 1.0f / mDispScale; } float getLiquidHeight() const { return mMoreFloats7[5]; } + float getL() { return mL; } + float getU() { return mU; } + float getD() { return mD; } + float getR() { return mR; } + u16 cvtL() { return getL(); } + u16 cvtR() { return getR(); } + u16 cvtU() { return getU(); } + u16 cvtD() { return getD(); } + u16 cvtW() { return getR() - getL(); } + u16 cvtH() { return getU() - getD(); } + dBgScrollLimit_c *getScrLim(int area, int group, int idx) { return &mScrLimit[area][group][idx]; } dBgSubstruct2_c * getData2(int idx, int i) { return &mData2[idx][i]; } diff --git a/include/game/bases/d_bg_global.hpp b/include/game/bases/d_bg_global.hpp index 8d6b5655..b8259b8e 100644 --- a/include/game/bases/d_bg_global.hpp +++ b/include/game/bases/d_bg_global.hpp @@ -36,7 +36,7 @@ enum UNIT_NUM_e { class dBgUnit_c { public: - dBgUnit_c *fn_80083b40(u16, u16, int *, bool); ///< @unofficial + dBgUnit_c *GetBuffPos(u16, u16, int *, bool); static bool fn_80081900(u16, u16 *); ///< @unofficial static u16 cvtNum(u16); ///< @unofficial diff --git a/source/dol/bases/d_bg.cpp b/source/dol/bases/d_bg.cpp index 7a178530..81a14572 100644 --- a/source/dol/bases/d_bg.cpp +++ b/source/dol/bases/d_bg.cpp @@ -167,7 +167,7 @@ u64 dBg_c::CvtBgCheckFromUnitNo(u16 num) { dBgUnit_c *dBg_c::fn_80077520(u16 x, u16 y, u8 layer, int *param_5, bool b) { int file = dScStage_c::m_instance->mCurrFile; dBgUnit_c *bgUnit = dBgGlobal_c::ms_pInstance->GetBgUnitP(file, layer); - return bgUnit->fn_80083b40(x, y, param_5, b); + return bgUnit->GetBuffPos(x, y, param_5, b); } u16 fn_80081ab0(u16); @@ -319,48 +319,47 @@ void dBg_c::DispScaleCalc() { void dBg_c::CreateBgTex() { mTexMng.create(mHeap::g_gameHeaps[2]); - u16 iMu, iMd, iw, ih; - u16 texWidthMaybe, texHeightMaybe; + u16 texL = getL() / 16.0f; + u16 texU = -getU() / 16.0f; - texWidthMaybe = mL / 16.0f; - texHeightMaybe = -mU / 16.0f; - iMu = mU; - iMd = mD; - iw = mL - mR; - ih = mU - mD; + u16 iMu = getU(); + u16 iMd = getD(); + u16 iw = cvtW(); + u16 ih = cvtH(); - if ((iw & 0xF) != 0) { - iw /= 16; + if (iw % 16U > 0) { + iw = iw >> 4; iw++; } else { - iw /= 16; + iw = iw >> 4; } - if ((ih & 0xF) != 0) { - ih /= 16; + if (ih % 16U > 0) { + ih = ih >> 4; ih++; } else { - ih /= 16; - if ((iMu & 0xF) != 0) { + ih = ih >> 4; + if (iMu % 16U > 0) { ih++; } - if ((iMd & 0xF) != 0) { + if (iMd % 16U > 0) { ih++; } } if (dScStage_c::m_loopType == 0) { iw += 2; - texWidthMaybe--; + texL--; } ih += 2; - texHeightMaybe--; - mTex[0] = __createBgTex(0, texWidthMaybe, texHeightMaybe, iw, ih, 0, 4); + texU--; + + mTex[0] = __createBgTex(0, texL, texU, iw, ih, 0, 4); if (CheckExistLayer(1)) { - mTex[1] = __createBgTex(1, texWidthMaybe, texHeightMaybe, iw, ih, 127, 3); + mTex[1] = __createBgTex(1, texL, texU, iw, ih, 127, 3); } if (CheckExistLayer(2)) { - mTex[2] = __createBgTex(2, texWidthMaybe, texHeightMaybe, iw, ih, 3, -1); + mTex[2] = __createBgTex(2, texL, texU, iw, ih, 3, -1); mTexProc = new(m_FrmHeap_p, 4) dShareBgTexProc_c(); mTexProc->create(mTex[2], m_FrmHeap_p); } From 5d06effba52e823fc8823cfd5f1a13b07edee759 Mon Sep 17 00:00:00 2001 From: RootCubed Date: Tue, 18 Nov 2025 12:01:10 +0100 Subject: [PATCH 15/29] `dBg_c::CreateBgTex` matching more --- include/game/bases/d_bg.hpp | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/include/game/bases/d_bg.hpp b/include/game/bases/d_bg.hpp index dbce7497..415ef4eb 100644 --- a/include/game/bases/d_bg.hpp +++ b/include/game/bases/d_bg.hpp @@ -216,6 +216,17 @@ class dBg_c : public dBase_c { u16 cvtW() { return getR() - getL(); } u16 cvtH() { return getU() - getD(); } + float getL() { return mL; } + float getU() { return mU; } + float getD() { return mD; } + float getR() { return mR; } + u16 cvtL() { return getL(); } + u16 cvtR() { return getR(); } + u16 cvtU() { return getU(); } + u16 cvtD() { return getD(); } + u16 cvtW() { return getR() - getL(); } + u16 cvtH() { return getU() - getD(); } + dBgScrollLimit_c *getScrLim(int area, int group, int idx) { return &mScrLimit[area][group][idx]; } dBgSubstruct2_c * getData2(int idx, int i) { return &mData2[idx][i]; } From 76b35ea0d897dfc1ae3c5d26b5e1bba60d50015a Mon Sep 17 00:00:00 2001 From: RootCubed Date: Tue, 18 Nov 2025 12:16:03 +0100 Subject: [PATCH 16/29] `dBg_c::__createBgTex` matching --- include/game/bases/d_bg_global.hpp | 18 ------------------ include/game/bases/d_bg_tex.hpp | 17 +++++++++++------ source/dol/bases/d_bg.cpp | 26 ++++++++++++++++++-------- 3 files changed, 29 insertions(+), 32 deletions(-) diff --git a/include/game/bases/d_bg_global.hpp b/include/game/bases/d_bg_global.hpp index b8259b8e..78ddc835 100644 --- a/include/game/bases/d_bg_global.hpp +++ b/include/game/bases/d_bg_global.hpp @@ -16,24 +16,6 @@ enum UNIT_NUM_e { UNIT_GRASS_FLOWER_3, ///< Grass with blue flower }; -#define UNIT_IS_GRASS(x) (\ - x == UNIT_GRASS_L || \ - x == UNIT_GRASS_C1 || x == UNIT_GRASS_C2 || x == UNIT_GRASS_C3 || \ - x == UNIT_GRASS_R \ -) - -#define UNIT_IS_FLOWER(x) (\ - x == UNIT_FLOWER_1 || \ - x == UNIT_FLOWER_2 || \ - x == UNIT_FLOWER_3 \ -) - -#define UNIT_IS_GRASS_FLOWER(x) (\ - x == UNIT_GRASS_FLOWER_1 || \ - x == UNIT_GRASS_FLOWER_2 || \ - x == UNIT_GRASS_FLOWER_3 \ -) - class dBgUnit_c { public: dBgUnit_c *GetBuffPos(u16, u16, int *, bool); diff --git a/include/game/bases/d_bg_tex.hpp b/include/game/bases/d_bg_tex.hpp index b12b9d53..3d03ce46 100644 --- a/include/game/bases/d_bg_tex.hpp +++ b/include/game/bases/d_bg_tex.hpp @@ -1,12 +1,14 @@ #pragma once + #include +#include #include class dPanelObjMgr_c { u8 mPad[12]; }; -class bgTex_c { +class bgTex_c : public m3d::proc_c { public: bgTex_c(); virtual ~bgTex_c() {} @@ -14,11 +16,14 @@ class bgTex_c { void setOpaBuffer(u16, u16, u16); void setUnitChange(u16, u16, u16); - u16 mCount; - u16 mSmth; - u8 mPad[0x28]; - u16 m_30; - u8 mPad2[6]; + mAllocator_c mAllocator; + u16 m_24; + u16 m_26; + void *m_28; + void *m_2c; + u16 mXCount; + u16 mYCount; + u8 mPad[4]; dPanelObjMgr_c mPanelObjMgr; }; diff --git a/source/dol/bases/d_bg.cpp b/source/dol/bases/d_bg.cpp index 81a14572..b72ce5eb 100644 --- a/source/dol/bases/d_bg.cpp +++ b/source/dol/bases/d_bg.cpp @@ -393,27 +393,34 @@ bgTex_c *dBg_c::__createBgTex(int layer, u16 tw, u16 th, u16 w, u16 h, int i1, i check = true; } - for (u16 y = 0; y < tex->mCount; y++) { + for (u16 y = 0; y < tex->mYCount; y++) { u16 x = 0; - if (tex->m_30 == 0) { + if (tex->mXCount == 0) { continue; } unsigned int unitX, unitY; unitY = (y + th) * 16; - while (x < tex->mSmth) { + while (x < tex->mXCount) { unitX = (x + tw) * 16; u16 unitNum = GetUnitNumber(unitX, unitY, layer, false); if (unitNum == 0xffff) { unitNum = UNIT_0; } - if (check && (UNIT_IS_GRASS(unitNum) || UNIT_IS_FLOWER(unitNum) || UNIT_IS_GRASS_FLOWER(unitNum))) { + if (check && ( + unitNum >= UNIT_GRASS_L && unitNum <= UNIT_GRASS_R || + unitNum >= UNIT_FLOWER_1 && unitNum <= UNIT_FLOWER_3 || + unitNum >= UNIT_GRASS_FLOWER_1 && unitNum <= UNIT_GRASS_FLOWER_3 + )) { int grassIdx = mGrassCount; int flowerIdx = mFlowerCount; dBgAnimObj_c animObj; animObj.mX = unitX + 8; animObj.mY = -(float) (unitY + 16); - if (UNIT_IS_GRASS(unitNum) || UNIT_IS_GRASS_FLOWER(unitNum)) { - if (UNIT_IS_GRASS(unitNum)) { + if ( + unitNum >= UNIT_GRASS_L && unitNum <= UNIT_GRASS_R || + unitNum >= UNIT_GRASS_FLOWER_1 && unitNum <= UNIT_GRASS_FLOWER_3 + ) { + if (unitNum >= UNIT_GRASS_L && unitNum <= UNIT_GRASS_R) { animObj.mType = unitNum - UNIT_GRASS_L; } else { animObj.mType = unitNum - UNIT_GRASS_FLOWER_1 + 1; // use center grass style @@ -425,8 +432,11 @@ bgTex_c *dBg_c::__createBgTex(int layer, u16 tw, u16 th, u16 w, u16 h, int i1, i } mGrassCount = grassIdx; } - if (UNIT_IS_FLOWER(unitNum) || UNIT_IS_GRASS_FLOWER(unitNum)) { - if (unitNum == 432 || unitNum == 433 || unitNum == 434) { + if ( + unitNum >= UNIT_FLOWER_1 && unitNum <= UNIT_FLOWER_3 || + unitNum >= UNIT_GRASS_FLOWER_1 && unitNum <= UNIT_GRASS_FLOWER_3 + ) { + if (unitNum >= UNIT_FLOWER_1 && unitNum <= UNIT_FLOWER_3) { animObj.mType = unitNum - UNIT_FLOWER_1; } else { animObj.mType = unitNum - UNIT_GRASS_FLOWER_1; From 26a40d9de087995940cdfe52bd3af5fbcb08db1f Mon Sep 17 00:00:00 2001 From: RootCubed Date: Tue, 18 Nov 2025 12:34:30 +0100 Subject: [PATCH 17/29] `dBg_c::calcLoopAutoScroll` matching --- include/game/bases/d_bg.hpp | 2 ++ source/dol/bases/d_bg.cpp | 19 +++++++++++++------ 2 files changed, 15 insertions(+), 6 deletions(-) diff --git a/include/game/bases/d_bg.hpp b/include/game/bases/d_bg.hpp index 415ef4eb..df64545f 100644 --- a/include/game/bases/d_bg.hpp +++ b/include/game/bases/d_bg.hpp @@ -227,6 +227,8 @@ class dBg_c : public dBase_c { u16 cvtW() { return getR() - getL(); } u16 cvtH() { return getU() - getD(); } + float getLimitD() { return mDLimit; } + dBgScrollLimit_c *getScrLim(int area, int group, int idx) { return &mScrLimit[area][group][idx]; } dBgSubstruct2_c * getData2(int idx, int i) { return &mData2[idx][i]; } diff --git a/source/dol/bases/d_bg.cpp b/source/dol/bases/d_bg.cpp index b72ce5eb..394274e4 100644 --- a/source/dol/bases/d_bg.cpp +++ b/source/dol/bases/d_bg.cpp @@ -999,14 +999,18 @@ void dBg_c::calcLoopAutoScroll() { float maxX = 6000.0f; mVec3_c unitVec; - mVec3_c pos; unitVec.x = 1.0f; unitVec.y = 0.0f; - float actualY = bgParam->mSize.y + mDLimit; + float actualY = bgParam->ySize() + getLimitD(); + + mVec3_c pos; + pos.x = mAutoscrolls[0].mPos.x; + pos.y = mAutoscrolls[0].mPos.y; + pos.z = mAutoscrolls[0].mPos.z; + mSomeParameterPos.x = bgParam->xStart(); + mSomeParameterPos.y = bgParam->yStart(); - pos = mAutoscrolls[0].mPos; - mSomeParameterPos = bgParam->mPos; if (m_90958 == 1) { if (bgParam->mPos.x > 2290.0f) { @@ -1047,11 +1051,14 @@ void dBg_c::calcLoopAutoScroll() { pos.x = maxX; } mAutoscrolls[0].mPos = pos; - mSomePos.x = pos.x; - mSomePos.y = pos.y; + float posX = pos.x; + float posY = pos.y; + mSomePos.set(posX, posY); + float lWidth = mVideo::l_rayoutWidthF; float lHeight = mVideo::l_rayoutHeightF; float target = m_bg_p->getZoomTargetMin(); + mDispScale = 1.0f / target; mSomeSize.x = lWidth * (1.0f / mDispScale); mSomeSize.y = lHeight * (1.0f / mDispScale); From e68af5636ffb43e675fca223ec59f10ce0799da6 Mon Sep 17 00:00:00 2001 From: RootCubed Date: Thu, 7 May 2026 08:55:02 +0200 Subject: [PATCH 18/29] `dBg_c::fn_8007ca90` matching --- include/game/bases/d_bg.hpp | 11 -------- source/dol/bases/d_bg.cpp | 51 ++++++++++++++++++++----------------- 2 files changed, 27 insertions(+), 35 deletions(-) diff --git a/include/game/bases/d_bg.hpp b/include/game/bases/d_bg.hpp index df64545f..736e42ed 100644 --- a/include/game/bases/d_bg.hpp +++ b/include/game/bases/d_bg.hpp @@ -216,17 +216,6 @@ class dBg_c : public dBase_c { u16 cvtW() { return getR() - getL(); } u16 cvtH() { return getU() - getD(); } - float getL() { return mL; } - float getU() { return mU; } - float getD() { return mD; } - float getR() { return mR; } - u16 cvtL() { return getL(); } - u16 cvtR() { return getR(); } - u16 cvtU() { return getU(); } - u16 cvtD() { return getD(); } - u16 cvtW() { return getR() - getL(); } - u16 cvtH() { return getU() - getD(); } - float getLimitD() { return mDLimit; } dBgScrollLimit_c *getScrLim(int area, int group, int idx) { return &mScrLimit[area][group][idx]; } diff --git a/source/dol/bases/d_bg.cpp b/source/dol/bases/d_bg.cpp index 394274e4..8d15c5c7 100644 --- a/source/dol/bases/d_bg.cpp +++ b/source/dol/bases/d_bg.cpp @@ -2045,11 +2045,12 @@ void swap(dAcPy_c **pl1, dAcPy_c **pl2) { } void dBg_c::fn_8007ca90(dBgSomeInfo_c *info, int i1, int i2) { - static bool (*compareFuncs[4])(dAcPy_c *, dAcPy_c *) = { - isRightPlayer, - isLeftPlayer, - isUpPlayer, - isDownPlayer + typedef bool (*CompareFunc)(dAcPy_c *, dAcPy_c *); + static const CompareFunc compareFuncs[4] = { + &isRightPlayer, + &isUpPlayer, + &isLeftPlayer, + &isDownPlayer }; dAcPy_c *pls[4]; int count2 = 0; @@ -2080,67 +2081,69 @@ void dBg_c::fn_8007ca90(dBgSomeInfo_c *info, int i1, int i2) { m_bg_p->m_9095a = 0; // sort players - for (int i = 0; i < 3; i++) { - for (int j = i + 1; j < 4; j++) { - dAcPy_c *pl1 = pls[i]; - dAcPy_c *pl2 = pls[j]; - if (pls[j] != nullptr) { - if (pls[i] == nullptr) { - swap(&pls[i], &pls[j]); - } else if (compareFuncs[i1 & 0xFF](pl1, pl2)) { - swap(&pls[i], &pls[j]); - } + for (int i = 0; i < PLAYER_COUNT - 1; i++) { + for (int j = i + 1; j < PLAYER_COUNT; j++) { + dAcPy_c *pl1 = pls[j]; + dAcPy_c *pl2 = pls[i]; + if (pls[j] == nullptr) { + continue; + } + if (pls[i] == nullptr) { + swap(&pls[i], &pls[j]); + } else if (compareFuncs[i1 & 0xFF](pl1, pl2)) { + swap(&pls[i], &pls[j]); } } } - dAcPy_c *pl1, *pl2; + dAcPy_c *pl2; + dAcPy_c *pl1; pl1 = pls[0]; pl2 = pls[i2 - 1]; switch (i1) { case 0: - if (pls[0] != nullptr) { + if (pl1 != nullptr) { info->m_14 = pl1; info->mBounds.mRight = fn_8007c7d0(pl1->mPc.m_30.x); info->m_24 = pl1->mPlayerType; } if (pls[i2 - 1] != nullptr) { - info->m_10 = pl2; + info->m_10 = pls[i2 - 1]; info->mBounds.mLeft = fn_8007c7d0(pl2->mPc.m_30.x); info->m_20 = pl2->mPlayerType; } break; case 2: - if (pls[i2 - 1] != nullptr) { + if (pl2 != nullptr) { info->m_14 = pl2; info->mBounds.mRight = fn_8007c7d0(pl2->mPc.m_30.x); info->m_24 = pl2->mPlayerType; } if (pls[0] != nullptr) { - info->m_10 = pl1; + info->m_10 = pls[0]; info->mBounds.mLeft = fn_8007c7d0(pl1->mPc.m_30.x); info->m_20 = pl1->mPlayerType; } break; case 1: - if (pls[0] != nullptr) { + if (pl1 != nullptr) { info->m_18 = pl1; info->mBounds.mUp = pl1->mPc.m_30.y; info->m_28 = pl1->mPlayerType; } if (pls[i2 - 1] != nullptr) { - info->m_1c = pl2; + info->m_1c = pls[i2 - 1]; info->mBounds.mDown = pl2->mPc.m_30.y; info->m_2c = pl2->mPlayerType; } break; case 3: - if (pls[i2 - 1] != nullptr) { + if (pl2 != nullptr) { info->m_18 = pl2; info->mBounds.mUp = pl2->mPc.m_30.y; info->m_28 = pl2->mPlayerType; } if (pls[0] != nullptr) { - info->m_1c = pl1; + info->m_1c = pls[0]; info->mBounds.mDown = pl1->mPc.m_30.y; info->m_2c = pl1->mPlayerType; } From 0f1ecaf35708ecf1b18f597833baff8109ddc541 Mon Sep 17 00:00:00 2001 From: RootCubed Date: Tue, 18 Nov 2025 12:54:29 +0100 Subject: [PATCH 19/29] `dBg_c::initScroll` matching --- include/game/bases/d_bg.hpp | 5 +++++ source/dol/bases/d_bg.cpp | 22 +++++++++++++--------- 2 files changed, 18 insertions(+), 9 deletions(-) diff --git a/include/game/bases/d_bg.hpp b/include/game/bases/d_bg.hpp index 736e42ed..c348ae2a 100644 --- a/include/game/bases/d_bg.hpp +++ b/include/game/bases/d_bg.hpp @@ -218,6 +218,11 @@ class dBg_c : public dBase_c { float getLimitD() { return mDLimit; } + float getSomePosX() { return mSomePos.x; } + float getSomePosY() { return mSomePos.y; } + float getSomeSizeX() { return mSomeSize.x; } + float getSomeSizeY() { return mSomeSize.y; } + dBgScrollLimit_c *getScrLim(int area, int group, int idx) { return &mScrLimit[area][group][idx]; } dBgSubstruct2_c * getData2(int idx, int i) { return &mData2[idx][i]; } diff --git a/source/dol/bases/d_bg.cpp b/source/dol/bases/d_bg.cpp index 8d15c5c7..6c70a2a7 100644 --- a/source/dol/bases/d_bg.cpp +++ b/source/dol/bases/d_bg.cpp @@ -1878,16 +1878,20 @@ void dBg_c::initScroll() { } calcScroll(plPos, 1); - mPrevSomePos = mSomePos; - bgParam->mPos = mSomePos; + mPrevSomePos.x = getSomePosX(); + mPrevSomePos.y = getSomePosY(); + bgParam->mPos.x = getSomePosX(); + bgParam->mPos.y = getSomePosY(); - m_90960 = mSomePos.y; + m_90960 = getSomePosY(); - mPrevSomeSize = mSomeSize; - bgParam->mSize = mSomeSize; + mPrevSomeSize.x = getSomeSizeX(); + mPrevSomeSize.y = getSomeSizeY(); + bgParam->mSize.x = getSomeSizeX(); + bgParam->mSize.y = getSomeSizeY(); - bgParam->mCenter.x = bgParam->mPos.x + bgParam->mSize.x * 0.5f; - bgParam->mCenter.y = bgParam->mPos.y - bgParam->mSize.y * 0.5f; + bgParam->mCenter.x = bgParam->xStart() + bgParam->xSize() * 0.5f; + bgParam->mCenter.y = bgParam->yStart() - bgParam->ySize() * 0.5f; mU8s[3] = 0; mU8s[4] = 0; @@ -1903,8 +1907,8 @@ void dBg_c::initScroll() { mMoreFloats5[1] = 1.0f; mMoreFloats5[2] = 1.0f; mMoreFloats5[4] = 0.0f; - mSomeParameterPos.x = dBgParameter_c::ms_Instance_p->mPos.x; - mSomeParameterPos.y = dBgParameter_c::ms_Instance_p->mPos.y; + mSomeParameterPos.x = dBgParameter_c::ms_Instance_p->xStart(); + mSomeParameterPos.y = dBgParameter_c::ms_Instance_p->yStart(); dBgScrollLimit_c zeroLimit; zeroLimit.mL = 0.0f; From aac48200b14e2a75f886289fde5afb527d32d8e9 Mon Sep 17 00:00:00 2001 From: RootCubed Date: Tue, 18 Nov 2025 13:16:43 +0100 Subject: [PATCH 20/29] `dBg_c::fn_8007c7d0` matching --- include/game/bases/d_bg.hpp | 2 ++ source/dol/bases/d_bg.cpp | 33 +++++++++++++++++---------------- 2 files changed, 19 insertions(+), 16 deletions(-) diff --git a/include/game/bases/d_bg.hpp b/include/game/bases/d_bg.hpp index c348ae2a..f873668b 100644 --- a/include/game/bases/d_bg.hpp +++ b/include/game/bases/d_bg.hpp @@ -223,6 +223,8 @@ class dBg_c : public dBase_c { float getSomeSizeX() { return mSomeSize.x; } float getSomeSizeY() { return mSomeSize.y; } + float getLoopOffsetX() { return mLoopOffsetX; } + dBgScrollLimit_c *getScrLim(int area, int group, int idx) { return &mScrLimit[area][group][idx]; } dBgSubstruct2_c * getData2(int idx, int i) { return &mData2[idx][i]; } diff --git a/source/dol/bases/d_bg.cpp b/source/dol/bases/d_bg.cpp index 6c70a2a7..d48ac094 100644 --- a/source/dol/bases/d_bg.cpp +++ b/source/dol/bases/d_bg.cpp @@ -1999,27 +1999,28 @@ void dBg_c::initScroll() { } float dBg_c::fn_8007c7d0(float x) { - float res = x; - float loopOffset = mLoopOffsetX; + float loopOffset = getLoopOffsetX(); + if (dScStage_c::m_loopType == 2) { - if (dBgParameter_c::ms_Instance_p->posX() < getMaxLeftPos()) { - float tmp1 = getMaxLeftPos() + (getMaxRightPos() - getMaxLeftPos()) * 0.5f; - float bgW = dBgParameter_c::ms_Instance_p->width(); - float bgX = dBgParameter_c::ms_Instance_p->posX(); - bgW += getMaxLeftPos(); - if (bgX > bgW && tmp1 > x) { - res -= loopOffset; + if (dBgParameter_c::ms_Instance_p->xStart() < getMaxLeftPos()) { + float midPos = getMaxLeftPos() + (getMaxRightPos() - getMaxLeftPos()) * 0.5f; + float xSize = dBgParameter_c::ms_Instance_p->xSize(); + float xStart = dBgParameter_c::ms_Instance_p->xStart(); + float xLeft = getMaxLeftPos(); + xLeft += xSize; + if (xStart > xLeft && x > midPos) { + x -= loopOffset; } - } else if (dBgParameter_c::ms_Instance_p->posX() > getMaxRightPos() - dBgParameter_c::ms_Instance_p->width()) { - float tmp1 = getMaxLeftPos() + (getMaxRightPos() - getMaxLeftPos()) * 0.5f; - float bgW = dBgParameter_c::ms_Instance_p->width(); - float bgX = dBgParameter_c::ms_Instance_p->posX(); - if (dBgParameter_c::ms_Instance_p->posX() < getMaxRightPos() && tmp1 < x) { - res += loopOffset; + } else if (dBgParameter_c::ms_Instance_p->xStart() > getMaxRightPos() - dBgParameter_c::ms_Instance_p->xSize()) { + float midPos = getMaxLeftPos() + (getMaxRightPos() - getMaxLeftPos()) * 0.5f; + float xStart = dBgParameter_c::ms_Instance_p->xStart(); + if (xStart < getMaxRightPos() && x < midPos) { + x += loopOffset; } } } - return res; + + return x; } bool isRightPlayer(dAcPy_c *pl1, dAcPy_c *pl2) { From 84dffea4286f7045615d94dc84131db7b505609c Mon Sep 17 00:00:00 2001 From: RootCubed Date: Tue, 18 Nov 2025 13:43:00 +0100 Subject: [PATCH 21/29] `dBg_c::freeUpScrollLimit` and `dBg_c::freeUpScrollLimit2` matching --- include/game/bases/d_bg.hpp | 2 +- source/dol/bases/d_bg.cpp | 46 ++++++++++++++++++++++--------------- 2 files changed, 28 insertions(+), 20 deletions(-) diff --git a/include/game/bases/d_bg.hpp b/include/game/bases/d_bg.hpp index f873668b..d28d3da0 100644 --- a/include/game/bases/d_bg.hpp +++ b/include/game/bases/d_bg.hpp @@ -189,7 +189,7 @@ class dBg_c : public dBase_c { void fn_8007cd70(dBgSomeInfo_c *, dBgSomeInfo_c *, int); ///< @unofficial u8 freeUpScrollLimit(const dBgScrollLimit_c &scrollLimit, int group, int area); ///< @unofficial - u8 freeUpScrollLimit2(dBgScrollLimit_c *scrollLimit, int group, int area); ///< @unofficial + u8 freeUpScrollLimit2(const dBgScrollLimit_c &scrollLimit, int group, int area); ///< @unofficial void setScrollLimit(dBgScrollLimit_c *scrollLimit, int areaNo, int type, int group); ///< @unofficial diff --git a/source/dol/bases/d_bg.cpp b/source/dol/bases/d_bg.cpp index d48ac094..cf235f9a 100644 --- a/source/dol/bases/d_bg.cpp +++ b/source/dol/bases/d_bg.cpp @@ -2333,23 +2333,27 @@ void dBg_c::fn_8007cd70(dBgSomeInfo_c *info1, dBgSomeInfo_c *info2, int i1) { } u8 dBg_c::freeUpScrollLimit(const dBgScrollLimit_c &scrollLimit, int group, int area) { - dBgScrollLimit_c *base = getScrLim(area, group, 0); + dBgScrollLimit_c *base = mScrLimit[area][group]; + dBgScrollLimit_c *currSL; + u8 idx = 0; for (; idx < 16; idx++) { - // idx = i; - if (base[idx].mR2 >= scrollLimit.mR2) { + currSL = &base[idx]; + if (currSL->mR2 >= scrollLimit.mR2) { break; } } if (idx >= 16) { idx = 0; } - dBgScrollLimit_c *currSL, *prevSL; - u8 prev = 15; + + u8 curr = 15; for (u32 i = idx; i != 15; i++) { - prevSL = getScrLim(area, group, prev); - currSL = getScrLim(area, group, --prev); - *prevSL = *currSL; + dBgScrollLimit_c *c = &mScrLimit[area][group][curr]; + curr--; + dBgScrollLimit_c *n = &mScrLimit[area][group][curr]; + *c = *n; + currSL = n; } currSL->mL = 0.0f; @@ -2369,24 +2373,28 @@ u8 dBg_c::freeUpScrollLimit(const dBgScrollLimit_c &scrollLimit, int group, int return idx; } -u8 dBg_c::freeUpScrollLimit2(dBgScrollLimit_c *scrollLimit, int group, int area) { - dBgScrollLimit_c *base = getScrLim(area, group, 0); +u8 dBg_c::freeUpScrollLimit2(const dBgScrollLimit_c &scrollLimit, int group, int area) { + dBgScrollLimit_c *base = mScrLimit[area][group]; + dBgScrollLimit_c *currSL; + u8 idx = 0; for (; idx < 16; idx++) { - // idx = i; - if (base[idx].mD3 >= scrollLimit->mD3) { + currSL = &base[idx]; + if (currSL->mD3 >= scrollLimit.mD3) { break; } } if (idx >= 16) { idx = 0; } - dBgScrollLimit_c *currSL, *prevSL; - u8 prev = 15; + + u8 curr = 15; for (u32 i = idx; i != 15; i++) { - prevSL = getScrLim(area, group, prev); - currSL = getScrLim(area, group, --prev); - *prevSL = *currSL; + dBgScrollLimit_c *c = &mScrLimit[area][group][curr]; + curr--; + dBgScrollLimit_c *n = &mScrLimit[area][group][curr]; + *c = *n; + currSL = n; } currSL->mL = 0.0f; @@ -2484,7 +2492,7 @@ void dBg_c::setScrollLimit(dBgScrollLimit_c *scrollLimit, int areaNo, int type, } } if (idx >= 16) { - idx = freeUpScrollLimit2(scrollLimit, group, areaNo); + idx = freeUpScrollLimit2(*scrollLimit, group, areaNo); } curr = &mScrLimit[areaNo][group][idx]; curr->mU2 = scrollLimit->mU2; @@ -2506,7 +2514,7 @@ void dBg_c::setScrollLimit(dBgScrollLimit_c *scrollLimit, int areaNo, int type, } } if (idx >= 16) { - idx = freeUpScrollLimit2(scrollLimit, group, areaNo); + idx = freeUpScrollLimit2(*scrollLimit, group, areaNo); } curr = &mScrLimit[areaNo][group][idx]; curr->mD2 = (short) (scrollLimit->mD2 + 16.0f); From 97344c30fba6fc818da6bbcbc373b33078366421 Mon Sep 17 00:00:00 2001 From: RootCubed Date: Tue, 18 Nov 2025 17:51:29 +0100 Subject: [PATCH 22/29] Various minor improvements --- include/game/bases/d_bg.hpp | 18 ++- include/game/bases/d_cd.hpp | 2 + source/dol/bases/d_bg.cpp | 220 +++++++++++++++++++++--------------- 3 files changed, 149 insertions(+), 91 deletions(-) diff --git a/include/game/bases/d_bg.hpp b/include/game/bases/d_bg.hpp index d28d3da0..d010381a 100644 --- a/include/game/bases/d_bg.hpp +++ b/include/game/bases/d_bg.hpp @@ -37,6 +37,13 @@ class dBgBound_c { public: dBgBound_c() : mLeft(0.0f), mRight(0.0f), mUp(0.0f), mDown(0.0f) {} + float getR() const { return mRight; } + float getL() const { return mLeft; } + float getU() const { return mUp; } + float getD() const { return mDown; } + float getW() const { return getR() - getL(); } + float getH() const { return getU() - getD(); } + float mLeft, mRight, mUp, mDown; }; @@ -159,6 +166,10 @@ class dBg_c : public dBase_c { return (1.0f / getZoomTargetMin()) + bgVal * (1.0f / tmp1 - (1.0f / getZoomTargetMin())); } + float invZoomTargetMin() { + return 1.0f / getZoomTargetMin(); + } + float getZoomSpreadLine(); float getZoomSpreadLine2(); float getZoomShrinkLine(); @@ -217,6 +228,7 @@ class dBg_c : public dBase_c { u16 cvtH() { return getU() - getD(); } float getLimitD() { return mDLimit; } + float getLimitU() { return mULimit; } float getSomePosX() { return mSomePos.x; } float getSomePosY() { return mSomePos.y; } @@ -225,6 +237,9 @@ class dBg_c : public dBase_c { float getLoopOffsetX() { return mLoopOffsetX; } + float get_900ac() { return m_900ac; } + float get_900b0() { return m_900b0; } + dBgScrollLimit_c *getScrLim(int area, int group, int idx) { return &mScrLimit[area][group][idx]; } dBgSubstruct2_c * getData2(int idx, int i) { return &mData2[idx][i]; } @@ -257,7 +272,8 @@ class dBg_c : public dBase_c { float mMoreFloats7[7]; float mWaveRelated[80]; float mDispScale; - float mMoreFloats3[4]; + float mSomeScale; + float mMoreFloats3[3]; u8 mU8s[6]; float mZoomDenom; u8 m_8ffbc; diff --git a/include/game/bases/d_cd.hpp b/include/game/bases/d_cd.hpp index f692bc1a..46a4e702 100644 --- a/include/game/bases/d_cd.hpp +++ b/include/game/bases/d_cd.hpp @@ -98,6 +98,8 @@ class dCd_c { static void createInstance(EGG::Heap *heap); static void deleteInstance(); + static dCd_c *getInstance() { return m_instance; } + dCdFile_c *getFileP(int idx) { dCdFile_c *course = &mFiles[idx]; if (course->mpAreas != nullptr) { diff --git a/source/dol/bases/d_bg.cpp b/source/dol/bases/d_bg.cpp index cf235f9a..5be22cb1 100644 --- a/source/dol/bases/d_bg.cpp +++ b/source/dol/bases/d_bg.cpp @@ -76,11 +76,11 @@ dBg_c::dBg_c() { } mDispScale = 1.0f; + mSomeScale = 1.0f; mMoreFloats3[0] = 1.0f; - mMoreFloats3[1] = 1.0f; - mMoreFloats3[2] = 0.0f; + mMoreFloats3[1] = 0.0f; mZoomDenom = 1.0f; - mMoreFloats3[3] = -999999.0f; + mMoreFloats3[2] = -999999.0f; mU8s[0] = 0; mU8s[1] = 0; mU8s[2] = 0; @@ -1066,28 +1066,32 @@ void dBg_c::calcLoopAutoScroll() { void dBg_c::calcAutoScroll() { dBgParameter_c *bgParam = dBgParameter_c::ms_Instance_p; - float bgW = bgParam->mSize.x; - float bgH = bgParam->mSize.y; + float bgW = bgParam->xSize(); + float bgH = bgParam->ySize(); + sRailInfoData *ri = dRail_c::getRailInfoP(mAutoscrolls[0].m_14); - dScStage_c *stage = dScStage_c::m_instance; + dScStage_c *stage = dScStage_c::getInstance(); dCdFile_c *file = dCd_c::m_instance->getFileP(stage->mCurrFile); - float calcArg2, calcArg; + float calcArg, calcArg2; float leftLim, rightLim, upLim, downLim; leftLim = getLeftLimit(); rightLim = getRightLimit() - bgW; - upLim = mULimit; - downLim = bgH + mDLimit; - bool cond1 = true; - bool cond2 = true; + downLim = getLimitD() + bgH; + upLim = getLimitU(); + + bool updateX; + bool updateY; + updateX = true; + updateY = true; if (stage->mCurrWorld == WORLD_2 && stage->mCurrCourse == STAGE_CASTLE && stage->mCurrFile == 0) { calcLoopAutoScroll(); } else if ((dActor_c::mExecStop & 8) == 0 && m_9008c == 0) { sRailNodeData *base = &file->mpRailNodes[ri->mNodeIdx]; if (m_9008d != 0) { + int idx; for (int i = 0; i < 999; i++) { - int idx = m_9007c; - // dBgThing_c *tmp = &base[m_9007c]; + idx = m_9007c; if (m_90009 == 0) { if (mAutoscrolls[0].mPos.x > base[idx].mX) { m_9007c++; @@ -1110,20 +1114,20 @@ void dBg_c::calcAutoScroll() { mVec3_c someVec2; mVec3_c idk; mVec3_c someVec; - bgThingVec.x = base[offset].mX; - bgThingVec.y = -(float) base[offset].mY; + bgThingVec.x = base[tmp].mX; + bgThingVec.y = -(float) base[tmp].mY; bgThingVec.z = 0.0f; if (tmp > 0) { - asCopy.x = (&base[offset] - 1)->mX; - asCopy.y = -(float) (&base[offset] - 1)->mY; + asCopy.x = (&base[tmp] - 1)->mX; + asCopy.y = -(float) (&base[tmp] - 1)->mY; asCopy.z = 0.0f; } else { asCopy = asPos; } someVec = bgThingVec - asCopy; someVec.normalize(); - calcArg = base[offset].mSpeed; - calcArg2 = base[offset].mAccel; + calcArg = base[tmp].mSpeed; + calcArg2 = base[tmp].mAccel; someVec2 = bgThingVec - asPos; someVec2.normalize(); float len = someVec2.xzLen(); @@ -1195,19 +1199,19 @@ void dBg_c::calcAutoScroll() { } switch (mAutoscrolls[0].m_18) { case 0: - cond1 = true; - cond2 = true; + updateX = true; + updateY = true; break; case 1: - cond1 = true; - cond2 = false; + updateX = true; + updateY = false; break; case 2: - cond1 = false; - cond2 = true; + updateX = false; + updateY = true; break; } - if (cond1) { + if (updateX) { rightLim = -999999.0f; for (int i = 0; i < 4; i++) { dAcPy_c *pl = daPyMng_c::getPlayer(i); @@ -1220,7 +1224,7 @@ void dBg_c::calcAutoScroll() { } mSomePos.x = asPosCopy.x; } - if (cond2) { + if (updateY) { mSomePos.y = asPosCopy.y; } @@ -1243,37 +1247,46 @@ void dBg_c::AutoScroll_stop() { void dBg_c::calcScroll(const mVec3_c &pos, int param_2) { dBgParameter_c *bgParam = dBgParameter_c::getInstance(); - float lWidth = mVideo::getLayoutWidth(); - float lHeight = mVideo::getLayoutHeight(); + + float bgVal; + float lWidth = mVideo::l_rayoutWidthF; + float zoomFactor; + float lHeight = mVideo::l_rayoutHeightF; if (m_bg_p->m_9095a == 0) { m_bg_p->getZoomTargetMax(); // unused return value - float tmp1 = mMoreFloats3[0]; - if (tmp1 > 0.0f) { - float bgVal = dBgParameter_c::getInstance()->m_30.y; - mDispScale = m_bg_p->calcDispScale(bgVal, tmp1); + + zoomFactor = mSomeScale; + if (mSomeScale > 0.0f) { + dBg_c *bg = m_bg_p; + bgVal = dBgParameter_c::ms_Instance_p->m_30.y; + float tmp2 = bgVal * (1.0f / zoomFactor - bg->invZoomTargetMin()); + mDispScale = tmp2 + bg->invZoomTargetMin(); } m_90018 = mDispScale; mMoreFloats5[1] = mDispScale; - float invDispScale = 1.0f / mDispScale; - mSomeSize.x = lWidth * invDispScale; - mSomeSize.y = lHeight * invDispScale; + + mSomeSize.x = lWidth * (1.0f / mDispScale); + mSomeSize.y = lHeight * (1.0f / mDispScale); + float width = mSomeSize.x; float halfWidth = width * 0.5f; float leftLimit = getLeftLimit(); float rightLimit = getRightLimit() - width; + bool cond1 = true; bool cond2 = true; - float upLimit = mULimit; - float downLimit = lHeight + mDLimit; + + float upLimit = getLimitU(); + float downLimit = getLimitD() + lHeight; float maxLeft = getMaxLeftPos(); - mSomeParameterPos = bgParam->mPos; + + mSomeParameterPos = bgParam->pos(); mPlayerPosY = pos.y; - float height = mSomeSize.y; - float halfHeight = height * 0.5f; + float bounds40 = mBounds4[0]; float bounds41 = mBounds4[1]; float x = pos.x + bounds40 - halfWidth; - float y = pos.y + halfHeight - bounds41; + float y = pos.y + (mSomeSize.y / 2) - bounds41; if (dScStage_c::m_loopType != 2) { if (x < leftLimit) { x = leftLimit; @@ -1333,20 +1346,20 @@ void dBg_c::calcScroll(const mVec3_c &pos, int param_2) { } } if (mLimitRelated == 1 || mLimitRelated == 4) { - mSomePos.x = maxLeft + mLoopOffsetX * 0.5f - mSomeSize.x * 0.5f; + mSomePos.x = maxLeft + getLoopOffsetX() * 0.5f - getSomeSizeX() * 0.5f; } if (mLimitRelated == 6) { - mSomePos.y = mSomeSize.y + mD; + mSomePos.y = getD() + getSomeSizeY(); } mBounds4[0] = bounds40; mBounds4[1] = bounds41; if (!mAutoscrolls[0].mActive) { - mAutoscrolls[0].mPos.x = mSomePos.x; - mAutoscrolls[0].mPos.y = mSomePos.y; + mAutoscrolls[0].mPos.x = getSomePosX(); + mAutoscrolls[0].mPos.y = getSomePosY(); } if (m_900a7 != 0) { - mSomePos.x = m_900ac - mSomeSize.x / 2; - mSomePos.y = m_900b0 + mSomeSize.y; + mSomePos.x = m_900ac - getSomeSizeX() * 0.5f; + mSomePos.y = m_900b0 + getSomeSizeY(); } } fn_8007ca90(&mSomeInfo1, m_90009, 1); @@ -1737,42 +1750,60 @@ void dBg_c::fn_8007ba70(const dBgSomeInfo_c *info) { } float dBg_c::fn_8007bba0(const dBgSomeInfo_c *info) { - float tmp = 64.0f + info->mBounds.mUp; - if (tmp - mPrevSomePos.y < -6.0f) { - tmp = mPrevSomePos.y - 6.0f; + float tmp = 64.0f; + float u = info->mBounds.getU(); + + float res = u + tmp; + + if (res - mPrevSomePos.y < -6.0f) { + res = mPrevSomePos.y - 6.0f; } - if (!(tmp > mULimit)) { - return tmp; + + if (res > mULimit) { + res = mULimit; } - return mULimit; + + return res; } float dBg_c::fn_8007bbf0(const dBgSomeInfo_c *info) { - float sizeY = dBgParameter_c::getInstance()->mSize.y; - float tmp = info->mBounds.mDown + (sizeY - 32.0f); - if (tmp - mPrevSomePos.y > 6.0f) { - tmp = mPrevSomePos.y + 6.0f; + dBgParameter_c *bgParam = dBgParameter_c::getInstance(); + + float sizeY = bgParam->ySize(); + float offsY = sizeY - 32.0f; + float res = info->mBounds.getD() + offsY; + + if (res - mPrevSomePos.y > 6.0f) { + res = mPrevSomePos.y + 6.0f; } - if (!(tmp < sizeY + mDLimit)) { - return tmp; + + if (res < sizeY + mDLimit) { + res = sizeY + mDLimit; } - return mDLimit; + + return res; } bool dBg_c::fn_8007bc40(const dBgSomeInfo_c *info, float f) { - float fVar1 = info->mBounds.mLeft; - float fVar2 = info->mBounds.mRight; + float fVar1 = info->mBounds.getL(); + float fVar2 = info->mBounds.getR(); float ll = getLeftLimit(); float rl = getRightLimit(); - float fVar4 = dBgParameter_c::m_78_offset(); - float fVar3 = fVar4; + + dBgParameter_c *bgParam = dBgParameter_c::getInstance(); + + float tmp = 112.0f; + float fVar3 = tmp - bgParam->m_78; + float fVar4 = tmp - bgParam->m_78; if (fVar1 < ll + fVar4) { fVar3 = fVar1 - ll; } - if (fVar2 > rl - dBgParameter_c::m_78_offset()) { + float tmp2 = 112.0f; + float fVar5 = tmp2 - bgParam->m_78; + if (fVar2 > rl - fVar5) { fVar4 = rl - fVar2; } - if (f * mVideo::getLayoutWidth() - (fVar3 + fVar4) > info->mBounds.mRight - info->mBounds.mLeft) { + if (f * mVideo::getLayoutWidth() - (fVar3 + fVar4) > info->mBounds.getR() - info->mBounds.getL()) { return true; } else { return false; @@ -1782,43 +1813,52 @@ bool dBg_c::fn_8007bc40(const dBgSomeInfo_c *info, float f) { mVec2_c dBg_c::fn_8007bd40(const dBgSomeInfo_c *info, float f1, float f2) { mVec2_c result(0.0f, 0.0f); - float fVar4 = mVideo::getLayoutWidth(); - float fVar5 = mVideo::getLayoutHeight(); + float layoutWidth = mVideo::getLayoutWidth(); + float layoutHeight = mVideo::getLayoutHeight(); + float ll = getLeftLimit(); float rl = getRightLimit(); - float uLim = mULimit; - float dLim = mDLimit; - float fVar1 = 112.0f; - float tmpLeft = info->mBounds.mLeft - 112.0f; - float fVar6 = 112.0f; - float tmpRight = info->mBounds.mRight + 112.0f; + float uLim = getLimitU(); + float dLim = getLimitD(); + + float tmpLeft = info->mBounds.getL() - 112.0f; + float tmpRight = info->mBounds.getR() + 112.0f; + float offsX1 = 112.0f; + float offsX2 = 112.0f; if (tmpLeft < ll) { - fVar6 = info->mBounds.mLeft - ll; + offsX1 = info->mBounds.getL() - ll; } if (tmpRight > rl) { - fVar1 = rl - info->mBounds.mRight; + offsX2 = rl - info->mBounds.getR(); } - float resX = 1.0f; - float tmpX = (fVar1 + (info->mBounds.mRight - info->mBounds.mLeft) + fVar6) / fVar4; + + float baseX = info->mBounds.getW(); + float tmpX = (offsX1 + baseX + offsX2) / layoutWidth; + + float resX = info->mBounds.getR(); if (tmpX < 1.0f) { - resX = tmpX; + resX = 1.0f; } else if (tmpX > f1) { resX = f1; } - fVar1 = 88.0f; - fVar4 = 80.0f; - float tmpUp = info->mBounds.mUp + 88.0f; - float tmpDown = info->mBounds.mDown - 80.0f; + + float tmpUp = info->mBounds.getU() + 88.0f; + float tmpDown = info->mBounds.getD() - 80.0f; + float offsY1 = 88.0f; + float offsY2 = 80.0f; if (tmpUp > uLim) { - fVar1 = uLim - info->mBounds.mUp; + offsY1 = uLim - info->mBounds.getU(); } if (tmpDown < dLim) { - fVar4 = info->mBounds.mDown - dLim; + offsY2 = info->mBounds.getD() - dLim; } - float resY = 1.0f; - float tmpY = ((fVar4 + (info->mBounds.mUp - info->mBounds.mDown) + fVar1) * f2) / fVar5; + + float baseY = info->mBounds.getH(); + float tmpY = (offsY1 + baseY + offsY2) * f2 / layoutHeight; + + float resY = info->mBounds.getD(); if (tmpY < 1.0f) { - resY = tmpY; + resY = 1.0f; } else if (tmpY > f1) { resY = f1; } @@ -2552,5 +2592,5 @@ float dBg_c::getAreaUpLimitScroll() { float sizeY = bgParam->mSize.y; float posY = bgParam->mPos.y; float m = m_bg_p->getZoomTargetMin() * mVideo::getLayoutHeight() + (posY - sizeY); - return mMoreFloats3[3] + m; + return mMoreFloats3[2] + m; } From 948397ed66b4005d4b3dc54e7afe7e0fe1822957 Mon Sep 17 00:00:00 2001 From: RootCubed Date: Thu, 7 May 2026 08:56:18 +0200 Subject: [PATCH 23/29] Fix rebase, some match improvements --- include/game/bases/d_bg.hpp | 9 +- include/game/bases/d_bg_parameter.hpp | 3 +- source/dol/bases/d_bg.cpp | 332 +++++++++++++------------- 3 files changed, 175 insertions(+), 169 deletions(-) diff --git a/include/game/bases/d_bg.hpp b/include/game/bases/d_bg.hpp index d010381a..25ad07c7 100644 --- a/include/game/bases/d_bg.hpp +++ b/include/game/bases/d_bg.hpp @@ -110,7 +110,7 @@ class dBg_c : public dBase_c { unsigned long long CvtBgCheckFromUnitNo(u16); static unsigned long long fn_80081960(unsigned long long, int); - dBgUnit_c *fn_80077520(u16 param_2, u16 param_3, u8 param_4, int *param_5, bool b); + dBgUnit_c *__GetUnitPointer(u16 param_2, u16 param_3, u8 param_4, int *param_5, bool b); unsigned long long getBgCheckBuff(u16); unsigned long long *getpBgCheckBuff(u16); @@ -212,7 +212,7 @@ class dBg_c : public dBase_c { static void bg_destroyHeap(); float getDispScale() { return mDispScale; } - float getPrevDispScale() { return mMoreFloats3[1]; } + float getPrevDispScale() { return mMoreFloats3[0]; } float getScaleFactor() { return 1.0f / mDispScale; } float getLiquidHeight() const { return mMoreFloats7[5]; } @@ -237,9 +237,6 @@ class dBg_c : public dBase_c { float getLoopOffsetX() { return mLoopOffsetX; } - float get_900ac() { return m_900ac; } - float get_900b0() { return m_900b0; } - dBgScrollLimit_c *getScrLim(int area, int group, int idx) { return &mScrLimit[area][group][idx]; } dBgSubstruct2_c * getData2(int idx, int i) { return &mData2[idx][i]; } @@ -305,7 +302,7 @@ class dBg_c : public dBase_c { float mZoomWeight; u8 mZoomRelated; u8 m_900a5, m_900a6, m_900a7, m_900a8; - float m_900ac, m_900b0; + mVec2_c m_900ac; u8 m_900b4; short m_900b6; float m_900b8, m_900bc; diff --git a/include/game/bases/d_bg_parameter.hpp b/include/game/bases/d_bg_parameter.hpp index 368a6614..7cd80c38 100644 --- a/include/game/bases/d_bg_parameter.hpp +++ b/include/game/bases/d_bg_parameter.hpp @@ -25,8 +25,9 @@ class dBgParameter_c { mVec2_c mPos; mVec2_c mSize; mVec2_c mCenter; - u8 mPad2[0x2c]; + u8 mPad2[0x28]; float m_78; + u8 mPad3[0x4]; u8 mScrollDirX; ///< See BG_SCROLL_DIR_X_e. u8 mScrollDirY; ///< See BG_SCROLL_DIR_Y_e. diff --git a/source/dol/bases/d_bg.cpp b/source/dol/bases/d_bg.cpp index 5be22cb1..6952fbae 100644 --- a/source/dol/bases/d_bg.cpp +++ b/source/dol/bases/d_bg.cpp @@ -164,7 +164,7 @@ u64 dBg_c::CvtBgCheckFromUnitNo(u16 num) { return maskedData; } -dBgUnit_c *dBg_c::fn_80077520(u16 x, u16 y, u8 layer, int *param_5, bool b) { +dBgUnit_c *dBg_c::__GetUnitPointer(u16 x, u16 y, u8 layer, int *param_5, bool b) { int file = dScStage_c::m_instance->mCurrFile; dBgUnit_c *bgUnit = dBgGlobal_c::ms_pInstance->GetBgUnitP(file, layer); return bgUnit->GetBuffPos(x, y, param_5, b); @@ -173,7 +173,7 @@ dBgUnit_c *dBg_c::fn_80077520(u16 x, u16 y, u8 layer, int *param_5, bool b) { u16 fn_80081ab0(u16); u16 dBg_c::GetUnitNumber(u16 x, u16 y, u8 layer, bool p4) { - dBgUnit_c *unit = fn_80077520(x, y, layer, 0, false); + dBgUnit_c *unit = __GetUnitPointer(x, y, layer, 0, false); u16 res = -1; if (unit != nullptr) { if (p4) { @@ -195,7 +195,7 @@ u16 dBg_c::GetMaskedUnitNumber(u16 p1, u16 p2, u8 p3) { u64 dBg_c::GetBgCheckData(u16 p1, u16 p2, u8 p3) { int loopPos = dScStage_c::getLoopPosX(p1); - dBgUnit_c *data = fn_80077520(loopPos, p2, p3, 0, false); + dBgUnit_c *data = __GetUnitPointer(loopPos, p2, p3, 0, false); return CvtBgCheckFromUnitNo(data->mUnitNumber); } @@ -243,7 +243,7 @@ void dBg_c::BgUnitChange(u16 p1, u16 p2, int p3, u16 p4) { p4 = 4; } int idk; - dBgUnit_c *unit = fn_80077520(p1, p2, p3, &idk, true); + dBgUnit_c *unit = __GetUnitPointer(p1, p2, p3, &idk, true); if (idk != 0) { u16 smth = 0; if (dBgUnit_c::fn_80081900(unit->mUnitNumber, &smth)) { @@ -317,32 +317,32 @@ void dBg_c::DispScaleCalc() { } void dBg_c::CreateBgTex() { - mTexMng.create(mHeap::g_gameHeaps[2]); + mTexMng.create(mHeap::g_gameHeaps[mHeap::GAME_HEAP_MEM2]); u16 texL = getL() / 16.0f; u16 texU = -getU() / 16.0f; u16 iMu = getU(); u16 iMd = getD(); - u16 iw = cvtW(); - u16 ih = cvtH(); + u16 iw = getR() - getL(); + u16 ih = getU() - getD(); - if (iw % 16U > 0) { - iw = iw >> 4; + if ((iw & 0xF) != 0) { + iw >>= 4; iw++; } else { - iw = iw >> 4; + iw >>= 4; } - if (ih % 16U > 0) { - ih = ih >> 4; + if ((ih & 0xF) != 0) { + ih >>= 4; ih++; } else { - ih = ih >> 4; - if (iMu % 16U > 0) { + ih >>= 4; + if ((iMu & 0xF) != 0) { ih++; } - if (iMd % 16U > 0) { + if ((iMd & 0xF) != 0) { ih++; } } @@ -1065,28 +1065,30 @@ void dBg_c::calcLoopAutoScroll() { } void dBg_c::calcAutoScroll() { - dBgParameter_c *bgParam = dBgParameter_c::ms_Instance_p; + dBgParameter_c *bgParam = dBgParameter_c::getInstance(); float bgW = bgParam->xSize(); float bgH = bgParam->ySize(); sRailInfoData *ri = dRail_c::getRailInfoP(mAutoscrolls[0].m_14); - dScStage_c *stage = dScStage_c::getInstance(); + dScStage_c *stage = dScStage_c::m_instance; dCdFile_c *file = dCd_c::m_instance->getFileP(stage->mCurrFile); float calcArg, calcArg2; - float leftLim, rightLim, upLim, downLim; - leftLim = getLeftLimit(); - rightLim = getRightLimit() - bgW; - downLim = getLimitD() + bgH; - upLim = getLimitU(); - - bool updateX; - bool updateY; + float leftLim = getLeftLimit(); + float rightLim = getRightLimit() - bgW; + float downLim = getLimitD() + bgH; + float upLim = getLimitU(); + + bool cond3, cond4, updateX, updateY; updateX = true; updateY = true; + if (stage->mCurrWorld == WORLD_2 && stage->mCurrCourse == STAGE_CASTLE && stage->mCurrFile == 0) { calcLoopAutoScroll(); - } else if ((dActor_c::mExecStop & 8) == 0 && m_9008c == 0) { + return; + } + + if ((dActor_c::mExecStop & 8) == 0 && m_9008c == 0) { sRailNodeData *base = &file->mpRailNodes[ri->mNodeIdx]; if (m_9008d != 0) { int idx; @@ -1108,132 +1110,133 @@ void dBg_c::calcAutoScroll() { asPos.z = 0.0f; int tmp = m_9007c; int offset = m_90080; - if (offset < 999) { - mVec3_c bgThingVec; - mVec3_c asCopy; - mVec3_c someVec2; - mVec3_c idk; - mVec3_c someVec; - bgThingVec.x = base[tmp].mX; - bgThingVec.y = -(float) base[tmp].mY; - bgThingVec.z = 0.0f; - if (tmp > 0) { - asCopy.x = (&base[tmp] - 1)->mX; - asCopy.y = -(float) (&base[tmp] - 1)->mY; - asCopy.z = 0.0f; - } else { - asCopy = asPos; - } - someVec = bgThingVec - asCopy; - someVec.normalize(); - calcArg = base[tmp].mSpeed; - calcArg2 = base[tmp].mAccel; - someVec2 = bgThingVec - asPos; - someVec2.normalize(); - float len = someVec2.xzLen(); - short ang1 = cM::atan2s(someVec2.y, len); - short ang2 = cM::atan2s(someVec2.x, someVec2.z); - if (m_90080 == 0 && m_9007c <= 1 || mAutoscrolls[0].m_15 != 0) { - m_90088 = ang1; - m_9008a = ang2; - } else { - sLib::addCalcAngle(&m_90088, ang1, 60, 250, 1); - sLib::addCalcAngle(&m_9008a, ang2, 60, 250, 1); - } - idk.x = mAng(m_90088).cos() * mAng(m_9008a).sin(); - idk.y = mAng(m_90088).sin(); - idk.z = mAng(m_90088).cos() * mAng(m_9008a).cos(); - sLib::addCalc(&mAutoscrolls[0].m_0c, calcArg, 1.0f, calcArg2, 0.0001f); - mAutoscrolls[0].mPos.x += idk.x * mAutoscrolls[0].m_0c; - mAutoscrolls[0].mPos.y += idk.y * mAutoscrolls[0].m_0c; - mAutoscrolls[0].mPos.z = 0.0f; - float dist = mAutoscrolls[0].mPos.distTo(bgThingVec); - bool cond3 = false; - bool cond4 = false; - if (mAutoscrolls[0].m_18 == 1) { - cond3 = true; - } else if (mAutoscrolls[0].m_18 == 2) { - cond4 = true; - } - if (( - cond4 || someVec.x == 0.0f || - (someVec.x > 0.0f && mAutoscrolls[0].mPos.x >= bgThingVec.x) || - (someVec.x <= 0.0f && (mAutoscrolls[0].mPos.x <= bgThingVec.x)) - ) && ( - cond3 || someVec.y == 0.0f || - (someVec.y > 0.0f && mAutoscrolls[0].mPos.y >= bgThingVec.y) || - (someVec.y <= 0.0f && (mAutoscrolls[0].mPos.y <= bgThingVec.y)) - )) { - m_9007c++; - if (m_9007c >= ri->mCount) { - switch (mAutoscrolls[0].m_17) { - case 0: - AutoScroll_stop(); - break; - case 1: - m_9007c = mAutoscrolls[0].m_16; - m_90080++; - break; - default: - m_9007c = ri->mCount - 1; - m_90080 = 999; - break; - } - return; + if (offset >= 999) { + return; + } + mVec3_c bgThingVec; + mVec3_c asCopy; + mVec3_c someVec2; + mVec3_c idk; + mVec3_c someVec; + bgThingVec.x = base[tmp].mX; + bgThingVec.y = -(float) base[tmp].mY; + bgThingVec.z = 0.0f; + if (tmp > 0) { + asCopy.x = (&base[tmp] - 1)->mX; + asCopy.y = -(float) (&base[tmp] - 1)->mY; + asCopy.z = 0.0f; + } else { + asCopy = asPos; + } + someVec = bgThingVec - asCopy; + someVec.normalize(); + calcArg = base[tmp].mSpeed; + calcArg2 = base[tmp].mAccel; + someVec2 = bgThingVec - asPos; + someVec2.normalize(); + float len = someVec2.xzLen(); + short ang1 = cM::atan2s(someVec2.y, len); + short ang2 = cM::atan2s(someVec2.x, someVec2.z); + if (m_90080 == 0 && m_9007c <= 1 || mAutoscrolls[0].m_15 != 0) { + m_90088 = ang1; + m_9008a = ang2; + } else { + sLib::addCalcAngle(&m_90088, ang1, 60, 250, 1); + sLib::addCalcAngle(&m_9008a, ang2, 60, 250, 1); + } + idk.x = mAng(m_90088).cos() * mAng(m_9008a).sin(); + idk.y = mAng(m_90088).sin(); + idk.z = mAng(m_90088).cos() * mAng(m_9008a).cos(); + sLib::addCalc(&mAutoscrolls[0].m_0c, calcArg, 1.0f, calcArg2, 0.0001f); + mAutoscrolls[0].mPos.x += idk.x * mAutoscrolls[0].m_0c; + mAutoscrolls[0].mPos.y += idk.y * mAutoscrolls[0].m_0c; + mAutoscrolls[0].mPos.z = 0.0f; + float dist = mAutoscrolls[0].mPos.distTo(bgThingVec); + cond3 = false; + cond4 = false; + if (mAutoscrolls[0].m_18 == 1) { + cond3 = true; + } else if (mAutoscrolls[0].m_18 == 2) { + cond4 = true; + } + if (( + cond4 || someVec.x == 0.0f || + (someVec.x > 0.0f && mAutoscrolls[0].mPos.x >= bgThingVec.x) || + (someVec.x <= 0.0f && (mAutoscrolls[0].mPos.x <= bgThingVec.x)) + ) && ( + cond3 || someVec.y == 0.0f || + (someVec.y > 0.0f && mAutoscrolls[0].mPos.y >= bgThingVec.y) || + (someVec.y <= 0.0f && (mAutoscrolls[0].mPos.y <= bgThingVec.y)) + )) { + m_9007c++; + if (m_9007c >= ri->mCount) { + switch (mAutoscrolls[0].m_17) { + case 0: + AutoScroll_stop(); + break; + case 1: + m_9007c = mAutoscrolls[0].m_16; + m_90080++; + break; + default: + m_9007c = ri->mCount - 1; + m_90080 = 999; + break; } + return; } - mSomeParameterPos = bgParam->mPos; - mVec3_c asPosCopy; - asPosCopy.x = mAutoscrolls[0].mPos.x; - asPosCopy.y = mAutoscrolls[0].mPos.y; - asPosCopy.z = mAutoscrolls[0].mPos.z; - if (asPosCopy.x < leftLim) { - asPosCopy.x = leftLim; - } else if (asPosCopy.x > rightLim) { - asPosCopy.x = rightLim; - } - if (asPosCopy.y < downLim) { - asPosCopy.y = downLim; - } else if (asPosCopy.y > upLim) { - asPosCopy.y = upLim; - } - switch (mAutoscrolls[0].m_18) { - case 0: - updateX = true; - updateY = true; - break; - case 1: - updateX = true; - updateY = false; - break; - case 2: - updateX = false; - updateY = true; - break; - } - if (updateX) { - rightLim = -999999.0f; - for (int i = 0; i < 4; i++) { - dAcPy_c *pl = daPyMng_c::getPlayer(i); - if (pl != nullptr) { - upLim = pl->mPc.m_30.x; - if (upLim > rightLim) { - rightLim = upLim; - } + } + mSomeParameterPos = bgParam->mPos; + mVec3_c asPosCopy; + asPosCopy.x = mAutoscrolls[0].mPos.x; + asPosCopy.y = mAutoscrolls[0].mPos.y; + asPosCopy.z = mAutoscrolls[0].mPos.z; + if (asPosCopy.x < leftLim) { + asPosCopy.x = leftLim; + } else if (asPosCopy.x > rightLim) { + asPosCopy.x = rightLim; + } + if (asPosCopy.y < downLim) { + asPosCopy.y = downLim; + } else if (asPosCopy.y > upLim) { + asPosCopy.y = upLim; + } + switch (mAutoscrolls[0].m_18) { + case 0: + updateX = true; + updateY = true; + break; + case 1: + updateX = true; + updateY = false; + break; + case 2: + updateX = false; + updateY = true; + break; + } + if (updateX) { + rightLim = -999999.0f; + for (int i = 0; i < 4; i++) { + dAcPy_c *pl = daPyMng_c::getPlayer(i); + if (pl != nullptr) { + upLim = pl->mPc.m_30.x; + if (upLim > rightLim) { + rightLim = upLim; } } - mSomePos.x = asPosCopy.x; - } - if (updateY) { - mSomePos.y = asPosCopy.y; } - - float lWidth = mVideo::l_rayoutWidthF; - float lHeight = mVideo::l_rayoutHeightF; - mDispScale = 1.0f / m_bg_p->getZoomTargetMin(); - mSomeSize.x = lWidth * (1.0f / mDispScale); - mSomeSize.y = lHeight * (1.0f / mDispScale); + mSomePos.x = asPosCopy.x; + } + if (updateY) { + mSomePos.y = asPosCopy.y; } + + float lWidth = mVideo::l_rayoutWidthF; + float lHeight = mVideo::l_rayoutHeightF; + mDispScale = 1.0f / m_bg_p->getZoomTargetMin(); + mSomeSize.x = lWidth * (1.0f / mDispScale); + mSomeSize.y = lHeight * (1.0f / mDispScale); } } @@ -1248,6 +1251,8 @@ void dBg_c::AutoScroll_stop() { void dBg_c::calcScroll(const mVec3_c &pos, int param_2) { dBgParameter_c *bgParam = dBgParameter_c::getInstance(); + float bounds40; + float bounds41; float bgVal; float lWidth = mVideo::l_rayoutWidthF; float zoomFactor; @@ -1265,28 +1270,30 @@ void dBg_c::calcScroll(const mVec3_c &pos, int param_2) { m_90018 = mDispScale; mMoreFloats5[1] = mDispScale; - mSomeSize.x = lWidth * (1.0f / mDispScale); - mSomeSize.y = lHeight * (1.0f / mDispScale); + float width = lWidth * (1.0f / mDispScale); + float height = lHeight * (1.0f / mDispScale); + mSomeSize.set(width, height); - float width = mSomeSize.x; float halfWidth = width * 0.5f; + float leftLimit = getLeftLimit(); float rightLimit = getRightLimit() - width; + float upLimit = getLimitU(); + float downLimit = getLimitD() + height; bool cond1 = true; bool cond2 = true; - float upLimit = getLimitU(); - float downLimit = getLimitD() + lHeight; float maxLeft = getMaxLeftPos(); mSomeParameterPos = bgParam->pos(); - mPlayerPosY = pos.y; + bounds40 = mBounds4[0]; + bounds41 = mBounds4[1]; + + float x = pos.x + mBounds4[0] - halfWidth; + float y = pos.y + mSomeSize.y / 2.0f - mBounds4[1]; - float bounds40 = mBounds4[0]; - float bounds41 = mBounds4[1]; - float x = pos.x + bounds40 - halfWidth; - float y = pos.y + (mSomeSize.y / 2) - bounds41; + mPlayerPosY = pos.y; if (dScStage_c::m_loopType != 2) { if (x < leftLimit) { x = leftLimit; @@ -1358,8 +1365,9 @@ void dBg_c::calcScroll(const mVec3_c &pos, int param_2) { mAutoscrolls[0].mPos.y = getSomePosY(); } if (m_900a7 != 0) { - mSomePos.x = m_900ac - getSomeSizeX() * 0.5f; - mSomePos.y = m_900b0 + getSomeSizeY(); + float x = m_900ac.x - mSomeSize.x / 2.0f; + float y = m_900ac.y + mSomeSize.y; + mSomePos.set(x, y); } } fn_8007ca90(&mSomeInfo1, m_90009, 1); @@ -1699,8 +1707,8 @@ void dBg_c::fn_8007ac40(const dBgSomeInfo_c *info, int arg1) { } if (m_900a7 != 0) { - mPrevSomePos.x = m_900ac - 0.5f * mPrevSomeSize.x; - mPrevSomePos.y = m_900b0 + mPrevSomeSize.y; + mPrevSomePos.x = m_900ac.x - 0.5f * mPrevSomeSize.x; + mPrevSomePos.y = m_900ac.y + mPrevSomeSize.y; } // Auto-scroll backup @@ -2014,8 +2022,8 @@ void dBg_c::initScroll() { m_900a6 = 0; m_900a7 = 0; m_900a8 = 0; - m_900ac = 0.0f; - m_900b0 = 0.0f; + m_900ac.x = 0.0f; + m_900ac.y = 0.0f; m_900b8 = 0.0f; m_900bc = 0.0f; From c4fef2f098cde79e37de14e8c0bb436683e2b3d7 Mon Sep 17 00:00:00 2001 From: RootCubed Date: Thu, 7 May 2026 09:15:20 +0200 Subject: [PATCH 24/29] Fix rebase, `dBg_c::calcAutoScroll` matching --- source/dol/bases/d_bg.cpp | 21 +++++++++++---------- 1 file changed, 11 insertions(+), 10 deletions(-) diff --git a/source/dol/bases/d_bg.cpp b/source/dol/bases/d_bg.cpp index 6952fbae..2de9877e 100644 --- a/source/dol/bases/d_bg.cpp +++ b/source/dol/bases/d_bg.cpp @@ -1079,9 +1079,10 @@ void dBg_c::calcAutoScroll() { float downLim = getLimitD() + bgH; float upLim = getLimitU(); - bool cond3, cond4, updateX, updateY; - updateX = true; - updateY = true; + sRailNodeData *base; + + bool updateX = true; + bool updateY = true; if (stage->mCurrWorld == WORLD_2 && stage->mCurrCourse == STAGE_CASTLE && stage->mCurrFile == 0) { calcLoopAutoScroll(); @@ -1089,7 +1090,7 @@ void dBg_c::calcAutoScroll() { } if ((dActor_c::mExecStop & 8) == 0 && m_9008c == 0) { - sRailNodeData *base = &file->mpRailNodes[ri->mNodeIdx]; + base = &file->mpRailNodes[ri->mNodeIdx]; if (m_9008d != 0) { int idx; for (int i = 0; i < 999; i++) { @@ -1152,8 +1153,8 @@ void dBg_c::calcAutoScroll() { mAutoscrolls[0].mPos.y += idk.y * mAutoscrolls[0].m_0c; mAutoscrolls[0].mPos.z = 0.0f; float dist = mAutoscrolls[0].mPos.distTo(bgThingVec); - cond3 = false; - cond4 = false; + bool cond3 = false; + bool cond4 = false; if (mAutoscrolls[0].m_18 == 1) { cond3 = true; } else if (mAutoscrolls[0].m_18 == 2) { @@ -2072,14 +2073,14 @@ float dBg_c::fn_8007c7d0(float x) { } bool isRightPlayer(dAcPy_c *pl1, dAcPy_c *pl2) { - float p1 = dBg_c::m_bg_p->fn_8007c7d0(pl1->m_129c.x); - float p2 = dBg_c::m_bg_p->fn_8007c7d0(pl2->m_129c.x); + float p1 = dBg_c::m_bg_p->fn_8007c7d0(pl1->mPc.m_30.x); + float p2 = dBg_c::m_bg_p->fn_8007c7d0(pl2->mPc.m_30.x); return p1 > p2; } bool isLeftPlayer(dAcPy_c *pl1, dAcPy_c *pl2) { - float p1 = dBg_c::m_bg_p->fn_8007c7d0(pl1->m_129c.x); - float p2 = dBg_c::m_bg_p->fn_8007c7d0(pl2->m_129c.x); + float p1 = dBg_c::m_bg_p->fn_8007c7d0(pl1->mPc.m_30.x); + float p2 = dBg_c::m_bg_p->fn_8007c7d0(pl2->mPc.m_30.x); return p1 < p2; } From 98892dc45b5cf6d77fa36e17c5dec2142aef4564 Mon Sep 17 00:00:00 2001 From: RootCubed Date: Thu, 7 May 2026 11:25:42 +0200 Subject: [PATCH 25/29] `fn_8007ba70`, `fn_8007bba0`, `fn_8007bbf0` matching --- include/game/bases/d_a_player_manager.hpp | 2 +- source/dol/bases/d_bg.cpp | 24 +++++++++++------------ 2 files changed, 13 insertions(+), 13 deletions(-) diff --git a/include/game/bases/d_a_player_manager.hpp b/include/game/bases/d_a_player_manager.hpp index 51fb8eb7..cf7d0321 100644 --- a/include/game/bases/d_a_player_manager.hpp +++ b/include/game/bases/d_a_player_manager.hpp @@ -51,7 +51,7 @@ class daPyMng_c { static int getRest(PLAYER_TYPE_e plrNo) { return mRest[plrNo]; } static PLAYER_TYPE_e getPlayerType(int plrNo) { return mPlayerType[plrNo]; } static int getPlayerMode(int plrNo) { return mPlayerMode[plrNo]; } - static nw4r::math::VEC3 getPlayerSetPos(u8 file, u8 gotoNo); + static mVec3_c getPlayerSetPos(u8 file, u8 gotoNo); static int mNum; static u32 mPauseDisable; diff --git a/source/dol/bases/d_bg.cpp b/source/dol/bases/d_bg.cpp index 2de9877e..be8a3833 100644 --- a/source/dol/bases/d_bg.cpp +++ b/source/dol/bases/d_bg.cpp @@ -1739,8 +1739,8 @@ void dBg_c::fn_8007ba70(const dBgSomeInfo_c *info) { } else { fVar4 = w - (112.0f - dBgParameter_c::ms_Instance_p->getM78()); } + float diff = (smth - fVar4) - mPrevSomePos.x; float tmp = smth - fVar4; - float diff = tmp - mPrevSomePos.x; if (diff > 6.0f) { tmp = mPrevSomePos.x + 6.0f; } else if (diff < -6.0f) { @@ -1759,12 +1759,11 @@ void dBg_c::fn_8007ba70(const dBgSomeInfo_c *info) { } float dBg_c::fn_8007bba0(const dBgSomeInfo_c *info) { - float tmp = 64.0f; - float u = info->mBounds.getU(); + float offset = 64.0f; + float res = info->mBounds.mUp + offset; - float res = u + tmp; - - if (res - mPrevSomePos.y < -6.0f) { + float diff = res - mPrevSomePos.y; + if (diff < -6.0f) { res = mPrevSomePos.y - 6.0f; } @@ -1776,14 +1775,15 @@ float dBg_c::fn_8007bba0(const dBgSomeInfo_c *info) { } float dBg_c::fn_8007bbf0(const dBgSomeInfo_c *info) { - dBgParameter_c *bgParam = dBgParameter_c::getInstance(); + float sizeY = dBgParameter_c::getInstance()->ySize(); - float sizeY = bgParam->ySize(); - float offsY = sizeY - 32.0f; - float res = info->mBounds.getD() + offsY; + float prevPos = mPrevSomePos.y; + float actualSize = sizeY - 32.0f; - if (res - mPrevSomePos.y > 6.0f) { - res = mPrevSomePos.y + 6.0f; + float res = info->mBounds.mDown + actualSize; + float diff = res - prevPos; + if (diff > 6.0f) { + res = prevPos + 6.0f; } if (res < sizeY + mDLimit) { From c8eadbf1f3bf549541407a0d6b1e9d4f3bd52682 Mon Sep 17 00:00:00 2001 From: RootCubed Date: Thu, 7 May 2026 12:13:12 +0200 Subject: [PATCH 26/29] `fn_8007bc40` and `fn_8007bd40` matching --- source/dol/bases/d_bg.cpp | 71 +++++++++++++++++++-------------------- 1 file changed, 34 insertions(+), 37 deletions(-) diff --git a/source/dol/bases/d_bg.cpp b/source/dol/bases/d_bg.cpp index be8a3833..f21cdf6d 100644 --- a/source/dol/bases/d_bg.cpp +++ b/source/dol/bases/d_bg.cpp @@ -1252,8 +1252,6 @@ void dBg_c::AutoScroll_stop() { void dBg_c::calcScroll(const mVec3_c &pos, int param_2) { dBgParameter_c *bgParam = dBgParameter_c::getInstance(); - float bounds40; - float bounds41; float bgVal; float lWidth = mVideo::l_rayoutWidthF; float zoomFactor; @@ -1279,22 +1277,26 @@ void dBg_c::calcScroll(const mVec3_c &pos, int param_2) { float leftLimit = getLeftLimit(); float rightLimit = getRightLimit() - width; - float upLimit = getLimitU(); float downLimit = getLimitD() + height; + float upLimit = getLimitU(); - bool cond1 = true; - bool cond2 = true; + bool updateX = true; + bool updateY = true; float maxLeft = getMaxLeftPos(); + float posX = pos.x; + float posY = pos.y; mSomeParameterPos = bgParam->pos(); - bounds40 = mBounds4[0]; - bounds41 = mBounds4[1]; + mPlayerPosY = pos.y; - float x = pos.x + mBounds4[0] - halfWidth; - float y = pos.y + mSomeSize.y / 2.0f - mBounds4[1]; + float bounds40 = mBounds4[0]; + float bounds41 = mBounds4[1]; + + float halfHeight = getSomeSizeY() * 0.5f; + float x = posX + mBounds4[0] - halfWidth; + float y = posY + halfHeight - mBounds4[1]; - mPlayerPosY = pos.y; if (dScStage_c::m_loopType != 2) { if (x < leftLimit) { x = leftLimit; @@ -1322,23 +1324,23 @@ void dBg_c::calcScroll(const mVec3_c &pos, int param_2) { if (mAutoscrolls[0].mActive) { switch (mAutoscrolls[0].m_18) { case 0: - cond1 = false; - cond2 = false; + updateX = false; + updateY = false; break; case 1: - cond1 = false; - cond2 = true; + updateX = false; + updateY = true; break; case 2: - cond1 = true; - cond2 = false; + updateX = true; + updateY = false; break; } } - if (cond1) { + if (updateX) { mSomePos.x = x; } - if (cond2) { + if (updateY) { if ( getAreaUpLimitScroll() > -999999.0f && dBgParameter_c::getInstance()->posY() <= getAreaUpLimitScroll() && @@ -1366,9 +1368,9 @@ void dBg_c::calcScroll(const mVec3_c &pos, int param_2) { mAutoscrolls[0].mPos.y = getSomePosY(); } if (m_900a7 != 0) { - float x = m_900ac.x - mSomeSize.x / 2.0f; - float y = m_900ac.y + mSomeSize.y; - mSomePos.set(x, y); + mSomePos = m_900ac; + mSomePos.x = getSomePosX() - getSomeSizeX() * 0.5f; + mSomePos.y = getSomePosY() + getSomeSizeY(); } } fn_8007ca90(&mSomeInfo1, m_90009, 1); @@ -1801,18 +1803,16 @@ bool dBg_c::fn_8007bc40(const dBgSomeInfo_c *info, float f) { dBgParameter_c *bgParam = dBgParameter_c::getInstance(); - float tmp = 112.0f; - float fVar3 = tmp - bgParam->m_78; - float fVar4 = tmp - bgParam->m_78; + float fVar3 = 112.0f - bgParam->getM78(); + float fVar4 = fVar3; if (fVar1 < ll + fVar4) { fVar3 = fVar1 - ll; } - float tmp2 = 112.0f; - float fVar5 = tmp2 - bgParam->m_78; + float fVar5 = 112.0f - bgParam->getM78(); if (fVar2 > rl - fVar5) { fVar4 = rl - fVar2; } - if (f * mVideo::getLayoutWidth() - (fVar3 + fVar4) > info->mBounds.getR() - info->mBounds.getL()) { + if (info->mBounds.getW() > f * mVideo::getLayoutWidth() - (fVar3 + fVar4)) { return true; } else { return false; @@ -1842,12 +1842,10 @@ mVec2_c dBg_c::fn_8007bd40(const dBgSomeInfo_c *info, float f1, float f2) { } float baseX = info->mBounds.getW(); - float tmpX = (offsX1 + baseX + offsX2) / layoutWidth; - - float resX = info->mBounds.getR(); - if (tmpX < 1.0f) { + float resX = (offsX1 + baseX + offsX2) / layoutWidth; + if (resX < 1.0f) { resX = 1.0f; - } else if (tmpX > f1) { + } else if (resX > f1) { resX = f1; } @@ -1863,12 +1861,11 @@ mVec2_c dBg_c::fn_8007bd40(const dBgSomeInfo_c *info, float f1, float f2) { } float baseY = info->mBounds.getH(); - float tmpY = (offsY1 + baseY + offsY2) * f2 / layoutHeight; - - float resY = info->mBounds.getD(); - if (tmpY < 1.0f) { + float tmp = offsY1 + baseY + offsY2; + float resY = tmp * f2 / layoutHeight; + if (resY < 1.0f) { resY = 1.0f; - } else if (tmpY > f1) { + } else if (resY > f1) { resY = f1; } result.x = resX; From 5ec490aae61aa08aff14873d9983c96d3c56091a Mon Sep 17 00:00:00 2001 From: RootCubed Date: Thu, 7 May 2026 22:10:06 +0200 Subject: [PATCH 27/29] `dBg_c::fn_8007cd70` matching --- include/game/bases/d_bg.hpp | 4 +- source/dol/bases/d_bg.cpp | 195 +++++++++++++++++++++--------------- 2 files changed, 116 insertions(+), 83 deletions(-) diff --git a/include/game/bases/d_bg.hpp b/include/game/bases/d_bg.hpp index 25ad07c7..eaca75ae 100644 --- a/include/game/bases/d_bg.hpp +++ b/include/game/bases/d_bg.hpp @@ -227,8 +227,8 @@ class dBg_c : public dBase_c { u16 cvtW() { return getR() - getL(); } u16 cvtH() { return getU() - getD(); } - float getLimitD() { return mDLimit; } - float getLimitU() { return mULimit; } + float getDownLimit() { return mDLimit; } + float getUpLimit() { return mULimit; } float getSomePosX() { return mSomePos.x; } float getSomePosY() { return mSomePos.y; } diff --git a/source/dol/bases/d_bg.cpp b/source/dol/bases/d_bg.cpp index f21cdf6d..110bb70b 100644 --- a/source/dol/bases/d_bg.cpp +++ b/source/dol/bases/d_bg.cpp @@ -1002,7 +1002,7 @@ void dBg_c::calcLoopAutoScroll() { unitVec.x = 1.0f; unitVec.y = 0.0f; - float actualY = bgParam->ySize() + getLimitD(); + float actualY = bgParam->ySize() + getDownLimit(); mVec3_c pos; pos.x = mAutoscrolls[0].mPos.x; @@ -1076,8 +1076,8 @@ void dBg_c::calcAutoScroll() { float calcArg, calcArg2; float leftLim = getLeftLimit(); float rightLim = getRightLimit() - bgW; - float downLim = getLimitD() + bgH; - float upLim = getLimitU(); + float downLim = getDownLimit() + bgH; + float upLim = getUpLimit(); sRailNodeData *base; @@ -1277,8 +1277,8 @@ void dBg_c::calcScroll(const mVec3_c &pos, int param_2) { float leftLimit = getLeftLimit(); float rightLimit = getRightLimit() - width; - float downLimit = getLimitD() + height; - float upLimit = getLimitU(); + float downLimit = getDownLimit() + height; + float upLimit = getUpLimit(); bool updateX = true; bool updateY = true; @@ -1827,8 +1827,8 @@ mVec2_c dBg_c::fn_8007bd40(const dBgSomeInfo_c *info, float f1, float f2) { float ll = getLeftLimit(); float rl = getRightLimit(); - float uLim = getLimitU(); - float dLim = getLimitD(); + float uLim = getUpLimit(); + float dLim = getDownLimit(); float tmpLeft = info->mBounds.getL() - 112.0f; float tmpRight = info->mBounds.getR() + 112.0f; @@ -2203,11 +2203,40 @@ void dBg_c::fn_8007ca90(dBgSomeInfo_c *info, int i1, int i2) { } void dBg_c::fn_8007cd70(dBgSomeInfo_c *info1, dBgSomeInfo_c *info2, int i1) { - float px = dBgParameter_c::getInstance()->mPos.x; - float py = dBgParameter_c::getInstance()->mPos.y; - float sx = dBgParameter_c::getInstance()->mSize.x; - float sy = dBgParameter_c::getInstance()->mSize.y; - bool cond = false; + float f23; + float fVar7; + float fVar6; + float fVar5; + float tmp1; + float tmp2; + float f22; + float f21; + float calcScale; + float fVar12; + float fVar13; + float f17; + float calcArg1; + float calcArg2; + float calcArg3; + float w1; + float h1; + float w2; + float h2; + float dw; + float dh; + float len; + float sx; + float sy; + float px; + float py; + bool cond; + bool cond2; + dBgParameter_c *bgParam2 = dBgParameter_c::getInstance(); + px = bgParam2->mPos.x; + py = bgParam2->mPos.y; + sx = bgParam2->mSize.x; + sy = bgParam2->mSize.y; + cond2 = false; if ((dActor_c::mExecStop & 2) != 0) { return; } @@ -2220,28 +2249,33 @@ void dBg_c::fn_8007cd70(dBgSomeInfo_c *info1, dBgSomeInfo_c *info2, int i1) { } if ( info1->m_30 != info2->m_30 && - info1->m_20 != info2->m_20 || + (info1->m_20 != info2->m_20 || info1->m_24 != info2->m_24 || info1->m_28 != info2->m_28 || - info1->m_2c != info2->m_2c + info1->m_2c != info2->m_2c) ) { - cond = true; + cond2 = true; } - bool cond2 = false; + cond = false; + float fVar4 = 32.0f; bool bVar14 = false; info1->m_20 = info2->m_20; info1->m_24 = info2->m_24; info1->m_28 = info2->m_28; info1->m_2c = info2->m_2c; info1->m_30 = info2->m_30; + float bl = info1->mBounds.getL(); + float l = info2->mBounds.getL(); + float br = info1->mBounds.getR(); + float r = info2->mBounds.getR(); + float bu = info1->mBounds.getU(); + float u = info2->mBounds.getU(); + float bd = info1->mBounds.getD(); + float d = info2->mBounds.getD(); + float tmpx = (bl + br) * 0.5f; + float tmpy = (bu + bd) * 0.5f; dBgParameter_c *bgParam = dBgParameter_c::getInstance(); - dScStage_c *stage = dScStage_c::m_instance; - dBgBound_c b = info1->mBounds; - mVec2_c tmp((b.mLeft + b.mRight) * 0.5f, (b.mUp + b.mDown) * 0.5f); - float l = info2->mBounds.mLeft; - float r = info2->mBounds.mRight; - float u = info2->mBounds.mUp; - float d = info2->mBounds.mDown; + dScStage_c *stage = dScStage_c::getInstance(); if (l < px) { l = px; } @@ -2254,52 +2288,50 @@ void dBg_c::fn_8007cd70(dBgSomeInfo_c *info1, dBgSomeInfo_c *info2, int i1) { if (d < py - sy) { d = py - sy; } - float fVar4 = 32.0f; if (dScStage_c::m_loopType == 2 || i1 == 1) { info1->mBounds.mRight = r; - info1->mBounds.mLeft = l; - info1->mBounds.mUp = u + 8.0f; + info1->mBounds.mLeft = l + 8.0f; + info1->mBounds.mUp = u; info1->mBounds.mDown = d; } else { if (m_90009 == 3) { fVar4 = 80.0f; } - if (b.mUp > u && py - fVar4 > u || d < b.mDown && d < fVar4 + (py - sy)) { - cond2 = true; + if (u > bu && u > py - fVar4 || d < bd && d < fVar4 + (py - sy)) { + cond = true; } - float w1 = (info1->mBounds.mRight + info1->mBounds.mLeft) * 0.5f; - float h1 = (info1->mBounds.mUp + info1->mBounds.mDown) * 0.5f; - float w2 = (info2->mBounds.mRight + info2->mBounds.mLeft) * 0.5f; - float h2 = (info2->mBounds.mUp + info2->mBounds.mDown) * 0.5f; - float dw = w2 - w1; - float dh = h2 - h1; - float len = sqrt(dw * dw + dh * dh); + w1 = (info1->mBounds.getR() + info1->mBounds.getL()) * 0.5f; + h1 = (info1->mBounds.getU() + info1->mBounds.getD()) * 0.5f; + w2 = (info2->mBounds.getR() + info2->mBounds.getL()) * 0.5f; + h2 = (info2->mBounds.getU() + info2->mBounds.getD()) * 0.5f; + len = sqrt((w2 - w1) * (w2 - w1) + (h2 - h1) * (h2 - h1)); if (len != 0.0f) { dw = (w2 - w1) / len; dh = (h2 - h1) / len; } else { - dh = 1.0f; dw = 1.0f; + dh = 1.0f; } - float fVar5 = std::fabs(dw); - float fVar6, fVar7; - float fVar12 = fVar5 * 6.0f; - float fVar13 = std::fabs(dh) * 12.0f; + calcScale = 0.5f; + fVar5 = std::fabs(dw); + fVar6 = std::fabs(dh); + fVar12 = 6.0f * fVar5; + fVar13 = std::fabs(dh) * 12.0f; if (stage->mCurrWorld == WORLD_8 && stage->mCurrCourse == STAGE_7 || cond) { - fVar6 = 6.0f; + f23 = 0.5f; fVar7 = 0.5f; - fVar5 *= 6.0f; + fVar5 = 6.0f * fVar5; + f21 = 6.0f * fVar6; } else { - fVar6 = 2.0f; - fVar7 = 0.2f; + f21 = 2.0f * fVar6; + f23 = 0.2f; + fVar7 = 0.5f; } - fVar6 *= std::fabs(dh); - float calcArg1 = 0.1f; - float calcArg2 = 0.005f; - float calcArg3 = 0.0001f; - float calcScale = 0.5f; - float calcAdd = 0.5f; + f17 = 0.0f; + calcArg1 = 0.1f; + calcArg2 = 0.005f; + calcArg3 = 0.0001f; if (cond2) { mIdkI = 120; mIdkF[0] = 1.0f; @@ -2309,72 +2341,73 @@ void dBg_c::fn_8007cd70(dBgSomeInfo_c *info1, dBgSomeInfo_c *info2, int i1) { } if (mIdkI != 0) { mIdkI--; - fVar4 = 1.0f; + f17 = 1.0f; } - float tmp1, tmp2; - - if (l < b.mLeft) { + if (l < bl) { sLib::addCalc(&mIdkF[0], 0.0f, calcArg1, calcArg2, calcArg3); - } else if (l > bgParam->mPos.x + bgParam->mSize.x / 2.0f) { + } else if (l > bgParam->xStart() + bgParam->xSize() * 0.5f) { sLib::addCalc(&mIdkF[0], 0.0f, calcArg1, calcArg2, calcArg3); } else { - sLib::addCalc(&mIdkF[0], fVar4, calcArg1, calcArg2, calcArg3); + sLib::addCalc(&mIdkF[0], f17, calcArg1, calcArg2, calcArg3); } - tmp1 = mIdkF[0] * (fVar7 - calcScale) + calcAdd; + tmp1 = mIdkF[0] * (f23 - calcScale) + calcScale; tmp2 = fVar12 + mIdkF[0] * (fVar5 - fVar12); - sLib::addCalc(&b.mLeft, l, tmp1, tmp2, 0.1f); + sLib::addCalc(&bl, l, tmp1, tmp2, 0.1f); - if (r > b.mRight) { + if (r > br) { sLib::addCalc(&mIdkF[1], 0.0f, calcArg1, calcArg2, calcArg3); - } else if (r < bgParam->mPos.x + bgParam->mSize.x / 2.0f) { + } else if (r < bgParam->xStart() + bgParam->xSize() * 0.5f) { sLib::addCalc(&mIdkF[1], 0.0f, calcArg1, calcArg2, calcArg3); } else { - sLib::addCalc(&mIdkF[1], fVar4, calcArg1, calcArg2, calcArg3); + sLib::addCalc(&mIdkF[1], f17, calcArg1, calcArg2, calcArg3); } - tmp1 = mIdkF[1] * (fVar7 - calcScale) + calcAdd; + tmp1 = mIdkF[1] * (f23 - calcScale) + calcScale; tmp2 = fVar12 + mIdkF[1] * (fVar5 - fVar12); - sLib::addCalc(&b.mRight, l, tmp1, tmp2, 0.1f); + sLib::addCalc(&br, r, tmp1, tmp2, 0.1f); - if (u > b.mUp) { + if (u > bu) { sLib::addCalc(&mIdkF[2], 0.0f, calcArg1, calcArg2, calcArg3); - } else if (u < bgParam->mPos.y - bgParam->mSize.y / 2.0f) { + } else if (u < bgParam->yStart() - bgParam->ySize() * 0.5f) { sLib::addCalc(&mIdkF[2], 0.0f, calcArg1, calcArg2, calcArg3); } else { - sLib::addCalc(&mIdkF[2], fVar4, calcArg1, calcArg2, calcArg3); + sLib::addCalc(&mIdkF[2], f17, calcArg1, calcArg2, calcArg3); } - tmp1 = mIdkF[2] * (fVar7 - calcScale) + calcAdd; - tmp2 = fVar13 + mIdkF[2] * (fVar5 - fVar13); - sLib::addCalc(&b.mUp, l, tmp1, tmp2, 0.1f); + tmp1 = mIdkF[2] * (fVar7 - calcScale) + calcScale; + tmp2 = fVar13 + mIdkF[2] * (f21 - fVar13); + sLib::addCalc(&bu, u, tmp1, tmp2, 0.1f); - if (d < b.mDown) { + if (d < bd) { sLib::addCalc(&mIdkF[3], 0.0f, calcArg1, calcArg2, calcArg3); - } else if (d > bgParam->mPos.y - bgParam->mSize.y / 2.0f) { + } else if (d > bgParam->yStart() - bgParam->ySize() * 0.5f) { sLib::addCalc(&mIdkF[3], 0.0f, calcArg1, calcArg2, calcArg3); } else { - sLib::addCalc(&mIdkF[3], fVar4, calcArg1, calcArg2, calcArg3); + sLib::addCalc(&mIdkF[3], f17, calcArg1, calcArg2, calcArg3); } - tmp1 = mIdkF[3] * (fVar7 - calcScale) + calcAdd; - tmp2 = fVar13 + mIdkF[3] * (fVar5 - fVar13); - sLib::addCalc(&b.mDown, l, tmp1, tmp2, 0.1f); + tmp1 = mIdkF[3] * (fVar7 - calcScale) + calcScale; + tmp2 = fVar13 + mIdkF[3] * (f21 - fVar13); + sLib::addCalc(&bd, d, tmp1, tmp2, 0.1f); - info1->mBounds = b; + info1->mBounds.mLeft = bl; + info1->mBounds.mRight = br; + info1->mBounds.mUp = bu; + info1->mBounds.mDown = bd; } float r2 = info1->mBounds.mRight; float l2 = info1->mBounds.mLeft; - float u2 = info1->mBounds.mUp; float d2 = info1->mBounds.mDown; + float u2 = info1->mBounds.mUp; float h_lr = (l2 + r2) * 0.5f; float h_ud = (u2 + d2) * 0.5f; - if (m_bg_p->getLeftLimit() <= px || px + sx <= m_bg_p->getRightLimit()) { + if (px <= m_bg_p->getLeftLimit() || px + sx >= m_bg_p->getRightLimit()) { m_bg_p->m_900b8 = 0.0f; } else { - m_bg_p->m_900b8 = h_lr - tmp.x; + m_bg_p->m_900b8 = h_lr - tmpx; } - if (py >= m_bg_p->mULimit || py - sy <= m_bg_p->mDLimit) { + if (py >= m_bg_p->getUpLimit() || py - sy <= m_bg_p->getDownLimit()) { m_bg_p->m_900bc = 0.0f; } else { - m_bg_p->m_900bc = h_ud - tmp.y; + m_bg_p->m_900bc = h_ud - tmpy; } } From 22da619c1c2fcee1ce6e278a47703539c0abe547 Mon Sep 17 00:00:00 2001 From: RootCubed Date: Fri, 8 May 2026 10:25:52 +0200 Subject: [PATCH 28/29] Continue progress --- include/game/bases/d_bg.hpp | 6 + include/game/bases/d_bg_parameter.hpp | 1 + source/dol/bases/d_bg.cpp | 327 ++++++++++++++++---------- 3 files changed, 208 insertions(+), 126 deletions(-) diff --git a/include/game/bases/d_bg.hpp b/include/game/bases/d_bg.hpp index eaca75ae..a31398f5 100644 --- a/include/game/bases/d_bg.hpp +++ b/include/game/bases/d_bg.hpp @@ -232,8 +232,14 @@ class dBg_c : public dBase_c { float getSomePosX() { return mSomePos.x; } float getSomePosY() { return mSomePos.y; } + float getPrevSomePosX() { return mPrevSomePos.x; } + float getPrevSomePosY() { return mPrevSomePos.y; } float getSomeSizeX() { return mSomeSize.x; } float getSomeSizeY() { return mSomeSize.y; } + float getPrevSomeSizeX() { return mPrevSomeSize.x; } + float getPrevSomeSizeY() { return mPrevSomeSize.y; } + + float getSomeScale() { return mSomeScale; } float getLoopOffsetX() { return mLoopOffsetX; } diff --git a/include/game/bases/d_bg_parameter.hpp b/include/game/bases/d_bg_parameter.hpp index 7cd80c38..99d0c020 100644 --- a/include/game/bases/d_bg_parameter.hpp +++ b/include/game/bases/d_bg_parameter.hpp @@ -36,6 +36,7 @@ class dBgParameter_c { const mVec2_c &pos() const { return mPos; } const mVec2_c &size() const { return mSize; } float getM78() const { return m_78; } + float getM34() const { return m_30.y; } float posX() const { return mPos.x; } float posY() const { return mPos.y; } diff --git a/source/dol/bases/d_bg.cpp b/source/dol/bases/d_bg.cpp index 110bb70b..d0f0f6c3 100644 --- a/source/dol/bases/d_bg.cpp +++ b/source/dol/bases/d_bg.cpp @@ -1252,28 +1252,29 @@ void dBg_c::AutoScroll_stop() { void dBg_c::calcScroll(const mVec3_c &pos, int param_2) { dBgParameter_c *bgParam = dBgParameter_c::getInstance(); - float bgVal; - float lWidth = mVideo::l_rayoutWidthF; - float zoomFactor; - float lHeight = mVideo::l_rayoutHeightF; + float maxLeft; + float lWidth = mVideo::getLayoutWidth(); + float lHeight = mVideo::getLayoutHeight(); if (m_bg_p->m_9095a == 0) { m_bg_p->getZoomTargetMax(); // unused return value - zoomFactor = mSomeScale; if (mSomeScale > 0.0f) { dBg_c *bg = m_bg_p; - bgVal = dBgParameter_c::ms_Instance_p->m_30.y; - float tmp2 = bgVal * (1.0f / zoomFactor - bg->invZoomTargetMin()); - mDispScale = tmp2 + bg->invZoomTargetMin(); + float bgVal = dBgParameter_c::ms_Instance_p->getM34(); + float scale = getSomeScale(); + float b = bgVal * (1.0f / scale - 1.0f / bg->getZoomTargetMin()); + float a = 1.0f / bg->getZoomTargetMin(); + mDispScale = a + b; } m_90018 = mDispScale; mMoreFloats5[1] = mDispScale; - float width = lWidth * (1.0f / mDispScale); - float height = lHeight * (1.0f / mDispScale); - mSomeSize.set(width, height); + mSomeSize.x = lWidth * (1.0f / mDispScale); + mSomeSize.y = lHeight * (1.0f / mDispScale); + float width = getSomeSizeX(); + float height = getSomeSizeY(); - float halfWidth = width * 0.5f; + float halfWidth = getSomeSizeX() * 0.5f; float leftLimit = getLeftLimit(); float rightLimit = getRightLimit() - width; @@ -1283,19 +1284,18 @@ void dBg_c::calcScroll(const mVec3_c &pos, int param_2) { bool updateX = true; bool updateY = true; - float maxLeft = getMaxLeftPos(); + maxLeft = getMaxLeftPos(); - float posX = pos.x; - float posY = pos.y; - mSomeParameterPos = bgParam->pos(); - mPlayerPosY = pos.y; + mSomeParameterPos.x = bgParam->pos().x; + float x = pos.x + mBounds4[0] - halfWidth; + + mSomeParameterPos.y = bgParam->pos().y; + float y = pos.y + getSomeSizeY() * 0.5f - mBounds4[1]; float bounds40 = mBounds4[0]; float bounds41 = mBounds4[1]; - float halfHeight = getSomeSizeY() * 0.5f; - float x = posX + mBounds4[0] - halfWidth; - float y = posY + halfHeight - mBounds4[1]; + mPlayerPosY = pos.y; if (dScStage_c::m_loopType != 2) { if (x < leftLimit) { @@ -1356,7 +1356,8 @@ void dBg_c::calcScroll(const mVec3_c &pos, int param_2) { } } if (mLimitRelated == 1 || mLimitRelated == 4) { - mSomePos.x = maxLeft + getLoopOffsetX() * 0.5f - getSomeSizeX() * 0.5f; + maxLeft += getLoopOffsetX() * 0.5f; + mSomePos.x = maxLeft - getSomeSizeX() * 0.5f; } if (mLimitRelated == 6) { mSomePos.y = getD() + getSomeSizeY(); @@ -1391,18 +1392,33 @@ void dBg_c::calcMultiScroll(int arg1) { } void dBg_c::fn_8007ac40(const dBgSomeInfo_c *info, int arg1) { - // dBgBound_c b = info->mBounds; - - float boundScale = 0.5f; + float br = info->mBounds.getR(); + float bl = info->mBounds.getL(); + float bu = info->mBounds.getU(); + float bd = info->mBounds.getD(); + float val; + float fVar28; + float fVar25; + float copy_90018; + float f26; + float f27; + float lowerBound; + float upperBound; + float finalY; - float lWidth = mVideo::getLayoutWidth(); - float lHeight = mVideo::getLayoutHeight(); + float lWidth = mVideo::l_rayoutWidthF; + float lHeight = mVideo::l_rayoutHeightF; float invScale = 1.0f / mDispScale; float zoom = 1.0f / mZoomDenom; - float tmpRight = std::fabs(info->mBounds.mRight - info->mBounds.mLeft) / lWidth; - float tmpUp = std::fabs(info->mBounds.mUp - info->mBounds.mDown) / lHeight; + float boundScale = 0.5f; + float tmpRight = std::fabs(bl - br) / lWidth; + float tmpUp = std::fabs(bd - bu) / lHeight; + + float scale; + float someTmp2; + float someTmp; float spL = m_bg_p->getZoomSpreadLine(); float spL2 = m_bg_p->getZoomSpreadLine2(); @@ -1415,57 +1431,55 @@ void dBg_c::fn_8007ac40(const dBgSomeInfo_c *info, int arg1) { dScStage_c *stage = dScStage_c::m_instance; bool bVar7 = false; - - float scale; if (mLimitRelated == 1) { scale = 1.2f; } else { scale = 0.9f; } - float someTmp2 = tmpUp * scale; + someTmp2 = tmpUp * scale; mVec2_c r = fn_8007bd40(info, zoom, scale); - float someTmp = tmpRight; + someTmp = tmpRight; if (mLimitRelated == 1) { r.x = r.y; someTmp = someTmp2; } - if (mLimitRelated2 >= 6 && mLimitRelated2 <= 7) { + if (mLimitRelated >= 6 && mLimitRelated <= 7) { r.y = r.x - 1.0f; someTmp2 = someTmp; } if (mLimitRelated == 2) { if (mLimitRelated2 >= 5 && mLimitRelated2 <= 7 || mLimitRelated2 >= 1 && mLimitRelated2 <= 2) { - if (invScale < m_bg_p->getZoomTargetMax() && spL2 > someTmp) { + if (invScale < m_bg_p->getZoomTargetMax() && someTmp > spL2) { someTmp = spL2; } - if (!dBg_isFlyPlayer() && mU8s[2] == 0 && spL2 > someTmp2) { + if (!dBg_isFlyPlayer() && mU8s[2] == 0 && someTmp2 > spL2) { someTmp2 = spL2; } } else { - if (invScale <= m_bg_p->getZoomTargetMid() && spL > someTmp) { + if (invScale <= m_bg_p->getZoomTargetMid() && someTmp > spL) { someTmp = spL; } - if (!dBg_isFlyPlayer() && mU8s[2] == 0 && spL > someTmp2) { + if (!dBg_isFlyPlayer() && mU8s[2] == 0 && someTmp2 > spL) { someTmp2 = spL; } } } if (mLimitRelated == 0 && mLimitRelated2 == 10) { if (dBg_isCloudFlyPlayerMulti() != 1) { - someTmp = shL2 - 0.01f; - if (someTmp2 > someTmp || m_9095b != 0) { - someTmp = spL2 + 0.01f; + float tmp = shL2 - 0.01f; + if (someTmp > tmp || m_9095b != 0) { + someTmp = tmp; } + } else { + someTmp = spL2 + 0.01f; } someTmp2 = someTmp - 1.0f; } - if (someTmp2 > someTmp) { - someTmp2 = someTmp; - } + someTmp = MAX(someTmp, someTmp2); if ((daPyDemoMng_c::mspInstance->mFlags & 1) == 0) { switch (m_90024) { case 0: - if (someTmp2 > spL) { + if (someTmp > spL) { mMoreFloats5[0] = tgMid; m_90024 = 1; } else { @@ -1473,39 +1487,36 @@ void dBg_c::fn_8007ac40(const dBgSomeInfo_c *info, int arg1) { } break; case 1: - if (someTmp2 > spL2) { + if (someTmp > spL2) { mMoreFloats5[0] = tgMax; m_90024 = 2; - } else if (someTmp2 < shL) { + } else if (someTmp < shL) { bVar7 = true; if (m_900b6 > 120) { mMoreFloats5[0] = tgMin; m_90024 = 0; } - } else if (someTmp2 > spL) { + } else if (!(someTmp < spL)) { mMoreFloats5[0] = tgMid; } break; case 2: - if (someTmp2 > shL2) { + if (someTmp < shL2) { bVar7 = true; if (m_900b6 > 120) { mMoreFloats5[0] = tgMid; m_90024 = 1; } - } else if (someTmp2 > spL2) { + } else if (!(someTmp < spL2)) { mMoreFloats5[0] = tgMax; } break; } if (mMoreFloats5[0] == tgMax) { - if (mMoreFloats5[2] != tgMid) { - // info->mBounds.mRight = m_90018; - if (mMoreFloats5[1] <= info->mBounds.mRight) { - mMoreFloats5[1] = info->mBounds.mRight; - } - mMoreFloats5[2] = tgMid; + if (mMoreFloats5[2] != tgMid && m_90018 >= mMoreFloats5[1]) { + mMoreFloats5[1] = m_90018; } + mMoreFloats5[2] = tgMid; } else { mMoreFloats5[2] = tgMin; } @@ -1517,36 +1528,39 @@ void dBg_c::fn_8007ac40(const dBgSomeInfo_c *info, int arg1) { } else { mMoreFloats5[0] = m_90018; } - float fVar28 = mMoreFloats5[0]; - float fVar25 = m_90018; - if (mMoreFloats5[0] > m_90018) { + fVar28 = mMoreFloats5[0]; + fVar25 = m_90018; + if (m_90018 < mMoreFloats5[0]) { fVar25 = 0.25f; - float calcArg = 0.0015f; float scale = 0.003f; + float calcArg = 0.0015f; if (mZoomRelated != 0 && mZoomRelated != 8) { fVar25 = 1.0f; calcArg = 0.1; scale = 1.0f; } - sLib::addCalc(&m_90018, fVar28, fVar25, scale * (someTmp2 * someTmp2 * someTmp2 * 6.0f + 1.0f), calcArg); - fVar25 = m_90018; - if (fVar25 > mMoreFloats5[1]) { - if (std::fabs(fVar28 - fVar25) > 0.1f) { + float cubed = someTmp * someTmp * someTmp; + float maxStep = cubed * 6.0f + 1.0f; + sLib::addCalc(&mMoreFloats5[1], fVar28, fVar25, scale * maxStep, calcArg); + if (mMoreFloats5[1] > m_90018) { + if (std::fabs(fVar28 - m_90018) > 0.1f) { m_9001c = 90; } m_90018 = mMoreFloats5[1]; } - } else if (mMoreFloats5[0] > m_90018) { + } else if (m_90018 > mMoreFloats5[0]) { fVar25 = 0.5f; - float calcArg = 0.0015f; float scale = 0.003f; + float calcArg = 0.0015f; if (mZoomRelated != 0 && mZoomRelated != 8) { fVar25 = 1.0f; calcArg = 0.1; scale = 1.0f; } + // TODO: someTmp + float maxStep = someTmp2 * someTmp2 * someTmp2 * 6.0f + 1.0f; if (m_9001c == 0) { - sLib::addCalc(&m_90018, fVar28, fVar25, scale * (someTmp2 * someTmp2 * someTmp2 * 6.0f + 1.0f), calcArg); + sLib::addCalc(&m_90018, fVar28, fVar25, scale * maxStep, calcArg); } mMoreFloats5[1] = mMoreFloats5[2]; } else { @@ -1558,18 +1572,19 @@ void dBg_c::fn_8007ac40(const dBgSomeInfo_c *info, int arg1) { if (m_90018 > zoom) { m_90018 = zoom; } - if (m_90018 < zoom) { - m_90018 = zoom; + if (m_90018 < tgMin) { + m_90018 = tgMin; } else if (m_90018 > tgMax) { m_90018 = tgMax; } - float copy_90018 = m_90018; - float val = -(mDLimit - mULimit); + copy_90018 = m_90018; + val = -(getDownLimit() - getUpLimit()); if (val < m_90018 * mVideo::getLayoutHeight()) { - m_90018 = m_90018 / mVideo::getLayoutHeight(); + copy_90018 = val / mVideo::getLayoutHeight(); + m_90018 = copy_90018; } if (getAreaUpLimitScroll() > -999999.0f) { - float divres = (mD - getAreaUpLimitScroll()) / mVideo::getLayoutHeight(); + float divres = -(getD() - getAreaUpLimitScroll()) / mVideo::getLayoutHeight(); if (mU8s[2] == 0) { m_90964 = 1.0f; } else { @@ -1580,22 +1595,28 @@ void dBg_c::fn_8007ac40(const dBgSomeInfo_c *info, int arg1) { mPrevSomeSize.x = lWidth * copy_90018; mPrevSomeSize.y = lHeight * copy_90018; mDispScale = 1.0f / copy_90018; - fVar28 *= boundScale; + float f18 = mPrevSomeSize.x * boundScale; + float f19 = mPrevSomeSize.y * boundScale; float mLP = getMaxLeftPos(); float mRP = getMaxRightPos(); - float w = (info->mBounds.mRight + info->mBounds.mLeft) * 0.5f; float u = mU; float d = mD; + float tmpcalc = info->mBounds.getU() + info->mBounds.getD(); + float wo = info->mBounds.getR() + info->mBounds.getL(); + float w = wo * 0.5f; + float asdf = tmpcalc * 0.5f; + float x123 = w - f18; + float x234 = tmpcalc + f18; if (dScStage_c::m_loopType != 2) { - if (mLP > w - fVar28) { - w += mLP - (w - fVar28); - } else if (mRP < w + fVar28) { - w -= (w + fVar28) - mRP; + if (x123 < mLP) { + w += mLP - x123; + } else if (x234 > mRP) { + w -= x234 - mRP; } } - w -= fVar28; + w -= f18; if (mLimitRelated == 1 || mLimitRelated == 4) { - w = mLP + mLoopOffsetX * 0.5f - mPrevSomeSize.x * 0.5f; + w = mLP + getLoopOffsetX() * 0.5f - getPrevSomeSizeX() * 0.5f; if ( dScStage_c::m_instance->mCurrWorld == 11 && dScStage_c::m_instance->mCurrCourse == 65 && @@ -1609,85 +1630,138 @@ void dBg_c::fn_8007ac40(const dBgSomeInfo_c *info, int arg1) { fn_8007ba70(info); check = true; } - float newW = w; if (dScStage_c::m_loopType != 2) { - newW = getLeftLimit(); - float d = getRightLimit() - newW; - if (newW < w) { - newW = w; - if (d > w) { - newW = d; - } + float leftLimit = getLeftLimit(); + float rightLimit = getRightLimit() - getPrevSomeSizeX(); + if (w < leftLimit) { + w = leftLimit; + } else if (w > rightLimit) { + w = rightLimit; } } if (!check && dScStage_c::m_loopType != 1) { - mPrevSomePos.x = newW; + mPrevSomePos.x = w; + } + float unused; + float a = asdf + f19; + float b = asdf - f19; + if (a > u) { + unused = 0.0f; + } else if (b > d) { + unused = 1.0f; } u8 iVar9 = 0; float fnres = fn_8007bbf0(info); - float fVar12 = 0.5f; if (fnres < mPrevSomePos.y && (m_90009 == 3 || m_9000a == 3)) { + boundScale = fnres; iVar9 |= 0x10; - fVar12 = fnres; } float fnres2 = fn_8007bba0(info); - if (mPrevSomePos.y < fnres2) { - if (m_90009 == 1 || m_9000a == 2) { + if (fnres2 > mPrevSomePos.y) { + if (m_90009 == 1 || m_9000a == 1) { iVar9 = 1; - fVar12 = fnres2; + boundScale = fnres2; } else if (m_9000a == 3 && (iVar9 & 0x10) == 0) { int rounded = fnres2 - mPrevSomePos.y; mBounds3[3] = rounded; } } - if (iVar9 == 0 || iVar9 != 17 && (m_90009 == 1 || m_9000a == 1)) { - fVar12 = fnres2; + float unused2; + if (iVar9 != 0) { + if (iVar9 != 17) { + if ((m_90009 == 1 || m_9000a == 1)) { + if (iVar9 & 0x10) { + unused2 = 0.0f; + } + } else if (iVar9 & 0x1) { + unused2 = 0.0f; + } + } else if (m_90009 == 1 || m_9000a == 1) { + boundScale = fnres2; + } } if (iVar9 != 0) { - if ((int) fVar12 < (int) mPrevSomePos.y) { - float diff = mPrevSomePos.y - fVar12; + if ((int) boundScale < (int) getPrevSomePosY()) { + float diff = getPrevSomePosY() - boundScale; if (diff < 16.0f) { - mMoreFloats5[2] -= diff; + mMoreFloats5[3] -= diff; } else { - mMoreFloats5[2] -= 16.0f; + mMoreFloats5[3] -= 16.0f; } - } else if ((int) mPrevSomePos.y < (int) fVar12) { - float diff = fVar12 - mPrevSomePos.y; + } else if ((int) boundScale > (int) getPrevSomePosY()) { + float diff = boundScale - getPrevSomePosY(); if (diff < 16.0f) { - mMoreFloats5[2] += diff; + mMoreFloats5[3] += diff; } else { - mMoreFloats5[2] += 16.0f; + mMoreFloats5[3] += 16.0f; } } } - // if (mPrevSomePos.y + 32.0f < info->mBounds.mUp) { - // info->mBounds.mUp = mPrevSomePos.y + 32.0f; - // } - // if (info->mBounds.mDown < mPrevSomePos.y - mPrevSomeSize.y - 32.0f) { - // info->mBounds.mDown = mPrevSomePos.y - mPrevSomeSize.y - 32.0f; - // } - float dVar12 = mMoreFloats5[4] + lHeight * 0.5f + (copy_90018 - 1.0f); + float up = info->mBounds.getU(); + float down = info->mBounds.getD(); + if (up > getPrevSomePosY() + 32.0f) { + up = getPrevSomePosY() + 32.0f; + } + if (down < getPrevSomePosY() - getPrevSomeSizeY() - 32.0f) { + down = getPrevSomePosY() - getPrevSomeSizeY() - 32.0f; + } + float fVar17 = up + down; + float dVar12 = mMoreFloats5[4] + (up + down) * 0.5f + (copy_90018 - 1.0f); calcLookatOffsLimit(); + float fVar27 = (1.0f / mDispScale - m_bg_p->getZoomTargetMin()) * 0.5f + 1.0f; + float fVar26 = getPrevSomePosY() - mBounds3[0] * fVar27; + fVar27 = mBounds3[1] * fVar27 + (getPrevSomePosY() - getPrevSomeSizeY()); + + float fVar5 = getPrevSomePosY() - getPrevSomeSizeY() * 0.5f; + if (fVar26 < fVar5 + 16.0f) { + fVar26 = fVar5 + 16.0f; + } + float fVar3 = getPrevSomePosY() - getPrevSomeSizeY() * 0.5f; + if (fVar27 > fVar3 - 16.0f) { + fVar27 = fVar3 - 16.0f; + } + if (fVar17 > fVar26) { + mMoreFloats5[4] = mMoreFloats5[4] + (fVar17 - fVar26); + } else if (fVar17 < fVar27) { + mMoreFloats5[4] = mMoreFloats5[4] - (fVar27 - fVar17); + } + + mMoreFloats6[0] = dVar12 + mMoreFloats5[4]; + + float tmp27 = mMoreFloats6[0] - fVar17 * copy_90018; + if (mMoreFloats6[0] > u) { + mMoreFloats6[0] = (dVar12 - (dVar12 - u)); + mMoreFloats5[4] -= dVar12 - u; + } else if (tmp27 < d) { + mMoreFloats6[0] = (dVar12 + (d - tmp27)); + mMoreFloats5[4] += d - tmp27; + } + + mU8s[2] = 0; + float fVar14 = mMoreFloats6[0]; if (getAreaUpLimitScroll() > -999999.0f) { - if (getAreaUpLimitScroll() < dBgParameter_c::ms_Instance_p->mPos.y) { - mU8s[2] = 1; - } else if (getAreaUpLimitScroll() < fVar14) { - if (!dBg_isFlyPlayer() && copy_90018 <= -(mD - getAreaUpLimitScroll()) / mVideo::getLayoutHeight()) { - fVar14 = getAreaUpLimitScroll(); + if (dBgParameter_c::ms_Instance_p->yStart() <= getAreaUpLimitScroll()) { + if (fVar14 > getAreaUpLimitScroll()) { + float h = -(mD - getAreaUpLimitScroll()) / mVideo::getLayoutHeight(); + if (!dBg_isFlyPlayer() && copy_90018 <= h) { + fVar14 = getAreaUpLimitScroll(); + } } + } else { + mU8s[2] = 1; } } - float upperBound = mULimit; - float lowerBound = mDLimit + mPrevSomeSize.y; - float finalY = fVar14; + lowerBound = getDownLimit() + getPrevSomeSizeY(); + upperBound = getUpLimit(); + finalY = fVar14; if (finalY < upperBound) { mMoreFloats5[4] += lowerBound - finalY; finalY = lowerBound; } else if (finalY > lowerBound) { - mMoreFloats5[4] -= upperBound - finalY; + mMoreFloats5[4] -= finalY - upperBound; finalY = upperBound; } @@ -1697,7 +1771,8 @@ void dBg_c::fn_8007ac40(const dBgSomeInfo_c *info, int arg1) { } if (m_9095c == 0) { - if ((stage->mCurrCourse != STAGE_DOOMSHIP || stage->mCurrFile != 2) && stage->mCurrCourse != STAGE_CASTLE) { + if ((stage->mCurrCourse != STAGE_DOOMSHIP || stage->m_1211 != 2) && stage->mCurrCourse != STAGE_CASTLE) { + finalY = m_90960; mMoreFloats5[4] = m_90960 - dVar12; } m_9095c = 1; @@ -1710,14 +1785,14 @@ void dBg_c::fn_8007ac40(const dBgSomeInfo_c *info, int arg1) { } if (m_900a7 != 0) { - mPrevSomePos.x = m_900ac.x - 0.5f * mPrevSomeSize.x; - mPrevSomePos.y = m_900ac.y + mPrevSomeSize.y; + mPrevSomePos = m_900ac; + mPrevSomePos.x -= getPrevSomeSizeX() * 0.5f; + mPrevSomePos.y += getPrevSomeSizeY(); } - // Auto-scroll backup if (!mAutoscrolls[0].mActive) { - mAutoscrolls[0].mPos.x = mPrevSomePos.x; - mAutoscrolls[0].mPos.y = mPrevSomePos.y; + mAutoscrolls[0].mPos.x = getPrevSomePosX(); + mAutoscrolls[0].mPos.y = getPrevSomePosY(); } } From 3a15cd9ff991abe1d40611ce4abe4ccf46f9d9b4 Mon Sep 17 00:00:00 2001 From: RootCubed Date: Fri, 8 May 2026 17:40:48 +0200 Subject: [PATCH 29/29] close to matching --- include/game/bases/d_bg.hpp | 6 + source/dol/bases/d_bg.cpp | 275 +++++++++++++++++++----------------- 2 files changed, 148 insertions(+), 133 deletions(-) diff --git a/include/game/bases/d_bg.hpp b/include/game/bases/d_bg.hpp index a31398f5..6a69029f 100644 --- a/include/game/bases/d_bg.hpp +++ b/include/game/bases/d_bg.hpp @@ -214,6 +214,7 @@ class dBg_c : public dBase_c { float getDispScale() { return mDispScale; } float getPrevDispScale() { return mMoreFloats3[0]; } float getScaleFactor() { return 1.0f / mDispScale; } + float getZoom() { return 1.0f / mZoomDenom; } float getLiquidHeight() const { return mMoreFloats7[5]; } float getL() { return mL; } @@ -239,8 +240,13 @@ class dBg_c : public dBase_c { float getPrevSomeSizeX() { return mPrevSomeSize.x; } float getPrevSomeSizeY() { return mPrevSomeSize.y; } + float get_900acX() { return m_900ac.x; } + float get_900acY() { return m_900ac.y; } + float getSomeScale() { return mSomeScale; } + float getZoomDenom() { return mZoomDenom; } + float getLoopOffsetX() { return mLoopOffsetX; } dBgScrollLimit_c *getScrLim(int area, int group, int idx) { return &mScrLimit[area][group][idx]; } diff --git a/source/dol/bases/d_bg.cpp b/source/dol/bases/d_bg.cpp index d0f0f6c3..4aeab79a 100644 --- a/source/dol/bases/d_bg.cpp +++ b/source/dol/bases/d_bg.cpp @@ -1252,27 +1252,26 @@ void dBg_c::AutoScroll_stop() { void dBg_c::calcScroll(const mVec3_c &pos, int param_2) { dBgParameter_c *bgParam = dBgParameter_c::getInstance(); - float maxLeft; - float lWidth = mVideo::getLayoutWidth(); - float lHeight = mVideo::getLayoutHeight(); + float lHeight; + float lWidth; + + lWidth = mVideo::getLayoutWidth(); + lHeight = mVideo::getLayoutHeight(); + if (m_bg_p->m_9095a == 0) { m_bg_p->getZoomTargetMax(); // unused return value if (mSomeScale > 0.0f) { dBg_c *bg = m_bg_p; - float bgVal = dBgParameter_c::ms_Instance_p->getM34(); - float scale = getSomeScale(); - float b = bgVal * (1.0f / scale - 1.0f / bg->getZoomTargetMin()); - float a = 1.0f / bg->getZoomTargetMin(); - mDispScale = a + b; + mDispScale = 1.0f / bg->getZoomTargetMin() + dBgParameter_c::ms_Instance_p->getM34() * (1.0f / getSomeScale() - 1.0f / bg->getZoomTargetMin()); } m_90018 = mDispScale; mMoreFloats5[1] = mDispScale; - mSomeSize.x = lWidth * (1.0f / mDispScale); - mSomeSize.y = lHeight * (1.0f / mDispScale); - float width = getSomeSizeX(); - float height = getSomeSizeY(); + float width = lWidth * (1.0f / mDispScale); + float height = lHeight * (1.0f / mDispScale); + mSomeSize.x = width; + mSomeSize.y = height; float halfWidth = getSomeSizeX() * 0.5f; @@ -1284,19 +1283,17 @@ void dBg_c::calcScroll(const mVec3_c &pos, int param_2) { bool updateX = true; bool updateY = true; - maxLeft = getMaxLeftPos(); + float maxLeft = getMaxLeftPos(); - mSomeParameterPos.x = bgParam->pos().x; - float x = pos.x + mBounds4[0] - halfWidth; + mSomeParameterPos = bgParam->pos(); - mSomeParameterPos.y = bgParam->pos().y; + float x = pos.x + mBounds4[0] - halfWidth; + mPlayerPosY = pos.y; float y = pos.y + getSomeSizeY() * 0.5f - mBounds4[1]; float bounds40 = mBounds4[0]; float bounds41 = mBounds4[1]; - mPlayerPosY = pos.y; - if (dScStage_c::m_loopType != 2) { if (x < leftLimit) { x = leftLimit; @@ -1356,8 +1353,7 @@ void dBg_c::calcScroll(const mVec3_c &pos, int param_2) { } } if (mLimitRelated == 1 || mLimitRelated == 4) { - maxLeft += getLoopOffsetX() * 0.5f; - mSomePos.x = maxLeft - getSomeSizeX() * 0.5f; + mSomePos.x = (maxLeft + getLoopOffsetX() * 0.5f) - getSomeSizeX() * 0.5f; } if (mLimitRelated == 6) { mSomePos.y = getD() + getSomeSizeY(); @@ -1369,9 +1365,12 @@ void dBg_c::calcScroll(const mVec3_c &pos, int param_2) { mAutoscrolls[0].mPos.y = getSomePosY(); } if (m_900a7 != 0) { - mSomePos = m_900ac; - mSomePos.x = getSomePosX() - getSomeSizeX() * 0.5f; - mSomePos.y = getSomePosY() + getSomeSizeY(); + float px = get_900acX(); + float py = get_900acY(); + float x = px - getSomeSizeX() * 0.5f; + float y = py + getSomeSizeY(); + mSomePos.x = x; + mSomePos.y = y; } } fn_8007ca90(&mSomeInfo1, m_90009, 1); @@ -1392,33 +1391,34 @@ void dBg_c::calcMultiScroll(int arg1) { } void dBg_c::fn_8007ac40(const dBgSomeInfo_c *info, int arg1) { - float br = info->mBounds.getR(); - float bl = info->mBounds.getL(); - float bu = info->mBounds.getU(); - float bd = info->mBounds.getD(); - float val; - float fVar28; - float fVar25; - float copy_90018; - float f26; - float f27; - float lowerBound; - float upperBound; - float finalY; + float lWidth = mVideo::getLayoutWidth(); + float lHeight = mVideo::getLayoutHeight(); - float lWidth = mVideo::l_rayoutWidthF; - float lHeight = mVideo::l_rayoutHeightF; + float copy_90018; + float dVar12; + float fVar25; + float fVar28; - float invScale = 1.0f / mDispScale; + float invScale = 1.0f / getDispScale(); float zoom = 1.0f / mZoomDenom; float boundScale = 0.5f; - float tmpRight = std::fabs(bl - br) / lWidth; - float tmpUp = std::fabs(bd - bu) / lHeight; - - float scale; - float someTmp2; - float someTmp; + float fVar14; + + // float bdr = info->mBounds.getW(); + // float bdu = info->mBounds.getH(); + // float bdw; + // float bdh; + // info->mBounds.getSize(bdw, bdh); + // someTmp2 = bdw / lWidth; + // someTmp = bdh / lHeight; + float someTmp, someTmp2; + float bdr = info->mBounds.getR(); + float bdl = info->mBounds.getL(); + float bdu = info->mBounds.getU(); + float bdd = info->mBounds.getD(); + someTmp2 = std::fabs(bdl - bdr) / lWidth; + someTmp = std::fabs(bdd - bdu) / lHeight; float spL = m_bg_p->getZoomSpreadLine(); float spL2 = m_bg_p->getZoomSpreadLine2(); @@ -1431,55 +1431,55 @@ void dBg_c::fn_8007ac40(const dBgSomeInfo_c *info, int arg1) { dScStage_c *stage = dScStage_c::m_instance; bool bVar7 = false; + float scale; if (mLimitRelated == 1) { scale = 1.2f; } else { scale = 0.9f; } - someTmp2 = tmpUp * scale; + someTmp *= scale; mVec2_c r = fn_8007bd40(info, zoom, scale); - someTmp = tmpRight; if (mLimitRelated == 1) { r.x = r.y; - someTmp = someTmp2; + someTmp2 = someTmp; } if (mLimitRelated >= 6 && mLimitRelated <= 7) { r.y = r.x - 1.0f; - someTmp2 = someTmp; + someTmp = someTmp2; } if (mLimitRelated == 2) { if (mLimitRelated2 >= 5 && mLimitRelated2 <= 7 || mLimitRelated2 >= 1 && mLimitRelated2 <= 2) { - if (invScale < m_bg_p->getZoomTargetMax() && someTmp > spL2) { - someTmp = spL2; - } - if (!dBg_isFlyPlayer() && mU8s[2] == 0 && someTmp2 > spL2) { + if (invScale < m_bg_p->getZoomTargetMax() && someTmp2 > spL2) { someTmp2 = spL2; } - } else { - if (invScale <= m_bg_p->getZoomTargetMid() && someTmp > spL) { - someTmp = spL; + if (!dBg_isFlyPlayer() && mU8s[2] == 0 && someTmp > spL2) { + someTmp = spL2; } - if (!dBg_isFlyPlayer() && mU8s[2] == 0 && someTmp2 > spL) { + } else { + if (invScale <= m_bg_p->getZoomTargetMid() && someTmp2 > spL) { someTmp2 = spL; } + if (!dBg_isFlyPlayer() && mU8s[2] == 0 && someTmp > spL) { + someTmp = spL; + } } } if (mLimitRelated == 0 && mLimitRelated2 == 10) { if (dBg_isCloudFlyPlayerMulti() != 1) { float tmp = shL2 - 0.01f; - if (someTmp > tmp || m_9095b != 0) { - someTmp = tmp; + if (someTmp2 > tmp || m_9095b != 0) { + someTmp2 = tmp; } } else { - someTmp = spL2 + 0.01f; + someTmp2 = spL2 + 0.01f; } - someTmp2 = someTmp - 1.0f; + someTmp = someTmp2 - 1.0f; } - someTmp = MAX(someTmp, someTmp2); + someTmp2 = MAX(someTmp, someTmp2); if ((daPyDemoMng_c::mspInstance->mFlags & 1) == 0) { switch (m_90024) { case 0: - if (someTmp > spL) { + if (someTmp2 > spL) { mMoreFloats5[0] = tgMid; m_90024 = 1; } else { @@ -1487,27 +1487,27 @@ void dBg_c::fn_8007ac40(const dBgSomeInfo_c *info, int arg1) { } break; case 1: - if (someTmp > spL2) { + if (someTmp2 > spL2) { mMoreFloats5[0] = tgMax; m_90024 = 2; - } else if (someTmp < shL) { + } else if (someTmp2 < shL) { bVar7 = true; if (m_900b6 > 120) { mMoreFloats5[0] = tgMin; m_90024 = 0; } - } else if (!(someTmp < spL)) { + } else if (!(someTmp2 < spL)) { mMoreFloats5[0] = tgMid; } break; case 2: - if (someTmp < shL2) { + if (someTmp2 < shL2) { bVar7 = true; if (m_900b6 > 120) { mMoreFloats5[0] = tgMid; m_90024 = 1; } - } else if (!(someTmp < spL2)) { + } else if (!(someTmp2 < spL2)) { mMoreFloats5[0] = tgMax; } break; @@ -1528,6 +1528,7 @@ void dBg_c::fn_8007ac40(const dBgSomeInfo_c *info, int arg1) { } else { mMoreFloats5[0] = m_90018; } + fVar28 = mMoreFloats5[0]; fVar25 = m_90018; if (m_90018 < mMoreFloats5[0]) { @@ -1536,11 +1537,10 @@ void dBg_c::fn_8007ac40(const dBgSomeInfo_c *info, int arg1) { float calcArg = 0.0015f; if (mZoomRelated != 0 && mZoomRelated != 8) { fVar25 = 1.0f; - calcArg = 0.1; + calcArg = 0.1f; scale = 1.0f; } - float cubed = someTmp * someTmp * someTmp; - float maxStep = cubed * 6.0f + 1.0f; + float maxStep = (someTmp2 * someTmp2 * someTmp2) * 6.0f + 1.0f; sLib::addCalc(&mMoreFloats5[1], fVar28, fVar25, scale * maxStep, calcArg); if (mMoreFloats5[1] > m_90018) { if (std::fabs(fVar28 - m_90018) > 0.1f) { @@ -1554,10 +1554,9 @@ void dBg_c::fn_8007ac40(const dBgSomeInfo_c *info, int arg1) { float calcArg = 0.0015f; if (mZoomRelated != 0 && mZoomRelated != 8) { fVar25 = 1.0f; - calcArg = 0.1; + calcArg = 0.1f; scale = 1.0f; } - // TODO: someTmp float maxStep = someTmp2 * someTmp2 * someTmp2 * 6.0f + 1.0f; if (m_9001c == 0) { sLib::addCalc(&m_90018, fVar28, fVar25, scale * maxStep, calcArg); @@ -1578,45 +1577,49 @@ void dBg_c::fn_8007ac40(const dBgSomeInfo_c *info, int arg1) { m_90018 = tgMax; } copy_90018 = m_90018; - val = -(getDownLimit() - getUpLimit()); + float val = -(getDownLimit() - getUpLimit()); if (val < m_90018 * mVideo::getLayoutHeight()) { copy_90018 = val / mVideo::getLayoutHeight(); m_90018 = copy_90018; } if (getAreaUpLimitScroll() > -999999.0f) { - float divres = -(getD() - getAreaUpLimitScroll()) / mVideo::getLayoutHeight(); + float d = getD(); + d = -(d - getAreaUpLimitScroll()) / mVideo::getLayoutHeight(); if (mU8s[2] == 0) { m_90964 = 1.0f; } else { sLib::addCalc(&m_90964, 0.0f, 0.5f, 0.01f, 0.01f); } - copy_90018 += m_90964 * (divres - copy_90018); + copy_90018 += m_90964 * (d - copy_90018); } - mPrevSomeSize.x = lWidth * copy_90018; - mPrevSomeSize.y = lHeight * copy_90018; + float psx = lWidth * copy_90018; + float psy = lHeight * copy_90018; + mPrevSomeSize.set(psx, psy); mDispScale = 1.0f / copy_90018; - float f18 = mPrevSomeSize.x * boundScale; - float f19 = mPrevSomeSize.y * boundScale; + float f18 = psx * boundScale; + float f19 = psy * boundScale; + float tmpcalc = 0.0f; + float ow = 0.0f; float mLP = getMaxLeftPos(); float mRP = getMaxRightPos(); - float u = mU; - float d = mD; - float tmpcalc = info->mBounds.getU() + info->mBounds.getD(); - float wo = info->mBounds.getR() + info->mBounds.getL(); - float w = wo * 0.5f; - float asdf = tmpcalc * 0.5f; - float x123 = w - f18; - float x234 = tmpcalc + f18; + float u = getU(); + float d = getD(); + tmpcalc = (info->mBounds.getU() + info->mBounds.getD()) * 0.5f; + ow = (info->mBounds.getR() + info->mBounds.getL()) * 0.5f; + float x123 = ow - f18; + float x234 = ow + f18; + float cpy = ow; if (dScStage_c::m_loopType != 2) { if (x123 < mLP) { - w += mLP - x123; + cpy = ow + (mLP - x123); } else if (x234 > mRP) { - w -= x234 - mRP; + cpy = ow - (x234 - mRP); } } - w -= f18; + float w = cpy - f18; if (mLimitRelated == 1 || mLimitRelated == 4) { - w = mLP + getLoopOffsetX() * 0.5f - getPrevSomeSizeX() * 0.5f; + w = mLP + getLoopOffsetX() * 0.5f; + w -= getPrevSomeSizeX() * 0.5f; if ( dScStage_c::m_instance->mCurrWorld == 11 && dScStage_c::m_instance->mCurrCourse == 65 && @@ -1631,20 +1634,20 @@ void dBg_c::fn_8007ac40(const dBgSomeInfo_c *info, int arg1) { check = true; } if (dScStage_c::m_loopType != 2) { - float leftLimit = getLeftLimit(); - float rightLimit = getRightLimit() - getPrevSomeSizeX(); - if (w < leftLimit) { - w = leftLimit; - } else if (w > rightLimit) { - w = rightLimit; + mLP = getLeftLimit(); + mRP = getRightLimit() - getPrevSomeSizeX(); + if (w < mLP) { + w = mLP; + } else if (w > mRP) { + w = mRP; } } if (!check && dScStage_c::m_loopType != 1) { mPrevSomePos.x = w; } float unused; - float a = asdf + f19; - float b = asdf - f19; + float a = tmpcalc + f19; + float b = tmpcalc - f19; if (a > u) { unused = 0.0f; } else if (b > d) { @@ -1705,13 +1708,16 @@ void dBg_c::fn_8007ac40(const dBgSomeInfo_c *info, int arg1) { if (down < getPrevSomePosY() - getPrevSomeSizeY() - 32.0f) { down = getPrevSomePosY() - getPrevSomeSizeY() - 32.0f; } - float fVar17 = up + down; - float dVar12 = mMoreFloats5[4] + (up + down) * 0.5f + (copy_90018 - 1.0f); + float fVar17; + float tmp123123 = (up + down) * 0.5f; + dVar12 = mMoreFloats5[3] + lHeight * 0.5f * (copy_90018 - 1.0f); + fVar17 = dVar12; calcLookatOffsLimit(); - float fVar27 = (1.0f / mDispScale - m_bg_p->getZoomTargetMin()) * 0.5f + 1.0f; - float fVar26 = getPrevSomePosY() - mBounds3[0] * fVar27; - fVar27 = mBounds3[1] * fVar27 + (getPrevSomePosY() - getPrevSomeSizeY()); + float x = (1.0f / getDispScale() - m_bg_p->getZoomTargetMin()) * 0.5f; + x += 1.0f; + float fVar26 = getPrevSomePosY() - mBounds3[0] * x; + float fVar27 = getPrevSomePosY() - getPrevSomeSizeY() + mBounds3[1] * x; float fVar5 = getPrevSomePosY() - getPrevSomeSizeY() * 0.5f; if (fVar26 < fVar5 + 16.0f) { @@ -1721,31 +1727,32 @@ void dBg_c::fn_8007ac40(const dBgSomeInfo_c *info, int arg1) { if (fVar27 > fVar3 - 16.0f) { fVar27 = fVar3 - 16.0f; } - if (fVar17 > fVar26) { - mMoreFloats5[4] = mMoreFloats5[4] + (fVar17 - fVar26); - } else if (fVar17 < fVar27) { - mMoreFloats5[4] = mMoreFloats5[4] - (fVar27 - fVar17); + if (tmp123123 > fVar26) { + mMoreFloats5[4] = mMoreFloats5[4] + (tmp123123 - fVar26); + } else if (tmp123123 < fVar27) { + mMoreFloats5[4] = mMoreFloats5[4] - (fVar27 - tmp123123); } - mMoreFloats6[0] = dVar12 + mMoreFloats5[4]; + dVar12 += mMoreFloats5[4]; + mMoreFloats6[0] = dVar12; - float tmp27 = mMoreFloats6[0] - fVar17 * copy_90018; + float tmp27 = mMoreFloats6[0] - lHeight * copy_90018; if (mMoreFloats6[0] > u) { - mMoreFloats6[0] = (dVar12 - (dVar12 - u)); + mMoreFloats6[0] -= dVar12 - u; mMoreFloats5[4] -= dVar12 - u; } else if (tmp27 < d) { - mMoreFloats6[0] = (dVar12 + (d - tmp27)); + mMoreFloats6[0] += d - tmp27; mMoreFloats5[4] += d - tmp27; } mU8s[2] = 0; - float fVar14 = mMoreFloats6[0]; + fVar14 = mMoreFloats6[0]; if (getAreaUpLimitScroll() > -999999.0f) { if (dBgParameter_c::ms_Instance_p->yStart() <= getAreaUpLimitScroll()) { if (fVar14 > getAreaUpLimitScroll()) { - float h = -(mD - getAreaUpLimitScroll()) / mVideo::getLayoutHeight(); - if (!dBg_isFlyPlayer() && copy_90018 <= h) { + dVar12 = -(getD() - getAreaUpLimitScroll()) / mVideo::getLayoutHeight(); + if (!dBg_isFlyPlayer() && dVar12 >= copy_90018) { fVar14 = getAreaUpLimitScroll(); } } @@ -1754,40 +1761,42 @@ void dBg_c::fn_8007ac40(const dBgSomeInfo_c *info, int arg1) { } } - lowerBound = getDownLimit() + getPrevSomeSizeY(); - upperBound = getUpLimit(); - finalY = fVar14; - if (finalY < upperBound) { - mMoreFloats5[4] += lowerBound - finalY; - finalY = lowerBound; - } else if (finalY > lowerBound) { - mMoreFloats5[4] -= finalY - upperBound; - finalY = upperBound; + float lowerBound = getDownLimit() + getPrevSomeSizeY(); + float upperBound = getUpLimit(); + if (fVar14 < lowerBound) { + mMoreFloats5[4] += lowerBound - fVar14; + fVar14 = lowerBound; + } else if (fVar14 > upperBound) { + mMoreFloats5[4] -= fVar14 - upperBound; + fVar14 = upperBound; } if (mLimitRelated == 6) { mMoreFloats5[4] = 0.0f; - finalY = lowerBound; + fVar14 = lowerBound; } if (m_9095c == 0) { if ((stage->mCurrCourse != STAGE_DOOMSHIP || stage->m_1211 != 2) && stage->mCurrCourse != STAGE_CASTLE) { - finalY = m_90960; - mMoreFloats5[4] = m_90960 - dVar12; + fVar14 = m_90960; + mMoreFloats5[4] = m_90960 - fVar17; } m_9095c = 1; } if (arg1 != 0 || getAreaUpLimitScroll() <= -999999.0f) { - mPrevSomePos.y = finalY; + mPrevSomePos.y = fVar14; } else { - sLib::chase(&mPrevSomePos.y, finalY, 16.0f); + sLib::chase(&mPrevSomePos.y, fVar14, 16.0f); } if (m_900a7 != 0) { - mPrevSomePos = m_900ac; - mPrevSomePos.x -= getPrevSomeSizeX() * 0.5f; - mPrevSomePos.y += getPrevSomeSizeY(); + float px = get_900acX(); + float py = get_900acY(); + float x = px - getPrevSomeSizeX() * 0.5f; + float y = py + getPrevSomeSizeY(); + mPrevSomePos.x = x; + mPrevSomePos.y = y; } if (!mAutoscrolls[0].mActive) {