From d9c498e2f44800aafc2fa29f579c339e65dcf2b1 Mon Sep 17 00:00:00 2001 From: RootCubed Date: Sun, 1 Jun 2025 10:55:49 +0200 Subject: [PATCH 01/22] dBg_c 69% matching (nice) --- include/game/bases/d_3d.hpp | 10 + include/game/bases/d_a_player.hpp | 8 +- .../game/bases/d_a_player_demo_manager.hpp | 6 +- include/game/bases/d_a_player_manager.hpp | 6 +- include/game/bases/d_bg.hpp | 313 ++- include/game/bases/d_bg_global.hpp | 63 + include/game/bases/d_bg_parameter.hpp | 17 +- include/game/bases/d_bg_tex.hpp | 32 + include/game/bases/d_cd_blocks.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 | 6 +- include/game/mLib/m_3d/proc.hpp | 2 + include/game/mLib/m_vec.hpp | 5 + include/game/mLib/m_video.hpp | 5 + include/game/sLib/s_math.hpp | 1 + slices/wiimj2d.json | 15 +- source/dol/bases/d_actor.cpp | 4 +- source/dol/bases/d_bg.cpp | 1956 +++++++++++++++++ source/dol/bases/d_cc.cpp | 4 +- 20 files changed, 2462 insertions(+), 19 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.hpp b/include/game/bases/d_a_player.hpp index 3b6532a1..394c0396 100644 --- a/include/game/bases/d_a_player.hpp +++ b/include/game/bases/d_a_player.hpp @@ -17,7 +17,13 @@ class dAcPy_c : public daPlBase_c { bool FUN_8012e540(dActor_c *, bool); ///< @unofficial - char mPad[0x15e8]; + u8 mPad1[0x60]; + float m_68; + u8 mPad2[0x38]; + mVec3_c mBgRelatedPos; + u8 mPad3[0x4]; + s8 mScrollMode; + u8 mPad4[0x1538]; fBaseID_e mCarryActorID; static const float msc_JUMP_SPEED; diff --git a/include/game/bases/d_a_player_demo_manager.hpp b/include/game/bases/d_a_player_demo_manager.hpp index cf69b3e0..5e00fa1f 100644 --- a/include/game/bases/d_a_player_demo_manager.hpp +++ b/include/game/bases/d_a_player_demo_manager.hpp @@ -1,8 +1,12 @@ #pragma once +#include + class daPyDemoMng_c { public: - char filler[0x80]; + u8 mPad1[0x10]; + u32 mFlags; + u8 mPad2[0x6c]; int mPlNo; static daPyDemoMng_c *mspInstance; diff --git a/include/game/bases/d_a_player_manager.hpp b/include/game/bases/d_a_player_manager.hpp index c5ed3ac7..811db064 100644 --- a/include/game/bases/d_a_player_manager.hpp +++ b/include/game/bases/d_a_player_manager.hpp @@ -4,16 +4,20 @@ class daPyMng_c { public: - static void changeItemKinopioPlrNo(int &); static int getPlayerIndex(PLAYER_TYPE_e); ///< @unofficial static dAcPy_c *getPlayer(int); static dAcPy_c *getCtrlPlayer(int); + static mVec3_c getPlayerSetPos(u8, u8); static void addScore(int, int); + static void changeItemKinopioPlrNo(int &); + static u8 getActScrollInfo(); /// @unofficial + static int getScrollNum(); static bool checkPlayer(u8 plrNo) { return mActPlayerInfo & (1 << plrNo); } static int getRest(PLAYER_TYPE_e plrNo) { return mRest[plrNo]; } static int getPlayerType(int plrNo) { return mPlayerType[plrNo]; } static int getPlayerMode(int plrNo) { return mPlayerMode[plrNo]; } + static bool isScrollMode1() { return getScrollNum() == 1; } static int mNum; static u8 mActPlayerInfo; diff --git a/include/game/bases/d_bg.hpp b/include/game/bases/d_bg.hpp index 7419f045..b4dc806b 100644 --- a/include/game/bases/d_bg.hpp +++ b/include/game/bases/d_bg.hpp @@ -1,12 +1,315 @@ #pragma once -#include +#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: - char pad[0x8fea0]; - float mLoopOffset; + 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; + u8 m_14, m_15, m_16, m_17; + u8 m_18; + bool m_19; + bool mActive; + }; + +public: + 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); + + 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] + + 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 getScaleFactor() { return 1.0f / mDispScale; } + + typedef void (dBg_c::*callbackFunc)(dBgSomeInfo_c *, int); - void setWaterInWave(float x, float y, u8 type); + 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 dc220f78..e1544329 100644 --- a/include/game/bases/d_bg_parameter.hpp +++ b/include/game/bases/d_bg_parameter.hpp @@ -6,13 +6,26 @@ class dBgParameter_c { public: - u8 mPad[0x38]; + u16 getOneGetBuff(u16, u16, int); + u16 setOneGetBuff(u16, u16, int, u16); + + u8 mPad1[0x30]; + mVec2_c m_30; mVec2_c mPos; mVec2_c mSize; + mVec2_c mCenter; + u8 mPad2[0x28]; + float m_78; 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; } @@ -31,6 +44,8 @@ class dBgParameter_c { return y - offset > yStart(); } + 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_blocks.hpp b/include/game/bases/d_cd_blocks.hpp index f03e7e40..b2e271e4 100644 --- a/include/game/bases/d_cd_blocks.hpp +++ b/include/game/bases/d_cd_blocks.hpp @@ -33,9 +33,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 @@ -46,7 +49,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 e531d17b..651c9fab 100644 --- a/include/game/bases/d_info.hpp +++ b/include/game/bases/d_info.hpp @@ -67,7 +67,8 @@ class dInfo_c { int m_54; u8 pad3[0x44]; int m_9c; - u8 pad4[0x2e4]; + u8 pad4[0x2e0]; + bool mIsWmSwitchHit; int mCharIDs[4]; bool mIsWorldSelect; ///< Whether the World Select Menu is being displayed. int pad5[7]; 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 b4eb9b59..64c2b8f8 100644 --- a/include/game/bases/d_s_stage.hpp +++ b/include/game/bases/d_s_stage.hpp @@ -15,8 +15,12 @@ class dScStage_c : public dScene_c { LOOP_COUNT, }; - char pad[0x119a]; + u8 mPad1[0x1198]; + u8 mCurrWorld; + u8 mCurrCourse; u8 mCurrFile; + u8 mPad2[0x2]; + u8 m_1211; static float getLoopPosX(float x); static int m_loopType; 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 b62a374e..c5989e87 100644 --- a/include/game/mLib/m_vec.hpp +++ b/include/game/mLib/m_vec.hpp @@ -189,6 +189,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 e0070cd5..6c2647f5 100644 --- a/include/game/mLib/m_video.hpp +++ b/include/game/mLib/m_video.hpp @@ -4,6 +4,11 @@ class mVideo { public: GXRenderModeObj &mRenderModeObj; + static float l_rayoutWidthF; + static float l_rayoutHeightF; + + 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; } diff --git a/include/game/sLib/s_math.hpp b/include/game/sLib/s_math.hpp index 23c1fce2..754021e4 100644 --- a/include/game/sLib/s_math.hpp +++ b/include/game/sLib/s_math.hpp @@ -5,6 +5,7 @@ namespace sLib { bool chase(short *, short, short); bool chase(float *, float, float); short addCalcAngle(short *, short, short, short, short); +void addCalc(float *, float, float, float, float); template T calcTimer(T *val) { diff --git a/slices/wiimj2d.json b/slices/wiimj2d.json index 137d66b0..c0eb5111 100644 --- a/slices/wiimj2d.json +++ b/slices/wiimj2d.json @@ -184,11 +184,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_actor.cpp b/source/dol/bases/d_actor.cpp index be16c83e..43f63b23 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..1d779517 --- /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::sCurrentHeap, + 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->mRes.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->mBgRelatedPos.y > param->mPos.y - 160.0f && mDispScale < 0.7f + || mDispScale >= 0.7f && pl->mBgRelatedPos.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->mBgRelatedPos.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->mBgRelatedPos.x); + float p2 = dBg_c::m_bg_p->fn_8007c7d0(pl2->mBgRelatedPos.x); + return p1 > p2; +} + +bool isLeftPlayer(dAcPy_c *pl1, dAcPy_c *pl2) { + float p1 = dBg_c::m_bg_p->fn_8007c7d0(pl1->mBgRelatedPos.x); + float p2 = dBg_c::m_bg_p->fn_8007c7d0(pl2->mBgRelatedPos.x); + return p1 < p2; +} + +bool isUpPlayer(dAcPy_c *pl1, dAcPy_c *pl2) { + return pl1->mBgRelatedPos.y > pl2->mBgRelatedPos.y; +} + +bool isDownPlayer(dAcPy_c *pl1, dAcPy_c *pl2) { + return pl1->mBgRelatedPos.y < pl2->mBgRelatedPos.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 3c8daee7..11e6863b 100644 --- a/source/dol/bases/d_cc.cpp +++ b/source/dol/bases/d_cc.cpp @@ -339,9 +339,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 3924e0f972c15639e1c173d0d15ad5f68fba383f Mon Sep 17 00:00:00 2001 From: RootCubed Date: Thu, 1 May 2025 17:39:54 +0200 Subject: [PATCH 02/22] dBg_c 86% matching --- include/game/bases/d_a_player.hpp | 12 +- include/game/bases/d_bg.hpp | 33 +- include/game/bases/d_s_stage.hpp | 2 + source/dol/bases/d_bg.cpp | 532 +++++++++++++++++++++++++++++- 4 files changed, 548 insertions(+), 31 deletions(-) diff --git a/include/game/bases/d_a_player.hpp b/include/game/bases/d_a_player.hpp index 394c0396..e29987b7 100644 --- a/include/game/bases/d_a_player.hpp +++ b/include/game/bases/d_a_player.hpp @@ -17,14 +17,18 @@ class dAcPy_c : public daPlBase_c { bool FUN_8012e540(dActor_c *, bool); ///< @unofficial - u8 mPad1[0x60]; + u8 mPad1[0x10]; + u32 mPlayerType; + u8 mPad2[0x4c]; float m_68; - u8 mPad2[0x38]; + float m_6c; + u8 mPad3[0x34]; mVec3_c mBgRelatedPos; - u8 mPad3[0x4]; + u8 mPad4[0x4]; s8 mScrollMode; - u8 mPad4[0x1538]; + u8 mPad5[0x1538]; fBaseID_e mCarryActorID; + s8 mPowerup; static const float msc_JUMP_SPEED; }; diff --git a/include/game/bases/d_bg.hpp b/include/game/bases/d_bg.hpp index b4dc806b..40daab76 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/include/game/bases/d_s_stage.hpp b/include/game/bases/d_s_stage.hpp index 64c2b8f8..bb14fdfb 100644 --- a/include/game/bases/d_s_stage.hpp +++ b/include/game/bases/d_s_stage.hpp @@ -26,6 +26,8 @@ class dScStage_c : public dScene_c { static int m_loopType; static int mCollectionCoin[STAR_COIN_COUNT]; + static u32 m_exeFrame; + static const char mCdArcName[]; static bool m_isCourseOut; ///< Whether the game is transitioning from a stage scene to a non-stage scene. diff --git a/source/dol/bases/d_bg.cpp b/source/dol/bases/d_bg.cpp index 1d779517..55fd1f79 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->m_6c; + info->m_24 = pl1->mPlayerType; + } + if (pls[i2 - 1] != nullptr) { + info->m_10 = pl2; + info->mBounds.mDown = pl2->m_6c; + info->m_20 = pl2->mPlayerType; + } + break; + case 3: + if (pls[i2 - 1] != nullptr) { + info->m_14 = pl2; + info->mBounds.mUp = pl2->m_6c; + info->m_24 = pl2->mPlayerType; + } + if (pls[0] != nullptr) { + info->m_10 = pl1; + info->mBounds.mDown = pl1->m_6c; + 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 7f6a80efca61d77fea8b84a26dc521198349e1f1 Mon Sep 17 00:00:00 2001 From: user Date: Thu, 1 May 2025 22:06:14 +0200 Subject: [PATCH 03/22] Match dBg_c::fn_8007E060 --- include/game/bases/d_bg.hpp | 2 ++ source/dol/bases/d_bg.cpp | 2 +- 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/include/game/bases/d_bg.hpp b/include/game/bases/d_bg.hpp index 40daab76..c7d30b91 100644 --- a/include/game/bases/d_bg.hpp +++ b/include/game/bases/d_bg.hpp @@ -235,6 +235,8 @@ class dBg_c : public dBase_c { float getScaleFactor() { return 1.0f / mDispScale; } + 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 55fd1f79..4fd946bc 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 7a52f16871c7858fedfa7e2ece2e70f0932076cc Mon Sep 17 00:00:00 2001 From: RootCubed Date: Fri, 2 May 2025 00:54:41 +0200 Subject: [PATCH 04/22] 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 c7d30b91..05fb7aa9 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 @@ -235,6 +235,7 @@ class dBg_c : public dBase_c { float getScaleFactor() { return 1.0f / mDispScale; } + 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 4fd946bc..a6f10051 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->m_6c; - 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->m_6c; - 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->m_6c; - 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->m_6c; - 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 6a0418bff1adbaf80e7635dfc6fc85d105b074e6 Mon Sep 17 00:00:00 2001 From: RootCubed Date: Wed, 7 May 2025 16:46:17 +0200 Subject: [PATCH 05/22] 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 05fb7aa9..969499e2 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 a6f10051..6b447fa4 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 6f84cfe04c9fe8883ffd15b9e2b5a7e5c74530d5 Mon Sep 17 00:00:00 2001 From: RootCubed Date: Wed, 28 May 2025 21:25:01 +0200 Subject: [PATCH 06/22] dBg_c 92% matching --- include/game/bases/d_a_player.hpp | 9 +-- include/game/bases/d_bg.hpp | 7 +- source/dol/bases/d_bg.cpp | 123 ++++++++++++++---------------- 3 files changed, 67 insertions(+), 72 deletions(-) diff --git a/include/game/bases/d_a_player.hpp b/include/game/bases/d_a_player.hpp index e29987b7..78f1bbae 100644 --- a/include/game/bases/d_a_player.hpp +++ b/include/game/bases/d_a_player.hpp @@ -17,14 +17,11 @@ class dAcPy_c : public daPlBase_c { bool FUN_8012e540(dActor_c *, bool); ///< @unofficial - u8 mPad1[0x10]; + u8 mPad1[0x44]; u32 mPlayerType; - u8 mPad2[0x4c]; - float m_68; - float m_6c; - u8 mPad3[0x34]; + u8 mPad2[0x54]; mVec3_c mBgRelatedPos; - u8 mPad4[0x4]; + u8 mPad3[0x4]; s8 mScrollMode; u8 mPad5[0x1538]; fBaseID_e mCarryActorID; diff --git a/include/game/bases/d_bg.hpp b/include/game/bases/d_bg.hpp index 969499e2..02186b67 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(); @@ -268,7 +271,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 6b447fa4..d2e5a8c0 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->mBgRelatedPos.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->mBgRelatedPos.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->mBgRelatedPos.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->mBgRelatedPos.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->mBgRelatedPos.x); info->m_20 = pl1->mPlayerType; } break; case 1: if (pls[0] != nullptr) { info->m_18 = pl1; - info->mBounds.mUp = pl1->m_6c; + info->mBounds.mUp = pl1->mBgRelatedPos.y; info->m_28 = pl1->mPlayerType; } if (pls[i2 - 1] != nullptr) { info->m_1c = pl2; - info->mBounds.mDown = pl2->m_6c; + info->mBounds.mDown = pl2->mBgRelatedPos.y; info->m_2c = pl2->mPlayerType; } break; case 3: if (pls[i2 - 1] != nullptr) { info->m_18 = pl2; - info->mBounds.mUp = pl2->m_6c; + info->mBounds.mUp = pl2->mBgRelatedPos.y; info->m_28 = pl2->mPlayerType; } if (pls[0] != nullptr) { info->m_1c = pl1; - info->mBounds.mDown = pl1->m_6c; + info->mBounds.mDown = pl1->mBgRelatedPos.y; info->m_2c = pl1->mPlayerType; } break; From 6447324658eb4305fb66672d34843ca6e7151d7f Mon Sep 17 00:00:00 2001 From: RootCubed Date: Wed, 28 May 2025 22:17:39 +0200 Subject: [PATCH 07/22] 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 d2e5a8c0..b633832c 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 d21b8b6897268b3457c8ba6008168ba258e1873a Mon Sep 17 00:00:00 2001 From: RootCubed Date: Thu, 29 May 2025 10:27:55 +0200 Subject: [PATCH 08/22] 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 b633832c..b16c77a4 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 a955f93d36c53b18b6dfa2871041796bf4240204 Mon Sep 17 00:00:00 2001 From: RootCubed Date: Thu, 29 May 2025 13:34:21 +0200 Subject: [PATCH 09/22] 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 bb14fdfb..ca86bd38 100644 --- a/include/game/bases/d_s_stage.hpp +++ b/include/game/bases/d_s_stage.hpp @@ -35,6 +35,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 b16c77a4..0d35ea68 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 bcbbf62b0c66fd716a9e5f90741222a5125415ca Mon Sep 17 00:00:00 2001 From: RootCubed Date: Thu, 29 May 2025 14:21:32 +0200 Subject: [PATCH 10/22] calcLookatOffsX and calcLookatOffsY matching --- source/dol/bases/d_bg.cpp | 115 +++++++++++++++++++------------------- 1 file changed, 58 insertions(+), 57 deletions(-) diff --git a/source/dol/bases/d_bg.cpp b/source/dol/bases/d_bg.cpp index 0d35ea68..1916d101 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->mBgRelatedPos.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->mBgRelatedPos.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 08aef524d4560a6ee1d2708ba60687633f47eb2b Mon Sep 17 00:00:00 2001 From: RootCubed Date: Thu, 29 May 2025 16:33:36 +0200 Subject: [PATCH 11/22] 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 02186b67..9c6d15b9 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 @@ -241,7 +241,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 e1544329..41b8198c 100644 --- a/include/game/bases/d_bg_parameter.hpp +++ b/include/game/bases/d_bg_parameter.hpp @@ -19,6 +19,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 1916d101..b44b2a8a 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 7d42e0eae8315f99fdf0762294a49066a2394fa5 Mon Sep 17 00:00:00 2001 From: RootCubed Date: Sun, 1 Jun 2025 11:11:44 +0200 Subject: [PATCH 12/22] Fix some offsets --- include/game/bases/d_a_player.hpp | 4 ++-- source/dol/bases/d_bg.cpp | 16 ++++++++-------- 2 files changed, 10 insertions(+), 10 deletions(-) diff --git a/include/game/bases/d_a_player.hpp b/include/game/bases/d_a_player.hpp index 78f1bbae..c8d7a072 100644 --- a/include/game/bases/d_a_player.hpp +++ b/include/game/bases/d_a_player.hpp @@ -18,12 +18,12 @@ class dAcPy_c : public daPlBase_c { bool FUN_8012e540(dActor_c *, bool); ///< @unofficial u8 mPad1[0x44]; - u32 mPlayerType; + u32 m_44; u8 mPad2[0x54]; mVec3_c mBgRelatedPos; u8 mPad3[0x4]; s8 mScrollMode; - u8 mPad5[0x1538]; + u8 mPad4[0x1538]; fBaseID_e mCarryActorID; s8 mPowerup; diff --git a/source/dol/bases/d_bg.cpp b/source/dol/bases/d_bg.cpp index b44b2a8a..bfbc542c 100644 --- a/source/dol/bases/d_bg.cpp +++ b/source/dol/bases/d_bg.cpp @@ -2082,48 +2082,48 @@ void dBg_c::fn_8007ca90(dBgSomeInfo_c *info, int i1, int i2) { if (pls[0] != nullptr) { info->m_14 = pl1; info->mBounds.mRight = fn_8007c7d0(pl1->mBgRelatedPos.x); - info->m_24 = pl1->mPlayerType; + info->m_24 = pl1->m_44; } if (pls[i2 - 1] != nullptr) { info->m_10 = pl2; info->mBounds.mLeft = fn_8007c7d0(pl2->mBgRelatedPos.x); - info->m_20 = pl2->mPlayerType; + info->m_20 = pl2->m_44; } break; case 2: if (pls[i2 - 1] != nullptr) { info->m_14 = pl2; info->mBounds.mRight = fn_8007c7d0(pl2->mBgRelatedPos.x); - info->m_24 = pl2->mPlayerType; + info->m_24 = pl2->m_44; } if (pls[0] != nullptr) { info->m_10 = pl1; info->mBounds.mLeft = fn_8007c7d0(pl1->mBgRelatedPos.x); - info->m_20 = pl1->mPlayerType; + info->m_20 = pl1->m_44; } break; case 1: if (pls[0] != nullptr) { info->m_18 = pl1; info->mBounds.mUp = pl1->mBgRelatedPos.y; - info->m_28 = pl1->mPlayerType; + info->m_28 = pl1->m_44; } if (pls[i2 - 1] != nullptr) { info->m_1c = pl2; info->mBounds.mDown = pl2->mBgRelatedPos.y; - info->m_2c = pl2->mPlayerType; + info->m_2c = pl2->m_44; } break; case 3: if (pls[i2 - 1] != nullptr) { info->m_18 = pl2; info->mBounds.mUp = pl2->mBgRelatedPos.y; - info->m_28 = pl2->mPlayerType; + info->m_28 = pl2->m_44; } if (pls[0] != nullptr) { info->m_1c = pl1; info->mBounds.mDown = pl1->mBgRelatedPos.y; - info->m_2c = pl1->mPlayerType; + info->m_2c = pl1->m_44; } break; } From 0397e89803cee95a6e1845fd0dc6609ceaf50629 Mon Sep 17 00:00:00 2001 From: RootCubed Date: Tue, 18 Nov 2025 10:06:50 +0100 Subject: [PATCH 13/22] 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 9c6d15b9..6267df87 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 bfbc542c..9256a45b 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 a19b32f6932fa66284aad0b80dadb443808da84b Mon Sep 17 00:00:00 2001 From: RootCubed Date: Tue, 18 Nov 2025 11:18:07 +0100 Subject: [PATCH 14/22] `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 6267df87..dbc6d49b 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 9256a45b..59027f18 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 ab76e7869aad4822860136103dc343e2984ef39d Mon Sep 17 00:00:00 2001 From: RootCubed Date: Tue, 18 Nov 2025 12:01:10 +0100 Subject: [PATCH 15/22] `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 dbc6d49b..2c2fc9e2 100644 --- a/include/game/bases/d_bg.hpp +++ b/include/game/bases/d_bg.hpp @@ -204,6 +204,17 @@ class dBg_c : public dBase_c { float getScaleFactor() { return 1.0f / mDispScale; } + 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 59027f18..26571776 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 ec9e5b7a953c7f28dcf620c8c2378445f8626006 Mon Sep 17 00:00:00 2001 From: RootCubed Date: Tue, 18 Nov 2025 12:16:03 +0100 Subject: [PATCH 16/22] `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 26571776..605cf5a1 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 0487c7ec718678e220e66f164b3390c46c4dedb9 Mon Sep 17 00:00:00 2001 From: RootCubed Date: Tue, 18 Nov 2025 12:34:30 +0100 Subject: [PATCH 17/22] `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 2c2fc9e2..e62ed048 100644 --- a/include/game/bases/d_bg.hpp +++ b/include/game/bases/d_bg.hpp @@ -215,6 +215,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 605cf5a1..71d2cf5c 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 3e6e99d86032bd12a27b0a097fb148b5349f4945 Mon Sep 17 00:00:00 2001 From: RootCubed Date: Tue, 18 Nov 2025 12:45:08 +0100 Subject: [PATCH 18/22] `dBg_c::fn_8007ca90` matching --- source/dol/bases/d_bg.cpp | 51 +++++++++++++++++++++------------------ 1 file changed, 27 insertions(+), 24 deletions(-) diff --git a/source/dol/bases/d_bg.cpp b/source/dol/bases/d_bg.cpp index 71d2cf5c..47a529e0 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->mBgRelatedPos.x); info->m_24 = pl1->m_44; } if (pls[i2 - 1] != nullptr) { - info->m_10 = pl2; + info->m_10 = pls[i2 - 1]; info->mBounds.mLeft = fn_8007c7d0(pl2->mBgRelatedPos.x); info->m_20 = pl2->m_44; } break; case 2: - if (pls[i2 - 1] != nullptr) { + if (pl2 != nullptr) { info->m_14 = pl2; info->mBounds.mRight = fn_8007c7d0(pl2->mBgRelatedPos.x); info->m_24 = pl2->m_44; } if (pls[0] != nullptr) { - info->m_10 = pl1; + info->m_10 = pls[0]; info->mBounds.mLeft = fn_8007c7d0(pl1->mBgRelatedPos.x); info->m_20 = pl1->m_44; } break; case 1: - if (pls[0] != nullptr) { + if (pl1 != nullptr) { info->m_18 = pl1; info->mBounds.mUp = pl1->mBgRelatedPos.y; info->m_28 = pl1->m_44; } if (pls[i2 - 1] != nullptr) { - info->m_1c = pl2; + info->m_1c = pls[i2 - 1]; info->mBounds.mDown = pl2->mBgRelatedPos.y; info->m_2c = pl2->m_44; } break; case 3: - if (pls[i2 - 1] != nullptr) { + if (pl2 != nullptr) { info->m_18 = pl2; info->mBounds.mUp = pl2->mBgRelatedPos.y; info->m_28 = pl2->m_44; } if (pls[0] != nullptr) { - info->m_1c = pl1; + info->m_1c = pls[0]; info->mBounds.mDown = pl1->mBgRelatedPos.y; info->m_2c = pl1->m_44; } From dbb29b0a8b43d70c5866b4454e522ef2e1275eb9 Mon Sep 17 00:00:00 2001 From: RootCubed Date: Tue, 18 Nov 2025 12:54:29 +0100 Subject: [PATCH 19/22] `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 e62ed048..3bb2cdee 100644 --- a/include/game/bases/d_bg.hpp +++ b/include/game/bases/d_bg.hpp @@ -217,6 +217,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 47a529e0..c40cc256 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 5bebb60c7c2809f3ac40bf493fea30ba5b3271f7 Mon Sep 17 00:00:00 2001 From: RootCubed Date: Tue, 18 Nov 2025 13:16:43 +0100 Subject: [PATCH 20/22] `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 3bb2cdee..3365e218 100644 --- a/include/game/bases/d_bg.hpp +++ b/include/game/bases/d_bg.hpp @@ -222,6 +222,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 c40cc256..0749d941 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 dfb41a51969497b8625bb3fb15565d9a84ff3334 Mon Sep 17 00:00:00 2001 From: RootCubed Date: Tue, 18 Nov 2025 13:43:00 +0100 Subject: [PATCH 21/22] `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 3365e218..9303f87b 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 0749d941..2cf15c28 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 6c4cfa64ebf3087b6b2181ab65b7e0f5ef920b6e Mon Sep 17 00:00:00 2001 From: RootCubed Date: Tue, 18 Nov 2025 17:51:29 +0100 Subject: [PATCH 22/22] 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 9303f87b..63e8bedc 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(); @@ -216,6 +227,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; } @@ -224,6 +236,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]; } @@ -256,7 +271,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 46de0691..9eed9b4b 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 2cf15c28..234c2b65 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; }